Conclusion
-In conclusion, 8 Ball Pool Ultima Version APK is a fantastic game that you should definitely try if you love pool games. It offers you unlimited coins and cash, all cues and tables unlocked, all game modes and features accessible, all players and locations available, no ads or pop-ups, frequent updates and content, high compatibility and performance, and many more benefits. It also improves your concentration, focus, hand-eye coordination, motor skills, stress relief, brain stimulation, memory function, social skills, confidence, etc. So what are you waiting for? Download 8 Ball Pool Ultima Version APK today and enjoy playing the best pool game ever!
-FAQs
-Q1: Is 8 Ball Pool Ultima Version APK safe to download?
-A1: Yes, 8 Ball Pool Ultima Version APK is safe to download. It does not contain any viruses or malware that can harm your device or data. However, you should always download it from a trusted source like [this link] to avoid any fake or corrupted files.
-Q2: Can I play 8 Ball Pool Ultima Version APK offline?
-A2: No, 8 Ball Pool Ultima Version APK is an online game that requires an internet connection to play. You cannot play it offline or without wifi. However, you can play it on any network speed or quality without any lag or connection issues.
-Q3: How can I customize my cue and pool table in 8 Ball Pool Ultima Version APK?
-A3: You can customize your cue and pool table in 8 Ball Pool Ultima Version APK by going to the shop section of the game. There you can find a variety of cues and tables with different designs, colors, patterns, attributes, etc. You can buy them with coins or cash that you have unlimited in this version of the game. You can also change your cue or table anytime during the game by tapping on the gear icon on the top right corner of the screen.
-Q4: How can I challenge my friends in 8 Ball Pool Ultima Version APK?
-A4: You can challenge your friends in 8 Ball Pool Ultima Version APK by tapping on the friends button on the bottom left corner of the screen. There you can see a list of your Facebook friends or Miniclip friends who are online or offline. You can also search for a friend by their name or ID. To challenge a friend, just tap on their name and select the table you want to play on. You can also chat with them before or during the game by tapping on the chat button on the top left corner of the screen.
-Q5: How can I get more coins and cash in 8 Ball Pool Ultima Version APK?
-A5: You don't need to worry about getting more coins and cash in 8 Ball Pool Ultima Version APK because you have unlimited amounts of them in this version of the game. You can use them to buy anything you want from the shop, play any game mode or feature, or enter any tournament. However, if you want to earn more coins and cash in the original game, you can do so by winning matches, spinning the wheel, playing mini-games, watching videos, completing offers, or inviting friends.
197e85843d-
-
\ No newline at end of file diff --git a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Disney 39s Aladdin 1994 Video Game Apk.md b/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Disney 39s Aladdin 1994 Video Game Apk.md deleted file mode 100644 index b4780082008b28e922962920931d9d080cb08c19..0000000000000000000000000000000000000000 --- a/spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Disney 39s Aladdin 1994 Video Game Apk.md +++ /dev/null @@ -1,74 +0,0 @@ - -
Disney's Aladdin 1994 Video Game APK: A Retro Classic on Your Smartphone
-Introduction
-If you grew up in the 90s, chances are you have fond memories of playing Disney's Aladdin video game on your Sega Genesis, Game Gear, or Master System. Based on the animated film of the same name, this side-scrolling platformer was one of the best-selling and most acclaimed games of its time. It featured stunning graphics, catchy music, and addictive gameplay that captured the magic and adventure of the movie.
-But what if you want to relive those memories on your smartphone? Is there a way to play Disney's Aladdin 1994 video game on your Android or iOS device? The answer is yes, thanks to a special APK file that allows you to run the game on your phone or tablet. In this article, we will tell you everything you need to know about Disney's Aladdin 1994 video game APK, including its features, how to download and install it, and some tips and tricks to optimize your experience.
-disney 39;s aladdin 1994 video game apk
DOWNLOAD • https://urlin.us/2uSY6I
-
Features of Disney's Aladdin 1994 video game
-Gameplay and controls
-Disney's Aladdin 1994 video game is a side-scrolling platformer in which you control Aladdin, the street-smart hero who falls in love with Princess Jasmine. You have to navigate through various levels inspired by the movie, such as the streets of Agrabah, the Cave of Wonders, and the Sultan's Palace. Along the way, you have to avoid enemies and obstacles, collect gems and apples, and use your scimitar and throwing skills to defeat foes.
-The game has two difficulty settings: normal and hard. The normal mode has six levels, while the hard mode has seven levels. The hard mode also has more enemies, traps, and hazards. The game also has a password system that allows you to resume your progress from any level.
-The controls are simple and intuitive. You can use the virtual buttons on the screen or tilt your device to move Aladdin left or right. You can also swipe up or down to jump or crouch. To attack with your scimitar, tap the sword button. To throw an apple, tap the apple button. You can also use the magic lamp button to summon Genie for help in certain situations.
-Graphics and sound
-One of the most impressive aspects of Disney's Aladdin 1994 video game is its graphics. The game features colorful and detailed sprites and backgrounds that faithfully recreate the look and feel of the movie. The animations are smooth and fluid, and the characters have expressive facial expressions. The game also has some cinematic cutscenes that tell the story between levels.
-The sound is equally impressive. The game features a high-quality soundtrack that includes songs from the movie, such as "A Whole New World", "Prince Ali", and "Friend Like Me". The sound effects are also realistic and immersive, such as the clashing of swords, the roaring of tigers, and the cheering of crowds.
- -Levels and challenges
-Disney's Aladdin 1994 video game has a variety of levels that offer different challenges and surprises. Some of the levels are:
--
-
- Agrabah Market: The first level where you have to escape from the guards and meet Jasmine. -
- The Desert: The second level where you have to ride a magic carpet through a sandstorm. -
- The Escape: The fourth level where you have to fly on a magic carpet and dodge falling rocks and lava. -
- Rooftops: The fifth level where you have to climb and jump across the rooftops of Agrabah and fight Jafar's minions. -
- Sultan's Dungeon: The sixth level where you have to rescue Abu from the dungeon and fight Iago, Jafar's parrot. -
- Jafar's Palace: The seventh and final level where you have to confront Jafar in his palace and defeat him in his snake form. -
escape from a lava-filled chamber. -
Each level has its own challenges and secrets, such as hidden items, bonus stages, and mini-games. For example, in the Cave of Wonders, you can find a magic flute that lets you play a snake-charming mini-game. In the Escape, you can find a magic carpet that lets you play a flying mini-game. In the Rooftops, you can find a scarab that lets you enter a bonus stage where you can collect extra lives and gems.
-Bonus content and secrets
-Disney's Aladdin 1994 video game also has some bonus content and secrets that add more fun and replay value to the game. Some of them are:
--
-
- Cheat codes: You can enter some cheat codes to unlock different features, such as invincibility, infinite lives, infinite apples, level select, and debug mode. -
- Easter eggs: You can find some Easter eggs that reference other Disney movies, such as The Lion King, The Little Mermaid, and Beauty and the Beast. -
- Alternate endings: You can get different endings depending on how many gems you collect throughout the game. The best ending is achieved by collecting 70 gems or more. -
How to download and install Disney's Aladdin 1994 video game APK
-Requirements and compatibility
-To download and install Disney's Aladdin 1994 video game APK, you need to have an Android or iOS device that meets the following requirements:
-| Operating system | -Version | -
|---|---|
| Android | -4.0 or higher | -
| iOS | -8.0 or higher | -
You also need to have enough storage space on your device to install the APK file, which is about 50 MB in size.
-Steps to download and install
-To download and install Disney's Aladdin 1994 video game APK, follow these steps:
--
-
- Go to the official website of Disney's Aladdin 1994 video game APK (link here) and click on the download button. -
- Wait for the download to finish and locate the APK file on your device. -
- If you are using an Android device, you need to enable the installation of apps from unknown sources. To do this, go to Settings > Security > Unknown Sources and toggle it on. -
- If you are using an iOS device, you need to trust the developer of the app. To do this, go to Settings > General > Device Management > Trust Developer Name and tap on Trust. -
- Tap on the APK file and follow the instructions to install it on your device. -
- Launch the app and enjoy playing Disney's Aladdin 1994 video game on your smartphone. -
Tips and tricks to optimize your experience
-To optimize your experience while playing Disney's Aladdin 1994 video game on your smartphone, here are some tips and tricks:
--
-
- Adjust the settings according to your preference. You can change the sound volume, screen size, language, and controller layout in the options menu. -
- Save your progress frequently. You can use the password system or the save state feature to save your progress at any point in the game. -
- Use Genie wisely. You can use Genie to help you in certain situations, such as finding hidden items, skipping levels, or getting extra lives. However, you can only use Genie once per level, so use him wisely. -
- Collect as many gems as possible. Gems are useful for unlocking bonus content, getting alternate endings, and buying items from Peddler shops. -
- Explore every level thoroughly. There are many secrets and hidden areas in each level that can reward you with extra items, bonus stages, or Easter eggs. -
-
-
\ No newline at end of file diff --git a/spaces/1phancelerku/anime-remove-background/Download Sniper 3D Mod Apk and Unlock Unlimited Money and Diamonds.md b/spaces/1phancelerku/anime-remove-background/Download Sniper 3D Mod Apk and Unlock Unlimited Money and Diamonds.md deleted file mode 100644 index b82b586dd587653c7d29b19e0edfa16954a942f1..0000000000000000000000000000000000000000 --- a/spaces/1phancelerku/anime-remove-background/Download Sniper 3D Mod Apk and Unlock Unlimited Money and Diamonds.md +++ /dev/null @@ -1,99 +0,0 @@ -
-
Sniper 3D Mod APK Unlimited Money and Diamonds 2021: A Review
-If you are a fan of shooting games and want to experience the thrill of being a professional sniper, then you should try Sniper 3D Mod APK. This is a modified version of the popular game Sniper 3D, which gives you access to unlimited money and diamonds, as well as all the weapons and upgrades in the game. In this article, we will review the features, benefits, and drawbacks of Sniper 3D Mod APK, as well as provide some tips and tricks on how to play it.
-What is Sniper 3D?
-Sniper 3D is a free-to-play action game developed by Fun Games For Free. It is available for Android and iOS devices, as well as Windows and Mac computers. The game puts you in the role of a deadly assassin who has to complete various missions around the world. You can choose from over 180+ authentic weapons, customize them with different attachments, and upgrade them to improve their performance. You can also play in different modes, such as offline missions, online PvP battles, squad wars, and special ops.
-sniper 3d mod apk unlimited money and diamonds 2021
Download ✺ https://jinyurl.com/2uNN12
-
Main features of Sniper 3D
-Some of the main features of Sniper 3D are :
--
-
- Sniper 3D Action: Experience the thrill of being a professional sniper in this stunning 3D gun game. Enjoy intuitive controls and realistic ballistics that'll make you feel like a real shooter. -
- Variety of Guns: Unlock a vast arsenal of sniper rifles, assault rifles, and other powerful guns. There are 180+ authentic weapons in the game. Upgrade your weapons and become the ultimate sniper 3D assassin. -
- Offline Gameplay: No internet connection? No problem! Enjoy Sniper 3D's offline mode and complete various challenging missions without the need for Wi-Fi or data. -
- PVE and PVP mode: Complete missions or play against other assassins in real time - whatever you like. -
- Diverse Locations: Travel to different parts of the world, taking on unique missions in various environments. Eliminate high-profile targets and show them who's the master shooter in town. -
- Free to Play: Join the action-packed world of Sniper 3D for free! This incredible shooting game offers hours of entertainment without costing a dime. -
How to download and install Sniper 3D Mod APK?
-If you want to enjoy the benefits of Sniper 3D Mod APK, you will need to download and install it on your device. Here are the steps to do so:
--
-
- Go to a trusted website that offers Sniper 3D Mod APK download link, such as [APK TRIGGER](^1^) or [GoogleModAPK](^2^). -
- Click on the download button and wait for the file to be downloaded. -
- Once the file is downloaded, go to your device settings and enable unknown sources installation. -
- Locate the downloaded file in your file manager and tap on it to start the installation process. -
- Follow the instructions on the screen and wait for the installation to finish. -
- Launch the game and enjoy Sniper 3D Mod APK unlimited money and diamonds 2021! -
Why use Sniper 3D Mod APK?
-Sniper 3D Mod APK is a modified version of the original game that gives you some extra advantages and features that are not available in the official version. Here are some of the reasons why you should use Sniper 3D Mod APK:
-Unlimited money and diamonds
-One of the main benefits of Sniper 3D Mod APK is that it gives you unlimited money and diamonds, which are the two main currencies in the game. You can use them to buy new weapons, upgrade them, unlock new skins, and more. You don't have to worry about running out of money or diamonds, or spending real money to get them. With Sniper 3D Mod APK, you can enjoy the game without any limitations.
-Unlock all weapons and upgrades
-Another benefit of Sniper 3D Mod APK is that it unlocks all the weapons and upgrades in the game. You can access over 180+ authentic weapons, from sniper rifles to assault rifles, and customize them with different attachments and scopes. You can also upgrade your weapons to increase their damage, accuracy, range, stability, and more. You don't have to complete missions or level up to unlock them. With Sniper 3D Mod APK, you can have the best weapons in the game at your disposal.
-sniper 3d hack apk download free coins and gems 2021
-sniper 3d modded apk latest version unlimited everything 2021
-sniper 3d cheats apk no root unlimited gold and energy 2021
-sniper 3d premium apk mod free download vip and weapons 2021
-sniper 3d cracked apk full unlocked unlimited ammo and lives 2021
-sniper 3d mod menu apk no ban unlimited cash and diamonds 2021
-sniper 3d unlimited money and diamonds apk offline download 2021
-sniper 3d mod apk android 1 unlimited coins and gems 2021
-sniper 3d hack online generator free money and diamonds 2021
-sniper 3d mod apk rexdl unlimited everything download 2021
-sniper 3d mod apk revdl unlimited money and diamonds 2021
-sniper 3d hack apk ios free coins and gems download 2021
-sniper 3d mod apk happymod unlimited money and diamonds 2021
-sniper 3d mod apk an1 unlimited coins and gems download 2021
-sniper 3d hack tool apk no survey unlimited cash and diamonds 2021
-sniper 3d mod apk obb unlimited money and diamonds download 2021
-sniper 3d mod apk pure unlimited everything free download 2021
-sniper 3d hack version apk unlimited coins and gems online 2021
-sniper 3d mod apk apkpure unlimited money and diamonds download 2021
-sniper 3d hack apk latest version unlimited cash and diamonds online 2021
-sniper 3d mod apk for pc unlimited money and diamonds download 2021
-sniper 3d hack apk uptodown unlimited coins and gems online 2021
-sniper 3d mod apk old version unlimited money and diamonds download 2021
-sniper 3d hack apk android unlimited cash and diamonds online 2021
-sniper 3d mod apk new version unlimited money and diamonds download 2021
Enjoy offline and online modes
-A third benefit of Sniper 3D Mod APK is that it allows you to enjoy both offline and online modes of the game. You can play offline missions without internet connection, or join online PvP battles and squad wars with other players around the world. You can also play special ops missions that require teamwork and strategy. You don't have to choose between offline and online modes. With Sniper 3D Mod APK, you can have the best of both worlds.
-Tips and tricks for Sniper 3D Mod APK
-Sniper 3D Mod APK is a fun and addictive game that will test your skills as a sniper. However, it can also be challenging and frustrating at times. Here are some tips and tricks that will help you improve your gameplay and become a master shooter:
-Aim for headshots and moving targets
-One of the most important tips for Sniper 3D Mod APK is to aim for headshots and moving targets. Headshots will deal more damage and earn you more points than body shots. Moving targets will also give you more points than stationary ones. However, they are also harder to hit, so you need to be patient and precise. Use your scope to zoom in on your target, wait for the right moment, and pull the trigger. Don't forget to account for wind direction and bullet drop as well.
-Choose the right weapon for each mission
-Another tip for Sniper 3D Mod APK is to choose the right weapon for each mission. Different missions will require different weapons, depending on the distance, environment, number of enemies, and other factors. For example, if you need to shoot from a long range, you should use a sniper rifle with a high magnification scope. If you need to shoot in a crowded area, you should use an assault rifle with a silencer. If you need to shoot in a dark place, you should use a weapon with a night vision scope. You can switch between different weapons before starting each mission.
-Use the environment to your advantage
-A third tip for Sniper 3D Mod APK is to use the environment to your advantage. The game features various locations with different elements that can help or hinder your shooting. For example, you can use buildings, cars, barrels, crates, and other objects as cover or distractions. You can also shoot explosive objects to cause chain reactions and eliminate multiple enemies at once. You can also shoot glass windows, lights, cameras, alarms, and other devices to create noise or confusion. Be creative and observant when using the environment.
-Conclusion
-Sniper 3D Mod APK is a great game for anyone who loves shooting games and wants to experience the thrill of being a professional sniper. It offers unlimited money and diamonds, as well as all the weapons and upgrades in the game. It also allows you to enjoy both offline and online modes of the game. However, it also requires skill, patience, precision, and strategy to complete various missions and challenges. If you follow our tips and tricks, you will be able to improve your gameplay and become a master shooter.
-Here are some of the frequently asked questions about Sniper 3D Mod APK:
-| Question | -Answer | -
|---|---|
| Is Sniper 3D Mod APK safe to use? | -Sniper 3D Mod APK is generally safe to use, as long as you download it from a trusted website and scan it with an antivirus program. However, you should be aware that using a modded version of the game may violate the terms and conditions of the original game, and may result in your account being banned or suspended. Therefore, you should use Sniper 3D Mod APK at your own risk. | -
| Can I play Sniper 3D Mod APK with my friends? | -Yes, you can play Sniper 3D Mod APK with your friends, as long as they also have the same version of the game installed on their devices. You can join online PvP battles and squad wars with your friends, or compete against them in leaderboards and rankings. You can also chat with them in the game and share your achievements and tips. | -
| What are the minimum requirements for Sniper 3D Mod APK? | -The minimum requirements for Sniper 3D Mod APK are:
|
-
| How can I update Sniper 3D Mod APK? | -To update Sniper 3D Mod APK, you will need to download and install the latest version of the game from the same website that you downloaded it from. You may also need to uninstall the previous version of the game before installing the new one. However, you should be careful when updating Sniper 3D Mod APK, as some updates may not be compatible with the modded version of the game, and may cause errors or crashes. | -
| Where can I get more information about Sniper 3D Mod APK? | -If you want to get more information about Sniper 3D Mod APK, you can visit the official website of the original game at [Sniper 3D], or follow their social media accounts on [Facebook], [Twitter], [Instagram], and [YouTube]. You can also check out some online forums and blogs that discuss Sniper 3D Mod APK, such as [Reddit] and [Quora]. | -
-
-
\ No newline at end of file diff --git a/spaces/4Taps/SadTalker/modules/gfpgan_inference.py b/spaces/4Taps/SadTalker/modules/gfpgan_inference.py deleted file mode 100644 index f4e7dc80eac012906b797843aa6019c2c4a39b3b..0000000000000000000000000000000000000000 --- a/spaces/4Taps/SadTalker/modules/gfpgan_inference.py +++ /dev/null @@ -1,36 +0,0 @@ -import os,sys - -def gfpgan(scale, origin_mp4_path): - current_code_path = sys.argv[0] - current_root_path = os.path.split(current_code_path)[0] - print(current_root_path) - gfpgan_code_path = current_root_path+'/repositories/GFPGAN/inference_gfpgan.py' - print(gfpgan_code_path) - - #video2pic - result_dir = os.path.split(origin_mp4_path)[0] - video_name = os.path.split(origin_mp4_path)[1] - video_name = video_name.split('.')[0] - print(video_name) - str_scale = str(scale).replace('.', '_') - output_mp4_path = os.path.join(result_dir, video_name+'##'+str_scale+'.mp4') - temp_output_mp4_path = os.path.join(result_dir, 'temp_'+video_name+'##'+str_scale+'.mp4') - - audio_name = video_name.split('##')[-1] - audio_path = os.path.join(result_dir, audio_name+'.wav') - temp_pic_dir1 = os.path.join(result_dir, video_name) - temp_pic_dir2 = os.path.join(result_dir, video_name+'##'+str_scale) - os.makedirs(temp_pic_dir1, exist_ok=True) - os.makedirs(temp_pic_dir2, exist_ok=True) - cmd1 = 'ffmpeg -i \"{}\" -start_number 0 \"{}\"/%06d.png -loglevel error -y'.format(origin_mp4_path, temp_pic_dir1) - os.system(cmd1) - cmd2 = f'python {gfpgan_code_path} -i {temp_pic_dir1} -o {temp_pic_dir2} -s {scale}' - os.system(cmd2) - cmd3 = f'ffmpeg -r 25 -f image2 -i {temp_pic_dir2}/%06d.png -vcodec libx264 -crf 25 -pix_fmt yuv420p {temp_output_mp4_path}' - os.system(cmd3) - cmd4 = f'ffmpeg -y -i {temp_output_mp4_path} -i {audio_path} -vcodec copy {output_mp4_path}' - os.system(cmd4) - #shutil.rmtree(temp_pic_dir1) - #shutil.rmtree(temp_pic_dir2) - - return output_mp4_path diff --git a/spaces/801artistry/RVC801/demucs/__init__.py b/spaces/801artistry/RVC801/demucs/__init__.py deleted file mode 100644 index d4182e356427e1b05a79f8da641c70bb732514fa..0000000000000000000000000000000000000000 --- a/spaces/801artistry/RVC801/demucs/__init__.py +++ /dev/null @@ -1,7 +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. - -__version__ = "2.0.3" diff --git a/spaces/A00001/bingothoo/src/lib/bots/bing/tts.ts b/spaces/A00001/bingothoo/src/lib/bots/bing/tts.ts deleted file mode 100644 index cd10b7d1d7581bf9cf46ff6755fcca550c558c9b..0000000000000000000000000000000000000000 --- a/spaces/A00001/bingothoo/src/lib/bots/bing/tts.ts +++ /dev/null @@ -1,82 +0,0 @@ -import { sleep } from './utils' - -const synth = window.speechSynthesis - -export class TTS { - currentText = '' - speakText = '' - private controller = new AbortController() - speaking = false - get isSpeaking() { - return this.speaking - } - finished = false - constructor() {} - abort = () => { - this.controller.abort() - } - - reset = () => { - this.speaking = false - this.finished = true - this.currentText = '' - this.speakText = '' - this.abort() - } - - speak = (text: string) => { - if (!synth || text?.trim()?.length < 2) { - return - } - this.currentText = text.replace(/[^\u4e00-\u9fa5_a-zA-Z0-9，。？,：；\.,:]+/g, '') - this.finished = false - this.loop() - } - - private async doSpeek() { - return new Promise((resolve) => { - const endIndex = this.finished ? this.currentText.length : - Math.max( - this.currentText.lastIndexOf('。'), - this.currentText.lastIndexOf('；'), - this.currentText.lastIndexOf('、'), - this.currentText.lastIndexOf('？'), - this.currentText.lastIndexOf('\n') - ) - const startIndex = this.speakText.length ? Math.max(0, this.currentText.lastIndexOf(this.speakText) + this.speakText.length) : 0 - - if (startIndex >= endIndex) { - return resolve(true) - } - const text = this.currentText.slice(startIndex, endIndex) - this.speakText = text - const utterThis = new SpeechSynthesisUtterance(text) - this.controller.signal.onabort = () => { - synth.cancel() - this.finished = true - resolve(false) - } - - utterThis.onend = function (event) { - resolve(true) - } - - utterThis.onerror = function (event) { - resolve(false) - } - - const voice = synth.getVoices().find(v => v.name.includes('Microsoft Yunxi Online')) ?? null - utterThis.voice = voice - synth.speak(utterThis) - }) - } - - private async loop() { - if (this.speaking) return - this.speaking = true - while(!this.finished) { - await Promise.all([sleep(1000), this.doSpeek()]) - } - this.speaking = false - } -} diff --git a/spaces/AIConsultant/MusicGen/tests/data/__init__.py b/spaces/AIConsultant/MusicGen/tests/data/__init__.py deleted file mode 100644 index 0952fcc3f57e34b3747962e9ebd6fc57aeea63fa..0000000000000000000000000000000000000000 --- a/spaces/AIConsultant/MusicGen/tests/data/__init__.py +++ /dev/null @@ -1,5 +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. diff --git a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/configs/tts/emotion/pre_align.py b/spaces/AIGC-Audio/AudioGPT/NeuralSeq/configs/tts/emotion/pre_align.py deleted file mode 100644 index 3b625295a118845c01a3677004070714d11c162b..0000000000000000000000000000000000000000 --- a/spaces/AIGC-Audio/AudioGPT/NeuralSeq/configs/tts/emotion/pre_align.py +++ /dev/null @@ -1,25 +0,0 @@ -import os - -from data_gen.tts.base_preprocess import BasePreprocessor -import glob -import re - -class EmoPreAlign(BasePreprocessor): - - def meta_data(self): - spks = ['0012', '0011', '0013', '0014', '0015', '0016', '0017', '0018', '0019', '0020'] - pattern = re.compile('[\t\n ]+') - for spk in spks: - for line in open(f"{self.raw_data_dir}/{spk}/{spk}.txt", 'r'): # 打开文件 - line = re.sub(pattern, ' ', line) - if line == ' ': continue - split_ = line.split(' ') - txt = ' '.join(split_[1: -2]) - item_name = split_[0] - emotion = split_[-2] - wav_fn = f'{self.raw_data_dir}/{spk}/{emotion}/{item_name}.wav' - yield item_name, wav_fn, txt, spk, emotion - - -if __name__ == "__main__": - EmoPreAlign().process() diff --git a/spaces/AIGC-Audio/AudioGPT/audio_detection/target_sound_detection/src/utils.py b/spaces/AIGC-Audio/AudioGPT/audio_detection/target_sound_detection/src/utils.py deleted file mode 100644 index cf1deeaef4e51fcc7cc42f4f3e2d9a34296371f9..0000000000000000000000000000000000000000 --- a/spaces/AIGC-Audio/AudioGPT/audio_detection/target_sound_detection/src/utils.py +++ /dev/null @@ -1,353 +0,0 @@ -# !/usr/bin/env python -# -*- coding: utf-8 -*- -# @Time : 2021/3/9 16:33 -# @Author : dongchao yang -# @File : train.py - -import collections -import sys -from loguru import logger -from pprint import pformat - -import numpy as np -import pandas as pd -import scipy -import six -import sklearn.preprocessing as pre -import torch -import tqdm -import yaml - -from scipy.interpolate import interp1d - -def parse_config_or_kwargs(config_file, **kwargs): - """parse_config_or_kwargs - :param config_file: Config file that has parameters, yaml format - :param **kwargs: Other alternative parameters or overwrites for config - """ - with open(config_file) as con_read: - yaml_config = yaml.load(con_read, Loader=yaml.FullLoader) - arguments = dict(yaml_config, **kwargs) - return arguments - - -def find_contiguous_regions(activity_array): # in this part, if you cannot understand the binary operation, I think you can write a O(n) complexity method - """Find contiguous regions from bool valued numpy.array. - Copy of https://dcase-repo.github.io/dcase_util/_modules/dcase_util/data/decisions.html#DecisionEncoder - Reason is: - 1. This does not belong to a class necessarily - 2. Import DecisionEncoder requires sndfile over some other imports..which causes some problems on clusters - """ - change_indices = np.logical_xor(activity_array[1:], activity_array[:-1]).nonzero()[0] - change_indices += 1 - if activity_array[0]: - # If the first element of activity_array is True add 0 at the beginning - change_indices = np.r_[0, change_indices] - - if activity_array[-1]: - # If the last element of activity_array is True, add the length of the array - change_indices = np.r_[change_indices, activity_array.size] - # print(change_indices.reshape((-1, 2))) - # Reshape the result into two columns - return change_indices.reshape((-1, 2)) - - -def split_train_cv( - data_frame: pd.DataFrame, - frac: float = 0.9, - y=None, # Only for stratified, computes necessary split - **kwargs): - """split_train_cv - - :param data_frame: - :type data_frame: pd.DataFrame - :param frac: - :type frac: float - """ - if kwargs.get('mode', - None) == 'urbansed': # Filenames are DATA_-1 DATA_-2 etc - data_frame.loc[:, 'id'] = data_frame.groupby( - data_frame['filename'].str.split('_').apply( - lambda x: '_'.join(x[:-1]))).ngroup() - sampler = np.random.permutation(data_frame['id'].nunique()) - num_train = int(frac * len(sampler)) - train_indexes = sampler[:num_train] - cv_indexes = sampler[num_train:] - train_data = data_frame[data_frame['id'].isin(train_indexes)] - cv_data = data_frame[data_frame['id'].isin(cv_indexes)] - del train_data['id'] - del cv_data['id'] - elif kwargs.get('mode', None) == 'stratified': # stratified --> 分层的 ? - # Use statified sampling - from skmultilearn.model_selection import iterative_train_test_split - index_train, _, index_cv, _ = iterative_train_test_split( - data_frame.index.values.reshape(-1, 1), y, test_size=1. - frac) - train_data = data_frame[data_frame.index.isin(index_train.squeeze())] - cv_data = data_frame[data_frame.index.isin(index_cv.squeeze())] # cv --> cross validation - else: - # Simply split train_test - train_data = data_frame.sample(frac=frac, random_state=10) - cv_data = data_frame[~data_frame.index.isin(train_data.index)] - return train_data, cv_data - - - -def pprint_dict(in_dict, outputfun=sys.stdout.write, formatter='yaml'): # print yaml file - """pprint_dict - :param outputfun: function to use, defaults to sys.stdout - :param in_dict: dict to print - """ - if formatter == 'yaml': - format_fun = yaml.dump - elif formatter == 'pretty': - format_fun = pformat - for line in format_fun(in_dict).split('\n'): - outputfun(line) - - -def getfile_outlogger(outputfile): - log_format = "[
- 
-
- """,
-
- # Avatar-URL Background-color Name-color Name-Content Font-color Font-size Content
- "AGENT": """
-
-
- {}
-{}
-
-
-
- """,
-
- # Background-color Font-size Font-color Name Content
- "SYSTEM": """
-
-
- {}
-{}
-
-
- """
- }
-
- ROLE_2_NAME = {}
-
- OBJECT_INFO = {
-
- "User": {
- # https://img-blog.csdnimg.cn/img_convert/7c20bc39ac69b6972a22e18762d02db3.jpeg
- "head_url": USER_HEAD_URL,
- "bubble_color": "#95EC69",
- "text_color": "#000000",
- "font_size": 0,
- "id": "USER"
- },
-
- "System": {
- # https://img-blog.csdnimg.cn/img_convert/e7e5887cfff67df8c2205c2ef0e5e7fa.png
- "head_url": "https://img.touxiangwu.com/zb_users/upload/2023/03/202303141678768524747045.jpg",
- "bubble_color": "#7F7F7F", ##FFFFFF
- "text_color": "#FFFFFF", ##000000
- "font_size": 0,
- "id": "SYSTEM"
- },
-
- "wait": {
- "head_url": "https://img.touxiangwu.com/zb_users/upload/2022/12/202212011669881536145501.jpg",
- "bubble_color": "#E7CBA6",
- "text_color": "#000000",
- "font_size": 0,
- "id": "AGENT"
- },
-
- "Recorder": {
- "head_url": "https://img.touxiangwu.com/zb_users/upload/2023/02/202302281677545695326193.jpg",
- "bubble_color": "#F7F7F7",
- "text_color": "#000000",
- "font_size": 0,
- "id": "AGENT"
- }
- }
-
- @classmethod
- def color_for_img(cls, url):
- """
- Extract the main colors from the picture and set them as the background color,
- then determine the corresponding text color.
- """
-
- def get_main_color(image):
- image = image.convert("RGB")
- width, height = image.size
- pixels = image.getcolors(width * height)
- most_common_pixel = max(pixels, key=lambda item: item[0])
- return most_common_pixel[1]
-
- def is_dark_color(rgb_color):
- r, g, b = rgb_color
- luminance = (0.299 * r + 0.587 * g + 0.114 * b) / 255
- return luminance < 0.5
-
- def download_image(url):
- print(f"binding: {url}")
- response = requests.get(url)
- if response.status_code == 200:
- with open('image.jpg', 'wb') as f:
- f.write(response.content)
-
- def rgb_to_hex(color):
- return "#{:02X}{:02X}{:02X}".format(color[0], color[1], color[2])
-
- def get_color(image_url):
- download_image(image_url)
-
- image = Image.open("image.jpg")
- main_color = get_main_color(image)
- is_dark = is_dark_color(main_color)
-
- if is_dark:
- font_color = "#FFFFFF"
- else:
- font_color = "#000000"
-
- return rgb_to_hex(main_color), font_color
-
- return get_color(url)
-
- @classmethod
- def init(cls, JSON):
- # Deprecated
- with open(JSON) as f:
- sop = json.load(f)
- cnt = 0
- FISRT_NODE = True
- fisrt_node_roles = []
- for node_name in sop['nodes']:
- node_info = sop['nodes'][node_name]
- agent_states = node_info['agent_states']
- for agent_role in agent_states:
- name = agent_states[agent_role]['style']['name']
- cls.ROLE_2_NAME[agent_role] = name
- if FISRT_NODE:
- fisrt_node_roles.append(agent_role)
- bubble_color, text_color = cls.color_for_img(cls.AGENT_HEAD_URL[cnt])
- cls.OBJECT_INFO[name] = {
- "head_url": f"{cls.AGENT_HEAD_URL[cnt]}",
- "bubble_color": bubble_color,
- "text_color": text_color,
- "font_size": 0,
- "id": "AGENT"
- }
- cnt += 1
- if FISRT_NODE:
- FISRT_NODE = False
- print(cls.OBJECT_INFO)
- for usr_name in cls.OBJECT_INFO:
- if cls.OBJECT_INFO[usr_name]["id"] == "SYSTEM":
- cls.OBJECT_INFO[usr_name]["font_size"] = 12
- elif cls.OBJECT_INFO[usr_name]["id"] in ["USER", "AGENT"]:
- cls.OBJECT_INFO[usr_name]["font_size"] = 16
- else:
- assert False
- return fisrt_node_roles
-
- @classmethod
- def add_agent(cls, agents_name:List,p:int=None):
- if p != None:
- cls.POINTER = p
- for name in agents_name:
- bubble_color, text_color = cls.color_for_img(cls.AGENT_HEAD_URL[cls.POINTER])
- cls.OBJECT_INFO[name] = {
- "head_url": f"{cls.AGENT_HEAD_URL[cls.POINTER]}",
- "bubble_color": bubble_color,
- "text_color": text_color,
- "font_size": 0,
- "id": "AGENT"
- }
- cls.POINTER += 1
- for usr_name in cls.OBJECT_INFO:
- if cls.OBJECT_INFO[usr_name]["id"] == "SYSTEM":
- cls.OBJECT_INFO[usr_name]["font_size"] = 12
- elif cls.OBJECT_INFO[usr_name]["id"] in ["USER", "AGENT"]:
- cls.OBJECT_INFO[usr_name]["font_size"] = 16
- else:
- assert False
-
-
-class StateConfig:
- """UI configuration for the step progress bar (indicating the current node)"""
-
- CSS = """
-:root {
- --gradient-start: 100%;
- --gradient-end: 0%;
- }
-.container.progress-bar-container {
- position: relative;
- display: flex;
- align-items: flex-end;
- width: 100%;
- overflow-x: auto;
- padding-bottom: 30px;
- padding-top: 20px
-}
-.container.progress-bar-container::-webkit-scrollbar {
- width: 8px;
- background-color: transparent;
-}
-
-.container.progress-bar-container::-webkit-scrollbar-thumb {
- background-color: transparent;
-}
-
-.progress-bar-container .progressbar {
- counter-reset: step;
- white-space: nowrap;
-}
-.progress-bar-container .progressbar li {
- list-style: none;
- display: inline-block;
- width: 200px;
- position: relative;
- text-align: center;
- cursor: pointer;
- white-space: normal;
-}
-.progress-bar-container .progressbar li:before {
- content: counter(step);
- counter-increment: step;
- width: 30px;
- height: 30px;
- line-height: 30px;
- border: 1px solid #ddd;
- border-radius: 100%;
- display: block;
- text-align: center;
- margin: 0 auto 10px auto;
- background-color: #ffffff;
-}
-.progress-bar-container .progressbar li:after {
- content: attr(data-content);
- position: absolute;
- width: 87%;
- height: 2px;
- background-color: #dddddd;
- top: 15px;
- left: -45%;
-}
-.progress-bar-container .progressbar li:first-child:after {
- content: none;
-}
-.progress-bar-container .progressbar li.active {
- color: green;
-}
-.progress-bar-container .progressbar li.active:before {
- border-color: green;
- background-color: green;
- color: white;
-}
-.progress-bar-container .progressbar li.active + li:after {
- background: linear-gradient(to right, green var(--gradient-start), lightgray var(--gradient-end));
-}
-.progress-bar-container .small-element {
- transform: scale(0.8);
-}
-.progress-bar-container .progressbar li span {
- position: absolute;
- top: 40px;
- left: 0;
- width: 100%;
- text-align: center;
-}
-.progress-bar-container .progressbar li .data-content {
- position: absolute;
- width: 100%;
- top: -10px;
- left: -100px;
- text-align: center;
-}
-"""
-
- FORMAT = """
-
-
-
-
-
-
-
- {}:{}
--
-
-
- {}
-
-
- {}
-- {} -
-- or
- Buy a license key for AVG PC TuneUp -
- Uninstall and reinstall AVG PC TuneUp free version -
- Click on the "Buy Now" button that appears on your screen when your trial expires. -
- You will be redirected to the AVG website where you can choose your plan and payment method. -
- Enter your billing details and confirm your order. -
- You will receive an email with your license key and instructions on how to activate it. -
- Open AVG PC TuneUp and enter your license key when prompted. -
- Enjoy using AVG PC TuneUp with full functionality. -
- Go to Control Panel > Programs > Uninstall a program. -
- Select AVG Internet Security or AVG Protection (depending on which trial version you have installed) and click on Uninstall. -
- Follow the instructions on the screen to complete the uninstallation process. -
- Restart your computer. -
- Download and install AVG PC TuneUp free version from this link: http://support.avg.com/SupportArticleView?urlname=Download-and-install-AVG-AntiVirus-Free. -
- Open AVG PC TuneUp and enjoy using some of its features for free. -
- Q: How long does it take to beat the game? -
- A: It depends on your skill level, luck, and persistence. Some players have beaten the game in less than 10 minutes, while others have spent hours or days on it. The average time to beat the game is around 5 hours, according to HowLongToBeat.com. -
- Q: What is the secret ending of the game? -
- A: The secret ending of the game is a reward for the players who manage to reach the top of the mountain. It involves a golden cauldron, a chat room, and a special song. We won't spoil it for you, but you can watch it on YouTube if you are curious. -
- Q: Is the game based on a true story? -
- A: No, the game is not based on a true story. However, the game does reference some real-life events and people, such as the Apollo 11 moon landing, Albert Camus, Che Guevara, and more. -
- Q: Can I play the game offline? -
- A: Yes, you can play the game offline. However, you will need an internet connection to access some features of the game, such as the chat room and the leaderboards. -
- Q: Is there a way to cheat or hack the game? -
- A: There are some ways to cheat or hack the game, such as using mods, trainers, or glitches. However, we do not recommend doing so, as it will ruin the fun and challenge of the game. Also, cheating or hacking might cause your device to malfunction or get infected by malware. -
- Stunning graphics and realistic sound. The game has beautiful pixel art graphics that are colorful and detailed. The sound effects are also realistic and immersive, making you feel like you are in the game world. -
- Simple, easy to play. The game has intuitive controls that make building and crafting easy and enjoyable. You can use the touch screen or the virtual joystick to move around and interact with the environment. You can also switch between first-person and third-person views to suit your preference. -
- Many game modes. The game offers different game modes for different play styles. You can choose between creative mode, where you have unlimited resources and no enemies, or survival mode, where you have to gather resources and fend off enemies. You can also choose between single-player mode, where you play alone, or multiplayer mode, where you play with other players online or offline. -
- Very much like the real world. The game has a realistic physics system that makes the blocks behave like they would in real life. For example, if you place a block on top of another block, it will stay there unless you remove it or something else pushes it down. If you place a block in mid-air, it will fall down due to gravity. You can also use water and lava to create different effects. -
- A lot of interesting things. The game has a lot of content and features that will keep you entertained for hours. You can find animals, plants, ores, chests, villages, dungeons, temples, and other structures in the world. You can also craft various items, such as beds, doors, ladders, torches, furnaces, chests, crafting tables, anvils, enchantment tables, potions, maps, compasses, clocks, books, paintings, banners, fireworks, armor stands, and more. You can also customize your character with different skins and accessories. -
- Go to a trusted website or app store that offers Craftsman 6 APK, such as [APKPure], [APKCombo], or [Uptodown]. -
- Click on the download button and wait for the file to be downloaded on your device. -
- Go to your device settings and enable the installation of apps from unknown sources. This will allow you to install Craftsman 6 APK without any problems. -
- Go to your file manager and locate the downloaded Craftsman 6 APK file. Tap on it and follow the instructions to install it on your device. -
- Launch the game and enjoy playing Craftsman 6 APK. -
- It is free to play and download.
- It is fun and creative.
- It is suitable for all ages.
- It has many game modes and features.
- It has multiplayer support.
- It may have some bugs and glitches.
- It may consume a lot of battery and storage.
- It may not be compatible with some devices.
- It may have some ads and in-app purchases.
- It may not be updated regularly.
- Use the right tools for the right blocks. Different blocks require different tools to break or place them. For example, you need a pickaxe to break stone, a shovel to break dirt, an axe to break wood, and so on. Using the right tools will make your work faster and easier. -
- Craft a bed as soon as possible. A bed is an essential item that allows you to sleep and set your spawn point. This means that if you die, you will respawn at your bed instead of at a random location. To craft a bed, you need three wool and three planks of the same color. -
- Light up your surroundings. Lighting is important for two reasons: it prevents monsters from spawning in dark areas, and it helps you see better at night or underground. You can use torches, lanterns, glowstone, or other light sources to illuminate your surroundings. -
- Gather resources wisely. Resources are limited in survival mode, so you need to gather them wisely. You can use chests, barrels, or other containers to store your items. You can also use maps, compasses, or coordinates to keep track of your location. You can also use signs, banners, or other markers to label your buildings or landmarks. -
- Be prepared for combat. Combat is inevitable in survival mode, so you need to be prepared for it. You can craft weapons, armor, shields, bows, arrows, and other items to help you fight against enemies. You can also use potions, food, or golden apples to heal yourself or boost your abilities. You can also use traps, walls, fences, or doors to protect yourself or your base from invaders. -
- Minecraft PE. This is the official mobile version of Minecraft, which offers the same gameplay and features as the original game. You can create your own world with blocks, explore, craft, survive, and play with other players online or offline. However, this game is not free; you need to pay a one-time fee of $6.99 to download it from Google Play or App Store. -
- Craftopia. This is another sandbox game that is similar to Minecraft but has more elements of RPGs and survival games. You can level up your character, learn skills, craft items, farm crops, tame animals, fish , hunt monsters, and more. You can also play with up to four players online or offline. This game is also not free; you need to pay $14.99 to download it from Steam or App Store. -
- Roblox. This is a platform that allows you to play and create various games with blocks. You can choose from millions of games created by other users, or make your own game with the Roblox Studio. You can also customize your avatar, chat with other players, join groups, and earn virtual currency. This game is free to play and download from Google Play or App Store, but it has some in-app purchases and ads. -
- Terraria. This is a 2D sandbox game that has elements of adventure, exploration, combat, and crafting. You can dig, build, fight, and explore in a randomly generated world with different biomes, enemies, bosses, items, and events. You can also play with up to eight players online or offline. This game is not free; you need to pay $4.99 to download it from Google Play or App Store. -
- Block Craft 3D. This is a 3D sandbox game that is similar to Craftsman 6 APK but has more focus on building and designing. You can create your own city with various buildings, such as houses, castles, skyscrapers, and more. You can also visit other cities created by other players and rate them. This game is free to play and download from Google Play or App Store, but it has some in-app purchases and ads. -
- Is Craftsman 6 APK safe to download? Yes, Craftsman 6 APK is safe to download as long as you get it from a trusted website or app store. However, you should always scan the file for viruses or malware before installing it on your device. -
- Is Craftsman 6 APK compatible with my device? Craftsman 6 APK is compatible with most Android devices that have Android 4.1 or higher. However, some devices may not be able to run the game smoothly due to low specifications or performance issues. -
- How do I update Craftsman 6 APK? To update Craftsman 6 APK, you need to download the latest version of the game from the same website or app store where you got the previous version. Then, you need to uninstall the old version and install the new one on your device. -
- How do I uninstall Craftsman 6 APK? To uninstall Craftsman 6 APK, you need to go to your device settings and find the app in the list of installed apps. Then, you need to tap on it and select the uninstall option. -
- How do I contact the developer of Craftsman 6 APK? To contact the developer of Craftsman 6 APK, you can send an email to craftsman6apk@gmail.com or visit their Facebook page at https://www.facebook.com/Craftsman-6-APK-105678918544321. -
- Create a Steam account if you don't have one already. -
- Go to the official page of Internet Cafe Simulator on Steam. -
- Click on "Download Demo" or "Play Game" depending on which option you prefer. -
- Wait for the download to finish and launch the game from your Steam library. -
- Enjoy playing internet cafe simulator for free! -
- Viruses and malware: Torrent files can contain harmful software that can infect your computer and compromise your data and security. -
- Legal trouble: Downloading internet cafe simulator for free without the permission of the developers or publishers is illegal and can result in fines or lawsuits. -
- Poor quality: Torrent files can be corrupted, incomplete, or outdated, resulting in a bad gaming experience. -
- Use a reputable torrent client, such as uTorrent or BitTorrent. -
- Use a reliable torrent site, such as The Pirate Bay or RARBG, and check the ratings and comments of the torrent files before downloading them. -
- Use a VPN (virtual private network) service, such as NordVPN or ExpressVPN, to hide your IP address and encrypt your traffic. -
- Use an antivirus software, such as Avast or Malwarebytes, to scan your downloaded files and remove any potential threats. -
- OS: Windows 7/8/10 -
- Processor: 2 GHz Dual Core CPU -
- Memory: 4 GB RAM -
- Graphics: Intel HD Graphics 4000 or better -
- Storage: 5 GB available space -
- Competition: You have to compete with other internet cafes in the city and attract more customers and revenue. -
- Customer satisfaction: You have to keep your customers happy and loyal by providing them with good service, quality products, and a comfortable environment. -
- City events: You have to deal with various events that happen in the city, such as protests, riots, power outages, or cyberattacks. -
- Crime: You have to protect your internet cafe from thieves, hackers, vandals, or corrupt cops. -
- Personal life: You have to balance your personal life with your business, such as paying your rent, maintaining your health, dating, or having fun. -
- Download Fotosizer Final Edition serials key from the official website of Fotosizer: https://www.fotosizer.com/ -
- Run the setup file and follow the installation instructions. -
- Enter the serial key from the text file or generate one using the keygen. -
- Enjoy Fotosizer Final Edition serials key. -
- You can save time by resizing hundreds of photos in one conversion. -
- You can save disk space by reducing the size and quality of your photos. -
- You can customize your photos according to your preferences and needs. -
- You can protect your photos by adding watermarks and metadata. -
- You can enhance your photos by applying effects and adjustments. -
- Launch Fotosizer Final Edition and click on the Add button to add your photos to the program. You can also drag and drop your photos to the program. -
- Choose the output size and quality of your photos. You can use the presets or enter your own values. -
- Choose the output format and destination of your photos. You can also output your photos to a compressed ZIP file. -
- Click on the Options button to access more settings and features. You can add text and image watermarks, rotate and flip your photos, apply rounded corners, adjust the color and brightness, and more. -
- Click on the Start button to start resizing your photos. You can also preview your photos before resizing them. -
- Enjoy your resized and optimized photos. -
- Go to Control Panel and click on Programs and Features. -
- Find Fotosizer Final Edition in the list of programs and click on Uninstall. -
- Follow the uninstallation wizard and confirm your choice. -
- Delete the serial key and the keygen file from your system. -
- Restart your system if needed. -
- You can get regular updates and new features for Fotosizer Final Edition. -
- You can get technical support and customer service from Fotosizer. -
- You can get security protection and privacy guarantee from Fotosizer. -
- You can avoid malware infection, data loss, legal issues, or poor performance that might come with Fotosizer Final Edition serials key crack. -
- You can support the developers of Fotosizer Final Edition and help them improve their software. -
- FastStone Photo Resizer: This is a simple and fast software that can help you resize, rename, crop, rotate, and convert your photos in batch mode. It also supports adding text and image watermarks, adjusting color and brightness, applying borders and effects, and more. You can download FastStone Photo Resizer for free from this link: https://www.faststone.org/FSResizerDetail.htm -
- Image Resizer for Windows: This is a handy and easy-to-use software that can help you resize your photos with a simple right-click. It integrates with Windows Explorer and lets you choose from predefined sizes or enter your own values. You can also rotate and compress your photos, and preserve the original metadata. You can download Image Resizer for Windows for free from this link: https://www.bricelam.net/ImageResizer/ -
- IrfanView: This is a powerful and versatile software that can help you view, edit, convert, and optimize your photos. It supports a wide range of formats and features, such as batch resizing, cropping, rotating, renaming, watermarking, color correction, effects, filters, and more. You can download IrfanView for free from this link: https://www.irfanview.com/ -
- Launch Fotosizer Final Edition and click on the Add button to add your photos to the program. You can also drag and drop your photos to the program. -
- Choose the output size and quality of your photos. You can use the presets or enter your own values. -
- Choose the output format and destination of your photos. You can also output your photos to a compressed ZIP file. -
- Click on the Options button to access more settings and features. You can add text and image watermarks, rotate and flip your photos, apply rounded corners, adjust the color and brightness, and more. -
- Click on the Start button to start resizing your photos. You can also preview your photos before resizing them. -
- Enjoy your resized and optimized photos. -
- Go to Control Panel and click on Programs and Features. -
- Find Fotosizer Final Edition in the list of programs and click on Uninstall. -
- Follow the uninstallation wizard and confirm your choice. -
- Delete the serial key and the keygen file from your system. -
- Restart your system if needed. -
- You can get regular updates and new features for Fotosizer Final Edition. -
- You can get technical support and customer service from Fotosizer. -
- You can get security protection and privacy guarantee from Fotosizer. -
- You can avoid malware infection, data loss, legal issues, or poor performance that might come with Fotosizer Final Edition serials key crack. -
- You can support the developers of Fotosizer Final Edition and help them improve their software. -
- If you have received a physical media kit, the serial number is printed on the label of the CD or DVD case. -
- If you have downloaded the product from the Progress website, the serial number is included in the confirmation email that you received after completing your order. -
- If you have installed the product using a network setup, the serial number is stored in the
progress.cfgfile in the installation directory (by default,C:\Progress\OpenEdge).
- - Openedge Development Studio: A graphical integrated development environment (IDE) that provides tools and wizards for creating, testing, debugging, and deploying Openedge applications. -
- Openedge RDBMS: A high-performance relational database management system (RDBMS) that supports data access, integrity, security, backup, and recovery. -
- Openedge Application Server: A scalable and robust application server that enables distributed processing, load balancing, clustering, and failover for Openedge applications. -
- Openedge DataServer: A data access technology that allows Openedge applications to access and manipulate data from other RDBMSs such as Oracle, Microsoft SQL Server, and ODBC. -
- Openedge WebClient: A deployment technology that allows Openedge applications to run on client machines without requiring installation or configuration. -
- Spam -
- Ham -
- Eggs -
- Go to https://www.gamecopyworld.com/games/pc_brian_lara_international_cricket_2007.shtml and scroll down to the section that says "Game Fixes". -
- Click on the link that says "Brian Lara International Cricket 2007 v1.0 [ENGLISH] No-CD/Fixed EXE". This will take you to another page where you can download the crack file. -
- Click on the "Download" button and save the file to your PC. -
- Extract the file using a program such as WinRAR or 7-Zip. -
- Copy the extracted file (BLIC07.exe) and paste it into the folder where you installed the game (usually C:\Program Files\Codemasters\Brian Lara International Cricket 2007). -
- Replace the original file when prompted. -
- Run the game using the new file (BLIC07.exe) and enjoy! -
- Make sure you have a good antivirus program on your PC before downloading and installing any crack files from Brian Lara International Cricket 2007 Crack Gamecopyworld or any other website. Some crack files may contain viruses or malware that can harm your PC or steal your personal information. -
- Do not update the game after installing the crack. Updating the game may overwrite the crack file and make the game unplayable. -
- Do not use the crack to play online. Playing online with a cracked version of the game may result in your account being banned or suspended by Codemasters or other players. -
- Downloading and installing cracked games is illegal and may violate the terms of service of Codemasters or other game developers. We do not condone or encourage piracy in any way. This article is for educational purposes only. -
- Install the PPSSPP app on your Android device and launch it. -
- Locate the Call of Duty Modern Warfare 3 PSP iso file on your device's storage and tap on it to load it into the emulator. -
- Adjust the settings of the emulator according to your device's specifications and preferences. You can change the graphics, sound, controls, and performance settings to optimize your gaming experience. -
- Start playing Call of Duty Modern Warfare 3 on your Android device using PPSSPP. You can use the virtual buttons on the screen or connect an external controller to enjoy the game. -
- Install the PPSSPP app on your Android device and launch it. -
- Locate the Call of Duty Modern Warfare 3 PSP iso file on your device's storage and tap on it to load it into the emulator. -
- Adjust the settings of the emulator according to your device's specifications and preferences. You can change the graphics, sound, controls, and performance settings to optimize your gaming experience. -
- Start playing Call of Duty Modern Warfare 3 on your Android device using PPSSPP. You can use the virtual buttons on the screen or connect an external controller to enjoy the game. -
- Practice the game's controls and mechanics before jumping into the action. You can use the game's tutorial mode or play some offline matches to get familiar with the game's features and functions. -
- Choose the right weapons and equipment for your playstyle and situation. You can customize your loadout with various perks, weapons attachments, killstreaks and proficiencies that suit your preferences and needs. You can also switch your loadout during the game if you need to adapt to changing circumstances. -
- Use cover and stealth to your advantage. You can hide behind walls, cars, crates, and other objects to avoid enemy fire and surprise them with your attacks. You can also crouch, prone, or lean to reduce your visibility and accuracy. -
- Communicate and cooperate with your teammates. You can use the game's voice chat or text chat to coordinate your strategies and tactics with your fellow players. You can also mark enemies, objectives, and locations with the game's ping system. -
- Learn from your mistakes and improve your skills. You can watch the game's killcam or replay mode to see how you died or how you performed in the game. You can also check your stats and achievements to see your strengths and weaknesses. -
- IGN gave the game a score of 9 out of 10, saying that "Modern Warfare 3 is an exceptional entry in the series, delivering a full package of campaign, cooperative, and multiplayer content. It might not have fixed all the problems from the previous games, but it balances the existing elements expertly, while adding a few new toys for extra fun." -
- GameSpot gave the game a score of 8.5 out of 10, saying that "Modern Warfare 3 iterates rather than innovates, so the fun you have is familiar. Fortunately, it's also utterly engrossing and immensely satisfying, giving fans another reason to rejoice in this busy shooter season." -
- Metacritic gave the game a score of 88 out of 100, based on 39 reviews from critics. The user score was 3.4 out of 10, based on 5,248 ratings from players. The critics praised the game's action-packed and cinematic campaign, its robust and varied multiplayer mode, its new and challenging cooperative mode, and its impressive graphics and sound. The players criticized the game's lack of innovation, its short and linear campaign, its repetitive and scripted gameplay, and its technical issues and bugs. -
- Download and install CardRecovery v5.30 Build 1206 Software from its official website[^2^]. -
- Connect your memory card to your computer using a card reader or a USB cable. -
- Launch CardRecovery v5.30 Build 1206 Software and select your memory card from the list of drives. -
- Select the file types you want to recover (such as JPG, PNG, MOV, MP4, etc.) and click "Next". -
- Wait for the scanning process to complete. You can preview the recovered photos and videos before saving them. -
- Select a destination folder to save the recovered files and click "Save". -
- "License" shall mean the terms and conditions for use, reproduction, and Distribution as defined - in this document. -
- “Data” - means a collection of texts extracted from the - BigScience Corpus used with the Model, including to train, pretrain, or - otherwise evaluate the Model. The Data is not licensed under this License. The BigScience Corpus is a collection of existing sources of - language data documented on the BigScience website. -
- “Output” means the - results of operating a Model as embodied in informational content resulting therefrom. -
- “Model” means any accompanying machine-learning based assemblies (including checkpoints), consisting of learnt weights, parameters (including optimizer states), corresponding - to the BigScience BLOOM model architecture as embodied in the Complementary Material, that have been - trained or tuned, in whole or in part, on the Data using the Complementary - Material. -
- “Derivatives of the Model” means all modifications to the Model, works based on - the Model, or any other model which is created or initialized by transfer of patterns of the weights, - parameters, activations or output of the Model, to the - other model, in order to cause the other model to perform similarly to the Model, including - but not limited to - distillation methods - entailing the use of intermediate data representations or methods based on the generation of synthetic - data by the Model for training the other model. -
- “Complementary - Material” shall mean the accompanying source - code and scripts used to define, run, load, - benchmark or evaluate the Model, and used to prepare data for training or evaluation. This includes any accompanying documentation, tutorials, examples etc. -
- “Distribution” means any transmission, reproduction, publication or other sharing of the Model or - Derivatives of the Model to a third party, including providing the Model as a hosted service made - available by electronic or other remote means - e.g. API-based or web access. -
- “Licensor” means the copyright owner or entity authorized by the copyright owner that is granting the License, including the persons or - entities that may have rights in the Model and/or distributing the Model. -
- "You" - (or "Your") shall mean an individual or - Legal Entity exercising permissions granted by this License and/or making use of the Model for whichever - purpose and in any field of use, including usage of the Model in an end-use application - e.g. chatbot, - translator. -
- “Third Parties” means individuals or legal entities that are not under common control with - Licensor or You. -
- "Contribution" shall mean any work of authorship, including the original version of the Model and any - modifications or additions to that Model or Derivatives of the Model thereof, that is intentionally - submitted to Licensor for inclusion in the Model by the copyright owner or by an individual or Legal - Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, - “submitted” means any form of electronic, - verbal, or written communication sent to the Licensor or its representatives, including but not limited - to communication on electronic mailing lists, source code control systems, and issue tracking systems - that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the - Model, but excluding communication that is conspicuously marked or otherwise designated in writing by - the copyright owner as "Not a Contribution." -
- "Contributor" shall mean Licensor and any individual or Legal Entity on - behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the - Model. -
- Use-based restrictions as referenced in paragraph 5 MUST be included as an - enforceable provision by You in any type of legal agreement (e.g. a license) governing the use and/or - distribution of the Model or Derivatives of the Model, and You shall give notice to subsequent users You - Distribute to, that the Model or Derivatives of the Model are subject to paragraph 5. This provision - does not apply to the use of Complementary Material. -
- You must give any Third Party recipients of the Model or - Derivatives of the Model a copy of this License; -
- You must cause any modified files to carry prominent notices - stating that You changed the files; -
- You must retain all copyright, patent, trademark, and - attribution notices excluding those notices that do not pertain to any part of the Model, Derivatives of - the Model. -
- In any way that violates any applicable national, federal, - state, local or international law or regulation; -
- For the purpose of exploiting, harming or attempting to exploit - or harm minors in any way; -
- To generate or disseminate verifiably false information with - the purpose of harming others; -
- To generate or disseminate personal - identifiable information that can be used to harm an individual; -
- To generate or disseminate information or content, in any context (e.g. posts, articles, tweets, - chatbots or other kinds of automated bots) without expressly and intelligibly disclaiming that the text - is machine generated; -
- To defame, disparage or otherwise harass others; -
- To impersonate or attempt to impersonate others; -
- For fully automated decision making that adversely impacts an - individual’s legal rights or otherwise creates or modifies a binding, enforceable - obligation; -
- For any use intended to or which has the - effect of discriminating against or harming individuals or groups based on online or offline social behavior or known or - predicted personal or personality characteristics -
- To exploit any of the vulnerabilities of a specific group of - persons based on their age, social, physical or mental characteristics, in order to materially distort the behavior of a person pertaining - to that group in a manner that causes or is likely to cause that person or another person physical or - psychological harm; -
- For any use intended to or which has the - effect of discriminating against individuals or groups based on legally protected characteristics or - categories; -
- To provide medical advice and medical results interpretation; - -
- To generate or disseminate information for the purpose to be used - for administration of justice, law enforcement, immigraton or asylum processes, such as predicting an - individual will commit fraud/crime commitment (e.g. by text profiling, drawing causal relationships - between assertions made in documents, indiscriminate and arbitrarily-targeted use). -
- to be generated instead of a
.
- if re.search(r'(\n\d+\.?|\n\*\s*)$', result):
- delete_str = '|delete|'
-
- if re.search(r'(\d+\.?)$', result) and not result.endswith('.'):
- result += '.'
-
- result = re.sub(r'(\n\d+\.?|\n\*\s*)$', r'\g<1> ' + delete_str, result)
-
- html_output = markdown.markdown(result, extensions=['fenced_code', 'tables'])
- pos = html_output.rfind(delete_str)
- if pos > -1:
- html_output = html_output[:pos] + html_output[pos + len(delete_str):]
- else:
- html_output = markdown.markdown(result, extensions=['fenced_code', 'tables'])
-
- # Unescape code blocks
- pattern = re.compile(r' Si estás buscando un juego que ponga a prueba tu paciencia, habilidad y cordura, es posible que hayas oído hablar de Cómo superarlo con Bennett Foddy. Este juego se ha vuelto notorio por su dificultad extrema y su juego provocador de ira. Pero, ¿de qué se trata este juego y cómo puedes conseguirlo gratis en 2022? En este artículo, responderemos a estas preguntas y te daremos algunos consejos y trucos para ayudarte a superar esta montaña de frustración. Getting Over It with Bennett Foddy es un videojuego que fue lanzado en 2017 por Bennett Foddy, un desarrollador de juegos y filósofo australiano. El juego es descrito por Foddy como "un juego que hice para un cierto tipo de persona. Para hacerles daño." DOWNLOAD ☆☆☆ https://bltlly.com/2v6J3M La premisa del juego es simple: controlas a un hombre llamado Diógenes que está atrapado en un caldero y tiene que usar un martillo para escalar una montaña escarpada y resbaladiza de objetos aleatorios. El juego no tiene puntos de control, sistema de guardado ni piedad. Si haces un movimiento en falso, puedes retroceder hasta el principio. El juego está diseñado para ser frustrante, injusto e impredecible. El juego también es un tributo a Sexy Hiking, un juego B de 2002 de Jazzuo que tenía un concepto y jugabilidad similares. Foddy se inspiró en Sexy Hiking y quería crear su propia versión con mejores gráficos, física y sonido. También agregó su propia voz como narrador que comenta sobre tu progreso, fracaso y filosofía. Superar No es un juego para todos. Es un juego que te hará enojar, triste, desesperado y desesperado. Es un juego que te hará cuestionar tus elecciones de vida y tu cordura. Entonces, ¿por qué la gente quiere jugar? Aquí hay algunas posibles razones: A algunas personas les gusta jugar juegos duros que los llevan a sus límites. Les gusta la sensación de superar obstáculos y alcanzar metas que parecen imposibles. Les gusta la emoción del riesgo y la recompensa. Les gusta la satisfacción de demostrarse a sí mismos y a otros que están equivocados. Les gusta el dolor y el placer de jugar a Getting Over It. Algunas personas juegan Getting Over It porque quieren ver lo que sucede cuando terminan el juego. Sienten curiosidad por el final y la recompensa que les espera. Están decididos a no rendirse y a llegar a la cima de la montaña. Están motivados por el desafío y el misterio de superarlo. Algunas personas juegan Getting Over It porque quieren unirse a la comunidad en línea y la cultura que ha surgido alrededor del juego. Quieren compartir sus experiencias, reacciones y opiniones con otros jugadores y espectadores. Quieren ver o crear videos, transmisiones, memes, fan art y parodias del juego. Quieren divertirse y reírse del absurdo y la hilaridad de Getting Over It. Getting Over Es un juego de pago que está disponible en varias plataformas, como Steam, Humble Bundle, iOS y Android. El precio del juego varía dependiendo de la plataforma y la región, pero por lo general es de alrededor de $ 8 USD. Sin embargo, algunas personas pueden no querer pagar por el juego o no tener acceso a las plataformas oficiales. En ese caso, ¿cómo pueden obtener Getting Over It gratis en 2022? Aquí hay algunas opciones: La forma no oficial de obtener Getting Over It de forma gratuita es descargarlo desde un sitio web de terceros o tienda de aplicaciones que ofrece versiones pirateadas o agrietadas del juego. Uno de estos sitios web es Uptodown, que es una plataforma popular para descargar aplicaciones y juegos para dispositivos Android. Uptodown afirma ofrecer una descarga gratuita de Getting Over It con Bennett Foddy APK, que es el formato de archivo para las aplicaciones de Android. Sin embargo, este método no es recomendado o respaldado por el desarrollador o las plataformas. Si bien conseguir Getting Over It gratis puede sonar tentador, hay algunos riesgos y desventajas involucradas en hacerlo. En primer lugar, descargar juegos pirateados o agrietados es ilegal y poco ético, ya que viola los derechos de propiedad intelectual del desarrollador y las plataformas. También les priva de los ingresos y el apoyo que merecen para crear y distribuir el juego. En segundo lugar, la descarga de juegos de fuentes no confiables puede exponer su dispositivo a malware, virus, spyware u otro software dañino que puede dañar su sistema o robar su información personal. En tercer lugar, la descarga de juegos de plataformas no oficiales puede resultar en un rendimiento deficiente, problemas de compatibilidad, errores, problemas técnicos o características que pueden arruinar su experiencia de juego. Por lo tanto, es mejor comprar el juego en las plataformas oficiales o esperar un regalo o promoción legítima. Si has decidido jugar a Getting Over It, ya sea que lo hayas comprado o descargado gratis, es posible que necesites algunos consejos y trucos para ayudarte a sobrevivir a este juego brutal. Aquí hay algunas sugerencias: Otra cosa que hacer en Getting Over es usar afirmaciones y pensamiento positivo. El juego puede ser muy frustrante y desmoralizante, especialmente cuando se pierde mucho progreso o escuchar los comentarios sarcásticos de Foddy. Puede sentirse enojado, desesperado o deprimido. Para lidiar con estas emociones negativas, necesita usar afirmaciones y pensamiento positivo. Necesitas recordarte que puedes hacerlo, que estás mejorando, que estás aprendiendo, que te estás divirtiendo y que no estás solo. Necesitas enfocarte en los aspectos positivos del juego y tu experiencia, en lugar de los negativos. Una última cosa que hacer en Getting Over es ver carreras rápidas y guías. Speedruns son vídeos de jugadores que completan el juego en el menor tiempo posible, utilizando diversas técnicas y estrategias. Las guías son videos de jugadores que explican cómo superar partes específicas del juego, usando consejos y trucos. Ver carreras rápidas y guías puede ayudarle a aprender de los expertos y mejorar sus propias habilidades. También puedes inspirarte y motivarte viendo cómo otros han conquistado el juego. Superarlo con Bennett Foddy es un juego que te desafiará, te frustrará y te hará cuestionar tu existencia. Es un juego que pondrá a prueba tu paciencia, habilidad y cordura. Es un juego que te hará reír, llorar, gritar y rabiar. Pero también es un juego que te recompensará, te enseñará e inspirará. Es un juego que te hará sentir vivo. Si quieres jugar a este juego, puedes comprarlo en las plataformas oficiales o esperar un regalo o promoción gratis. También puede descargarlo de fuentes no oficiales, pero sea consciente de los riesgos y desventajas involucrados. Y si quieres tener éxito en este juego, necesitas practicar, usar afirmaciones y pensamiento positivo, y ver carreras rápidas y guías. Aquí hay algunas preguntas frecuentes acerca de Cómo superarlo con Bennett Foddy:{string}'
- return string
-
-
-def process_post(post, c):
- t = post.split('\n')
- number = t[0].split(' ')[1]
- if len(t) > 1:
- src = '\n'.join(t[1:])
- else:
- src = ''
- src = re.sub('>', '>', src)
- src = re.sub('(>>[0-9]*)', '\\1', src)
- src = re.sub('\n', '
\n', src)
- src = f'{src}\n'
- src = f'Anonymous No.{number}\n{src}'
- return src
-
-
-def generate_4chan_html(f):
- posts = []
- post = ''
- c = -2
- for line in f.splitlines():
- line += "\n"
- if line == '-----\n':
- continue
- elif line.startswith('--- '):
- c += 1
- if post != '':
- src = process_post(post, c)
- posts.append(src)
- post = line
- else:
- post += line
-
- if post != '':
- src = process_post(post, c)
- posts.append(src)
-
- for i in range(len(posts)):
- if i == 0:
- posts[i] = f'
{posts[i]}\n'
- else:
- posts[i] = f'{posts[i]}\n'
-
- output = ''
- output += f''
- output = output.split('\n')
- for i in range(len(output)):
- output[i] = re.sub(r'^(>(.*?)('
- for post in posts:
- output += post
-
- output += '
|))', r'\1', output[i])
- output[i] = re.sub(r'^(>(.*?)(
|))', r'\1', output[i])
-
- output = '\n'.join(output)
- return output
-
-
-def make_thumbnail(image):
- image = image.resize((350, round(image.size[1] / image.size[0] * 350)), Image.Resampling.LANCZOS)
- if image.size[1] > 470:
- image = ImageOps.fit(image, (350, 470), Image.LANCZOS)
-
- return image
-
-
-def get_image_cache(path):
- cache_folder = Path("cache")
- if not cache_folder.exists():
- cache_folder.mkdir()
-
- mtime = os.stat(path).st_mtime
- if (path in image_cache and mtime != image_cache[path][0]) or (path not in image_cache):
- img = make_thumbnail(Image.open(path))
-
- old_p = Path(f'cache/{path.name}_cache.png')
- p = Path(f'cache/cache_{path.name}.png')
- if old_p.exists():
- old_p.rename(p)
-
- output_file = p
- img.convert('RGB').save(output_file, format='PNG')
- image_cache[path] = [mtime, output_file.as_posix()]
-
- return image_cache[path][1]
-
-
-def generate_instruct_html(history):
- output = f'
"
-
- return output
-
-
-def generate_cai_chat_html(history, name1, name2, style, reset_cache=False):
- output = f'"
- return output
-
-
-def generate_chat_html(history, name1, name2, reset_cache=False):
- output = f''
-
- # We use ?name2 and ?time.time() to force the browser to reset caches
- img_bot = f'
' if Path("cache/pfp_character.png").exists() else ''
- img_me = f' if reset_cache else )
' if Path("cache/pfp_me.png").exists() else ''
-
- for i, _row in enumerate(history):
- row = [convert_to_markdown(entry) for entry in _row]
-
- if row[0]: # don't display empty user messages
- output += f"""
-
- """
-
- output += f"""
-
- """
-
- output += ""
- return output
-
-
-def chat_html_wrapper(history, name1, name2, mode, style, reset_cache=False):
- if mode == 'instruct':
- return generate_instruct_html(history['visible'])
- elif style == 'wpp':
- return generate_chat_html(history['visible'], name1, name2)
- else:
- return generate_cai_chat_html(history['visible'], name1, name2, style, reset_cache)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/urllib3/util/ssl_.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/urllib3/util/ssl_.py
deleted file mode 100644
index 2b45d391d4d7398e4769f45f9dd25eb55daef437..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/urllib3/util/ssl_.py
+++ /dev/null
@@ -1,495 +0,0 @@
-from __future__ import absolute_import
-
-import hmac
-import os
-import sys
-import warnings
-from binascii import hexlify, unhexlify
-from hashlib import md5, sha1, sha256
-
-from ..exceptions import (
- InsecurePlatformWarning,
- ProxySchemeUnsupported,
- SNIMissingWarning,
- SSLError,
-)
-from ..packages import six
-from .url import BRACELESS_IPV6_ADDRZ_RE, IPV4_RE
-
-SSLContext = None
-SSLTransport = None
-HAS_SNI = False
-IS_PYOPENSSL = False
-IS_SECURETRANSPORT = False
-ALPN_PROTOCOLS = ["http/1.1"]
-
-# Maps the length of a digest to a possible hash function producing this digest
-HASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256}
-
-
-def _const_compare_digest_backport(a, b):
- """
- Compare two digests of equal length in constant time.
-
- The digests must be of type str/bytes.
- Returns True if the digests match, and False otherwise.
- """
- result = abs(len(a) - len(b))
- for left, right in zip(bytearray(a), bytearray(b)):
- result |= left ^ right
- return result == 0
-
-
-_const_compare_digest = getattr(hmac, "compare_digest", _const_compare_digest_backport)
-
-try: # Test for SSL features
- import ssl
- from ssl import CERT_REQUIRED, wrap_socket
-except ImportError:
- pass
-
-try:
- from ssl import HAS_SNI # Has SNI?
-except ImportError:
- pass
-
-try:
- from .ssltransport import SSLTransport
-except ImportError:
- pass
-
-
-try: # Platform-specific: Python 3.6
- from ssl import PROTOCOL_TLS
-
- PROTOCOL_SSLv23 = PROTOCOL_TLS
-except ImportError:
- try:
- from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS
-
- PROTOCOL_SSLv23 = PROTOCOL_TLS
- except ImportError:
- PROTOCOL_SSLv23 = PROTOCOL_TLS = 2
-
-try:
- from ssl import PROTOCOL_TLS_CLIENT
-except ImportError:
- PROTOCOL_TLS_CLIENT = PROTOCOL_TLS
-
-
-try:
- from ssl import OP_NO_COMPRESSION, OP_NO_SSLv2, OP_NO_SSLv3
-except ImportError:
- OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000
- OP_NO_COMPRESSION = 0x20000
-
-
-try: # OP_NO_TICKET was added in Python 3.6
- from ssl import OP_NO_TICKET
-except ImportError:
- OP_NO_TICKET = 0x4000
-
-
-# A secure default.
-# Sources for more information on TLS ciphers:
-#
-# - https://wiki.mozilla.org/Security/Server_Side_TLS
-# - https://www.ssllabs.com/projects/best-practices/index.html
-# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/
-#
-# The general intent is:
-# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE),
-# - prefer ECDHE over DHE for better performance,
-# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and
-# security,
-# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common,
-# - disable NULL authentication, MD5 MACs, DSS, and other
-# insecure ciphers for security reasons.
-# - NOTE: TLS 1.3 cipher suites are managed through a different interface
-# not exposed by CPython (yet!) and are enabled by default if they're available.
-DEFAULT_CIPHERS = ":".join(
- [
- "ECDHE+AESGCM",
- "ECDHE+CHACHA20",
- "DHE+AESGCM",
- "DHE+CHACHA20",
- "ECDH+AESGCM",
- "DH+AESGCM",
- "ECDH+AES",
- "DH+AES",
- "RSA+AESGCM",
- "RSA+AES",
- "!aNULL",
- "!eNULL",
- "!MD5",
- "!DSS",
- ]
-)
-
-try:
- from ssl import SSLContext # Modern SSL?
-except ImportError:
-
- class SSLContext(object): # Platform-specific: Python 2
- def __init__(self, protocol_version):
- self.protocol = protocol_version
- # Use default values from a real SSLContext
- self.check_hostname = False
- self.verify_mode = ssl.CERT_NONE
- self.ca_certs = None
- self.options = 0
- self.certfile = None
- self.keyfile = None
- self.ciphers = None
-
- def load_cert_chain(self, certfile, keyfile):
- self.certfile = certfile
- self.keyfile = keyfile
-
- def load_verify_locations(self, cafile=None, capath=None, cadata=None):
- self.ca_certs = cafile
-
- if capath is not None:
- raise SSLError("CA directories not supported in older Pythons")
-
- if cadata is not None:
- raise SSLError("CA data not supported in older Pythons")
-
- def set_ciphers(self, cipher_suite):
- self.ciphers = cipher_suite
-
- def wrap_socket(self, socket, server_hostname=None, server_side=False):
- warnings.warn(
- "A true SSLContext object is not available. This prevents "
- "urllib3 from configuring SSL appropriately and may cause "
- "certain SSL connections to fail. You can upgrade to a newer "
- "version of Python to solve this. For more information, see "
- "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html"
- "#ssl-warnings",
- InsecurePlatformWarning,
- )
- kwargs = {
- "keyfile": self.keyfile,
- "certfile": self.certfile,
- "ca_certs": self.ca_certs,
- "cert_reqs": self.verify_mode,
- "ssl_version": self.protocol,
- "server_side": server_side,
- }
- return wrap_socket(socket, ciphers=self.ciphers, **kwargs)
-
-
-def assert_fingerprint(cert, fingerprint):
- """
- Checks if given fingerprint matches the supplied certificate.
-
- :param cert:
- Certificate as bytes object.
- :param fingerprint:
- Fingerprint as string of hexdigits, can be interspersed by colons.
- """
-
- fingerprint = fingerprint.replace(":", "").lower()
- digest_length = len(fingerprint)
- hashfunc = HASHFUNC_MAP.get(digest_length)
- if not hashfunc:
- raise SSLError("Fingerprint of invalid length: {0}".format(fingerprint))
-
- # We need encode() here for py32; works on py2 and p33.
- fingerprint_bytes = unhexlify(fingerprint.encode())
-
- cert_digest = hashfunc(cert).digest()
-
- if not _const_compare_digest(cert_digest, fingerprint_bytes):
- raise SSLError(
- 'Fingerprints did not match. Expected "{0}", got "{1}".'.format(
- fingerprint, hexlify(cert_digest)
- )
- )
-
-
-def resolve_cert_reqs(candidate):
- """
- Resolves the argument to a numeric constant, which can be passed to
- the wrap_socket function/method from the ssl module.
- Defaults to :data:`ssl.CERT_REQUIRED`.
- If given a string it is assumed to be the name of the constant in the
- :mod:`ssl` module or its abbreviation.
- (So you can specify `REQUIRED` instead of `CERT_REQUIRED`.
- If it's neither `None` nor a string we assume it is already the numeric
- constant which can directly be passed to wrap_socket.
- """
- if candidate is None:
- return CERT_REQUIRED
-
- if isinstance(candidate, str):
- res = getattr(ssl, candidate, None)
- if res is None:
- res = getattr(ssl, "CERT_" + candidate)
- return res
-
- return candidate
-
-
-def resolve_ssl_version(candidate):
- """
- like resolve_cert_reqs
- """
- if candidate is None:
- return PROTOCOL_TLS
-
- if isinstance(candidate, str):
- res = getattr(ssl, candidate, None)
- if res is None:
- res = getattr(ssl, "PROTOCOL_" + candidate)
- return res
-
- return candidate
-
-
-def create_urllib3_context(
- ssl_version=None, cert_reqs=None, options=None, ciphers=None
-):
- """All arguments have the same meaning as ``ssl_wrap_socket``.
-
- By default, this function does a lot of the same work that
- ``ssl.create_default_context`` does on Python 3.4+. It:
-
- - Disables SSLv2, SSLv3, and compression
- - Sets a restricted set of server ciphers
-
- If you wish to enable SSLv3, you can do::
-
- from pip._vendor.urllib3.util import ssl_
- context = ssl_.create_urllib3_context()
- context.options &= ~ssl_.OP_NO_SSLv3
-
- You can do the same to enable compression (substituting ``COMPRESSION``
- for ``SSLv3`` in the last line above).
-
- :param ssl_version:
- The desired protocol version to use. This will default to
- PROTOCOL_SSLv23 which will negotiate the highest protocol that both
- the server and your installation of OpenSSL support.
- :param cert_reqs:
- Whether to require the certificate verification. This defaults to
- ``ssl.CERT_REQUIRED``.
- :param options:
- Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``,
- ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``.
- :param ciphers:
- Which cipher suites to allow the server to select.
- :returns:
- Constructed SSLContext object with specified options
- :rtype: SSLContext
- """
- # PROTOCOL_TLS is deprecated in Python 3.10
- if not ssl_version or ssl_version == PROTOCOL_TLS:
- ssl_version = PROTOCOL_TLS_CLIENT
-
- context = SSLContext(ssl_version)
-
- context.set_ciphers(ciphers or DEFAULT_CIPHERS)
-
- # Setting the default here, as we may have no ssl module on import
- cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs
-
- if options is None:
- options = 0
- # SSLv2 is easily broken and is considered harmful and dangerous
- options |= OP_NO_SSLv2
- # SSLv3 has several problems and is now dangerous
- options |= OP_NO_SSLv3
- # Disable compression to prevent CRIME attacks for OpenSSL 1.0+
- # (issue #309)
- options |= OP_NO_COMPRESSION
- # TLSv1.2 only. Unless set explicitly, do not request tickets.
- # This may save some bandwidth on wire, and although the ticket is encrypted,
- # there is a risk associated with it being on wire,
- # if the server is not rotating its ticketing keys properly.
- options |= OP_NO_TICKET
-
- context.options |= options
-
- # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is
- # necessary for conditional client cert authentication with TLS 1.3.
- # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older
- # versions of Python. We only enable on Python 3.7.4+ or if certificate
- # verification is enabled to work around Python issue #37428
- # See: https://bugs.python.org/issue37428
- if (cert_reqs == ssl.CERT_REQUIRED or sys.version_info >= (3, 7, 4)) and getattr(
- context, "post_handshake_auth", None
- ) is not None:
- context.post_handshake_auth = True
-
- def disable_check_hostname():
- if (
- getattr(context, "check_hostname", None) is not None
- ): # Platform-specific: Python 3.2
- # We do our own verification, including fingerprints and alternative
- # hostnames. So disable it here
- context.check_hostname = False
-
- # The order of the below lines setting verify_mode and check_hostname
- # matter due to safe-guards SSLContext has to prevent an SSLContext with
- # check_hostname=True, verify_mode=NONE/OPTIONAL. This is made even more
- # complex because we don't know whether PROTOCOL_TLS_CLIENT will be used
- # or not so we don't know the initial state of the freshly created SSLContext.
- if cert_reqs == ssl.CERT_REQUIRED:
- context.verify_mode = cert_reqs
- disable_check_hostname()
- else:
- disable_check_hostname()
- context.verify_mode = cert_reqs
-
- # Enable logging of TLS session keys via defacto standard environment variable
- # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values.
- if hasattr(context, "keylog_filename"):
- sslkeylogfile = os.environ.get("SSLKEYLOGFILE")
- if sslkeylogfile:
- context.keylog_filename = sslkeylogfile
-
- return context
-
-
-def ssl_wrap_socket(
- sock,
- keyfile=None,
- certfile=None,
- cert_reqs=None,
- ca_certs=None,
- server_hostname=None,
- ssl_version=None,
- ciphers=None,
- ssl_context=None,
- ca_cert_dir=None,
- key_password=None,
- ca_cert_data=None,
- tls_in_tls=False,
-):
- """
- All arguments except for server_hostname, ssl_context, and ca_cert_dir have
- the same meaning as they do when using :func:`ssl.wrap_socket`.
-
- :param server_hostname:
- When SNI is supported, the expected hostname of the certificate
- :param ssl_context:
- A pre-made :class:`SSLContext` object. If none is provided, one will
- be created using :func:`create_urllib3_context`.
- :param ciphers:
- A string of ciphers we wish the client to support.
- :param ca_cert_dir:
- A directory containing CA certificates in multiple separate files, as
- supported by OpenSSL's -CApath flag or the capath argument to
- SSLContext.load_verify_locations().
- :param key_password:
- Optional password if the keyfile is encrypted.
- :param ca_cert_data:
- Optional string containing CA certificates in PEM format suitable for
- passing as the cadata parameter to SSLContext.load_verify_locations()
- :param tls_in_tls:
- Use SSLTransport to wrap the existing socket.
- """
- context = ssl_context
- if context is None:
- # Note: This branch of code and all the variables in it are no longer
- # used by urllib3 itself. We should consider deprecating and removing
- # this code.
- context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers)
-
- if ca_certs or ca_cert_dir or ca_cert_data:
- try:
- context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data)
- except (IOError, OSError) as e:
- raise SSLError(e)
-
- elif ssl_context is None and hasattr(context, "load_default_certs"):
- # try to load OS default certs; works well on Windows (require Python3.4+)
- context.load_default_certs()
-
- # Attempt to detect if we get the goofy behavior of the
- # keyfile being encrypted and OpenSSL asking for the
- # passphrase via the terminal and instead error out.
- if keyfile and key_password is None and _is_key_file_encrypted(keyfile):
- raise SSLError("Client private key is encrypted, password is required")
-
- if certfile:
- if key_password is None:
- context.load_cert_chain(certfile, keyfile)
- else:
- context.load_cert_chain(certfile, keyfile, key_password)
-
- try:
- if hasattr(context, "set_alpn_protocols"):
- context.set_alpn_protocols(ALPN_PROTOCOLS)
- except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols
- pass
-
- # If we detect server_hostname is an IP address then the SNI
- # extension should not be used according to RFC3546 Section 3.1
- use_sni_hostname = server_hostname and not is_ipaddress(server_hostname)
- # SecureTransport uses server_hostname in certificate verification.
- send_sni = (use_sni_hostname and HAS_SNI) or (
- IS_SECURETRANSPORT and server_hostname
- )
- # Do not warn the user if server_hostname is an invalid SNI hostname.
- if not HAS_SNI and use_sni_hostname:
- warnings.warn(
- "An HTTPS request has been made, but the SNI (Server Name "
- "Indication) extension to TLS is not available on this platform. "
- "This may cause the server to present an incorrect TLS "
- "certificate, which can cause validation failures. You can upgrade to "
- "a newer version of Python to solve this. For more information, see "
- "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html"
- "#ssl-warnings",
- SNIMissingWarning,
- )
-
- if send_sni:
- ssl_sock = _ssl_wrap_socket_impl(
- sock, context, tls_in_tls, server_hostname=server_hostname
- )
- else:
- ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls)
- return ssl_sock
-
-
-def is_ipaddress(hostname):
- """Detects whether the hostname given is an IPv4 or IPv6 address.
- Also detects IPv6 addresses with Zone IDs.
-
- :param str hostname: Hostname to examine.
- :return: True if the hostname is an IP address, False otherwise.
- """
- if not six.PY2 and isinstance(hostname, bytes):
- # IDN A-label bytes are ASCII compatible.
- hostname = hostname.decode("ascii")
- return bool(IPV4_RE.match(hostname) or BRACELESS_IPV6_ADDRZ_RE.match(hostname))
-
-
-def _is_key_file_encrypted(key_file):
- """Detects if a key file is encrypted or not."""
- with open(key_file, "r") as f:
- for line in f:
- # Look for Proc-Type: 4,ENCRYPTED
- if "ENCRYPTED" in line:
- return True
-
- return False
-
-
-def _ssl_wrap_socket_impl(sock, ssl_context, tls_in_tls, server_hostname=None):
- if tls_in_tls:
- if not SSLTransport:
- # Import error, ssl is not available.
- raise ProxySchemeUnsupported(
- "TLS in TLS requires support for the 'ssl' module"
- )
-
- SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context)
- return SSLTransport(sock, ssl_context, server_hostname)
-
- if server_hostname:
- return ssl_context.wrap_socket(sock, server_hostname=server_hostname)
- else:
- return ssl_context.wrap_socket(sock)
diff --git a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/exceptions.py b/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/exceptions.py
deleted file mode 100644
index a38447bb05bd5d503a32651d6046ff8667785c0c..0000000000000000000000000000000000000000
--- a/spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/exceptions.py
+++ /dev/null
@@ -1,267 +0,0 @@
-# exceptions.py
-
-import re
-import sys
-import typing
-
-from .util import col, line, lineno, _collapse_string_to_ranges
-from .unicode import pyparsing_unicode as ppu
-
-
-class ExceptionWordUnicode(ppu.Latin1, ppu.LatinA, ppu.LatinB, ppu.Greek, ppu.Cyrillic):
- pass
-
-
-_extract_alphanums = _collapse_string_to_ranges(ExceptionWordUnicode.alphanums)
-_exception_word_extractor = re.compile("([" + _extract_alphanums + "]{1,16})|.")
-
-
-class ParseBaseException(Exception):
- """base exception class for all parsing runtime exceptions"""
-
- # Performance tuning: we construct a *lot* of these, so keep this
- # constructor as small and fast as possible
- def __init__(
- self,
- pstr: str,
- loc: int = 0,
- msg: typing.Optional[str] = None,
- elem=None,
- ):
- self.loc = loc
- if msg is None:
- self.msg = pstr
- self.pstr = ""
- else:
- self.msg = msg
- self.pstr = pstr
- self.parser_element = self.parserElement = elem
- self.args = (pstr, loc, msg)
-
- @staticmethod
- def explain_exception(exc, depth=16):
- """
- Method to take an exception and translate the Python internal traceback into a list
- of the pyparsing expressions that caused the exception to be raised.
-
- Parameters:
-
- - exc - exception raised during parsing (need not be a ParseException, in support
- of Python exceptions that might be raised in a parse action)
- - depth (default=16) - number of levels back in the stack trace to list expression
- and function names; if None, the full stack trace names will be listed; if 0, only
- the failing input line, marker, and exception string will be shown
-
- Returns a multi-line string listing the ParserElements and/or function names in the
- exception's stack trace.
- """
- import inspect
- from .core import ParserElement
-
- if depth is None:
- depth = sys.getrecursionlimit()
- ret = []
- if isinstance(exc, ParseBaseException):
- ret.append(exc.line)
- ret.append(" " * (exc.column - 1) + "^")
- ret.append("{}: {}".format(type(exc).__name__, exc))
-
- if depth > 0:
- callers = inspect.getinnerframes(exc.__traceback__, context=depth)
- seen = set()
- for i, ff in enumerate(callers[-depth:]):
- frm = ff[0]
-
- f_self = frm.f_locals.get("self", None)
- if isinstance(f_self, ParserElement):
- if frm.f_code.co_name not in ("parseImpl", "_parseNoCache"):
- continue
- if id(f_self) in seen:
- continue
- seen.add(id(f_self))
-
- self_type = type(f_self)
- ret.append(
- "{}.{} - {}".format(
- self_type.__module__, self_type.__name__, f_self
- )
- )
-
- elif f_self is not None:
- self_type = type(f_self)
- ret.append("{}.{}".format(self_type.__module__, self_type.__name__))
-
- else:
- code = frm.f_code
- if code.co_name in ("wrapper", "
-Cómo superarlo Descargar gratis 2022 Uptodown: Una guía para jugadores frustrados
-¿Qué es superar con Bennett Foddy?
-conseguir sobre él descarga gratuita 2022 uptodown
- Un juego de escalada castigador
-Un homenaje al senderismo sexy
-Un comentario filosófico
-
- ¿Por qué la gente quiere jugar Getting Over It?
-Un desafío para el masoquista
-Una recompensa por la persistencia
-Un meme para internet
-¿Cómo conseguir sobre él para libre en 2022?
-El camino oficial
-
- La forma no oficial
-Los riesgos y desventajas
-Consejos y trucos para superarlo
-La práctica hace la perfección
-
- Usar afirmaciones y pensamiento positivo
-Ver carreras rápidas y guías
-Conclusión
-Preguntas frecuentes
-Question Answer ¿Cuánto tiempo se tarda en terminar el juego? La duración del juego depende de su nivel de habilidad y suerte. Algunos jugadores han terminado el juego en menos de 2 minutos, mientras que otros han pasado cientos de horas sin llegar al final. ¿Cuál es la recompensa por terminar el juego? No te lo vamos a estropear, pero digamos que hay una recompensa por terminar el juego que es único y exclusivo para cada jugador. ¿Quién es Bennett Foddy? Bennett Foddy es un desarrollador de juegos australiano y filósofo que enseña en la Universidad de Nueva York. Es conocido por crear juegos que exploran los temas de frustración, dificultad y fracaso, como QWOP, GIRP, CLOP y Getting Over It. ¿Quién es Diógenes? Diógenes es el nombre del carácter que controlas en Cómo superarlo. Lleva el nombre de Diógenes de Sinope, un antiguo filósofo griego que vivió en un barril y rechazó los valores convencionales. ¿Qué es Sexy Hiking? Sexy Hiking es un juego B de 2002 de Jazzuo que inspiró Getting Over It. Tiene un concepto similar y juego de escalar una montaña con un martillo.
-
-
\ No newline at end of file diff --git a/spaces/BetterAPI/BetterChat/src/lib/types/AbortedGeneration.ts b/spaces/BetterAPI/BetterChat/src/lib/types/AbortedGeneration.ts deleted file mode 100644 index fe4c2824b4f3257bea71c3acacd65fcee0918188..0000000000000000000000000000000000000000 --- a/spaces/BetterAPI/BetterChat/src/lib/types/AbortedGeneration.ts +++ /dev/null @@ -1,8 +0,0 @@ -// Ideally shouldn't be needed, see https://github.com/huggingface/chat-ui/pull/88#issuecomment-1523173850 - -import type { Conversation } from "./Conversation"; -import type { Timestamps } from "./Timestamps"; - -export interface AbortedGeneration extends Timestamps { - conversationId: Conversation["_id"]; -} diff --git a/spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/docs/bcdoc/restdoc.py b/spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/docs/bcdoc/restdoc.py deleted file mode 100644 index d23fcf2825197f7deca64c062f5c4c6d76911608..0000000000000000000000000000000000000000 --- a/spaces/Big-Web/MMSD/env/Lib/site-packages/botocore/docs/bcdoc/restdoc.py +++ /dev/null @@ -1,282 +0,0 @@ -# Copyright 2012-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved. -# -# Licensed under the Apache License, Version 2.0 (the "License"). You -# may not use this file except in compliance with the License. A copy of -# the License is located at -# -# http://aws.amazon.com/apache2.0/ -# -# or in the "license" file accompanying this file. This file is -# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF -# ANY KIND, either express or implied. See the License for the specific -# language governing permissions and limitations under the License. -import logging -import os -import re - -from botocore.compat import OrderedDict -from botocore.docs.bcdoc.docstringparser import DocStringParser -from botocore.docs.bcdoc.style import ReSTStyle - -DEFAULT_AWS_DOCS_LINK = 'https://docs.aws.amazon.com/index.html' -DOCUMENTATION_LINK_REGEX = re.compile( - r'`AWS API Documentation ' - r'
Created by Chukwuka [09. PyTorch Model Deployment] Tutorial by Mr. DBourke(https://www.learnpytorch.io/09_pytorch_model_deployment/).
" - - -# Create examples list from "examples/" directory -example_list = [["examples/" + example] for example in os.listdir("examples")] - -# Create the Gradio demo -demo = gr.Interface(fn=predict, # mapping function from input to output - inputs=gr.inputs.Image(type='pil'), # What are the inputs? - outputs=[gr.Label(num_top_classes=3, label="Predictions"), # what are the outputs? - gr.Number(label='Prediction time (s)')], # Our fn has two outputs, therefore we have two outputs - examples=example_list, - title=title, - description=description, - article=article - ) -# Launch the demo -print('Gradio Demo Launched') -demo.launch() diff --git a/spaces/CikeyQI/meme-api/meme_generator/memes/genshin_start/__init__.py b/spaces/CikeyQI/meme-api/meme_generator/memes/genshin_start/__init__.py deleted file mode 100644 index 507fdd22dfff4045eb99e68afbf6f747c7732b5c..0000000000000000000000000000000000000000 --- a/spaces/CikeyQI/meme-api/meme_generator/memes/genshin_start/__init__.py +++ /dev/null @@ -1,50 +0,0 @@ -from pathlib import Path -from typing import List - -from pil_utils import BuildImage - -from meme_generator import add_meme -from meme_generator.exception import TextOverLength -from meme_generator.utils import make_jpg_or_gif - -img_dir = Path(__file__).parent / "images" - - -def genshin_start(images: List[BuildImage], texts: List[str], args): - frame = BuildImage.open(img_dir / "0.png") - if texts: - text = texts[0] - try: - frame.draw_text( - (100, frame.height - 150, frame.width - 100, frame.height), - text, - max_fontsize=100, - min_fontsize=70, - fill="white", - stroke_fill="black", - stroke_ratio=0.05, - ) - except: - raise TextOverLength(text) - - def make(img: BuildImage) -> BuildImage: - points = ((0, 116), (585, 0), (584, 319), (43, 385)) - screen = ( - img.convert("RGBA").resize((600, 330), keep_ratio=True).perspective(points) - ) - return frame.copy().paste(screen, (412, 121), below=True) - - return make_jpg_or_gif(images[0], make) - - -add_meme( - "genshin_start", - genshin_start, - min_images=1, - max_images=1, - min_texts=0, - max_texts=1, - default_texts=["原神，启动！"], - keywords=["原神启动"], - patterns=[r"(\S+启动[!！]?)"], -) diff --git a/spaces/Cletrason/Cletrason-toad-mario-movie/utils (1).py b/spaces/Cletrason/Cletrason-toad-mario-movie/utils (1).py deleted file mode 100644 index b4a3f8401a1a27cc93b6c45d3b2882f256aa7864..0000000000000000000000000000000000000000 --- a/spaces/Cletrason/Cletrason-toad-mario-movie/utils (1).py +++ /dev/null @@ -1,207 +0,0 @@ -import os - -import PIL.Image -import numpy as np -import torch -import torchvision -from torchvision.transforms import Resize, InterpolationMode -import imageio -from einops import rearrange -import cv2 -from PIL import Image -from annotator.util import resize_image, HWC3 -from annotator.canny import CannyDetector -from annotator.openpose import OpenposeDetector -import decord -# decord.bridge.set_bridge('torch') - -apply_canny = CannyDetector() -apply_openpose = OpenposeDetector() - - -def add_watermark(image, watermark_path, wm_rel_size=1/16, boundary=5): - ''' - Creates a watermark on the saved inference image. - We request that you do not remove this to properly assign credit to - Shi-Lab's work. - ''' - watermark = Image.open(watermark_path) - w_0, h_0 = watermark.size - H, W, _ = image.shape - wmsize = int(max(H, W) * wm_rel_size) - aspect = h_0 / w_0 - if aspect > 1.0: - watermark = watermark.resize((wmsize, int(aspect * wmsize)), Image.LANCZOS) - else: - watermark = watermark.resize((int(wmsize / aspect), wmsize), Image.LANCZOS) - w, h = watermark.size - loc_h = H - h - boundary - loc_w = W - w - boundary - image = Image.fromarray(image) - mask = watermark if watermark.mode in ('RGBA', 'LA') else None - image.paste(watermark, (loc_w, loc_h), mask) - return image - - -def pre_process_canny(input_video, low_threshold=100, high_threshold=200): - detected_maps = [] - for frame in input_video: - img = rearrange(frame, 'c h w -> h w c').cpu().numpy().astype(np.uint8) - detected_map = apply_canny(img, low_threshold, high_threshold) - detected_map = HWC3(detected_map) - detected_maps.append(detected_map[None]) - detected_maps = np.concatenate(detected_maps) - control = torch.from_numpy(detected_maps.copy()).float() / 255.0 - return rearrange(control, 'f h w c -> f c h w') - - -def pre_process_pose(input_video, apply_pose_detect: bool = True): - detected_maps = [] - for frame in input_video: - img = rearrange(frame, 'c h w -> h w c').cpu().numpy().astype(np.uint8) - img = HWC3(img) - if apply_pose_detect: - detected_map, _ = apply_openpose(img) - else: - detected_map = img - detected_map = HWC3(detected_map) - H, W, C = img.shape - detected_map = cv2.resize(detected_map, (W, H), interpolation=cv2.INTER_NEAREST) - detected_maps.append(detected_map[None]) - detected_maps = np.concatenate(detected_maps) - control = torch.from_numpy(detected_maps.copy()).float() / 255.0 - return rearrange(control, 'f h w c -> f c h w') - - -def create_video(frames, fps, rescale=False, path=None, watermark=None): - if path is None: - dir = "temporal" - os.makedirs(dir, exist_ok=True) - path = os.path.join(dir, 'movie.mp4') - - outputs = [] - for i, x in enumerate(frames): - x = torchvision.utils.make_grid(torch.Tensor(x), nrow=4) - if rescale: - x = (x + 1.0) / 2.0 # -1,1 -> 0,1 - x = (x * 255).numpy().astype(np.uint8) - - if watermark is not None: - x = add_watermark(x, watermark) - outputs.append(x) - # imageio.imsave(os.path.join(dir, os.path.splitext(name)[0] + f'_{i}.jpg'), x) - - imageio.mimsave(path, outputs, fps=fps) - return path - -def create_gif(frames, fps, rescale=False, path=None, watermark=None): - if path is None: - dir = "temporal" - os.makedirs(dir, exist_ok=True) - path = os.path.join(dir, 'canny_db.gif') - - outputs = [] - for i, x in enumerate(frames): - x = torchvision.utils.make_grid(torch.Tensor(x), nrow=4) - if rescale: - x = (x + 1.0) / 2.0 # -1,1 -> 0,1 - x = (x * 255).numpy().astype(np.uint8) - if watermark is not None: - x = add_watermark(x, watermark) - outputs.append(x) - # imageio.imsave(os.path.join(dir, os.path.splitext(name)[0] + f'_{i}.jpg'), x) - - imageio.mimsave(path, outputs, fps=fps) - return path - -def prepare_video(video_path:str, resolution:int, device, dtype, normalize=True, start_t:float=0, end_t:float=-1, output_fps:int=-1): - vr = decord.VideoReader(video_path) - initial_fps = vr.get_avg_fps() - if output_fps == -1: - output_fps = int(initial_fps) - if end_t == -1: - end_t = len(vr) / initial_fps - else: - end_t = min(len(vr) / initial_fps, end_t) - assert 0 <= start_t < end_t - assert output_fps > 0 - start_f_ind = int(start_t * initial_fps) - end_f_ind = int(end_t * initial_fps) - num_f = int((end_t - start_t) * output_fps) - sample_idx = np.linspace(start_f_ind, end_f_ind, num_f, endpoint=False).astype(int) - video = vr.get_batch(sample_idx) - if torch.is_tensor(video): - video = video.detach().cpu().numpy() - else: - video = video.asnumpy() - _, h, w, _ = video.shape - video = rearrange(video, "f h w c -> f c h w") - video = torch.Tensor(video).to(device).to(dtype) - if h > w: - w = int(w * resolution / h) - w = w - w % 8 - h = resolution - resolution % 8 - else: - h = int(h * resolution / w) - h = h - h % 8 - w = resolution - resolution % 8 - video = Resize((h, w), interpolation=InterpolationMode.BILINEAR, antialias=True)(video) - if normalize: - video = video / 127.5 - 1.0 - return video, output_fps - - -def post_process_gif(list_of_results, image_resolution): - output_file = "/tmp/ddxk.gif" - imageio.mimsave(output_file, list_of_results, fps=4) - return output_file - - -class CrossFrameAttnProcessor: - def __init__(self, unet_chunk_size=2): - self.unet_chunk_size = unet_chunk_size - - def __call__( - self, - attn, - hidden_states, - encoder_hidden_states=None, - attention_mask=None): - batch_size, sequence_length, _ = hidden_states.shape - attention_mask = attn.prepare_attention_mask(attention_mask, sequence_length, batch_size) - query = attn.to_q(hidden_states) - - is_cross_attention = encoder_hidden_states is not None - if encoder_hidden_states is None: - encoder_hidden_states = hidden_states - elif attn.cross_attention_norm: - encoder_hidden_states = attn.norm_cross(encoder_hidden_states) - key = attn.to_k(encoder_hidden_states) - value = attn.to_v(encoder_hidden_states) - # Sparse Attention - if not is_cross_attention: - video_length = key.size()[0] // self.unet_chunk_size - # former_frame_index = torch.arange(video_length) - 1 - # former_frame_index[0] = 0 - former_frame_index = [0] * video_length - key = rearrange(key, "(b f) d c -> b f d c", f=video_length) - key = key[:, former_frame_index] - key = rearrange(key, "b f d c -> (b f) d c") - value = rearrange(value, "(b f) d c -> b f d c", f=video_length) - value = value[:, former_frame_index] - value = rearrange(value, "b f d c -> (b f) d c") - - query = attn.head_to_batch_dim(query) - key = attn.head_to_batch_dim(key) - value = attn.head_to_batch_dim(value) - - attention_probs = attn.get_attention_scores(query, key, attention_mask) - hidden_states = torch.bmm(attention_probs, value) - hidden_states = attn.batch_to_head_dim(hidden_states) - - # linear proj - hidden_states = attn.to_out[0](hidden_states) - # dropout - hidden_states = attn.to_out[1](hidden_states) - - return hidden_states diff --git a/spaces/Cong723/gpt-academic-public/docs/waifu_plugin/waifu.css b/spaces/Cong723/gpt-academic-public/docs/waifu_plugin/waifu.css deleted file mode 100644 index 42639df0794e46fc58f66e2c772e2bf9ba605eed..0000000000000000000000000000000000000000 --- a/spaces/Cong723/gpt-academic-public/docs/waifu_plugin/waifu.css +++ /dev/null @@ -1,290 +0,0 @@ -.waifu { - position: fixed; - bottom: 0; - z-index: 1; - font-size: 0; - -webkit-transform: translateY(3px); - transform: translateY(3px); -} -.waifu:hover { - -webkit-transform: translateY(0); - transform: translateY(0); -} -.waifu-tips { - opacity: 0; - margin: -20px 20px; - padding: 5px 10px; - border: 1px solid rgba(224, 186, 140, 0.62); - border-radius: 12px; - background-color: rgba(236, 217, 188, 0.5); - box-shadow: 0 3px 15px 2px rgba(191, 158, 118, 0.2); - text-overflow: ellipsis; - overflow: hidden; - position: absolute; - animation-delay: 5s; - animation-duration: 50s; - animation-iteration-count: infinite; - animation-name: shake; - animation-timing-function: ease-in-out; -} -.waifu-tool { - display: none; - color: #aaa; - top: 50px; - right: 10px; - position: absolute; -} -.waifu:hover .waifu-tool { - display: block; -} -.waifu-tool span { - display: block; - cursor: pointer; - color: #5b6c7d; - transition: 0.2s; -} -.waifu-tool span:hover { - color: #34495e; -} -.waifu #live2d{ - position: relative; -} - -@keyframes shake { - 2% { - transform: translate(0.5px, -1.5px) rotate(-0.5deg); - } - - 4% { - transform: translate(0.5px, 1.5px) rotate(1.5deg); - } - - 6% { - transform: translate(1.5px, 1.5px) rotate(1.5deg); - } - - 8% { - transform: translate(2.5px, 1.5px) rotate(0.5deg); - } - - 10% { - transform: translate(0.5px, 2.5px) rotate(0.5deg); - } - - 12% { - transform: translate(1.5px, 1.5px) rotate(0.5deg); - } - - 14% { - transform: translate(0.5px, 0.5px) rotate(0.5deg); - } - - 16% { - transform: translate(-1.5px, -0.5px) rotate(1.5deg); - } - - 18% { - transform: translate(0.5px, 0.5px) rotate(1.5deg); - } - - 20% { - transform: translate(2.5px, 2.5px) rotate(1.5deg); - } - - 22% { - transform: translate(0.5px, -1.5px) rotate(1.5deg); - } - - 24% { - transform: translate(-1.5px, 1.5px) rotate(-0.5deg); - } - - 26% { - transform: translate(1.5px, 0.5px) rotate(1.5deg); - } - - 28% { - transform: translate(-0.5px, -0.5px) rotate(-0.5deg); - } - - 30% { - transform: translate(1.5px, -0.5px) rotate(-0.5deg); - } - - 32% { - transform: translate(2.5px, -1.5px) rotate(1.5deg); - } - - 34% { - transform: translate(2.5px, 2.5px) rotate(-0.5deg); - } - - 36% { - transform: translate(0.5px, -1.5px) rotate(0.5deg); - } - - 38% { - transform: translate(2.5px, -0.5px) rotate(-0.5deg); - } - - 40% { - transform: translate(-0.5px, 2.5px) rotate(0.5deg); - } - - 42% { - transform: translate(-1.5px, 2.5px) rotate(0.5deg); - } - - 44% { - transform: translate(-1.5px, 1.5px) rotate(0.5deg); - } - - 46% { - transform: translate(1.5px, -0.5px) rotate(-0.5deg); - } - - 48% { - transform: translate(2.5px, -0.5px) rotate(0.5deg); - } - - 50% { - transform: translate(-1.5px, 1.5px) rotate(0.5deg); - } - - 52% { - transform: translate(-0.5px, 1.5px) rotate(0.5deg); - } - - 54% { - transform: translate(-1.5px, 1.5px) rotate(0.5deg); - } - - 56% { - transform: translate(0.5px, 2.5px) rotate(1.5deg); - } - - 58% { - transform: translate(2.5px, 2.5px) rotate(0.5deg); - } - - 60% { - transform: translate(2.5px, -1.5px) rotate(1.5deg); - } - - 62% { - transform: translate(-1.5px, 0.5px) rotate(1.5deg); - } - - 64% { - transform: translate(-1.5px, 1.5px) rotate(1.5deg); - } - - 66% { - transform: translate(0.5px, 2.5px) rotate(1.5deg); - } - - 68% { - transform: translate(2.5px, -1.5px) rotate(1.5deg); - } - - 70% { - transform: translate(2.5px, 2.5px) rotate(0.5deg); - } - - 72% { - transform: translate(-0.5px, -1.5px) rotate(1.5deg); - } - - 74% { - transform: translate(-1.5px, 2.5px) rotate(1.5deg); - } - - 76% { - transform: translate(-1.5px, 2.5px) rotate(1.5deg); - } - - 78% { - transform: translate(-1.5px, 2.5px) rotate(0.5deg); - } - - 80% { - transform: translate(-1.5px, 0.5px) rotate(-0.5deg); - } - - 82% { - transform: translate(-1.5px, 0.5px) rotate(-0.5deg); - } - - 84% { - transform: translate(-0.5px, 0.5px) rotate(1.5deg); - } - - 86% { - transform: translate(2.5px, 1.5px) rotate(0.5deg); - } - - 88% { - transform: translate(-1.5px, 0.5px) rotate(1.5deg); - } - - 90% { - transform: translate(-1.5px, -0.5px) rotate(-0.5deg); - } - - 92% { - transform: translate(-1.5px, -1.5px) rotate(1.5deg); - } - - 94% { - transform: translate(0.5px, 0.5px) rotate(-0.5deg); - } - - 96% { - transform: translate(2.5px, -0.5px) rotate(-0.5deg); - } - - 98% { - transform: translate(-1.5px, -1.5px) rotate(-0.5deg); - } - - 0%, 100% { - transform: translate(0, 0) rotate(0); - } -} -@font-face { - font-family: 'Flat-UI-Icons'; - src: url('flat-ui-icons-regular.eot'); - src: url('flat-ui-icons-regular.eot?#iefix') format('embedded-opentype'), url('flat-ui-icons-regular.woff') format('woff'), url('flat-ui-icons-regular.ttf') format('truetype'), url('flat-ui-icons-regular.svg#flat-ui-icons-regular') format('svg'); -} -[class^="fui-"], -[class*="fui-"] { - font-family: 'Flat-UI-Icons'; - speak: none; - font-style: normal; - font-weight: normal; - font-variant: normal; - text-transform: none; - -webkit-font-smoothing: antialiased; - -moz-osx-font-smoothing: grayscale; -} -.fui-cross:before { - content: "\e609"; -} -.fui-info-circle:before { - content: "\e60f"; -} -.fui-photo:before { - content: "\e62a"; -} -.fui-eye:before { - content: "\e62c"; -} -.fui-chat:before { - content: "\e62d"; -} -.fui-home:before { - content: "\e62e"; -} -.fui-user:before { - content: "\e631"; -} \ No newline at end of file diff --git a/spaces/CyberPeace-Institute/Cybersecurity-Knowledge-Graph-Extraction/utils.py b/spaces/CyberPeace-Institute/Cybersecurity-Knowledge-Graph-Extraction/utils.py deleted file mode 100644 index 49297c66c62fedfec8558f2c8e69846d55994713..0000000000000000000000000000000000000000 --- a/spaces/CyberPeace-Institute/Cybersecurity-Knowledge-Graph-Extraction/utils.py +++ /dev/null @@ -1,196 +0,0 @@ -list_of_pos_tags = [ - "ADJ", - "ADP", - "ADV", - "AUX", - "CCONJ", - "DET", - "INTJ", - "NOUN", - "NUM", - "PART", - "PRON", - "PROPN", - "PUNCT", - "SCONJ", - "SYM", - "VERB", - "X" -] - -realis_list = ["O", - "Generic", - "Other", - "Actual" -] - - -event_args_list = ['O', - 'B-System', - 'I-System', - 'B-Organization', - 'B-Money', - 'I-Money', - 'B-Device', - 'B-Person', - 'I-Person', - 'B-Vulnerability', - 'I-Vulnerability', - 'B-Capabilities', - 'I-Capabilities', - 'I-Organization', - 'B-PaymentMethod', - 'I-PaymentMethod', - 'B-Data', - 'I-Data', - 'B-Number', - 'I-Number', - 'B-Malware', - 'I-Malware', - 'B-PII', - 'I-PII', - 'B-CVE', - 'I-CVE', - 'B-Purpose', - 'I-Purpose', - 'B-File', - 'I-File', - 'I-Device', - 'B-Time', - 'I-Time', - 'B-Software', - 'I-Software', - 'B-Patch', - 'I-Patch', - 'B-Version', - 'I-Version', - 'B-Website', - 'I-Website', - 'B-GPE', - 'I-GPE' -] - -event_nugget_list = ['O', - 'B-Ransom', - 'I-Ransom', - 'B-DiscoverVulnerability', - 'I-DiscoverVulnerability', - 'B-PatchVulnerability', - 'I-PatchVulnerability', - 'B-Databreach', - 'I-Databreach', - 'B-Phishing', - 'I-Phishing' -] - -arg_2_role = { - "File" : ['Tool', 'Trusted-Entity'], - "Person" : ['Victim', 'Attacker', 'Discoverer', 'Releaser', 'Trusted-Entity', 'Vulnerable_System_Owner'], - "Capabilities" : ['Attack-Pattern', 'Capabilities', 'Issues-Addressed'], - "Purpose" : ['Purpose'], - "Time" : ['Time'], - "PII" : ['Compromised-Data', 'Trusted-Entity'], - "Data" : ['Compromised-Data', 'Trusted-Entity'], - "Organization" : ['Victim', 'Releaser', 'Discoverer', 'Attacker', 'Vulnerable_System_Owner', 'Trusted-Entity'], - "Patch" : ['Patch'], - "Software" : ['Vulnerable_System', 'Victim', 'Trusted-Entity', 'Supported_Platform'], - "Vulnerability" : ['Vulnerability'], - "Version" : ['Patch-Number', 'Vulnerable_System_Version'], - "Device" : ['Vulnerable_System', 'Victim', 'Supported_Platform'], - "CVE" : ['CVE'], - "Number" : ['Number-of-Data', 'Number-of-Victim'], - "System" : ['Victim', 'Supported_Platform', 'Vulnerable_System', 'Trusted-Entity'], - "Malware" : ['Tool'], - "Money" : ['Price', 'Damage-Amount'], - "PaymentMethod" : ['Payment-Method'], - "GPE" : ['Place'], - "Website" : ['Trusted-Entity', 'Tool', 'Vulnerable_System', 'Victim', 'Supported_Platform'], -} - -def get_content(data): - return data["content"] - -def get_event_nugget(data): - return [ - {"nugget" : event["nugget"], "type" : event["type"], "subtype" : event["subtype"], "realis" : event["realis"]} - for hopper in data["cyberevent"]["hopper"] for event in hopper["events"] - ] -def get_event_args(data): - events = [event for hopper in data["cyberevent"]["hopper"] for event in hopper["events"]] - args = [] - for event in events: - if "argument" in event.keys(): - args.extend(event["argument"]) - return args - -def get_idxs_from_text(text, text_tokenized): - rest_text = text - last_idx = 0 - result_dict = [] - - for substring in text_tokenized: - index = rest_text.find(substring) - result_dict.append( - { - "word" : substring, - "start_idx" : last_idx + index, - "end_idx" : last_idx + index + len(substring) - } - ) - rest_text = rest_text[index + len(substring) : ] - last_idx += index + len(substring) - return result_dict - -def get_entity_from_idx(start_idx, end_idx, event_nuggets): - event_nuggets_idxs = [(nugget["nugget"]["startOffset"], nugget["nugget"]["endOffset"]) for nugget in event_nuggets] - for idx, (nugget_start, nugget_end) in enumerate(event_nuggets_idxs): - if (start_idx == nugget_start and end_idx == nugget_end) or (start_idx == nugget_start and end_idx <= nugget_end) or (start_idx == nugget_start and end_idx > nugget_end) or (end_idx == nugget_end and start_idx < nugget_start) or (start_idx <= nugget_start and end_idx <= nugget_end and end_idx > nugget_start): - return "B-" + event_nuggets[idx]["subtype"] - elif (start_idx > nugget_start and end_idx <= nugget_end) or (start_idx > nugget_start and start_idx < nugget_end): - return "I-" + event_nuggets[idx]["subtype"] - return "O" - -def get_entity_and_realis_from_idx(start_idx, end_idx, event_nuggets): - event_nuggets_idxs = [(nugget["nugget"]["startOffset"], nugget["nugget"]["endOffset"]) for nugget in event_nuggets] - for idx, (nugget_start, nugget_end) in enumerate(event_nuggets_idxs): - if (start_idx == nugget_start and end_idx == nugget_end) or (start_idx == nugget_start and end_idx <= nugget_end) or (start_idx == nugget_start and end_idx > nugget_end) or (end_idx == nugget_end and start_idx < nugget_start) or (start_idx <= nugget_start and end_idx <= nugget_end and end_idx > nugget_start): - return "B-" + event_nuggets[idx]["subtype"], "B-" + event_nuggets[idx]["realis"] - elif (start_idx > nugget_start and end_idx <= nugget_end) or (start_idx > nugget_start and start_idx < nugget_end): - return "I-" + event_nuggets[idx]["subtype"], "I-" + event_nuggets[idx]["realis"] - return "O", "O" - -def get_args_entity_from_idx(start_idx, end_idx, event_args): - event_nuggets_idxs = [(nugget["startOffset"], nugget["endOffset"]) for nugget in event_args] - for idx, (nugget_start, nugget_end) in enumerate(event_nuggets_idxs): - if (start_idx == nugget_start and end_idx == nugget_end) or (start_idx == nugget_start and end_idx <= nugget_end) or (start_idx == nugget_start and end_idx > nugget_end) or (end_idx == nugget_end and start_idx < nugget_start) or (start_idx <= nugget_start and end_idx <= nugget_end and end_idx > nugget_start): - return "B-" + event_args[idx]["type"] - elif (start_idx > nugget_start and end_idx <= nugget_end) or (start_idx > nugget_start and start_idx < nugget_end): - return "I-" + event_args[idx]["type"] - return "O" - -def split_with_character(string, char): - result = [] - start = 0 - for i, c in enumerate(string): - if c == char: - result.append(string[start:i]) - result.append(char) - start = i + 1 - result.append(string[start:]) - return [x for x in result if x != ''] - -def extend_list_with_character(content_list, character): - content_as_words = [] - for word in content_list: - if character in word: - split_list = split_with_character(word, character) - content_as_words.extend(split_list) - else: - content_as_words.append(word) - return content_as_words - -def find_dict_by_overlap(list_of_dicts, key_value_pairs): - for dictionary in list_of_dicts: - if max(dictionary["start"], dictionary["end"]) >= min(key_value_pairs["start"], key_value_pairs["end"]) and max(key_value_pairs["start"], key_value_pairs["end"]) >= min(dictionary["start"], dictionary["end"]): - return dictionary - return None diff --git a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/__init__.py b/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/__init__.py deleted file mode 100644 index 5c7f19c6c00a4ac3f2f2bc66f892e44bcbd72612..0000000000000000000000000000000000000000 --- a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved. diff --git a/spaces/Cyril666/ContourNet-ABI/modules/model_abinet_iter.py b/spaces/Cyril666/ContourNet-ABI/modules/model_abinet_iter.py deleted file mode 100644 index 6588890570a1180ea32f7969cefd4b59c25409a7..0000000000000000000000000000000000000000 --- a/spaces/Cyril666/ContourNet-ABI/modules/model_abinet_iter.py +++ /dev/null @@ -1,34 +0,0 @@ -import torch -import torch.nn as nn -from fastai.vision import * - -from .model_vision import BaseVision -from .model_language import BCNLanguage -from .model_alignment import BaseAlignment - - -class ABINetIterModel(nn.Module): - def __init__(self, config): - super().__init__() - self.iter_size = ifnone(config.model_iter_size, 1) - self.max_length = config.dataset_max_length + 1 # additional stop token - self.vision = BaseVision(config) - self.language = BCNLanguage(config) - self.alignment = BaseAlignment(config) - - def forward(self, images, *args): - v_res = self.vision(images) - a_res = v_res - all_l_res, all_a_res = [], [] - for _ in range(self.iter_size): - tokens = torch.softmax(a_res['logits'], dim=-1) - lengths = a_res['pt_lengths'] - lengths.clamp_(2, self.max_length) # TODO:move to langauge model - l_res = self.language(tokens, lengths) - all_l_res.append(l_res) - a_res = self.alignment(l_res['feature'], v_res['feature']) - all_a_res.append(a_res) - if self.training: - return all_a_res, all_l_res, v_res - else: - return a_res, all_l_res[-1], v_res diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/payload.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/payload.py deleted file mode 100644 index 625b2eaccec79699d400ac21e768211feefc60c1..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/aiohttp/payload.py +++ /dev/null @@ -1,465 +0,0 @@ -import asyncio -import enum -import io -import json -import mimetypes -import os -import warnings -from abc import ABC, abstractmethod -from itertools import chain -from typing import ( - IO, - TYPE_CHECKING, - Any, - ByteString, - Dict, - Iterable, - Optional, - TextIO, - Tuple, - Type, - Union, -) - -from multidict import CIMultiDict - -from . import hdrs -from .abc import AbstractStreamWriter -from .helpers import ( - PY_36, - content_disposition_header, - guess_filename, - parse_mimetype, - sentinel, -) -from .streams import StreamReader -from .typedefs import Final, JSONEncoder, _CIMultiDict - -__all__ = ( - "PAYLOAD_REGISTRY", - "get_payload", - "payload_type", - "Payload", - "BytesPayload", - "StringPayload", - "IOBasePayload", - "BytesIOPayload", - "BufferedReaderPayload", - "TextIOPayload", - "StringIOPayload", - "JsonPayload", - "AsyncIterablePayload", -) - -TOO_LARGE_BYTES_BODY: Final[int] = 2**20 # 1 MB - -if TYPE_CHECKING: # pragma: no cover - from typing import List - - -class LookupError(Exception): - pass - - -class Order(str, enum.Enum): - normal = "normal" - try_first = "try_first" - try_last = "try_last" - - -def get_payload(data: Any, *args: Any, **kwargs: Any) -> "Payload": - return PAYLOAD_REGISTRY.get(data, *args, **kwargs) - - -def register_payload( - factory: Type["Payload"], type: Any, *, order: Order = Order.normal -) -> None: - PAYLOAD_REGISTRY.register(factory, type, order=order) - - -class payload_type: - def __init__(self, type: Any, *, order: Order = Order.normal) -> None: - self.type = type - self.order = order - - def __call__(self, factory: Type["Payload"]) -> Type["Payload"]: - register_payload(factory, self.type, order=self.order) - return factory - - -PayloadType = Type["Payload"] -_PayloadRegistryItem = Tuple[PayloadType, Any] - - -class PayloadRegistry: - """Payload registry. - - note: we need zope.interface for more efficient adapter search - """ - - def __init__(self) -> None: - self._first: List[_PayloadRegistryItem] = [] - self._normal: List[_PayloadRegistryItem] = [] - self._last: List[_PayloadRegistryItem] = [] - - def get( - self, - data: Any, - *args: Any, - _CHAIN: "Type[chain[_PayloadRegistryItem]]" = chain, - **kwargs: Any, - ) -> "Payload": - if isinstance(data, Payload): - return data - for factory, type in _CHAIN(self._first, self._normal, self._last): - if isinstance(data, type): - return factory(data, *args, **kwargs) - - raise LookupError() - - def register( - self, factory: PayloadType, type: Any, *, order: Order = Order.normal - ) -> None: - if order is Order.try_first: - self._first.append((factory, type)) - elif order is Order.normal: - self._normal.append((factory, type)) - elif order is Order.try_last: - self._last.append((factory, type)) - else: - raise ValueError(f"Unsupported order {order!r}") - - -class Payload(ABC): - - _default_content_type: str = "application/octet-stream" - _size: Optional[int] = None - - def __init__( - self, - value: Any, - headers: Optional[ - Union[_CIMultiDict, Dict[str, str], Iterable[Tuple[str, str]]] - ] = None, - content_type: Optional[str] = sentinel, - filename: Optional[str] = None, - encoding: Optional[str] = None, - **kwargs: Any, - ) -> None: - self._encoding = encoding - self._filename = filename - self._headers: _CIMultiDict = CIMultiDict() - self._value = value - if content_type is not sentinel and content_type is not None: - self._headers[hdrs.CONTENT_TYPE] = content_type - elif self._filename is not None: - content_type = mimetypes.guess_type(self._filename)[0] - if content_type is None: - content_type = self._default_content_type - self._headers[hdrs.CONTENT_TYPE] = content_type - else: - self._headers[hdrs.CONTENT_TYPE] = self._default_content_type - self._headers.update(headers or {}) - - @property - def size(self) -> Optional[int]: - """Size of the payload.""" - return self._size - - @property - def filename(self) -> Optional[str]: - """Filename of the payload.""" - return self._filename - - @property - def headers(self) -> _CIMultiDict: - """Custom item headers""" - return self._headers - - @property - def _binary_headers(self) -> bytes: - return ( - "".join([k + ": " + v + "\r\n" for k, v in self.headers.items()]).encode( - "utf-8" - ) - + b"\r\n" - ) - - @property - def encoding(self) -> Optional[str]: - """Payload encoding""" - return self._encoding - - @property - def content_type(self) -> str: - """Content type""" - return self._headers[hdrs.CONTENT_TYPE] - - def set_content_disposition( - self, - disptype: str, - quote_fields: bool = True, - _charset: str = "utf-8", - **params: Any, - ) -> None: - """Sets ``Content-Disposition`` header.""" - self._headers[hdrs.CONTENT_DISPOSITION] = content_disposition_header( - disptype, quote_fields=quote_fields, _charset=_charset, **params - ) - - @abstractmethod - async def write(self, writer: AbstractStreamWriter) -> None: - """Write payload. - - writer is an AbstractStreamWriter instance: - """ - - -class BytesPayload(Payload): - def __init__(self, value: ByteString, *args: Any, **kwargs: Any) -> None: - if not isinstance(value, (bytes, bytearray, memoryview)): - raise TypeError(f"value argument must be byte-ish, not {type(value)!r}") - - if "content_type" not in kwargs: - kwargs["content_type"] = "application/octet-stream" - - super().__init__(value, *args, **kwargs) - - if isinstance(value, memoryview): - self._size = value.nbytes - else: - self._size = len(value) - - if self._size > TOO_LARGE_BYTES_BODY: - if PY_36: - kwargs = {"source": self} - else: - kwargs = {} - warnings.warn( - "Sending a large body directly with raw bytes might" - " lock the event loop. You should probably pass an " - "io.BytesIO object instead", - ResourceWarning, - **kwargs, - ) - - async def write(self, writer: AbstractStreamWriter) -> None: - await writer.write(self._value) - - -class StringPayload(BytesPayload): - def __init__( - self, - value: str, - *args: Any, - encoding: Optional[str] = None, - content_type: Optional[str] = None, - **kwargs: Any, - ) -> None: - - if encoding is None: - if content_type is None: - real_encoding = "utf-8" - content_type = "text/plain; charset=utf-8" - else: - mimetype = parse_mimetype(content_type) - real_encoding = mimetype.parameters.get("charset", "utf-8") - else: - if content_type is None: - content_type = "text/plain; charset=%s" % encoding - real_encoding = encoding - - super().__init__( - value.encode(real_encoding), - encoding=real_encoding, - content_type=content_type, - *args, - **kwargs, - ) - - -class StringIOPayload(StringPayload): - def __init__(self, value: IO[str], *args: Any, **kwargs: Any) -> None: - super().__init__(value.read(), *args, **kwargs) - - -class IOBasePayload(Payload): - _value: IO[Any] - - def __init__( - self, value: IO[Any], disposition: str = "attachment", *args: Any, **kwargs: Any - ) -> None: - if "filename" not in kwargs: - kwargs["filename"] = guess_filename(value) - - super().__init__(value, *args, **kwargs) - - if self._filename is not None and disposition is not None: - if hdrs.CONTENT_DISPOSITION not in self.headers: - self.set_content_disposition(disposition, filename=self._filename) - - async def write(self, writer: AbstractStreamWriter) -> None: - loop = asyncio.get_event_loop() - try: - chunk = await loop.run_in_executor(None, self._value.read, 2**16) - while chunk: - await writer.write(chunk) - chunk = await loop.run_in_executor(None, self._value.read, 2**16) - finally: - await loop.run_in_executor(None, self._value.close) - - -class TextIOPayload(IOBasePayload): - _value: TextIO - - def __init__( - self, - value: TextIO, - *args: Any, - encoding: Optional[str] = None, - content_type: Optional[str] = None, - **kwargs: Any, - ) -> None: - - if encoding is None: - if content_type is None: - encoding = "utf-8" - content_type = "text/plain; charset=utf-8" - else: - mimetype = parse_mimetype(content_type) - encoding = mimetype.parameters.get("charset", "utf-8") - else: - if content_type is None: - content_type = "text/plain; charset=%s" % encoding - - super().__init__( - value, - content_type=content_type, - encoding=encoding, - *args, - **kwargs, - ) - - @property - def size(self) -> Optional[int]: - try: - return os.fstat(self._value.fileno()).st_size - self._value.tell() - except OSError: - return None - - async def write(self, writer: AbstractStreamWriter) -> None: - loop = asyncio.get_event_loop() - try: - chunk = await loop.run_in_executor(None, self._value.read, 2**16) - while chunk: - data = ( - chunk.encode(encoding=self._encoding) - if self._encoding - else chunk.encode() - ) - await writer.write(data) - chunk = await loop.run_in_executor(None, self._value.read, 2**16) - finally: - await loop.run_in_executor(None, self._value.close) - - -class BytesIOPayload(IOBasePayload): - @property - def size(self) -> int: - position = self._value.tell() - end = self._value.seek(0, os.SEEK_END) - self._value.seek(position) - return end - position - - -class BufferedReaderPayload(IOBasePayload): - @property - def size(self) -> Optional[int]: - try: - return os.fstat(self._value.fileno()).st_size - self._value.tell() - except OSError: - # data.fileno() is not supported, e.g. - # io.BufferedReader(io.BytesIO(b'data')) - return None - - -class JsonPayload(BytesPayload): - def __init__( - self, - value: Any, - encoding: str = "utf-8", - content_type: str = "application/json", - dumps: JSONEncoder = json.dumps, - *args: Any, - **kwargs: Any, - ) -> None: - - super().__init__( - dumps(value).encode(encoding), - content_type=content_type, - encoding=encoding, - *args, - **kwargs, - ) - - -if TYPE_CHECKING: # pragma: no cover - from typing import AsyncIterable, AsyncIterator - - _AsyncIterator = AsyncIterator[bytes] - _AsyncIterable = AsyncIterable[bytes] -else: - from collections.abc import AsyncIterable, AsyncIterator - - _AsyncIterator = AsyncIterator - _AsyncIterable = AsyncIterable - - -class AsyncIterablePayload(Payload): - - _iter: Optional[_AsyncIterator] = None - - def __init__(self, value: _AsyncIterable, *args: Any, **kwargs: Any) -> None: - if not isinstance(value, AsyncIterable): - raise TypeError( - "value argument must support " - "collections.abc.AsyncIterablebe interface, " - "got {!r}".format(type(value)) - ) - - if "content_type" not in kwargs: - kwargs["content_type"] = "application/octet-stream" - - super().__init__(value, *args, **kwargs) - - self._iter = value.__aiter__() - - async def write(self, writer: AbstractStreamWriter) -> None: - if self._iter: - try: - # iter is not None check prevents rare cases - # when the case iterable is used twice - while True: - chunk = await self._iter.__anext__() - await writer.write(chunk) - except StopAsyncIteration: - self._iter = None - - -class StreamReaderPayload(AsyncIterablePayload): - def __init__(self, value: StreamReader, *args: Any, **kwargs: Any) -> None: - super().__init__(value.iter_any(), *args, **kwargs) - - -PAYLOAD_REGISTRY = PayloadRegistry() -PAYLOAD_REGISTRY.register(BytesPayload, (bytes, bytearray, memoryview)) -PAYLOAD_REGISTRY.register(StringPayload, str) -PAYLOAD_REGISTRY.register(StringIOPayload, io.StringIO) -PAYLOAD_REGISTRY.register(TextIOPayload, io.TextIOBase) -PAYLOAD_REGISTRY.register(BytesIOPayload, io.BytesIO) -PAYLOAD_REGISTRY.register(BufferedReaderPayload, (io.BufferedReader, io.BufferedRandom)) -PAYLOAD_REGISTRY.register(IOBasePayload, io.IOBase) -PAYLOAD_REGISTRY.register(StreamReaderPayload, StreamReader) -# try_last for giving a chance to more specialized async interables like -# multidict.BodyPartReaderPayload override the default -PAYLOAD_REGISTRY.register(AsyncIterablePayload, AsyncIterable, order=Order.try_last) diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/dependencies/utils.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/dependencies/utils.py deleted file mode 100644 index e2915268c00a39f976ec493a254301618a6c93a7..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/dependencies/utils.py +++ /dev/null @@ -1,802 +0,0 @@ -import inspect -from contextlib import contextmanager -from copy import deepcopy -from typing import ( - Any, - Callable, - Coroutine, - Dict, - ForwardRef, - List, - Mapping, - Optional, - Sequence, - Tuple, - Type, - Union, - cast, -) - -import anyio -from fastapi import params -from fastapi._compat import ( - PYDANTIC_V2, - ErrorWrapper, - ModelField, - Required, - Undefined, - _regenerate_error_with_loc, - copy_field_info, - create_body_model, - evaluate_forwardref, - field_annotation_is_scalar, - get_annotation_from_field_info, - get_missing_field_error, - is_bytes_field, - is_bytes_sequence_field, - is_scalar_field, - is_scalar_sequence_field, - is_sequence_field, - is_uploadfile_or_nonable_uploadfile_annotation, - is_uploadfile_sequence_annotation, - lenient_issubclass, - sequence_types, - serialize_sequence_value, - value_is_sequence, -) -from fastapi.concurrency import ( - AsyncExitStack, - asynccontextmanager, - contextmanager_in_threadpool, -) -from fastapi.dependencies.models import Dependant, SecurityRequirement -from fastapi.logger import logger -from fastapi.security.base import SecurityBase -from fastapi.security.oauth2 import OAuth2, SecurityScopes -from fastapi.security.open_id_connect_url import OpenIdConnect -from fastapi.utils import create_response_field, get_path_param_names -from pydantic.fields import FieldInfo -from starlette.background import BackgroundTasks -from starlette.concurrency import run_in_threadpool -from starlette.datastructures import FormData, Headers, QueryParams, UploadFile -from starlette.requests import HTTPConnection, Request -from starlette.responses import Response -from starlette.websockets import WebSocket -from typing_extensions import Annotated, get_args, get_origin - -multipart_not_installed_error = ( - 'Form data requires "python-multipart" to be installed. \n' - 'You can install "python-multipart" with: \n\n' - "pip install python-multipart\n" -) -multipart_incorrect_install_error = ( - 'Form data requires "python-multipart" to be installed. ' - 'It seems you installed "multipart" instead. \n' - 'You can remove "multipart" with: \n\n' - "pip uninstall multipart\n\n" - 'And then install "python-multipart" with: \n\n' - "pip install python-multipart\n" -) - - -def check_file_field(field: ModelField) -> None: - field_info = field.field_info - if isinstance(field_info, params.Form): - try: - # __version__ is available in both multiparts, and can be mocked - from multipart import __version__ # type: ignore - - assert __version__ - try: - # parse_options_header is only available in the right multipart - from multipart.multipart import parse_options_header # type: ignore - - assert parse_options_header - except ImportError: - logger.error(multipart_incorrect_install_error) - raise RuntimeError(multipart_incorrect_install_error) from None - except ImportError: - logger.error(multipart_not_installed_error) - raise RuntimeError(multipart_not_installed_error) from None - - -def get_param_sub_dependant( - *, - param_name: str, - depends: params.Depends, - path: str, - security_scopes: Optional[List[str]] = None, -) -> Dependant: - assert depends.dependency - return get_sub_dependant( - depends=depends, - dependency=depends.dependency, - path=path, - name=param_name, - security_scopes=security_scopes, - ) - - -def get_parameterless_sub_dependant(*, depends: params.Depends, path: str) -> Dependant: - assert callable( - depends.dependency - ), "A parameter-less dependency must have a callable dependency" - return get_sub_dependant(depends=depends, dependency=depends.dependency, path=path) - - -def get_sub_dependant( - *, - depends: params.Depends, - dependency: Callable[..., Any], - path: str, - name: Optional[str] = None, - security_scopes: Optional[List[str]] = None, -) -> Dependant: - security_requirement = None - security_scopes = security_scopes or [] - if isinstance(depends, params.Security): - dependency_scopes = depends.scopes - security_scopes.extend(dependency_scopes) - if isinstance(dependency, SecurityBase): - use_scopes: List[str] = [] - if isinstance(dependency, (OAuth2, OpenIdConnect)): - use_scopes = security_scopes - security_requirement = SecurityRequirement( - security_scheme=dependency, scopes=use_scopes - ) - sub_dependant = get_dependant( - path=path, - call=dependency, - name=name, - security_scopes=security_scopes, - use_cache=depends.use_cache, - ) - if security_requirement: - sub_dependant.security_requirements.append(security_requirement) - return sub_dependant - - -CacheKey = Tuple[Optional[Callable[..., Any]], Tuple[str, ...]] - - -def get_flat_dependant( - dependant: Dependant, - *, - skip_repeats: bool = False, - visited: Optional[List[CacheKey]] = None, -) -> Dependant: - if visited is None: - visited = [] - visited.append(dependant.cache_key) - - flat_dependant = Dependant( - path_params=dependant.path_params.copy(), - query_params=dependant.query_params.copy(), - header_params=dependant.header_params.copy(), - cookie_params=dependant.cookie_params.copy(), - body_params=dependant.body_params.copy(), - security_schemes=dependant.security_requirements.copy(), - use_cache=dependant.use_cache, - path=dependant.path, - ) - for sub_dependant in dependant.dependencies: - if skip_repeats and sub_dependant.cache_key in visited: - continue - flat_sub = get_flat_dependant( - sub_dependant, skip_repeats=skip_repeats, visited=visited - ) - flat_dependant.path_params.extend(flat_sub.path_params) - flat_dependant.query_params.extend(flat_sub.query_params) - flat_dependant.header_params.extend(flat_sub.header_params) - flat_dependant.cookie_params.extend(flat_sub.cookie_params) - flat_dependant.body_params.extend(flat_sub.body_params) - flat_dependant.security_requirements.extend(flat_sub.security_requirements) - return flat_dependant - - -def get_flat_params(dependant: Dependant) -> List[ModelField]: - flat_dependant = get_flat_dependant(dependant, skip_repeats=True) - return ( - flat_dependant.path_params - + flat_dependant.query_params - + flat_dependant.header_params - + flat_dependant.cookie_params - ) - - -def get_typed_signature(call: Callable[..., Any]) -> inspect.Signature: - signature = inspect.signature(call) - globalns = getattr(call, "__globals__", {}) - typed_params = [ - inspect.Parameter( - name=param.name, - kind=param.kind, - default=param.default, - annotation=get_typed_annotation(param.annotation, globalns), - ) - for param in signature.parameters.values() - ] - typed_signature = inspect.Signature(typed_params) - return typed_signature - - -def get_typed_annotation(annotation: Any, globalns: Dict[str, Any]) -> Any: - if isinstance(annotation, str): - annotation = ForwardRef(annotation) - annotation = evaluate_forwardref(annotation, globalns, globalns) - return annotation - - -def get_typed_return_annotation(call: Callable[..., Any]) -> Any: - signature = inspect.signature(call) - annotation = signature.return_annotation - - if annotation is inspect.Signature.empty: - return None - - globalns = getattr(call, "__globals__", {}) - return get_typed_annotation(annotation, globalns) - - -def get_dependant( - *, - path: str, - call: Callable[..., Any], - name: Optional[str] = None, - security_scopes: Optional[List[str]] = None, - use_cache: bool = True, -) -> Dependant: - path_param_names = get_path_param_names(path) - endpoint_signature = get_typed_signature(call) - signature_params = endpoint_signature.parameters - dependant = Dependant( - call=call, - name=name, - path=path, - security_scopes=security_scopes, - use_cache=use_cache, - ) - for param_name, param in signature_params.items(): - is_path_param = param_name in path_param_names - type_annotation, depends, param_field = analyze_param( - param_name=param_name, - annotation=param.annotation, - value=param.default, - is_path_param=is_path_param, - ) - if depends is not None: - sub_dependant = get_param_sub_dependant( - param_name=param_name, - depends=depends, - path=path, - security_scopes=security_scopes, - ) - dependant.dependencies.append(sub_dependant) - continue - if add_non_field_param_to_dependency( - param_name=param_name, - type_annotation=type_annotation, - dependant=dependant, - ): - assert ( - param_field is None - ), f"Cannot specify multiple FastAPI annotations for {param_name!r}" - continue - assert param_field is not None - if is_body_param(param_field=param_field, is_path_param=is_path_param): - dependant.body_params.append(param_field) - else: - add_param_to_fields(field=param_field, dependant=dependant) - return dependant - - -def add_non_field_param_to_dependency( - *, param_name: str, type_annotation: Any, dependant: Dependant -) -> Optional[bool]: - if lenient_issubclass(type_annotation, Request): - dependant.request_param_name = param_name - return True - elif lenient_issubclass(type_annotation, WebSocket): - dependant.websocket_param_name = param_name - return True - elif lenient_issubclass(type_annotation, HTTPConnection): - dependant.http_connection_param_name = param_name - return True - elif lenient_issubclass(type_annotation, Response): - dependant.response_param_name = param_name - return True - elif lenient_issubclass(type_annotation, BackgroundTasks): - dependant.background_tasks_param_name = param_name - return True - elif lenient_issubclass(type_annotation, SecurityScopes): - dependant.security_scopes_param_name = param_name - return True - return None - - -def analyze_param( - *, - param_name: str, - annotation: Any, - value: Any, - is_path_param: bool, -) -> Tuple[Any, Optional[params.Depends], Optional[ModelField]]: - field_info = None - depends = None - type_annotation: Any = Any - if ( - annotation is not inspect.Signature.empty - and get_origin(annotation) is Annotated - ): - annotated_args = get_args(annotation) - type_annotation = annotated_args[0] - fastapi_annotations = [ - arg - for arg in annotated_args[1:] - if isinstance(arg, (FieldInfo, params.Depends)) - ] - assert ( - len(fastapi_annotations) <= 1 - ), f"Cannot specify multiple `Annotated` FastAPI arguments for {param_name!r}" - fastapi_annotation = next(iter(fastapi_annotations), None) - if isinstance(fastapi_annotation, FieldInfo): - # Copy `field_info` because we mutate `field_info.default` below. - field_info = copy_field_info( - field_info=fastapi_annotation, annotation=annotation - ) - assert field_info.default is Undefined or field_info.default is Required, ( - f"`{field_info.__class__.__name__}` default value cannot be set in" - f" `Annotated` for {param_name!r}. Set the default value with `=` instead." - ) - if value is not inspect.Signature.empty: - assert not is_path_param, "Path parameters cannot have default values" - field_info.default = value - else: - field_info.default = Required - elif isinstance(fastapi_annotation, params.Depends): - depends = fastapi_annotation - elif annotation is not inspect.Signature.empty: - type_annotation = annotation - - if isinstance(value, params.Depends): - assert depends is None, ( - "Cannot specify `Depends` in `Annotated` and default value" - f" together for {param_name!r}" - ) - assert field_info is None, ( - "Cannot specify a FastAPI annotation in `Annotated` and `Depends` as a" - f" default value together for {param_name!r}" - ) - depends = value - elif isinstance(value, FieldInfo): - assert field_info is None, ( - "Cannot specify FastAPI annotations in `Annotated` and default value" - f" together for {param_name!r}" - ) - field_info = value - if PYDANTIC_V2: - field_info.annotation = type_annotation - - if depends is not None and depends.dependency is None: - depends.dependency = type_annotation - - if lenient_issubclass( - type_annotation, - (Request, WebSocket, HTTPConnection, Response, BackgroundTasks, SecurityScopes), - ): - assert depends is None, f"Cannot specify `Depends` for type {type_annotation!r}" - assert ( - field_info is None - ), f"Cannot specify FastAPI annotation for type {type_annotation!r}" - elif field_info is None and depends is None: - default_value = value if value is not inspect.Signature.empty else Required - if is_path_param: - # We might check here that `default_value is Required`, but the fact is that the same - # parameter might sometimes be a path parameter and sometimes not. See - # `tests/test_infer_param_optionality.py` for an example. - field_info = params.Path(annotation=type_annotation) - elif is_uploadfile_or_nonable_uploadfile_annotation( - type_annotation - ) or is_uploadfile_sequence_annotation(type_annotation): - field_info = params.File(annotation=type_annotation, default=default_value) - elif not field_annotation_is_scalar(annotation=type_annotation): - field_info = params.Body(annotation=type_annotation, default=default_value) - else: - field_info = params.Query(annotation=type_annotation, default=default_value) - - field = None - if field_info is not None: - if is_path_param: - assert isinstance(field_info, params.Path), ( - f"Cannot use `{field_info.__class__.__name__}` for path param" - f" {param_name!r}" - ) - elif ( - isinstance(field_info, params.Param) - and getattr(field_info, "in_", None) is None - ): - field_info.in_ = params.ParamTypes.query - use_annotation = get_annotation_from_field_info( - type_annotation, - field_info, - param_name, - ) - if not field_info.alias and getattr(field_info, "convert_underscores", None): - alias = param_name.replace("_", "-") - else: - alias = field_info.alias or param_name - field_info.alias = alias - field = create_response_field( - name=param_name, - type_=use_annotation, - default=field_info.default, - alias=alias, - required=field_info.default in (Required, Undefined), - field_info=field_info, - ) - - return type_annotation, depends, field - - -def is_body_param(*, param_field: ModelField, is_path_param: bool) -> bool: - if is_path_param: - assert is_scalar_field( - field=param_field - ), "Path params must be of one of the supported types" - return False - elif is_scalar_field(field=param_field): - return False - elif isinstance( - param_field.field_info, (params.Query, params.Header) - ) and is_scalar_sequence_field(param_field): - return False - else: - assert isinstance( - param_field.field_info, params.Body - ), f"Param: {param_field.name} can only be a request body, using Body()" - return True - - -def add_param_to_fields(*, field: ModelField, dependant: Dependant) -> None: - field_info = cast(params.Param, field.field_info) - if field_info.in_ == params.ParamTypes.path: - dependant.path_params.append(field) - elif field_info.in_ == params.ParamTypes.query: - dependant.query_params.append(field) - elif field_info.in_ == params.ParamTypes.header: - dependant.header_params.append(field) - else: - assert ( - field_info.in_ == params.ParamTypes.cookie - ), f"non-body parameters must be in path, query, header or cookie: {field.name}" - dependant.cookie_params.append(field) - - -def is_coroutine_callable(call: Callable[..., Any]) -> bool: - if inspect.isroutine(call): - return inspect.iscoroutinefunction(call) - if inspect.isclass(call): - return False - dunder_call = getattr(call, "__call__", None) # noqa: B004 - return inspect.iscoroutinefunction(dunder_call) - - -def is_async_gen_callable(call: Callable[..., Any]) -> bool: - if inspect.isasyncgenfunction(call): - return True - dunder_call = getattr(call, "__call__", None) # noqa: B004 - return inspect.isasyncgenfunction(dunder_call) - - -def is_gen_callable(call: Callable[..., Any]) -> bool: - if inspect.isgeneratorfunction(call): - return True - dunder_call = getattr(call, "__call__", None) # noqa: B004 - return inspect.isgeneratorfunction(dunder_call) - - -async def solve_generator( - *, call: Callable[..., Any], stack: AsyncExitStack, sub_values: Dict[str, Any] -) -> Any: - if is_gen_callable(call): - cm = contextmanager_in_threadpool(contextmanager(call)(**sub_values)) - elif is_async_gen_callable(call): - cm = asynccontextmanager(call)(**sub_values) - return await stack.enter_async_context(cm) - - -async def solve_dependencies( - *, - request: Union[Request, WebSocket], - dependant: Dependant, - body: Optional[Union[Dict[str, Any], FormData]] = None, - background_tasks: Optional[BackgroundTasks] = None, - response: Optional[Response] = None, - dependency_overrides_provider: Optional[Any] = None, - dependency_cache: Optional[Dict[Tuple[Callable[..., Any], Tuple[str]], Any]] = None, -) -> Tuple[ - Dict[str, Any], - List[Any], - Optional[BackgroundTasks], - Response, - Dict[Tuple[Callable[..., Any], Tuple[str]], Any], -]: - values: Dict[str, Any] = {} - errors: List[Any] = [] - if response is None: - response = Response() - del response.headers["content-length"] - response.status_code = None # type: ignore - dependency_cache = dependency_cache or {} - sub_dependant: Dependant - for sub_dependant in dependant.dependencies: - sub_dependant.call = cast(Callable[..., Any], sub_dependant.call) - sub_dependant.cache_key = cast( - Tuple[Callable[..., Any], Tuple[str]], sub_dependant.cache_key - ) - call = sub_dependant.call - use_sub_dependant = sub_dependant - if ( - dependency_overrides_provider - and dependency_overrides_provider.dependency_overrides - ): - original_call = sub_dependant.call - call = getattr( - dependency_overrides_provider, "dependency_overrides", {} - ).get(original_call, original_call) - use_path: str = sub_dependant.path # type: ignore - use_sub_dependant = get_dependant( - path=use_path, - call=call, - name=sub_dependant.name, - security_scopes=sub_dependant.security_scopes, - ) - - solved_result = await solve_dependencies( - request=request, - dependant=use_sub_dependant, - body=body, - background_tasks=background_tasks, - response=response, - dependency_overrides_provider=dependency_overrides_provider, - dependency_cache=dependency_cache, - ) - ( - sub_values, - sub_errors, - background_tasks, - _, # the subdependency returns the same response we have - sub_dependency_cache, - ) = solved_result - dependency_cache.update(sub_dependency_cache) - if sub_errors: - errors.extend(sub_errors) - continue - if sub_dependant.use_cache and sub_dependant.cache_key in dependency_cache: - solved = dependency_cache[sub_dependant.cache_key] - elif is_gen_callable(call) or is_async_gen_callable(call): - stack = request.scope.get("fastapi_astack") - assert isinstance(stack, AsyncExitStack) - solved = await solve_generator( - call=call, stack=stack, sub_values=sub_values - ) - elif is_coroutine_callable(call): - solved = await call(**sub_values) - else: - solved = await run_in_threadpool(call, **sub_values) - if sub_dependant.name is not None: - values[sub_dependant.name] = solved - if sub_dependant.cache_key not in dependency_cache: - dependency_cache[sub_dependant.cache_key] = solved - path_values, path_errors = request_params_to_args( - dependant.path_params, request.path_params - ) - query_values, query_errors = request_params_to_args( - dependant.query_params, request.query_params - ) - header_values, header_errors = request_params_to_args( - dependant.header_params, request.headers - ) - cookie_values, cookie_errors = request_params_to_args( - dependant.cookie_params, request.cookies - ) - values.update(path_values) - values.update(query_values) - values.update(header_values) - values.update(cookie_values) - errors += path_errors + query_errors + header_errors + cookie_errors - if dependant.body_params: - ( - body_values, - body_errors, - ) = await request_body_to_args( # body_params checked above - required_params=dependant.body_params, received_body=body - ) - values.update(body_values) - errors.extend(body_errors) - if dependant.http_connection_param_name: - values[dependant.http_connection_param_name] = request - if dependant.request_param_name and isinstance(request, Request): - values[dependant.request_param_name] = request - elif dependant.websocket_param_name and isinstance(request, WebSocket): - values[dependant.websocket_param_name] = request - if dependant.background_tasks_param_name: - if background_tasks is None: - background_tasks = BackgroundTasks() - values[dependant.background_tasks_param_name] = background_tasks - if dependant.response_param_name: - values[dependant.response_param_name] = response - if dependant.security_scopes_param_name: - values[dependant.security_scopes_param_name] = SecurityScopes( - scopes=dependant.security_scopes - ) - return values, errors, background_tasks, response, dependency_cache - - -def request_params_to_args( - required_params: Sequence[ModelField], - received_params: Union[Mapping[str, Any], QueryParams, Headers], -) -> Tuple[Dict[str, Any], List[Any]]: - values = {} - errors = [] - for field in required_params: - if is_scalar_sequence_field(field) and isinstance( - received_params, (QueryParams, Headers) - ): - value = received_params.getlist(field.alias) or field.default - else: - value = received_params.get(field.alias) - field_info = field.field_info - assert isinstance( - field_info, params.Param - ), "Params must be subclasses of Param" - loc = (field_info.in_.value, field.alias) - if value is None: - if field.required: - errors.append(get_missing_field_error(loc=loc)) - else: - values[field.name] = deepcopy(field.default) - continue - v_, errors_ = field.validate(value, values, loc=loc) - if isinstance(errors_, ErrorWrapper): - errors.append(errors_) - elif isinstance(errors_, list): - new_errors = _regenerate_error_with_loc(errors=errors_, loc_prefix=()) - errors.extend(new_errors) - else: - values[field.name] = v_ - return values, errors - - -async def request_body_to_args( - required_params: List[ModelField], - received_body: Optional[Union[Dict[str, Any], FormData]], -) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]: - values = {} - errors: List[Dict[str, Any]] = [] - if required_params: - field = required_params[0] - field_info = field.field_info - embed = getattr(field_info, "embed", None) - field_alias_omitted = len(required_params) == 1 and not embed - if field_alias_omitted: - received_body = {field.alias: received_body} - - for field in required_params: - loc: Tuple[str, ...] - if field_alias_omitted: - loc = ("body",) - else: - loc = ("body", field.alias) - - value: Optional[Any] = None - if received_body is not None: - if (is_sequence_field(field)) and isinstance(received_body, FormData): - value = received_body.getlist(field.alias) - else: - try: - value = received_body.get(field.alias) - except AttributeError: - errors.append(get_missing_field_error(loc)) - continue - if ( - value is None - or (isinstance(field_info, params.Form) and value == "") - or ( - isinstance(field_info, params.Form) - and is_sequence_field(field) - and len(value) == 0 - ) - ): - if field.required: - errors.append(get_missing_field_error(loc)) - else: - values[field.name] = deepcopy(field.default) - continue - if ( - isinstance(field_info, params.File) - and is_bytes_field(field) - and isinstance(value, UploadFile) - ): - value = await value.read() - elif ( - is_bytes_sequence_field(field) - and isinstance(field_info, params.File) - and value_is_sequence(value) - ): - # For types - assert isinstance(value, sequence_types) # type: ignore[arg-type] - results: List[Union[bytes, str]] = [] - - async def process_fn( - fn: Callable[[], Coroutine[Any, Any, Any]] - ) -> None: - result = await fn() - results.append(result) # noqa: B023 - - async with anyio.create_task_group() as tg: - for sub_value in value: - tg.start_soon(process_fn, sub_value.read) - value = serialize_sequence_value(field=field, value=results) - - v_, errors_ = field.validate(value, values, loc=loc) - - if isinstance(errors_, list): - errors.extend(errors_) - elif errors_: - errors.append(errors_) - else: - values[field.name] = v_ - return values, errors - - -def get_body_field(*, dependant: Dependant, name: str) -> Optional[ModelField]: - flat_dependant = get_flat_dependant(dependant) - if not flat_dependant.body_params: - return None - first_param = flat_dependant.body_params[0] - field_info = first_param.field_info - embed = getattr(field_info, "embed", None) - body_param_names_set = {param.name for param in flat_dependant.body_params} - if len(body_param_names_set) == 1 and not embed: - check_file_field(first_param) - return first_param - # If one field requires to embed, all have to be embedded - # in case a sub-dependency is evaluated with a single unique body field - # That is combined (embedded) with other body fields - for param in flat_dependant.body_params: - setattr(param.field_info, "embed", True) # noqa: B010 - model_name = "Body_" + name - BodyModel = create_body_model( - fields=flat_dependant.body_params, model_name=model_name - ) - required = any(True for f in flat_dependant.body_params if f.required) - BodyFieldInfo_kwargs: Dict[str, Any] = { - "annotation": BodyModel, - "alias": "body", - } - if not required: - BodyFieldInfo_kwargs["default"] = None - if any(isinstance(f.field_info, params.File) for f in flat_dependant.body_params): - BodyFieldInfo: Type[params.Body] = params.File - elif any(isinstance(f.field_info, params.Form) for f in flat_dependant.body_params): - BodyFieldInfo = params.Form - else: - BodyFieldInfo = params.Body - - body_param_media_types = [ - f.field_info.media_type - for f in flat_dependant.body_params - if isinstance(f.field_info, params.Body) - ] - if len(set(body_param_media_types)) == 1: - BodyFieldInfo_kwargs["media_type"] = body_param_media_types[0] - final_field = create_response_field( - name="body", - type_=BodyModel, - required=required, - alias="body", - field_info=BodyFieldInfo(**BodyFieldInfo_kwargs), - ) - check_file_field(final_field) - return final_field diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/D__e_b_g.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/D__e_b_g.py deleted file mode 100644 index ff64a9b519cc3ab725b78cec6f8044aa57bdea12..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/D__e_b_g.py +++ /dev/null @@ -1,17 +0,0 @@ -import json - -from . import DefaultTable - - -class table_D__e_b_g(DefaultTable.DefaultTable): - def decompile(self, data, ttFont): - self.data = json.loads(data) - - def compile(self, ttFont): - return json.dumps(self.data).encode("utf-8") - - def toXML(self, writer, ttFont): - writer.writecdata(json.dumps(self.data)) - - def fromXML(self, name, attrs, content, ttFont): - self.data = json.loads(content) diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/implementations/reference.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/implementations/reference.py deleted file mode 100644 index c960a59f9bcdb3fc13605e044866fc3d263de959..0000000000000000000000000000000000000000 --- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fsspec/implementations/reference.py +++ /dev/null @@ -1,1080 +0,0 @@ -import base64 -import collections -import io -import itertools -import logging -import math -import os -from functools import lru_cache -from typing import TYPE_CHECKING - -import fsspec.core - -try: - import ujson as json -except ImportError: - if not TYPE_CHECKING: - import json - -from ..asyn import AsyncFileSystem -from ..callbacks import _DEFAULT_CALLBACK -from ..core import filesystem, open, split_protocol -from ..utils import isfilelike, merge_offset_ranges, other_paths - -logger = logging.getLogger("fsspec.reference") - - -class ReferenceNotReachable(RuntimeError): - def __init__(self, reference, target, *args): - super().__init__(*args) - self.reference = reference - self.target = target - - def __str__(self): - return f'Reference "{self.reference}" failed to fetch target {self.target}' - - -def _first(d): - return list(d.values())[0] - - -def _prot_in_references(path, references): - ref = references.get(path) - if isinstance(ref, (list, tuple)): - return split_protocol(ref[0])[0] if ref[0] else ref[0] - - -def _protocol_groups(paths, references): - if isinstance(paths, str): - return {_prot_in_references(paths, references): [paths]} - out = {} - for path in paths: - protocol = _prot_in_references(path, references) - out.setdefault(protocol, []).append(path) - return out - - -class RefsValuesView(collections.abc.ValuesView): - def __iter__(self): - for val in self._mapping.zmetadata.values(): - yield json.dumps(val).encode() - yield from self._mapping._items.values() - for field in self._mapping.listdir(): - chunk_sizes = self._mapping._get_chunk_sizes(field) - if len(chunk_sizes) == 0: - yield self._mapping[field + "/0"] - continue - yield from self._mapping._generate_all_records(field) - - -class RefsItemsView(collections.abc.ItemsView): - def __iter__(self): - return zip(self._mapping.keys(), self._mapping.values()) - - -def ravel_multi_index(idx, sizes): - val = 0 - mult = 1 - for i, s in zip(idx[::-1], sizes[::-1]): - val += i * mult - mult *= s - return val - - -class LazyReferenceMapper(collections.abc.MutableMapping): - """Interface to read parquet store as if it were a standard kerchunk - references dict.""" - - # import is class level to prevent numpy dep requirement for fsspec - @property - def np(self): - import numpy as np - - return np - - @property - def pd(self): - import pandas as pd - - return pd - - def __init__( - self, root, fs=None, out_root=None, cache_size=128, categorical_threshold=10 - ): - """ - Parameters - ---------- - root : str - Root of parquet store - fs : fsspec.AbstractFileSystem - fsspec filesystem object, default is local filesystem. - cache_size : int - Maximum size of LRU cache, where cache_size*record_size denotes - the total number of references that can be loaded in memory at once. - """ - self.root = root - self.chunk_sizes = {} - self._items = {} - self.dirs = None - self.fs = fsspec.filesystem("file") if fs is None else fs - with self.fs.open("/".join([self.root, ".zmetadata"]), "rb") as f: - self._items[".zmetadata"] = f.read() - met = json.loads(self._items[".zmetadata"]) - self.record_size = met["record_size"] - self.zmetadata = met["metadata"] - self.url = self.root + "/{field}/refs.{record}.parq" - self.out_root = out_root or self.root - self.cat_thresh = categorical_threshold - - # Define function to open and decompress refs - @lru_cache(maxsize=cache_size) - def open_refs(field, record): - """cached parquet file loader""" - path = self.url.format(field=field, record=record) - with self.fs.open(path) as f: - # TODO: since all we do is iterate, is arrow without pandas - # better here? - df = self.pd.read_parquet(f, engine="fastparquet") - refs = {c: df[c].values for c in df.columns} - return refs - - self.open_refs = open_refs - - @staticmethod - def create(record_size, root, fs, **kwargs): - met = {"metadata": {}, "record_size": record_size} - fs.pipe("/".join([root, ".zmetadata"]), json.dumps(met).encode()) - return LazyReferenceMapper(root, fs, **kwargs) - - def listdir(self, basename=True): - """List top-level directories""" - if self.dirs is None: - dirs = [p.split("/", 1)[0] for p in self.zmetadata] - self.dirs = set(sorted(p for p in dirs if p and not p.startswith("."))) - listing = self.dirs - if basename: - listing = [os.path.basename(path) for path in listing] - return listing - - def ls(self, path="", detail=True): - """Shortcut file listings""" - if not path: - dirnames = self.listdir() - others = set( - [".zmetadata"] - + [name for name in self.zmetadata if "/" not in name] - + [name for name in self._items if "/" not in name] - ) - if detail is False: - others.update(dirnames) - return sorted(others) - dirinfo = [ - {"name": name, "type": "directory", "size": 0} for name in dirnames - ] - fileinfo = [ - { - "name": name, - "type": "file", - "size": len( - json.dumps(self.zmetadata[name]) - if name in self.zmetadata - else self._items[name] - ), - } - for name in others - ] - return sorted(dirinfo + fileinfo, key=lambda s: s["name"]) - parts = path.split("/", 1) - if len(parts) > 1: - raise FileNotFoundError("Cannot list within directories right now") - field = parts[0] - others = set( - [name for name in self.zmetadata if name.startswith(f"{path}/")] - + [name for name in self._items if name.startswith(f"{path}/")] - ) - fileinfo = [ - { - "name": name, - "type": "file", - "size": len( - json.dumps(self.zmetadata[name]) - if name in self.zmetadata - else self._items[name] - ), - } - for name in others - ] - keys = self._keys_in_field(field) - - if detail is False: - return list(others) + list(keys) - recs = self._generate_all_records(field) - recinfo = [ - {"name": name, "type": "file", "size": rec[-1]} - for name, rec in zip(keys, recs) - if rec[0] # filters out path==None, deleted/missing - ] - return fileinfo + recinfo - - def _load_one_key(self, key): - """Get the reference for one key - - Returns bytes, one-element list or three-element list. - """ - if key in self._items: - return self._items[key] - elif key in self.zmetadata: - return json.dumps(self.zmetadata[key]).encode() - elif "/" not in key or self._is_meta(key): - raise KeyError(key) - field, sub_key = key.split("/") - record, _, _ = self._key_to_record(key) - maybe = self._items.get((field, key), {}).get(sub_key, False) - if maybe is None: - # explicitly deleted - raise KeyError - elif maybe: - return maybe - - # Chunk keys can be loaded from row group and cached in LRU cache - try: - record, ri, chunk_size = self._key_to_record(key) - if chunk_size == 0: - return b"" - refs = self.open_refs(field, record) - except (ValueError, TypeError, FileNotFoundError): - raise KeyError(key) - columns = ["path", "offset", "size", "raw"] - selection = [refs[c][ri] if c in refs else None for c in columns] - raw = selection[-1] - if raw is not None: - return raw - if selection[0] is None: - raise KeyError("This reference has been deleted") - if selection[1:3] == [0, 0]: - # URL only - return selection[:1] - # URL, offset, size - return selection[:3] - - @lru_cache(4096) - def _key_to_record(self, key): - """Details needed to construct a reference for one key""" - field, chunk = key.split("/") - chunk_sizes = self._get_chunk_sizes(field) - if len(chunk_sizes) == 0: - return 0, 0, 0 - chunk_idx = [int(c) for c in chunk.split(".")] - chunk_number = ravel_multi_index(chunk_idx, chunk_sizes) - record = chunk_number // self.record_size - ri = chunk_number % self.record_size - return record, ri, len(chunk_sizes) - - def _get_chunk_sizes(self, field): - """The number of chunks along each axis for a given field""" - if field not in self.chunk_sizes: - zarray = self.zmetadata[f"{field}/.zarray"] - size_ratio = [ - math.ceil(s / c) for s, c in zip(zarray["shape"], zarray["chunks"]) - ] - self.chunk_sizes[field] = size_ratio - return self.chunk_sizes[field] - - def _generate_record(self, field, record): - """The references for a given parquet file of a given field""" - refs = self.open_refs(field, record) - it = iter(zip(refs.values())) - if len(refs) == 3: - # All urls - return (list(t) for t in it) - elif len(refs) == 1: - # All raws - return refs["raw"] - else: - # Mix of urls and raws - return (list(t[:3]) if not t[3] else t[3] for t in it) - - def _generate_all_records(self, field): - """Load all the references within a field by iterating over the parquet files""" - nrec = 1 - for ch in self._get_chunk_sizes(field): - nrec *= ch - nrec = math.ceil(nrec / self.record_size) - for record in range(nrec): - yield from self._generate_record(field, record) - - def values(self): - return RefsValuesView(self) - - def items(self): - return RefsItemsView(self) - - def __hash__(self): - return id(self) - - @lru_cache(20) - def __getitem__(self, key): - return self._load_one_key(key) - - def __setitem__(self, key, value): - if "/" in key and not self._is_meta(key): - field, chunk = key.split("/") - record, i, _ = self._key_to_record(key) - subdict = self._items.setdefault((field, record), {}) - subdict[i] = value - if len(subdict) == self.record_size: - self.write(field, record) - else: - # metadata or top-level - self._items[key] = value - self.zmetadata[key] = json.loads( - value.decode() if isinstance(value, bytes) else value - ) - - @staticmethod - def _is_meta(key): - return key.startswith(".z") or "/.z" in key - - def __delitem__(self, key): - if key in self._items: - del self._items[key] - elif key in self.zmetadata: - del self.zmetadata[key] - else: - if "/" in key and not self._is_meta(key): - field, chunk = key.split("/") - record, _, _ = self._key_to_record(key) - subdict = self._items.setdefault((field, record), {}) - subdict[chunk] = None - if len(subdict) == self.record_size: - self.write(field, record) - else: - # metadata or top-level - self._items[key] = None - - def write(self, field, record, base_url=None, storage_options=None): - # extra requirements if writing - import kerchunk.df - import numpy as np - import pandas as pd - - # TODO: if the dict is incomplete, also load records and merge in - partition = self._items[(field, record)] - fn = f"{base_url or self.out_root}/{field}/refs.{record}.parq" - - #### - paths = np.full(self.record_size, np.nan, dtype="O") - offsets = np.zeros(self.record_size, dtype="int64") - sizes = np.zeros(self.record_size, dtype="int64") - raws = np.full(self.record_size, np.nan, dtype="O") - nraw = 0 - npath = 0 - for j, data in partition.items(): - if isinstance(data, list): - npath += 1 - paths[j] = data[0] - if len(data) > 1: - offsets[j] = data[1] - sizes[j] = data[2] - else: - nraw += 1 - raws[j] = kerchunk.df._proc_raw(data) - # TODO: only save needed columns - df = pd.DataFrame( - dict( - path=paths, - offset=offsets, - size=sizes, - raw=raws, - ), - copy=False, - ) - if df.path.count() / (df.path.nunique() or 1) > self.cat_thresh: - df["path"] = df["path"].astype("category") - object_encoding = dict(raw="bytes", path="utf8") - has_nulls = ["path", "raw"] - - self.fs.mkdirs(f"{base_url or self.out_root}/{field}", exist_ok=True) - df.to_parquet( - fn, - engine="fastparquet", - storage_options=storage_options - or getattr(self.fs, "storage_options", None), - compression="zstd", - index=False, - stats=False, - object_encoding=object_encoding, - has_nulls=has_nulls, - # **kwargs, - ) - partition.clear() - self._items.pop((field, record)) - - def flush(self, base_url=None, storage_options=None): - """Output any modified or deleted keys - - Parameters - ---------- - base_url: str - Location of the output - """ - # write what we have so far and clear sub chunks - for thing in list(self._items): - if isinstance(thing, tuple): - field, record = thing - self.write( - field, - record, - base_url=base_url, - storage_options=storage_options, - ) - - # gather .zmetadata from self._items and write that too - for k in list(self._items): - if k != ".zmetadata" and ".z" in k: - self.zmetadata[k] = json.loads(self._items.pop(k)) - met = {"metadata": self.zmetadata, "record_size": self.record_size} - self._items[".zmetadata"] = json.dumps(met).encode() - self.fs.pipe( - "/".join([base_url or self.out_root, ".zmetadata"]), - self._items[".zmetadata"], - ) - - # TODO: only clear those that we wrote to? - self.open_refs.cache_clear() - - def __len__(self): - # Caveat: This counts expected references, not actual - count = 0 - for field in self.listdir(): - if field.startswith("."): - count += 1 - else: - chunk_sizes = self._get_chunk_sizes(field) - nchunks = self.np.product(chunk_sizes) - count += nchunks - count += len(self.zmetadata) # all metadata keys - count += len(self._items) # the metadata file itself - return count - - def __iter__(self): - # Caveat: Note that this generates all expected keys, but does not - # account for reference keys that are missing. - metas = set(self.zmetadata) - metas.update(self._items) - for bit in metas: - if isinstance(bit, str): - yield bit - for field in self.listdir(): - yield from self._keys_in_field(field) - - def __contains__(self, item): - try: - self._load_one_key(item) - return True - except KeyError: - return False - - def _keys_in_field(self, field): - """List key names in given field - - Produces strings like "field/x.y" appropriate from the chunking of the array - """ - chunk_sizes = self._get_chunk_sizes(field) - if len(chunk_sizes) == 0: - yield field + "/0" - return - inds = itertools.product(*(range(i) for i in chunk_sizes)) - for ind in inds: - yield field + "/" + ".".join([str(c) for c in ind]) - - -class ReferenceFileSystem(AsyncFileSystem): - """View byte ranges of some other file as a file system - Initial version: single file system target, which must support - async, and must allow start and end args in _cat_file. Later versions - may allow multiple arbitrary URLs for the targets. - This FileSystem is read-only. It is designed to be used with async - targets (for now). This FileSystem only allows whole-file access, no - ``open``. We do not get original file details from the target FS. - Configuration is by passing a dict of references at init, or a URL to - a JSON file containing the same; this dict - can also contain concrete data for some set of paths. - Reference dict format: - {path0: bytes_data, path1: (target_url, offset, size)} - https://github.com/fsspec/kerchunk/blob/main/README.md - """ - - protocol = "reference" - - def __init__( - self, - fo, - target=None, - ref_storage_args=None, - target_protocol=None, - target_options=None, - remote_protocol=None, - remote_options=None, - fs=None, - template_overrides=None, - simple_templates=True, - max_gap=64_000, - max_block=256_000_000, - cache_size=128, - **kwargs, - ): - """ - Parameters - ---------- - fo : dict or str - The set of references to use for this instance, with a structure as above. - If str referencing a JSON file, will use fsspec.open, in conjunction - with target_options and target_protocol to open and parse JSON at this - location. If a directory, then assume references are a set of parquet - files to be loaded lazily. - target : str - For any references having target_url as None, this is the default file - target to use - ref_storage_args : dict - If references is a str, use these kwargs for loading the JSON file. - Deprecated: use target_options instead. - target_protocol : str - Used for loading the reference file, if it is a path. If None, protocol - will be derived from the given path - target_options : dict - Extra FS options for loading the reference file ``fo``, if given as a path - remote_protocol : str - The protocol of the filesystem on which the references will be evaluated - (unless fs is provided). If not given, will be derived from the first - URL that has a protocol in the templates or in the references, in that - order. - remote_options : dict - kwargs to go with remote_protocol - fs : AbstractFileSystem | dict(str, (AbstractFileSystem | dict)) - Directly provide a file system(s): - - a single filesystem instance - - a dict of protocol:filesystem, where each value is either a filesystem - instance, or a dict of kwargs that can be used to create in - instance for the given protocol - - If this is given, remote_options and remote_protocol are ignored. - template_overrides : dict - Swap out any templates in the references file with these - useful for - testing. - simple_templates: bool - Whether templates can be processed with simple replace (True) or if - jinja is needed (False, much slower). All reference sets produced by - ``kerchunk`` are simple in this sense, but the spec allows for complex. - max_gap, max_block: int - For merging multiple concurrent requests to the same remote file. - Neighboring byte ranges will only be merged when their - inter-range gap is <= ``max_gap``. Default is 64KB. Set to 0 - to only merge when it requires no extra bytes. Pass a negative - number to disable merging, appropriate for local target files. - Neighboring byte ranges will only be merged when the size of - the aggregated range is <= ``max_block``. Default is 256MB. - cache_size : int - Maximum size of LRU cache, where cache_size*record_size denotes - the total number of references that can be loaded in memory at once. - Only used for lazily loaded references. - kwargs : passed to parent class - """ - super().__init__(**kwargs) - self.target = target - self.template_overrides = template_overrides - self.simple_templates = simple_templates - self.templates = {} - self.fss = {} - self._dircache = {} - self.max_gap = max_gap - self.max_block = max_block - if isinstance(fo, str): - dic = dict( - **(ref_storage_args or target_options or {}), protocol=target_protocol - ) - ref_fs, fo2 = fsspec.core.url_to_fs(fo, **dic) - if ref_fs.isfile(fo): - # text JSON - with fsspec.open(fo, "rb", **dic) as f: - logger.info("Read reference from URL %s", fo) - text = json.load(f) - self._process_references(text, template_overrides) - else: - # Lazy parquet refs - logger.info("Open lazy reference dict from URL %s", fo) - self.references = LazyReferenceMapper( - fo2, - fs=ref_fs, - cache_size=cache_size, - ) - else: - # dictionaries - self._process_references(fo, template_overrides) - if isinstance(fs, dict): - self.fss = { - k: ( - fsspec.filesystem(k.split(":", 1)[0], **opts) - if isinstance(opts, dict) - else opts - ) - for k, opts in fs.items() - } - if None not in self.fss: - self.fss[None] = filesystem("file") - return - if fs is not None: - # single remote FS - remote_protocol = ( - fs.protocol[0] if isinstance(fs.protocol, tuple) else fs.protocol - ) - self.fss[remote_protocol] = fs - - if remote_protocol is None: - # get single protocol from any templates - for ref in self.templates.values(): - if callable(ref): - ref = ref() - protocol, _ = fsspec.core.split_protocol(ref) - if protocol and protocol not in self.fss: - fs = filesystem(protocol, **(remote_options or {})) - self.fss[protocol] = fs - if remote_protocol is None: - # get single protocol from references - for ref in self.references.values(): - if callable(ref): - ref = ref() - if isinstance(ref, list) and ref[0]: - protocol, _ = fsspec.core.split_protocol(ref[0]) - if protocol not in self.fss: - fs = filesystem(protocol, **(remote_options or {})) - self.fss[protocol] = fs - # only use first remote URL - break - - if remote_protocol and remote_protocol not in self.fss: - fs = filesystem(remote_protocol, **(remote_options or {})) - self.fss[remote_protocol] = fs - - self.fss[None] = fs or filesystem("file") # default one - - def _cat_common(self, path, start=None, end=None): - path = self._strip_protocol(path) - logger.debug(f"cat: {path}") - try: - part = self.references[path] - except KeyError: - raise FileNotFoundError(path) - if isinstance(part, str): - part = part.encode() - if isinstance(part, bytes): - logger.debug(f"Reference: {path}, type bytes") - if part.startswith(b"base64:"): - part = base64.b64decode(part[7:]) - return part, None, None - - if len(part) == 1: - logger.debug(f"Reference: {path}, whole file => {part}") - url = part[0] - start1, end1 = start, end - else: - url, start0, size = part - logger.debug(f"Reference: {path} => {url}, offset {start0}, size {size}") - end0 = start0 + size - - if start is not None: - if start >= 0: - start1 = start0 + start - else: - start1 = end0 + start - else: - start1 = start0 - if end is not None: - if end >= 0: - end1 = start0 + end - else: - end1 = end0 + end - else: - end1 = end0 - if url is None: - url = self.target - return url, start1, end1 - - async def _cat_file(self, path, start=None, end=None, **kwargs): - part_or_url, start0, end0 = self._cat_common(path, start=start, end=end) - if isinstance(part_or_url, bytes): - return part_or_url[start:end] - protocol, _ = split_protocol(part_or_url) - try: - await self.fss[protocol]._cat_file(part_or_url, start=start, end=end) - except Exception as e: - raise ReferenceNotReachable(path, part_or_url) from e - - def cat_file(self, path, start=None, end=None, **kwargs): - part_or_url, start0, end0 = self._cat_common(path, start=start, end=end) - if isinstance(part_or_url, bytes): - return part_or_url[start:end] - protocol, _ = split_protocol(part_or_url) - try: - return self.fss[protocol].cat_file(part_or_url, start=start0, end=end0) - except Exception as e: - raise ReferenceNotReachable(path, part_or_url) from e - - def pipe_file(self, path, value, **_): - """Temporarily add binary data or reference as a file""" - self.references[path] = value - - async def _get_file(self, rpath, lpath, **kwargs): - if self.isdir(rpath): - return os.makedirs(lpath, exist_ok=True) - data = await self._cat_file(rpath) - with open(lpath, "wb") as f: - f.write(data) - - def get_file(self, rpath, lpath, callback=_DEFAULT_CALLBACK, **kwargs): - if self.isdir(rpath): - return os.makedirs(lpath, exist_ok=True) - data = self.cat_file(rpath, **kwargs) - callback.set_size(len(data)) - if isfilelike(lpath): - lpath.write(data) - else: - with open(lpath, "wb") as f: - f.write(data) - callback.absolute_update(len(data)) - - def get(self, rpath, lpath, recursive=False, **kwargs): - if recursive: - # trigger directory build - self.ls("") - rpath = self.expand_path(rpath, recursive=recursive) - fs = fsspec.filesystem("file", auto_mkdir=True) - targets = other_paths(rpath, lpath) - if recursive: - data = self.cat([r for r in rpath if not self.isdir(r)]) - else: - data = self.cat(rpath) - for remote, local in zip(rpath, targets): - if remote in data: - fs.pipe_file(local, data[remote]) - - def cat(self, path, recursive=False, on_error="raise", **kwargs): - if isinstance(path, str) and recursive: - raise NotImplementedError - if isinstance(path, list) and (recursive or any("*" in p for p in path)): - raise NotImplementedError - proto_dict = _protocol_groups(path, self.references) - out = {} - for proto, paths in proto_dict.items(): - fs = self.fss[proto] - urls, starts, ends = [], [], [] - for p in paths: - # find references or label not-found. Early exit if any not - # found and on_error is "raise" - try: - u, s, e = self._cat_common(p) - urls.append(u) - starts.append(s) - ends.append(e) - except FileNotFoundError as err: - if on_error == "raise": - raise - if on_error != "omit": - out[p] = err - - # process references into form for merging - urls2 = [] - starts2 = [] - ends2 = [] - paths2 = [] - whole_files = set() - for u, s, e, p in zip(urls, starts, ends, paths): - if isinstance(u, bytes): - # data - out[p] = u - elif s is None: - # whole file - limits are None, None, but no further - # entries take for this file - whole_files.add(u) - urls2.append(u) - starts2.append(s) - ends2.append(e) - paths2.append(p) - for u, s, e, p in zip(urls, starts, ends, paths): - # second run to account for files that are to be loaded whole - if s is not None and u not in whole_files: - urls2.append(u) - starts2.append(s) - ends2.append(e) - paths2.append(p) - - # merge and fetch consolidated ranges - new_paths, new_starts, new_ends = merge_offset_ranges( - list(urls2), - list(starts2), - list(ends2), - sort=True, - max_gap=self.max_gap, - max_block=self.max_block, - ) - bytes_out = fs.cat_ranges(new_paths, new_starts, new_ends) - - # unbundle from merged bytes - simple approach - for u, s, e, p in zip(urls, starts, ends, paths): - if p in out: - continue # was bytes, already handled - for np, ns, ne, b in zip(new_paths, new_starts, new_ends, bytes_out): - if np == u and (ns is None or ne is None): - if isinstance(b, Exception): - out[p] = b - else: - out[p] = b[s:e] - elif np == u and s >= ns and e <= ne: - if isinstance(b, Exception): - out[p] = b - else: - out[p] = b[s - ns : (e - ne) or None] - - for k, v in out.copy().items(): - # these were valid references, but fetch failed, so transform exc - if isinstance(v, Exception) and k in self.references: - ex = out[k] - new_ex = ReferenceNotReachable(k, self.references[k]) - new_ex.__cause__ = ex - if on_error == "raise": - raise new_ex - elif on_error != "omit": - out[k] = new_ex - - if len(out) == 1 and isinstance(path, str) and "*" not in path: - return _first(out) - return out - - def _process_references(self, references, template_overrides=None): - vers = references.get("version", None) - if vers is None: - self._process_references0(references) - elif vers == 1: - self._process_references1(references, template_overrides=template_overrides) - else: - raise ValueError(f"Unknown reference spec version: {vers}") - # TODO: we make dircache by iterating over all entries, but for Spec >= 1, - # can replace with programmatic. Is it even needed for mapper interface? - - def _process_references0(self, references): - """Make reference dict for Spec Version 0""" - self.references = references - - def _process_references1(self, references, template_overrides=None): - if not self.simple_templates or self.templates: - import jinja2 - self.references = {} - self._process_templates(references.get("templates", {})) - - @lru_cache(1000) - def _render_jinja(u): - return jinja2.Template(u).render(**self.templates) - - for k, v in references.get("refs", {}).items(): - if isinstance(v, str): - if v.startswith("base64:"): - self.references[k] = base64.b64decode(v[7:]) - self.references[k] = v - elif self.templates: - u = v[0] - if "{{" in u: - if self.simple_templates: - u = ( - u.replace("{{", "{") - .replace("}}", "}") - .format(**self.templates) - ) - else: - u = _render_jinja(u) - self.references[k] = [u] if len(v) == 1 else [u, v[1], v[2]] - else: - self.references[k] = v - self.references.update(self._process_gen(references.get("gen", []))) - - def _process_templates(self, tmp): - self.templates = {} - if self.template_overrides is not None: - tmp.update(self.template_overrides) - for k, v in tmp.items(): - if "{{" in v: - import jinja2 - - self.templates[k] = lambda temp=v, **kwargs: jinja2.Template( - temp - ).render(**kwargs) - else: - self.templates[k] = v - - def _process_gen(self, gens): - out = {} - for gen in gens: - dimension = { - k: v - if isinstance(v, list) - else range(v.get("start", 0), v["stop"], v.get("step", 1)) - for k, v in gen["dimensions"].items() - } - products = ( - dict(zip(dimension.keys(), values)) - for values in itertools.product(*dimension.values()) - ) - for pr in products: - import jinja2 - - key = jinja2.Template(gen["key"]).render(**pr, **self.templates) - url = jinja2.Template(gen["url"]).render(**pr, **self.templates) - if ("offset" in gen) and ("length" in gen): - offset = int( - jinja2.Template(gen["offset"]).render(**pr, **self.templates) - ) - length = int( - jinja2.Template(gen["length"]).render(**pr, **self.templates) - ) - out[key] = [url, offset, length] - elif ("offset" in gen) ^ ("length" in gen): - raise ValueError( - "Both 'offset' and 'length' are required for a " - "reference generator entry if either is provided." - ) - else: - out[key] = [url] - return out - - def _dircache_from_items(self): - self.dircache = {"": []} - it = self.references.items() - for path, part in it: - if isinstance(part, (bytes, str)): - size = len(part) - elif len(part) == 1: - size = None - else: - _, start, size = part - par = path.rsplit("/", 1)[0] if "/" in path else "" - par0 = par - while par0 and par0 not in self.dircache: - # build parent directories - self.dircache[par0] = [] - self.dircache.setdefault( - par0.rsplit("/", 1)[0] if "/" in par0 else "", [] - ).append({"name": par0, "type": "directory", "size": 0}) - par0 = self._parent(par0) - - self.dircache[par].append({"name": path, "type": "file", "size": size}) - - def _open(self, path, mode="rb", block_size=None, cache_options=None, **kwargs): - data = self.cat_file(path) # load whole chunk into memory - return io.BytesIO(data) - - def ls(self, path, detail=True, **kwargs): - path = self._strip_protocol(path) - if isinstance(self.references, LazyReferenceMapper): - try: - return self.references.ls(path, detail) - except KeyError: - pass - raise FileNotFoundError(f"'{path}' is not a known key") - if not self.dircache: - self._dircache_from_items() - out = self._ls_from_cache(path) - if out is None: - raise FileNotFoundError(path) - if detail: - return out - return [o["name"] for o in out] - - def exists(self, path, **kwargs): # overwrite auto-sync version - return self.isdir(path) or self.isfile(path) - - def isdir(self, path): # overwrite auto-sync version - if self.dircache: - return path in self.dircache - elif isinstance(self.references, LazyReferenceMapper): - return path in self.references.listdir("") - else: - # this may be faster than building dircache for single calls, but - # by looping will be slow for many calls; could cache it? - return any(_.startswith(f"{path}/") for _ in self.references) - - def isfile(self, path): # overwrite auto-sync version - return path in self.references - - async def _ls(self, path, detail=True, **kwargs): # calls fast sync code - return self.ls(path, detail, **kwargs) - - def find(self, path, maxdepth=None, withdirs=False, detail=False, **kwargs): - if withdirs: - return super().find( - path, maxdepth=maxdepth, withdirs=withdirs, detail=detail, **kwargs - ) - if path: - path = self._strip_protocol(path) - r = sorted(k for k in self.references if k.startswith(path)) - else: - r = sorted(self.references) - if detail: - if not self.dircache: - self._dircache_from_items() - return {k: self._ls_from_cache(k)[0] for k in r} - else: - return r - - def info(self, path, **kwargs): - out = self.references.get(path) - if out is not None: - if isinstance(out, (str, bytes)): - # decode base64 here - return {"name": path, "type": "file", "size": len(out)} - elif len(out) > 1: - return {"name": path, "type": "file", "size": out[2]} - else: - out0 = [{"name": path, "type": "file", "size": None}] - else: - out = self.ls(path, True) - out0 = [o for o in out if o["name"] == path] - if not out0: - return {"name": path, "type": "directory", "size": 0} - if out0[0]["size"] is None: - # if this is a whole remote file, update size using remote FS - prot, _ = split_protocol(self.references[path][0]) - out0[0]["size"] = self.fss[prot].size(self.references[path][0]) - return out0[0] - - async def _info(self, path, **kwargs): # calls fast sync code - return self.info(path) - - async def _rm_file(self, path, **kwargs): - self.references.pop( - path, None - ) # ignores FileNotFound, just as well for directories - self.dircache.clear() # this is a bit heavy handed - - async def _pipe_file(self, path, data): - # can be str or bytes - self.references[path] = data - self.dircache.clear() # this is a bit heavy handed - - async def _put_file(self, lpath, rpath): - # puts binary - with open(lpath, "rb") as f: - self.references[rpath] = f.read() - self.dircache.clear() # this is a bit heavy handed - - def save_json(self, url, **storage_options): - """Write modified references into new location""" - out = {} - for k, v in self.references.items(): - if isinstance(v, bytes): - try: - out[k] = v.decode("ascii") - except UnicodeDecodeError: - out[k] = (b"base64:" + base64.b64encode(v)).decode() - else: - out[k] = v - with fsspec.open(url, "wb", **storage_options) as f: - f.write(json.dumps({"version": 1, "refs": out}).encode()) diff --git a/spaces/Dorado607/ChuanhuChatGPT/modules/models/minimax.py b/spaces/Dorado607/ChuanhuChatGPT/modules/models/minimax.py deleted file mode 100644 index 2e1b50280fd2fbc43a69caaf660a0d64beaa405b..0000000000000000000000000000000000000000 --- a/spaces/Dorado607/ChuanhuChatGPT/modules/models/minimax.py +++ /dev/null @@ -1,161 +0,0 @@ -import json -import os - -import colorama -import requests -import logging - -from modules.models.base_model import BaseLLMModel -from modules.presets import STANDARD_ERROR_MSG, GENERAL_ERROR_MSG, TIMEOUT_STREAMING, TIMEOUT_ALL, i18n - -group_id = os.environ.get("MINIMAX_GROUP_ID", "") - - -class MiniMax_Client(BaseLLMModel): - """ - MiniMax Client - 接口文档见 https://api.minimax.chat/document/guides/chat - """ - - def __init__(self, model_name, api_key, user_name="", system_prompt=None): - super().__init__(model_name=model_name, user=user_name) - self.url = f'https://api.minimax.chat/v1/text/chatcompletion?GroupId={group_id}' - self.history = [] - self.api_key = api_key - self.system_prompt = system_prompt - self.headers = { - "Authorization": f"Bearer {api_key}", - "Content-Type": "application/json" - } - - def get_answer_at_once(self): - # minimax temperature is (0,1] and base model temperature is [0,2], and yuan 0.9 == base 1 so need to convert - temperature = self.temperature * 0.9 if self.temperature <= 1 else 0.9 + (self.temperature - 1) / 10 - - request_body = { - "model": self.model_name.replace('minimax-', ''), - "temperature": temperature, - "skip_info_mask": True, - 'messages': [{"sender_type": "USER", "text": self.history[-1]['content']}] - } - if self.n_choices: - request_body['beam_width'] = self.n_choices - if self.system_prompt: - request_body['prompt'] = self.system_prompt - if self.max_generation_token: - request_body['tokens_to_generate'] = self.max_generation_token - if self.top_p: - request_body['top_p'] = self.top_p - - response = requests.post(self.url, headers=self.headers, json=request_body) - - res = response.json() - answer = res['reply'] - total_token_count = res["usage"]["total_tokens"] - return answer, total_token_count - - def get_answer_stream_iter(self): - response = self._get_response(stream=True) - if response is not None: - iter = self._decode_chat_response(response) - partial_text = "" - for i in iter: - partial_text += i - yield partial_text - else: - yield STANDARD_ERROR_MSG + GENERAL_ERROR_MSG - - def _get_response(self, stream=False): - minimax_api_key = self.api_key - history = self.history - logging.debug(colorama.Fore.YELLOW + - f"{history}" + colorama.Fore.RESET) - headers = { - "Content-Type": "application/json", - "Authorization": f"Bearer {minimax_api_key}", - } - - temperature = self.temperature * 0.9 if self.temperature <= 1 else 0.9 + (self.temperature - 1) / 10 - - messages = [] - for msg in self.history: - if msg['role'] == 'user': - messages.append({"sender_type": "USER", "text": msg['content']}) - else: - messages.append({"sender_type": "BOT", "text": msg['content']}) - - request_body = { - "model": self.model_name.replace('minimax-', ''), - "temperature": temperature, - "skip_info_mask": True, - 'messages': messages - } - if self.n_choices: - request_body['beam_width'] = self.n_choices - if self.system_prompt: - lines = self.system_prompt.splitlines() - if lines[0].find(":") != -1 and len(lines[0]) < 20: - request_body["role_meta"] = { - "user_name": lines[0].split(":")[0], - "bot_name": lines[0].split(":")[1] - } - lines.pop() - request_body["prompt"] = "\n".join(lines) - if self.max_generation_token: - request_body['tokens_to_generate'] = self.max_generation_token - else: - request_body['tokens_to_generate'] = 512 - if self.top_p: - request_body['top_p'] = self.top_p - - if stream: - timeout = TIMEOUT_STREAMING - request_body['stream'] = True - request_body['use_standard_sse'] = True - else: - timeout = TIMEOUT_ALL - try: - response = requests.post( - self.url, - headers=headers, - json=request_body, - stream=stream, - timeout=timeout, - ) - except: - return None - - return response - - def _decode_chat_response(self, response): - error_msg = "" - for chunk in response.iter_lines(): - if chunk: - chunk = chunk.decode() - chunk_length = len(chunk) - print(chunk) - try: - chunk = json.loads(chunk[6:]) - except json.JSONDecodeError: - print(i18n("JSON解析错误,收到的内容: ") + f"{chunk}") - error_msg += chunk - continue - if chunk_length > 6 and "delta" in chunk["choices"][0]: - if "finish_reason" in chunk["choices"][0] and chunk["choices"][0]["finish_reason"] == "stop": - self.all_token_counts.append(chunk["usage"]["total_tokens"] - sum(self.all_token_counts)) - break - try: - yield chunk["choices"][0]["delta"] - except Exception as e: - logging.error(f"Error: {e}") - continue - if error_msg: - try: - error_msg = json.loads(error_msg) - if 'base_resp' in error_msg: - status_code = error_msg['base_resp']['status_code'] - status_msg = error_msg['base_resp']['status_msg'] - raise Exception(f"{status_code} - {status_msg}") - except json.JSONDecodeError: - pass - raise Exception(error_msg) diff --git a/spaces/DragGan/DragGan/stylegan_human/__init__.py b/spaces/DragGan/DragGan/stylegan_human/__init__.py deleted file mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000 diff --git a/spaces/DrishtiSharma/Image-search-using-CLIP/README.md b/spaces/DrishtiSharma/Image-search-using-CLIP/README.md deleted file mode 100644 index 01c6e3c80b3e340de56732ae64e98ba2cdc6f6dc..0000000000000000000000000000000000000000 --- a/spaces/DrishtiSharma/Image-search-using-CLIP/README.md +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Image Search Using CLIP -emoji: 🏢 -colorFrom: blue -colorTo: purple -sdk: gradio -app_file: app.py -pinned: false ---- - -# Configuration - -`title`: _string_ -Display title for the Space - -`emoji`: _string_ -Space emoji (emoji-only character allowed) - -`colorFrom`: _string_ -Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray) - -`colorTo`: _string_ -Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray) - -`sdk`: _string_ -Can be either `gradio` or `streamlit` - -`sdk_version` : _string_ -Only applicable for `streamlit` SDK. -See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions. - -`app_file`: _string_ -Path to your main application file (which contains either `gradio` or `streamlit` Python code). -Path is relative to the root of the repository. - -`pinned`: _boolean_ -Whether the Space stays on top of your list. diff --git a/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/transformer_decoder/mask2former_transformer_decoder.py b/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/transformer_decoder/mask2former_transformer_decoder.py deleted file mode 100644 index 52594f62693e6bf48a4c140ba2fe7131a0317774..0000000000000000000000000000000000000000 --- a/spaces/EPFL-VILAB/MultiMAE/mask2former/modeling/transformer_decoder/mask2former_transformer_decoder.py +++ /dev/null @@ -1,461 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -# Modified by Bowen Cheng from: https://github.com/facebookresearch/detr/blob/master/models/detr.py -import logging -import fvcore.nn.weight_init as weight_init -from typing import Optional -import torch -from torch import nn, Tensor -from torch.nn import functional as F - -from detectron2.config import configurable -from detectron2.layers import Conv2d - -from .position_encoding import PositionEmbeddingSine -from .maskformer_transformer_decoder import TRANSFORMER_DECODER_REGISTRY - - -class SelfAttentionLayer(nn.Module): - - def __init__(self, d_model, nhead, dropout=0.0, - activation="relu", normalize_before=False): - super().__init__() - self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) - - self.norm = nn.LayerNorm(d_model) - self.dropout = nn.Dropout(dropout) - - self.activation = _get_activation_fn(activation) - self.normalize_before = normalize_before - - self._reset_parameters() - - def _reset_parameters(self): - for p in self.parameters(): - if p.dim() > 1: - nn.init.xavier_uniform_(p) - - def with_pos_embed(self, tensor, pos: Optional[Tensor]): - return tensor if pos is None else tensor + pos - - def forward_post(self, tgt, - tgt_mask: Optional[Tensor] = None, - tgt_key_padding_mask: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - q = k = self.with_pos_embed(tgt, query_pos) - tgt2 = self.self_attn(q, k, value=tgt, attn_mask=tgt_mask, - key_padding_mask=tgt_key_padding_mask)[0] - tgt = tgt + self.dropout(tgt2) - tgt = self.norm(tgt) - - return tgt - - def forward_pre(self, tgt, - tgt_mask: Optional[Tensor] = None, - tgt_key_padding_mask: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - tgt2 = self.norm(tgt) - q = k = self.with_pos_embed(tgt2, query_pos) - tgt2 = self.self_attn(q, k, value=tgt2, attn_mask=tgt_mask, - key_padding_mask=tgt_key_padding_mask)[0] - tgt = tgt + self.dropout(tgt2) - - return tgt - - def forward(self, tgt, - tgt_mask: Optional[Tensor] = None, - tgt_key_padding_mask: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - if self.normalize_before: - return self.forward_pre(tgt, tgt_mask, - tgt_key_padding_mask, query_pos) - return self.forward_post(tgt, tgt_mask, - tgt_key_padding_mask, query_pos) - - -class CrossAttentionLayer(nn.Module): - - def __init__(self, d_model, nhead, dropout=0.0, - activation="relu", normalize_before=False): - super().__init__() - self.multihead_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout) - - self.norm = nn.LayerNorm(d_model) - self.dropout = nn.Dropout(dropout) - - self.activation = _get_activation_fn(activation) - self.normalize_before = normalize_before - - self._reset_parameters() - - def _reset_parameters(self): - for p in self.parameters(): - if p.dim() > 1: - nn.init.xavier_uniform_(p) - - def with_pos_embed(self, tensor, pos: Optional[Tensor]): - return tensor if pos is None else tensor + pos - - def forward_post(self, tgt, memory, - memory_mask: Optional[Tensor] = None, - memory_key_padding_mask: Optional[Tensor] = None, - pos: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt, query_pos), - key=self.with_pos_embed(memory, pos), - value=memory, attn_mask=memory_mask, - key_padding_mask=memory_key_padding_mask)[0] - tgt = tgt + self.dropout(tgt2) - tgt = self.norm(tgt) - - return tgt - - def forward_pre(self, tgt, memory, - memory_mask: Optional[Tensor] = None, - memory_key_padding_mask: Optional[Tensor] = None, - pos: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - tgt2 = self.norm(tgt) - tgt2 = self.multihead_attn(query=self.with_pos_embed(tgt2, query_pos), - key=self.with_pos_embed(memory, pos), - value=memory, attn_mask=memory_mask, - key_padding_mask=memory_key_padding_mask)[0] - tgt = tgt + self.dropout(tgt2) - - return tgt - - def forward(self, tgt, memory, - memory_mask: Optional[Tensor] = None, - memory_key_padding_mask: Optional[Tensor] = None, - pos: Optional[Tensor] = None, - query_pos: Optional[Tensor] = None): - if self.normalize_before: - return self.forward_pre(tgt, memory, memory_mask, - memory_key_padding_mask, pos, query_pos) - return self.forward_post(tgt, memory, memory_mask, - memory_key_padding_mask, pos, query_pos) - - -class FFNLayer(nn.Module): - - def __init__(self, d_model, dim_feedforward=2048, dropout=0.0, - activation="relu", normalize_before=False): - super().__init__() - # Implementation of Feedforward model - self.linear1 = nn.Linear(d_model, dim_feedforward) - self.dropout = nn.Dropout(dropout) - self.linear2 = nn.Linear(dim_feedforward, d_model) - - self.norm = nn.LayerNorm(d_model) - - self.activation = _get_activation_fn(activation) - self.normalize_before = normalize_before - - self._reset_parameters() - - def _reset_parameters(self): - for p in self.parameters(): - if p.dim() > 1: - nn.init.xavier_uniform_(p) - - def with_pos_embed(self, tensor, pos: Optional[Tensor]): - return tensor if pos is None else tensor + pos - - def forward_post(self, tgt): - tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt)))) - tgt = tgt + self.dropout(tgt2) - tgt = self.norm(tgt) - return tgt - - def forward_pre(self, tgt): - tgt2 = self.norm(tgt) - tgt2 = self.linear2(self.dropout(self.activation(self.linear1(tgt2)))) - tgt = tgt + self.dropout(tgt2) - return tgt - - def forward(self, tgt): - if self.normalize_before: - return self.forward_pre(tgt) - return self.forward_post(tgt) - - -def _get_activation_fn(activation): - """Return an activation function given a string""" - if activation == "relu": - return F.relu - if activation == "gelu": - return F.gelu - if activation == "glu": - return F.glu - raise RuntimeError(F"activation should be relu/gelu, not {activation}.") - - -class MLP(nn.Module): - """ Very simple multi-layer perceptron (also called FFN)""" - - def __init__(self, input_dim, hidden_dim, output_dim, num_layers): - super().__init__() - self.num_layers = num_layers - h = [hidden_dim] * (num_layers - 1) - self.layers = nn.ModuleList(nn.Linear(n, k) for n, k in zip([input_dim] + h, h + [output_dim])) - - def forward(self, x): - for i, layer in enumerate(self.layers): - x = F.relu(layer(x)) if i < self.num_layers - 1 else layer(x) - return x - - -@TRANSFORMER_DECODER_REGISTRY.register() -class MultiScaleMaskedTransformerDecoder(nn.Module): - - _version = 2 - - def _load_from_state_dict( - self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs - ): - version = local_metadata.get("version", None) - if version is None or version < 2: - # Do not warn if train from scratch - scratch = True - logger = logging.getLogger(__name__) - for k in list(state_dict.keys()): - newk = k - if "static_query" in k: - newk = k.replace("static_query", "query_feat") - if newk != k: - state_dict[newk] = state_dict[k] - del state_dict[k] - scratch = False - - if not scratch: - logger.warning( - f"Weight format of {self.__class__.__name__} have changed! " - "Please upgrade your models. Applying automatic conversion now ..." - ) - - @configurable - def __init__( - self, - in_channels, - mask_classification=True, - *, - num_classes: int, - hidden_dim: int, - num_queries: int, - nheads: int, - dim_feedforward: int, - dec_layers: int, - pre_norm: bool, - mask_dim: int, - enforce_input_project: bool, - ): - """ - NOTE: this interface is experimental. - Args: - in_channels: channels of the input features - mask_classification: whether to add mask classifier or not - num_classes: number of classes - hidden_dim: Transformer feature dimension - num_queries: number of queries - nheads: number of heads - dim_feedforward: feature dimension in feedforward network - enc_layers: number of Transformer encoder layers - dec_layers: number of Transformer decoder layers - pre_norm: whether to use pre-LayerNorm or not - mask_dim: mask feature dimension - enforce_input_project: add input project 1x1 conv even if input - channels and hidden dim is identical - """ - super().__init__() - - assert mask_classification, "Only support mask classification model" - self.mask_classification = mask_classification - - # positional encoding - N_steps = hidden_dim // 2 - self.pe_layer = PositionEmbeddingSine(N_steps, normalize=True) - - # define Transformer decoder here - self.num_heads = nheads - self.num_layers = dec_layers - self.transformer_self_attention_layers = nn.ModuleList() - self.transformer_cross_attention_layers = nn.ModuleList() - self.transformer_ffn_layers = nn.ModuleList() - - for _ in range(self.num_layers): - self.transformer_self_attention_layers.append( - SelfAttentionLayer( - d_model=hidden_dim, - nhead=nheads, - dropout=0.0, - normalize_before=pre_norm, - ) - ) - - self.transformer_cross_attention_layers.append( - CrossAttentionLayer( - d_model=hidden_dim, - nhead=nheads, - dropout=0.0, - normalize_before=pre_norm, - ) - ) - - self.transformer_ffn_layers.append( - FFNLayer( - d_model=hidden_dim, - dim_feedforward=dim_feedforward, - dropout=0.0, - normalize_before=pre_norm, - ) - ) - - self.decoder_norm = nn.LayerNorm(hidden_dim) - - self.num_queries = num_queries - # learnable query features - self.query_feat = nn.Embedding(num_queries, hidden_dim) - # learnable query p.e. - self.query_embed = nn.Embedding(num_queries, hidden_dim) - - # level embedding (we always use 3 scales) - self.num_feature_levels = 3 - self.level_embed = nn.Embedding(self.num_feature_levels, hidden_dim) - self.input_proj = nn.ModuleList() - for _ in range(self.num_feature_levels): - if in_channels != hidden_dim or enforce_input_project: - self.input_proj.append(Conv2d(in_channels, hidden_dim, kernel_size=1)) - weight_init.c2_xavier_fill(self.input_proj[-1]) - else: - self.input_proj.append(nn.Sequential()) - - # output FFNs - if self.mask_classification: - self.class_embed = nn.Linear(hidden_dim, num_classes + 1) - self.mask_embed = MLP(hidden_dim, hidden_dim, mask_dim, 3) - - @classmethod - def from_config(cls, cfg, in_channels, mask_classification): - ret = {} - ret["in_channels"] = in_channels - ret["mask_classification"] = mask_classification - - ret["num_classes"] = cfg.MODEL.SEM_SEG_HEAD.NUM_CLASSES - ret["hidden_dim"] = cfg.MODEL.MASK_FORMER.HIDDEN_DIM - ret["num_queries"] = cfg.MODEL.MASK_FORMER.NUM_OBJECT_QUERIES - # Transformer parameters: - ret["nheads"] = cfg.MODEL.MASK_FORMER.NHEADS - ret["dim_feedforward"] = cfg.MODEL.MASK_FORMER.DIM_FEEDFORWARD - - # NOTE: because we add learnable query features which requires supervision, - # we add minus 1 to decoder layers to be consistent with our loss - # implementation: that is, number of auxiliary losses is always - # equal to number of decoder layers. With learnable query features, the number of - # auxiliary losses equals number of decoders plus 1. - assert cfg.MODEL.MASK_FORMER.DEC_LAYERS >= 1 - ret["dec_layers"] = cfg.MODEL.MASK_FORMER.DEC_LAYERS - 1 - ret["pre_norm"] = cfg.MODEL.MASK_FORMER.PRE_NORM - ret["enforce_input_project"] = cfg.MODEL.MASK_FORMER.ENFORCE_INPUT_PROJ - - ret["mask_dim"] = cfg.MODEL.SEM_SEG_HEAD.MASK_DIM - - return ret - - def forward(self, x, mask_features, mask = None): - # x is a list of multi-scale feature - assert len(x) == self.num_feature_levels - src = [] - pos = [] - size_list = [] - - # disable mask, it does not affect performance - del mask - - for i in range(self.num_feature_levels): - size_list.append(x[i].shape[-2:]) - pos.append(self.pe_layer(x[i], None).flatten(2)) - src.append(self.input_proj[i](x[i]).flatten(2) + self.level_embed.weight[i][None, :, None]) - - # flatten NxCxHxW to HWxNxC - pos[-1] = pos[-1].permute(2, 0, 1) - src[-1] = src[-1].permute(2, 0, 1) - - _, bs, _ = src[0].shape - - # QxNxC - query_embed = self.query_embed.weight.unsqueeze(1).repeat(1, bs, 1) - output = self.query_feat.weight.unsqueeze(1).repeat(1, bs, 1) - - predictions_class = [] - predictions_mask = [] - - # prediction heads on learnable query features - outputs_class, outputs_mask, attn_mask = self.forward_prediction_heads(output, mask_features, attn_mask_target_size=size_list[0]) - predictions_class.append(outputs_class) - predictions_mask.append(outputs_mask) - - for i in range(self.num_layers): - level_index = i % self.num_feature_levels - attn_mask[torch.where(attn_mask.sum(-1) == attn_mask.shape[-1])] = False - # attention: cross-attention first - output = self.transformer_cross_attention_layers[i]( - output, src[level_index], - memory_mask=attn_mask, - memory_key_padding_mask=None, # here we do not apply masking on padded region - pos=pos[level_index], query_pos=query_embed - ) - - output = self.transformer_self_attention_layers[i]( - output, tgt_mask=None, - tgt_key_padding_mask=None, - query_pos=query_embed - ) - - # FFN - output = self.transformer_ffn_layers[i]( - output - ) - - outputs_class, outputs_mask, attn_mask = self.forward_prediction_heads(output, mask_features, attn_mask_target_size=size_list[(i + 1) % self.num_feature_levels]) - predictions_class.append(outputs_class) - predictions_mask.append(outputs_mask) - - assert len(predictions_class) == self.num_layers + 1 - - out = { - 'pred_logits': predictions_class[-1], - 'pred_masks': predictions_mask[-1], - 'aux_outputs': self._set_aux_loss( - predictions_class if self.mask_classification else None, predictions_mask - ) - } - return out - - def forward_prediction_heads(self, output, mask_features, attn_mask_target_size): - decoder_output = self.decoder_norm(output) - decoder_output = decoder_output.transpose(0, 1) - outputs_class = self.class_embed(decoder_output) - mask_embed = self.mask_embed(decoder_output) - outputs_mask = torch.einsum("bqc,bchw->bqhw", mask_embed, mask_features) - - # NOTE: prediction is of higher-resolution - # [B, Q, H, W] -> [B, Q, H*W] -> [B, h, Q, H*W] -> [B*h, Q, HW] - attn_mask = F.interpolate(outputs_mask, size=attn_mask_target_size, mode="bilinear", align_corners=False) - # must use bool type - # If a BoolTensor is provided, positions with ``True`` are not allowed to attend while ``False`` values will be unchanged. - attn_mask = (attn_mask.sigmoid().flatten(2).unsqueeze(1).repeat(1, self.num_heads, 1, 1).flatten(0, 1) < 0.5).bool() - attn_mask = attn_mask.detach() - - return outputs_class, outputs_mask, attn_mask - - @torch.jit.unused - def _set_aux_loss(self, outputs_class, outputs_seg_masks): - # this is a workaround to make torchscript happy, as torchscript - # doesn't support dictionary with non-homogeneous values, such - # as a dict having both a Tensor and a list. - if self.mask_classification: - return [ - {"pred_logits": a, "pred_masks": b} - for a, b in zip(outputs_class[:-1], outputs_seg_masks[:-1]) - ] - else: - return [{"pred_masks": b} for b in outputs_seg_masks[:-1]] diff --git a/spaces/Eddycrack864/Applio-Inference/MDXNet.py b/spaces/Eddycrack864/Applio-Inference/MDXNet.py deleted file mode 100644 index 9b7eb43844ad0d4f9ce61287ccf9a8a4206d3853..0000000000000000000000000000000000000000 --- a/spaces/Eddycrack864/Applio-Inference/MDXNet.py +++ /dev/null @@ -1,272 +0,0 @@ -import soundfile as sf -import torch, pdb, os, warnings, librosa -import numpy as np -import onnxruntime as ort -from tqdm import tqdm -import torch - -dim_c = 4 - - -class Conv_TDF_net_trim: - def __init__( - self, device, model_name, target_name, L, dim_f, dim_t, n_fft, hop=1024 - ): - super(Conv_TDF_net_trim, self).__init__() - - self.dim_f = dim_f - self.dim_t = 2**dim_t - self.n_fft = n_fft - self.hop = hop - self.n_bins = self.n_fft // 2 + 1 - self.chunk_size = hop * (self.dim_t - 1) - self.window = torch.hann_window(window_length=self.n_fft, periodic=True).to( - device - ) - self.target_name = target_name - self.blender = "blender" in model_name - - out_c = dim_c * 4 if target_name == "*" else dim_c - self.freq_pad = torch.zeros( - [1, out_c, self.n_bins - self.dim_f, self.dim_t] - ).to(device) - - self.n = L // 2 - - def stft(self, x): - x = x.reshape([-1, self.chunk_size]) - x = torch.stft( - x, - n_fft=self.n_fft, - hop_length=self.hop, - window=self.window, - center=True, - return_complex=True, - ) - x = torch.view_as_real(x) - x = x.permute([0, 3, 1, 2]) - x = x.reshape([-1, 2, 2, self.n_bins, self.dim_t]).reshape( - [-1, dim_c, self.n_bins, self.dim_t] - ) - return x[:, :, : self.dim_f] - - def istft(self, x, freq_pad=None): - freq_pad = ( - self.freq_pad.repeat([x.shape[0], 1, 1, 1]) - if freq_pad is None - else freq_pad - ) - x = torch.cat([x, freq_pad], -2) - c = 4 * 2 if self.target_name == "*" else 2 - x = x.reshape([-1, c, 2, self.n_bins, self.dim_t]).reshape( - [-1, 2, self.n_bins, self.dim_t] - ) - x = x.permute([0, 2, 3, 1]) - x = x.contiguous() - x = torch.view_as_complex(x) - x = torch.istft( - x, n_fft=self.n_fft, hop_length=self.hop, window=self.window, center=True - ) - return x.reshape([-1, c, self.chunk_size]) - - -def get_models(device, dim_f, dim_t, n_fft): - return Conv_TDF_net_trim( - device=device, - model_name="Conv-TDF", - target_name="vocals", - L=11, - dim_f=dim_f, - dim_t=dim_t, - n_fft=n_fft, - ) - - -warnings.filterwarnings("ignore") -cpu = torch.device("cpu") -if torch.cuda.is_available(): - device = torch.device("cuda:0") -elif torch.backends.mps.is_available(): - device = torch.device("mps") -else: - device = torch.device("cpu") - - -class Predictor: - def __init__(self, args): - self.args = args - self.model_ = get_models( - device=cpu, dim_f=args.dim_f, dim_t=args.dim_t, n_fft=args.n_fft - ) - self.model = ort.InferenceSession( - os.path.join(args.onnx, self.model_.target_name + ".onnx"), - providers=["CUDAExecutionProvider", "CPUExecutionProvider"], - ) - print("onnx load done") - - def demix(self, mix): - samples = mix.shape[-1] - margin = self.args.margin - chunk_size = self.args.chunks * 44100 - assert not margin == 0, "margin cannot be zero!" - if margin > chunk_size: - margin = chunk_size - - segmented_mix = {} - - if self.args.chunks == 0 or samples < chunk_size: - chunk_size = samples - - counter = -1 - for skip in range(0, samples, chunk_size): - counter += 1 - - s_margin = 0 if counter == 0 else margin - end = min(skip + chunk_size + margin, samples) - - start = skip - s_margin - - segmented_mix[skip] = mix[:, start:end].copy() - if end == samples: - break - - sources = self.demix_base(segmented_mix, margin_size=margin) - """ - mix:(2,big_sample) - segmented_mix:offset->(2,small_sample) - sources:(1,2,big_sample) - """ - return sources - - def demix_base(self, mixes, margin_size): - chunked_sources = [] - progress_bar = tqdm(total=len(mixes)) - progress_bar.set_description("Processing") - for mix in mixes: - cmix = mixes[mix] - sources = [] - n_sample = cmix.shape[1] - model = self.model_ - trim = model.n_fft // 2 - gen_size = model.chunk_size - 2 * trim - pad = gen_size - n_sample % gen_size - mix_p = np.concatenate( - (np.zeros((2, trim)), cmix, np.zeros((2, pad)), np.zeros((2, trim))), 1 - ) - mix_waves = [] - i = 0 - while i < n_sample + pad: - waves = np.array(mix_p[:, i : i + model.chunk_size]) - mix_waves.append(waves) - i += gen_size - mix_waves = torch.tensor(mix_waves, dtype=torch.float32).to(cpu) - with torch.no_grad(): - _ort = self.model - spek = model.stft(mix_waves) - if self.args.denoise: - spec_pred = ( - -_ort.run(None, {"input": -spek.cpu().numpy()})[0] * 0.5 - + _ort.run(None, {"input": spek.cpu().numpy()})[0] * 0.5 - ) - tar_waves = model.istft(torch.tensor(spec_pred)) - else: - tar_waves = model.istft( - torch.tensor(_ort.run(None, {"input": spek.cpu().numpy()})[0]) - ) - tar_signal = ( - tar_waves[:, :, trim:-trim] - .transpose(0, 1) - .reshape(2, -1) - .numpy()[:, :-pad] - ) - - start = 0 if mix == 0 else margin_size - end = None if mix == list(mixes.keys())[::-1][0] else -margin_size - if margin_size == 0: - end = None - sources.append(tar_signal[:, start:end]) - - progress_bar.update(1) - - chunked_sources.append(sources) - _sources = np.concatenate(chunked_sources, axis=-1) - # del self.model - progress_bar.close() - return _sources - - def prediction(self, m, vocal_root, others_root, format): - os.makedirs(vocal_root, exist_ok=True) - os.makedirs(others_root, exist_ok=True) - basename = os.path.basename(m) - mix, rate = librosa.load(m, mono=False, sr=44100) - if mix.ndim == 1: - mix = np.asfortranarray([mix, mix]) - mix = mix.T - sources = self.demix(mix.T) - opt = sources[0].T - if format in ["wav", "flac"]: - sf.write( - "%s/%s_main_vocal.%s" % (vocal_root, basename, format), mix - opt, rate - ) - sf.write("%s/%s_others.%s" % (others_root, basename, format), opt, rate) - else: - path_vocal = "%s/%s_main_vocal.wav" % (vocal_root, basename) - path_other = "%s/%s_others.wav" % (others_root, basename) - sf.write(path_vocal, mix - opt, rate) - sf.write(path_other, opt, rate) - if os.path.exists(path_vocal): - os.system( - "ffmpeg -i %s -vn %s -q:a 2 -y" - % (path_vocal, path_vocal[:-4] + ".%s" % format) - ) - if os.path.exists(path_other): - os.system( - "ffmpeg -i %s -vn %s -q:a 2 -y" - % (path_other, path_other[:-4] + ".%s" % format) - ) - - -class MDXNetDereverb: - def __init__(self, chunks): - self.onnx = "uvr5_weights/onnx_dereverb_By_FoxJoy" - self.shifts = 10 #'Predict with randomised equivariant stabilisation' - self.mixing = "min_mag" # ['default','min_mag','max_mag'] - self.chunks = chunks - self.margin = 44100 - self.dim_t = 9 - self.dim_f = 3072 - self.n_fft = 6144 - self.denoise = True - self.pred = Predictor(self) - - def _path_audio_(self, input, vocal_root, others_root, format): - self.pred.prediction(input, vocal_root, others_root, format) - - -if __name__ == "__main__": - dereverb = MDXNetDereverb(15) - from time import time as ttime - - t0 = ttime() - dereverb._path_audio_( - "雪雪伴奏对消HP5.wav", - "vocal", - "others", - ) - t1 = ttime() - print(t1 - t0) - - -""" - -runtime\python.exe MDXNet.py - -6G: -15/9:0.8G->6.8G -14:0.8G->6.5G -25:炸 - -half15:0.7G->6.6G,22.69s -fp32-15:0.7G->6.6G,20.85s - -""" diff --git a/spaces/ElainaFanBoy/MusicGen/audiocraft/__init__.py b/spaces/ElainaFanBoy/MusicGen/audiocraft/__init__.py deleted file mode 100644 index 2befac60faf6f406f78ff7b7da05225dbfe7b111..0000000000000000000000000000000000000000 --- a/spaces/ElainaFanBoy/MusicGen/audiocraft/__init__.py +++ /dev/null @@ -1,10 +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. - -# flake8: noqa -from . import data, modules, models - -__version__ = '0.0.2a1' diff --git a/spaces/EuroPython2022/BayesCap/networks_T1toT2.py b/spaces/EuroPython2022/BayesCap/networks_T1toT2.py deleted file mode 100644 index 0a4957071e817fb551bc1fc86fe1cc5dc4e75cfe..0000000000000000000000000000000000000000 --- a/spaces/EuroPython2022/BayesCap/networks_T1toT2.py +++ /dev/null @@ -1,477 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -import functools - -### components -class ResConv(nn.Module): - """ - Residual convolutional block, where - convolutional block consists: (convolution => [BN] => ReLU) * 3 - residual connection adds the input to the output - """ - def __init__(self, in_channels, out_channels, mid_channels=None): - super().__init__() - if not mid_channels: - mid_channels = out_channels - self.double_conv = nn.Sequential( - nn.Conv2d(in_channels, mid_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(mid_channels), - nn.ReLU(inplace=True), - nn.Conv2d(mid_channels, mid_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(mid_channels), - nn.ReLU(inplace=True), - nn.Conv2d(mid_channels, out_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(out_channels), - nn.ReLU(inplace=True) - ) - self.double_conv1 = nn.Sequential( - nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1), - nn.BatchNorm2d(out_channels), - nn.ReLU(inplace=True), - ) - def forward(self, x): - x_in = self.double_conv1(x) - x1 = self.double_conv(x) - return self.double_conv(x) + x_in - -class Down(nn.Module): - """Downscaling with maxpool then Resconv""" - def __init__(self, in_channels, out_channels): - super().__init__() - self.maxpool_conv = nn.Sequential( - nn.MaxPool2d(2), - ResConv(in_channels, out_channels) - ) - def forward(self, x): - return self.maxpool_conv(x) - -class Up(nn.Module): - """Upscaling then double conv""" - def __init__(self, in_channels, out_channels, bilinear=True): - super().__init__() - # if bilinear, use the normal convolutions to reduce the number of channels - if bilinear: - self.up = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) - self.conv = ResConv(in_channels, out_channels, in_channels // 2) - else: - self.up = nn.ConvTranspose2d(in_channels , in_channels // 2, kernel_size=2, stride=2) - self.conv = ResConv(in_channels, out_channels) - def forward(self, x1, x2): - x1 = self.up(x1) - # input is CHW - diffY = x2.size()[2] - x1.size()[2] - diffX = x2.size()[3] - x1.size()[3] - x1 = F.pad( - x1, - [ - diffX // 2, diffX - diffX // 2, - diffY // 2, diffY - diffY // 2 - ] - ) - # if you have padding issues, see - # https://github.com/HaiyongJiang/U-Net-Pytorch-Unstructured-Buggy/commit/0e854509c2cea854e247a9c615f175f76fbb2e3a - # https://github.com/xiaopeng-liao/Pytorch-UNet/commit/8ebac70e633bac59fc22bb5195e513d5832fb3bd - x = torch.cat([x2, x1], dim=1) - return self.conv(x) - -class OutConv(nn.Module): - def __init__(self, in_channels, out_channels): - super(OutConv, self).__init__() - self.conv = nn.Conv2d(in_channels, out_channels, kernel_size=1) - def forward(self, x): - # return F.relu(self.conv(x)) - return self.conv(x) - -##### The composite networks -class UNet(nn.Module): - def __init__(self, n_channels, out_channels, bilinear=True): - super(UNet, self).__init__() - self.n_channels = n_channels - self.out_channels = out_channels - self.bilinear = bilinear - #### - self.inc = ResConv(n_channels, 64) - self.down1 = Down(64, 128) - self.down2 = Down(128, 256) - self.down3 = Down(256, 512) - factor = 2 if bilinear else 1 - self.down4 = Down(512, 1024 // factor) - self.up1 = Up(1024, 512 // factor, bilinear) - self.up2 = Up(512, 256 // factor, bilinear) - self.up3 = Up(256, 128 // factor, bilinear) - self.up4 = Up(128, 64, bilinear) - self.outc = OutConv(64, out_channels) - def forward(self, x): - x1 = self.inc(x) - x2 = self.down1(x1) - x3 = self.down2(x2) - x4 = self.down3(x3) - x5 = self.down4(x4) - x = self.up1(x5, x4) - x = self.up2(x, x3) - x = self.up3(x, x2) - x = self.up4(x, x1) - y = self.outc(x) - return y - -class CasUNet(nn.Module): - def __init__(self, n_unet, io_channels, bilinear=True): - super(CasUNet, self).__init__() - self.n_unet = n_unet - self.io_channels = io_channels - self.bilinear = bilinear - #### - self.unet_list = nn.ModuleList() - for i in range(self.n_unet): - self.unet_list.append(UNet(self.io_channels, self.io_channels, self.bilinear)) - def forward(self, x, dop=None): - y = x - for i in range(self.n_unet): - if i==0: - if dop is not None: - y = F.dropout2d(self.unet_list[i](y), p=dop) - else: - y = self.unet_list[i](y) - else: - y = self.unet_list[i](y+x) - return y - -class CasUNet_2head(nn.Module): - def __init__(self, n_unet, io_channels, bilinear=True): - super(CasUNet_2head, self).__init__() - self.n_unet = n_unet - self.io_channels = io_channels - self.bilinear = bilinear - #### - self.unet_list = nn.ModuleList() - for i in range(self.n_unet): - if i != self.n_unet-1: - self.unet_list.append(UNet(self.io_channels, self.io_channels, self.bilinear)) - else: - self.unet_list.append(UNet_2head(self.io_channels, self.io_channels, self.bilinear)) - def forward(self, x): - y = x - for i in range(self.n_unet): - if i==0: - y = self.unet_list[i](y) - else: - y = self.unet_list[i](y+x) - y_mean, y_sigma = y[0], y[1] - return y_mean, y_sigma - -class CasUNet_3head(nn.Module): - def __init__(self, n_unet, io_channels, bilinear=True): - super(CasUNet_3head, self).__init__() - self.n_unet = n_unet - self.io_channels = io_channels - self.bilinear = bilinear - #### - self.unet_list = nn.ModuleList() - for i in range(self.n_unet): - if i != self.n_unet-1: - self.unet_list.append(UNet(self.io_channels, self.io_channels, self.bilinear)) - else: - self.unet_list.append(UNet_3head(self.io_channels, self.io_channels, self.bilinear)) - def forward(self, x): - y = x - for i in range(self.n_unet): - if i==0: - y = self.unet_list[i](y) - else: - y = self.unet_list[i](y+x) - y_mean, y_alpha, y_beta = y[0], y[1], y[2] - return y_mean, y_alpha, y_beta - -class UNet_2head(nn.Module): - def __init__(self, n_channels, out_channels, bilinear=True): - super(UNet_2head, self).__init__() - self.n_channels = n_channels - self.out_channels = out_channels - self.bilinear = bilinear - #### - self.inc = ResConv(n_channels, 64) - self.down1 = Down(64, 128) - self.down2 = Down(128, 256) - self.down3 = Down(256, 512) - factor = 2 if bilinear else 1 - self.down4 = Down(512, 1024 // factor) - self.up1 = Up(1024, 512 // factor, bilinear) - self.up2 = Up(512, 256 // factor, bilinear) - self.up3 = Up(256, 128 // factor, bilinear) - self.up4 = Up(128, 64, bilinear) - #per pixel multiple channels may exist - self.out_mean = OutConv(64, out_channels) - #variance will always be a single number for a pixel - self.out_var = nn.Sequential( - OutConv(64, 128), - OutConv(128, 1), - ) - def forward(self, x): - x1 = self.inc(x) - x2 = self.down1(x1) - x3 = self.down2(x2) - x4 = self.down3(x3) - x5 = self.down4(x4) - x = self.up1(x5, x4) - x = self.up2(x, x3) - x = self.up3(x, x2) - x = self.up4(x, x1) - y_mean, y_var = self.out_mean(x), self.out_var(x) - return y_mean, y_var - -class UNet_3head(nn.Module): - def __init__(self, n_channels, out_channels, bilinear=True): - super(UNet_3head, self).__init__() - self.n_channels = n_channels - self.out_channels = out_channels - self.bilinear = bilinear - #### - self.inc = ResConv(n_channels, 64) - self.down1 = Down(64, 128) - self.down2 = Down(128, 256) - self.down3 = Down(256, 512) - factor = 2 if bilinear else 1 - self.down4 = Down(512, 1024 // factor) - self.up1 = Up(1024, 512 // factor, bilinear) - self.up2 = Up(512, 256 // factor, bilinear) - self.up3 = Up(256, 128 // factor, bilinear) - self.up4 = Up(128, 64, bilinear) - #per pixel multiple channels may exist - self.out_mean = OutConv(64, out_channels) - #variance will always be a single number for a pixel - self.out_alpha = nn.Sequential( - OutConv(64, 128), - OutConv(128, 1), - nn.ReLU() - ) - self.out_beta = nn.Sequential( - OutConv(64, 128), - OutConv(128, 1), - nn.ReLU() - ) - def forward(self, x): - x1 = self.inc(x) - x2 = self.down1(x1) - x3 = self.down2(x2) - x4 = self.down3(x3) - x5 = self.down4(x4) - x = self.up1(x5, x4) - x = self.up2(x, x3) - x = self.up3(x, x2) - x = self.up4(x, x1) - y_mean, y_alpha, y_beta = self.out_mean(x), \ - self.out_alpha(x), self.out_beta(x) - return y_mean, y_alpha, y_beta - -class ResidualBlock(nn.Module): - def __init__(self, in_features): - super(ResidualBlock, self).__init__() - conv_block = [ - nn.ReflectionPad2d(1), - nn.Conv2d(in_features, in_features, 3), - nn.InstanceNorm2d(in_features), - nn.ReLU(inplace=True), - nn.ReflectionPad2d(1), - nn.Conv2d(in_features, in_features, 3), - nn.InstanceNorm2d(in_features) - ] - self.conv_block = nn.Sequential(*conv_block) - def forward(self, x): - return x + self.conv_block(x) - -class Generator(nn.Module): - def __init__(self, input_nc, output_nc, n_residual_blocks=9): - super(Generator, self).__init__() - # Initial convolution block - model = [ - nn.ReflectionPad2d(3), nn.Conv2d(input_nc, 64, 7), - nn.InstanceNorm2d(64), nn.ReLU(inplace=True) - ] - # Downsampling - in_features = 64 - out_features = in_features*2 - for _ in range(2): - model += [ - nn.Conv2d(in_features, out_features, 3, stride=2, padding=1), - nn.InstanceNorm2d(out_features), - nn.ReLU(inplace=True) - ] - in_features = out_features - out_features = in_features*2 - # Residual blocks - for _ in range(n_residual_blocks): - model += [ResidualBlock(in_features)] - # Upsampling - out_features = in_features//2 - for _ in range(2): - model += [ - nn.ConvTranspose2d(in_features, out_features, 3, stride=2, padding=1, output_padding=1), - nn.InstanceNorm2d(out_features), - nn.ReLU(inplace=True) - ] - in_features = out_features - out_features = in_features//2 - # Output layer - model += [nn.ReflectionPad2d(3), nn.Conv2d(64, output_nc, 7), nn.Tanh()] - self.model = nn.Sequential(*model) - def forward(self, x): - return self.model(x) - - -class ResnetGenerator(nn.Module): - """Resnet-based generator that consists of Resnet blocks between a few downsampling/upsampling operations. - We adapt Torch code and idea from Justin Johnson's neural style transfer project(https://github.com/jcjohnson/fast-neural-style) - """ - - def __init__(self, input_nc, output_nc, ngf=64, norm_layer=nn.BatchNorm2d, use_dropout=False, n_blocks=6, padding_type='reflect'): - """Construct a Resnet-based generator - Parameters: - input_nc (int) -- the number of channels in input images - output_nc (int) -- the number of channels in output images - ngf (int) -- the number of filters in the last conv layer - norm_layer -- normalization layer - use_dropout (bool) -- if use dropout layers - n_blocks (int) -- the number of ResNet blocks - padding_type (str) -- the name of padding layer in conv layers: reflect | replicate | zero - """ - assert(n_blocks >= 0) - super(ResnetGenerator, self).__init__() - if type(norm_layer) == functools.partial: - use_bias = norm_layer.func == nn.InstanceNorm2d - else: - use_bias = norm_layer == nn.InstanceNorm2d - - model = [nn.ReflectionPad2d(3), - nn.Conv2d(input_nc, ngf, kernel_size=7, padding=0, bias=use_bias), - norm_layer(ngf), - nn.ReLU(True)] - - n_downsampling = 2 - for i in range(n_downsampling): # add downsampling layers - mult = 2 ** i - model += [nn.Conv2d(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1, bias=use_bias), - norm_layer(ngf * mult * 2), - nn.ReLU(True)] - - mult = 2 ** n_downsampling - for i in range(n_blocks): # add ResNet blocks - - model += [ResnetBlock(ngf * mult, padding_type=padding_type, norm_layer=norm_layer, use_dropout=use_dropout, use_bias=use_bias)] - - for i in range(n_downsampling): # add upsampling layers - mult = 2 ** (n_downsampling - i) - model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2), - kernel_size=3, stride=2, - padding=1, output_padding=1, - bias=use_bias), - norm_layer(int(ngf * mult / 2)), - nn.ReLU(True)] - model += [nn.ReflectionPad2d(3)] - model += [nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)] - model += [nn.Tanh()] - - self.model = nn.Sequential(*model) - - def forward(self, input): - """Standard forward""" - return self.model(input) - - -class ResnetBlock(nn.Module): - """Define a Resnet block""" - - def __init__(self, dim, padding_type, norm_layer, use_dropout, use_bias): - """Initialize the Resnet block - A resnet block is a conv block with skip connections - We construct a conv block with build_conv_block function, - and implement skip connections inClick to Go
- -
- -You can download from : - -1. DIV2K: http://data.vision.ee.ethz.ch/cvl/DIV2K/DIV2K_train_HR.zip -2. Flickr2K: https://cv.snu.ac.kr/research/EDSR/Flickr2K.tar -3. OST: https://openmmlab.oss-cn-hangzhou.aliyuncs.com/datasets/OST_dataset.zip - -Here are steps for data preparation. - -#### Step 1: [Optional] Generate multi-scale images - -For the DF2K dataset, we use a multi-scale strategy, *i.e.*, we downsample HR images to obtain several Ground-Truth images with different scales.
-You can use the [scripts/generate_multiscale_DF2K.py](scripts/generate_multiscale_DF2K.py) script to generate multi-scale images.
-Note that this step can be omitted if you just want to have a fast try. - -```bash -python scripts/generate_multiscale_DF2K.py --input datasets/DF2K/DF2K_HR --output datasets/DF2K/DF2K_multiscale -``` - -#### Step 2: [Optional] Crop to sub-images - -We then crop DF2K images into sub-images for faster IO and processing.
-This step is optional if your IO is enough or your disk space is limited. - -You can use the [scripts/extract_subimages.py](scripts/extract_subimages.py) script. Here is the example: - -```bash - python scripts/extract_subimages.py --input datasets/DF2K/DF2K_multiscale --output datasets/DF2K/DF2K_multiscale_sub --crop_size 400 --step 200 -``` - -#### Step 3: Prepare a txt for meta information - -You need to prepare a txt file containing the image paths. The following are some examples in `meta_info_DF2Kmultiscale+OST_sub.txt` (As different users may have different sub-images partitions, this file is not suitable for your purpose and you need to prepare your own txt file): - -```txt -DF2K_HR_sub/000001_s001.png -DF2K_HR_sub/000001_s002.png -DF2K_HR_sub/000001_s003.png -... -``` - -You can use the [scripts/generate_meta_info.py](scripts/generate_meta_info.py) script to generate the txt file.
-You can merge several folders into one meta_info txt. Here is the example: - -```bash - python scripts/generate_meta_info.py --input datasets/DF2K/DF2K_HR datasets/DF2K/DF2K_multiscale --root datasets/DF2K datasets/DF2K --meta_info datasets/DF2K/meta_info/meta_info_DF2Kmultiscale.txt -``` - -### Train Real-ESRNet - -1. Download pre-trained model [ESRGAN](https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth) into `experiments/pretrained_models`. - ```bash - wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.1/ESRGAN_SRx4_DF2KOST_official-ff704c30.pth -P experiments/pretrained_models - ``` -1. Modify the content in the option file `options/train_realesrnet_x4plus.yml` accordingly: - ```yml - train: - name: DF2K+OST - type: RealESRGANDataset - dataroot_gt: datasets/DF2K # modify to the root path of your folder - meta_info: realesrgan/meta_info/meta_info_DF2Kmultiscale+OST_sub.txt # modify to your own generate meta info txt - io_backend: - type: disk - ``` -1. If you want to perform validation during training, uncomment those lines and modify accordingly: - ```yml - # Uncomment these for validation - # val: - # name: validation - # type: PairedImageDataset - # dataroot_gt: path_to_gt - # dataroot_lq: path_to_lq - # io_backend: - # type: disk - - ... - - # Uncomment these for validation - # validation settings - # val: - # val_freq: !!float 5e3 - # save_img: True - - # metrics: - # psnr: # metric name, can be arbitrary - # type: calculate_psnr - # crop_border: 4 - # test_y_channel: false - ``` -1. Before the formal training, you may run in the `--debug` mode to see whether everything is OK. We use four GPUs for training: - ```bash - CUDA_VISIBLE_DEVICES=0,1,2,3 \ - python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/train_realesrnet_x4plus.yml --launcher pytorch --debug - ``` - - Train with **a single GPU** in the *debug* mode: - ```bash - python realesrgan/train.py -opt options/train_realesrnet_x4plus.yml --debug - ``` -1. The formal training. We use four GPUs for training. We use the `--auto_resume` argument to automatically resume the training if necessary. - ```bash - CUDA_VISIBLE_DEVICES=0,1,2,3 \ - python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/train_realesrnet_x4plus.yml --launcher pytorch --auto_resume - ``` - - Train with **a single GPU**: - ```bash - python realesrgan/train.py -opt options/train_realesrnet_x4plus.yml --auto_resume - ``` - -### Train Real-ESRGAN - -1. After the training of Real-ESRNet, you now have the file `experiments/train_RealESRNetx4plus_1000k_B12G4_fromESRGAN/model/net_g_1000000.pth`. If you need to specify the pre-trained path to other files, modify the `pretrain_network_g` value in the option file `train_realesrgan_x4plus.yml`. -1. Modify the option file `train_realesrgan_x4plus.yml` accordingly. Most modifications are similar to those listed above. -1. Before the formal training, you may run in the `--debug` mode to see whether everything is OK. We use four GPUs for training: - ```bash - CUDA_VISIBLE_DEVICES=0,1,2,3 \ - python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/train_realesrgan_x4plus.yml --launcher pytorch --debug - ``` - - Train with **a single GPU** in the *debug* mode: - ```bash - python realesrgan/train.py -opt options/train_realesrgan_x4plus.yml --debug - ``` -1. The formal training. We use four GPUs for training. We use the `--auto_resume` argument to automatically resume the training if necessary. - ```bash - CUDA_VISIBLE_DEVICES=0,1,2,3 \ - python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/train_realesrgan_x4plus.yml --launcher pytorch --auto_resume - ``` - - Train with **a single GPU**: - ```bash - python realesrgan/train.py -opt options/train_realesrgan_x4plus.yml --auto_resume - ``` - -## Finetune Real-ESRGAN on your own dataset - -You can finetune Real-ESRGAN on your own dataset. Typically, the fine-tuning process can be divided into two cases: - -1. [Generate degraded images on the fly](#Generate-degraded-images-on-the-fly) -1. [Use your own **paired** data](#Use-paired-training-data) - -### Generate degraded images on the fly - -Only high-resolution images are required. The low-quality images are generated with the degradation process described in Real-ESRGAN during training. - -**1. Prepare dataset** - -See [this section](#dataset-preparation) for more details. - -**2. Download pre-trained models** - -Download pre-trained models into `experiments/pretrained_models`. - -- *RealESRGAN_x4plus.pth*: - ```bash - wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth -P experiments/pretrained_models - ``` - -- *RealESRGAN_x4plus_netD.pth*: - ```bash - wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.3/RealESRGAN_x4plus_netD.pth -P experiments/pretrained_models - ``` - -**3. Finetune** - -Modify [options/finetune_realesrgan_x4plus.yml](options/finetune_realesrgan_x4plus.yml) accordingly, especially the `datasets` part: - -```yml -train: - name: DF2K+OST - type: RealESRGANDataset - dataroot_gt: datasets/DF2K # modify to the root path of your folder - meta_info: realesrgan/meta_info/meta_info_DF2Kmultiscale+OST_sub.txt # modify to your own generate meta info txt - io_backend: - type: disk -``` - -We use four GPUs for training. We use the `--auto_resume` argument to automatically resume the training if necessary. - -```bash -CUDA_VISIBLE_DEVICES=0,1,2,3 \ -python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/finetune_realesrgan_x4plus.yml --launcher pytorch --auto_resume -``` - -Finetune with **a single GPU**: -```bash -python realesrgan/train.py -opt options/finetune_realesrgan_x4plus.yml --auto_resume -``` - -### Use your own paired data - -You can also finetune RealESRGAN with your own paired data. It is more similar to fine-tuning ESRGAN. - -**1. Prepare dataset** - -Assume that you already have two folders: - -- **gt folder** (Ground-truth, high-resolution images): *datasets/DF2K/DIV2K_train_HR_sub* -- **lq folder** (Low quality, low-resolution images): *datasets/DF2K/DIV2K_train_LR_bicubic_X4_sub* - -Then, you can prepare the meta_info txt file using the script [scripts/generate_meta_info_pairdata.py](scripts/generate_meta_info_pairdata.py): - -```bash -python scripts/generate_meta_info_pairdata.py --input datasets/DF2K/DIV2K_train_HR_sub datasets/DF2K/DIV2K_train_LR_bicubic_X4_sub --meta_info datasets/DF2K/meta_info/meta_info_DIV2K_sub_pair.txt -``` - -**2. Download pre-trained models** - -Download pre-trained models into `experiments/pretrained_models`. - -- *RealESRGAN_x4plus.pth* - ```bash - wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.1.0/RealESRGAN_x4plus.pth -P experiments/pretrained_models - ``` - -- *RealESRGAN_x4plus_netD.pth* - ```bash - wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.2.3/RealESRGAN_x4plus_netD.pth -P experiments/pretrained_models - ``` - -**3. Finetune** - -Modify [options/finetune_realesrgan_x4plus_pairdata.yml](options/finetune_realesrgan_x4plus_pairdata.yml) accordingly, especially the `datasets` part: - -```yml -train: - name: DIV2K - type: RealESRGANPairedDataset - dataroot_gt: datasets/DF2K # modify to the root path of your folder - dataroot_lq: datasets/DF2K # modify to the root path of your folder - meta_info: datasets/DF2K/meta_info/meta_info_DIV2K_sub_pair.txt # modify to your own generate meta info txt - io_backend: - type: disk -``` - -We use four GPUs for training. We use the `--auto_resume` argument to automatically resume the training if necessary. - -```bash -CUDA_VISIBLE_DEVICES=0,1,2,3 \ -python -m torch.distributed.launch --nproc_per_node=4 --master_port=4321 realesrgan/train.py -opt options/finetune_realesrgan_x4plus_pairdata.yml --launcher pytorch --auto_resume -``` - -Finetune with **a single GPU**: -```bash -python realesrgan/train.py -opt options/finetune_realesrgan_x4plus_pairdata.yml --auto_resume -``` diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/cascade_rcnn/README.md b/spaces/Gradio-Blocks/uniformer_image_detection/configs/cascade_rcnn/README.md deleted file mode 100644 index 15e6191ab994f4dd0346be545a6ff1e5e4b015d6..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/cascade_rcnn/README.md +++ /dev/null @@ -1,55 +0,0 @@ -# Cascade R-CNN: High Quality Object Detection and Instance Segmentation - -## Introduction - -[ALGORITHM] - -```latex -@article{Cai_2019, - title={Cascade R-CNN: High Quality Object Detection and Instance Segmentation}, - ISSN={1939-3539}, - url={http://dx.doi.org/10.1109/tpami.2019.2956516}, - DOI={10.1109/tpami.2019.2956516}, - journal={IEEE Transactions on Pattern Analysis and Machine Intelligence}, - publisher={Institute of Electrical and Electronics Engineers (IEEE)}, - author={Cai, Zhaowei and Vasconcelos, Nuno}, - year={2019}, - pages={1–1} -} -``` - -## Results and models - -### Cascade R-CNN - -| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | Config | Download | -| :-------------: | :-----: | :-----: | :------: | :------------: | :----: |:------:|:--------:| -| R-50-FPN | caffe | 1x | 4.2 | | 40.4 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco/cascade_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.404_20200504_174853-b857be87.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_caffe_fpn_1x_coco/cascade_rcnn_r50_caffe_fpn_1x_coco_20200504_174853.log.json) | -| R-50-FPN | pytorch | 1x | 4.4 | 16.1 | 40.3 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316-3dc56deb.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_1x_coco/cascade_rcnn_r50_fpn_1x_coco_20200316_214748.log.json) | -| R-50-FPN | pytorch | 20e | - | - | 41.0 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco/cascade_rcnn_r50_fpn_20e_coco_bbox_mAP-0.41_20200504_175131-e9872a90.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r50_fpn_20e_coco/cascade_rcnn_r50_fpn_20e_coco_20200504_175131.log.json) | -| R-101-FPN | caffe | 1x | 6.2 | | 42.3 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco/cascade_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.423_20200504_175649-cab8dbd5.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_caffe_fpn_1x_coco/cascade_rcnn_r101_caffe_fpn_1x_coco_20200504_175649.log.json) | -| R-101-FPN | pytorch | 1x | 6.4 | 13.5 | 42.0 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco/cascade_rcnn_r101_fpn_1x_coco_20200317-0b6a2fbf.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_1x_coco/cascade_rcnn_r101_fpn_1x_coco_20200317_101744.log.json) | -| R-101-FPN | pytorch | 20e | - | - | 42.5 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco/cascade_rcnn_r101_fpn_20e_coco_bbox_mAP-0.425_20200504_231812-5057dcc5.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_r101_fpn_20e_coco/cascade_rcnn_r101_fpn_20e_coco_20200504_231812.log.json) | -| X-101-32x4d-FPN | pytorch | 1x | 7.6 | 10.9 | 43.7 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco/cascade_rcnn_x101_32x4d_fpn_1x_coco_20200316-95c2deb6.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_1x_coco/cascade_rcnn_x101_32x4d_fpn_1x_coco_20200316_055608.log.json) | -| X-101-32x4d-FPN | pytorch | 20e | 7.6 | | 43.7 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco/cascade_rcnn_x101_32x4d_fpn_20e_coco_20200906_134608-9ae0a720.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_32x4d_fpn_20e_coco/cascade_rcnn_x101_32x4d_fpn_20e_coco_20200906_134608.log.json) | -| X-101-64x4d-FPN | pytorch | 1x | 10.7 | | 44.7 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco/cascade_rcnn_x101_64x4d_fpn_1x_coco_20200515_075702-43ce6a30.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_1x_coco/cascade_rcnn_x101_64x4d_fpn_1x_coco_20200515_075702.log.json) | -| X-101-64x4d-FPN | pytorch | 20e | 10.7 | | 44.5 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357-051557b1.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_rcnn_x101_64x4d_fpn_20e_coco/cascade_rcnn_x101_64x4d_fpn_20e_coco_20200509_224357.log.json)| - -### Cascade Mask R-CNN - -| Backbone | Style | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download | -| :-------------: | :-----: | :-----: | :------: | :------------: | :----: | :-----: | :------: | :--------: | -| R-50-FPN | caffe | 1x | 5.9 | | 41.2 | 36.0 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco/cascade_mask_rcnn_r50_caffe_fpn_1x_coco_bbox_mAP-0.412__segm_mAP-0.36_20200504_174659-5004b251.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_caffe_fpn_1x_coco/cascade_mask_rcnn_r50_caffe_fpn_1x_coco_20200504_174659.log.json) | -| R-50-FPN | pytorch | 1x | 6.0 | 11.2 | 41.2 | 35.9 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203-9d4dcb24.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_1x_coco/cascade_mask_rcnn_r50_fpn_1x_coco_20200203_170449.log.json) | -| R-50-FPN | pytorch | 20e | - | - | 41.9 | 36.5 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco/cascade_mask_rcnn_r50_fpn_20e_coco_bbox_mAP-0.419__segm_mAP-0.365_20200504_174711-4af8e66e.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r50_fpn_20e_coco/cascade_mask_rcnn_r50_fpn_20e_coco_20200504_174711.log.json)| -| R-101-FPN | caffe | 1x | 7.8 | | 43.2 | 37.6 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco/cascade_mask_rcnn_r101_caffe_fpn_1x_coco_bbox_mAP-0.432__segm_mAP-0.376_20200504_174813-5c1e9599.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_caffe_fpn_1x_coco/cascade_mask_rcnn_r101_caffe_fpn_1x_coco_20200504_174813.log.json)| -| R-101-FPN | pytorch | 1x | 7.9 | 9.8 | 42.9 | 37.3 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco/cascade_mask_rcnn_r101_fpn_1x_coco_20200203-befdf6ee.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_1x_coco/cascade_mask_rcnn_r101_fpn_1x_coco_20200203_092521.log.json) | -| R-101-FPN | pytorch | 20e | - | - | 43.4 | 37.8 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco/cascade_mask_rcnn_r101_fpn_20e_coco_bbox_mAP-0.434__segm_mAP-0.378_20200504_174836-005947da.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_r101_fpn_20e_coco/cascade_mask_rcnn_r101_fpn_20e_coco_20200504_174836.log.json)| -| X-101-32x4d-FPN | pytorch | 1x | 9.2 | 8.6 | 44.3 | 38.3 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco_20200201-0f411b1f.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco/cascade_mask_rcnn_x101_32x4d_fpn_1x_coco_20200201_052416.log.json) | -| X-101-32x4d-FPN | pytorch | 20e | 9.2 | - | 45.0 | 39.0 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco_20200528_083917-ed1f4751.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco/cascade_mask_rcnn_x101_32x4d_fpn_20e_coco_20200528_083917.log.json) | -| X-101-64x4d-FPN | pytorch | 1x | 12.2 | 6.7 | 45.3 | 39.2 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco_20200203-9a2db89d.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco/cascade_mask_rcnn_x101_64x4d_fpn_1x_coco_20200203_044059.log.json) | -| X-101-64x4d-FPN | pytorch | 20e | 12.2 | | 45.6 |39.5 | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco_20200512_161033-bdb5126a.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/cascade_rcnn/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco/cascade_mask_rcnn_x101_64x4d_fpn_20e_coco_20200512_161033.log.json)| - -**Notes:** - -- The `20e` schedule in Cascade (Mask) R-CNN indicates decreasing the lr at 16 and 19 epochs, with a total of 20 epochs. diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/detectors/cascade_rcnn_r50_sac_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/detectors/cascade_rcnn_r50_sac_1x_coco.py deleted file mode 100644 index ccd9319b2d1badebf3b891c8e3bdd55a435a4b7c..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/detectors/cascade_rcnn_r50_sac_1x_coco.py +++ /dev/null @@ -1,12 +0,0 @@ -_base_ = [ - '../_base_/models/cascade_rcnn_r50_fpn.py', - '../_base_/datasets/coco_detection.py', - '../_base_/schedules/schedule_1x.py', '../_base_/default_runtime.py' -] - -model = dict( - backbone=dict( - type='DetectoRS_ResNet', - conv_cfg=dict(type='ConvAWS'), - sac=dict(type='SAC', use_deform=True), - stage_with_sac=(False, True, True, True))) diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/fsaf/fsaf_x101_64x4d_fpn_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/fsaf/fsaf_x101_64x4d_fpn_1x_coco.py deleted file mode 100644 index b966f24969a60b95878b0b86bb8dae7b8cb3f1ae..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/fsaf/fsaf_x101_64x4d_fpn_1x_coco.py +++ /dev/null @@ -1,13 +0,0 @@ -_base_ = './fsaf_r50_fpn_1x_coco.py' -model = dict( - pretrained='open-mmlab://resnext101_64x4d', - backbone=dict( - type='ResNeXt', - depth=101, - groups=64, - base_width=4, - num_stages=4, - out_indices=(0, 1, 2, 3), - frozen_stages=1, - norm_cfg=dict(type='BN', requires_grad=True), - style='pytorch')) diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/reppoints_moment_r101_fpn_gn-neck+head_2x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/reppoints_moment_r101_fpn_gn-neck+head_2x_coco.py deleted file mode 100644 index 19efa0dd756993c9f51a3b9589e558beb2eb5f83..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/reppoints/reppoints_moment_r101_fpn_gn-neck+head_2x_coco.py +++ /dev/null @@ -1,2 +0,0 @@ -_base_ = './reppoints_moment_r50_fpn_gn-neck+head_2x_coco.py' -model = dict(pretrained='torchvision://resnet101', backbone=dict(depth=101)) diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/ann/ann_r101-d8_512x512_40k_voc12aug.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/ann/ann_r101-d8_512x512_40k_voc12aug.py deleted file mode 100644 index 893c53b1ca4bf9788e4d94f0f53cfe92a93f48ce..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/ann/ann_r101-d8_512x512_40k_voc12aug.py +++ /dev/null @@ -1,2 +0,0 @@ -_base_ = './ann_r50-d8_512x512_40k_voc12aug.py' -model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101)) diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/encnet/encnet_r50-d8_769x769_80k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/encnet/encnet_r50-d8_769x769_80k_cityscapes.py deleted file mode 100644 index 7b535f3c80818ce6b692b66f18ceee8e7b181fdc..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/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/Gradio-Blocks/uniformer_image_segmentation/configs/gcnet/gcnet_r50-d8_769x769_80k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/gcnet/gcnet_r50-d8_769x769_80k_cityscapes.py deleted file mode 100644 index d6d9cb1c64bcf8c3e952b6f8adc11bec0403d106..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/gcnet/gcnet_r50-d8_769x769_80k_cityscapes.py +++ /dev/null @@ -1,9 +0,0 @@ -_base_ = [ - '../_base_/models/gcnet_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/Gradio-Blocks/zero-and-few-shot-reasoning/README.md b/spaces/Gradio-Blocks/zero-and-few-shot-reasoning/README.md deleted file mode 100644 index eff9f0d1e89a99616e5fbc6684d33a53aade6c6f..0000000000000000000000000000000000000000 --- a/spaces/Gradio-Blocks/zero-and-few-shot-reasoning/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Zero And Few Shot Reasoning -emoji: 🧠 -colorFrom: gray -colorTo: gray -sdk: gradio -sdk_version: 3.0.5 -app_file: app.py -pinned: false -license: mit ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference diff --git a/spaces/Grezz/generate_human_motion/pyrender/examples/duck.py b/spaces/Grezz/generate_human_motion/pyrender/examples/duck.py deleted file mode 100644 index 9a94bad5bfb30493f7364f2e52cbb4badbccb2c7..0000000000000000000000000000000000000000 --- a/spaces/Grezz/generate_human_motion/pyrender/examples/duck.py +++ /dev/null @@ -1,13 +0,0 @@ -from pyrender import Mesh, Scene, Viewer -from io import BytesIO -import numpy as np -import trimesh -import requests - -duck_source = "https://github.com/KhronosGroup/glTF-Sample-Models/raw/master/2.0/Duck/glTF-Binary/Duck.glb" - -duck = trimesh.load(BytesIO(requests.get(duck_source).content), file_type='glb') -duckmesh = Mesh.from_trimesh(list(duck.geometry.values())[0]) -scene = Scene(ambient_light=np.array([1.0, 1.0, 1.0, 1.0])) -scene.add(duckmesh) -Viewer(scene) diff --git a/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_GPT2_medicalQA.sh b/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_GPT2_medicalQA.sh deleted file mode 100644 index d9a81670ed121ecfb9fa3e0e546f0773374087af..0000000000000000000000000000000000000000 --- a/spaces/HaloMaster/chinesesummary/fengshen/examples/wenzhong_qa/finetune_GPT2_medicalQA.sh +++ /dev/null @@ -1,123 +0,0 @@ -#!/bin/bash -#SBATCH --job-name=medical_qa_finetune -#SBATCH --nodes=2 -#SBATCH --ntasks-per-node=8 -#SBATCH --gres=gpu:8 # number of gpus -#SBATCH -o /cognitive_comp/wuziwei/task/fs_medical_qa_finetune/%x-%j.log -#SBATCH -e /cognitive_comp/wuziwei/task/fs_medical_qa_finetune/%x-%j.err -#SBATCH -x dgx[050,049] - -#export NCCL_DEBUG=INFO - -# export PATH=$PATH:/cognitive_comp/wuziwei/codes/fengshen/fengshen -set -x -e - -echo "START TIME: $(date)" -MICRO_BATCH_SIZE=1 -ROOT_DIR=/cognitive_comp/wuziwei/task/fs_medical_qa_finetune - -ZERO_STAGE=2 - -config_json="$ROOT_DIR/training_config.json" -export MASTER_PORT=$[RANDOM%10000+30000] - -# Deepspeed figures out GAS dynamically from dynamic GBS via set_train_batch_size() -cat <
](https://huggingface.co/spaces/lxe/simple-llama-finetuner?duplicate=true)
- This tunes the [llama-7b](https://huggingface.co/decapoda-research/llama-7b-hf) model on your own text. Duplicate this space onto a GPU-enabled space to run.
- """)
- training_tab()
- inference_tab()
- gr.Markdown("""
- Enter your samples separated by two blank lines, then click "Train" to start training a new LoRA model. Once the model is trained, you can use it to generate new text by entering a prompt and clicking "Generate".
- """)
-
-if __name__ == '__main__':
- parser = argparse.ArgumentParser(description="Simple LLaMA Finetuner")
- parser.add_argument("-s", "--share", action="store_true", help="Enable sharing of the Gradio interface")
- args = parser.parse_args()
-
- demo.queue().launch(share=args.share)
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/StableLM.py b/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/StableLM.py
deleted file mode 100644
index f4affc3699e335f1e42bf5fc8c93e92a41d027fe..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT/modules/models/StableLM.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline, StoppingCriteria, StoppingCriteriaList, TextIteratorStreamer
-import time
-import numpy as np
-from torch.nn import functional as F
-import os
-from .base_model import BaseLLMModel
-from threading import Thread
-
-STABLELM_MODEL = None
-STABLELM_TOKENIZER = None
-
-
-class StopOnTokens(StoppingCriteria):
- def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor, **kwargs) -> bool:
- stop_ids = [50278, 50279, 50277, 1, 0]
- for stop_id in stop_ids:
- if input_ids[0][-1] == stop_id:
- return True
- return False
-
-
-class StableLM_Client(BaseLLMModel):
- def __init__(self, model_name, user_name="") -> None:
- super().__init__(model_name=model_name, user=user_name)
- global STABLELM_MODEL, STABLELM_TOKENIZER
- print(f"Starting to load StableLM to memory")
- if model_name == "StableLM":
- model_name = "stabilityai/stablelm-tuned-alpha-7b"
- else:
- model_name = f"models/{model_name}"
- if STABLELM_MODEL is None:
- STABLELM_MODEL = AutoModelForCausalLM.from_pretrained(
- model_name, torch_dtype=torch.float16).cuda()
- if STABLELM_TOKENIZER is None:
- STABLELM_TOKENIZER = AutoTokenizer.from_pretrained(model_name)
- self.generator = pipeline(
- 'text-generation', model=STABLELM_MODEL, tokenizer=STABLELM_TOKENIZER, device=0)
- print(f"Sucessfully loaded StableLM to the memory")
- self.system_prompt = """StableAssistant
-- StableAssistant is A helpful and harmless Open Source AI Language Model developed by Stability and CarperAI.
-- StableAssistant is excited to be able to help the user, but will refuse to do anything that could be considered harmful to the user.
-- StableAssistant is more than just an information source, StableAssistant is also able to write poetry, short stories, and make jokes.
-- StableAssistant will refuse to participate in anything that could harm a human."""
- self.max_generation_token = 1024
- self.top_p = 0.95
- self.temperature = 1.0
-
- def _get_stablelm_style_input(self):
- history = self.history + [{"role": "assistant", "content": ""}]
- print(history)
- messages = self.system_prompt + \
- "".join(["".join(["<|USER|>"+history[i]["content"], "<|ASSISTANT|>"+history[i + 1]["content"]])
- for i in range(0, len(history), 2)])
- return messages
-
- def _generate(self, text, bad_text=None):
- stop = StopOnTokens()
- result = self.generator(text, max_new_tokens=self.max_generation_token, num_return_sequences=1, num_beams=1, do_sample=True,
- temperature=self.temperature, top_p=self.top_p, top_k=1000, stopping_criteria=StoppingCriteriaList([stop]))
- return result[0]["generated_text"].replace(text, "")
-
- def get_answer_at_once(self):
- messages = self._get_stablelm_style_input()
- return self._generate(messages), len(messages)
-
- def get_answer_stream_iter(self):
- stop = StopOnTokens()
- messages = self._get_stablelm_style_input()
-
- # model_inputs = tok([messages], return_tensors="pt")['input_ids'].cuda()[:, :4096-1024]
- model_inputs = STABLELM_TOKENIZER(
- [messages], return_tensors="pt").to("cuda")
- streamer = TextIteratorStreamer(
- STABLELM_TOKENIZER, timeout=10., skip_prompt=True, skip_special_tokens=True)
- generate_kwargs = dict(
- model_inputs,
- streamer=streamer,
- max_new_tokens=self.max_generation_token,
- do_sample=True,
- top_p=self.top_p,
- top_k=1000,
- temperature=self.temperature,
- num_beams=1,
- stopping_criteria=StoppingCriteriaList([stop])
- )
- t = Thread(target=STABLELM_MODEL.generate, kwargs=generate_kwargs)
- t.start()
-
- partial_text = ""
- for new_text in streamer:
- partial_text += new_text
- yield partial_text
diff --git a/spaces/Juno360219/stabilityai-stable-diffusion-2-1/README.md b/spaces/Juno360219/stabilityai-stable-diffusion-2-1/README.md
deleted file mode 100644
index 62a267d1cc4d281fa02a6acd90fd5ad5fcbfe1b3..0000000000000000000000000000000000000000
--- a/spaces/Juno360219/stabilityai-stable-diffusion-2-1/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: Stabilityai Stable Diffusion 2 1
-emoji: 🌍
-colorFrom: indigo
-colorTo: indigo
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Justin-Choo/Lemon_WEB_UI/README.md b/spaces/Justin-Choo/Lemon_WEB_UI/README.md
deleted file mode 100644
index 01b689fdb344bc093753e15da61a2189bf164502..0000000000000000000000000000000000000000
--- a/spaces/Justin-Choo/Lemon_WEB_UI/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Lemon Webui on Cpu
-emoji: 🍋
-colorFrom: red
-colorTo: blue
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
-python_version: 3.10.6
-duplicated_from: Justin-Chew/Grapefruit_WEB_UI
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/KatieChau/text-generator/README.md b/spaces/KatieChau/text-generator/README.md
deleted file mode 100644
index 59f26fc4e073249ce0e8f6d57160535421fc6076..0000000000000000000000000000000000000000
--- a/spaces/KatieChau/text-generator/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Text Generator
-emoji: 🚀
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.18.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/KevinQHLin/UniVTG/main/train_vlp.py b/spaces/KevinQHLin/UniVTG/main/train_vlp.py
deleted file mode 100644
index feed89496947c621c1a20f4f9326bcd13ec1fa52..0000000000000000000000000000000000000000
--- a/spaces/KevinQHLin/UniVTG/main/train_vlp.py
+++ /dev/null
@@ -1,278 +0,0 @@
-import os
-import pdb
-import sys
-import time
-import json
-import pprint
-import random
-import numpy as np
-from tqdm import tqdm, trange
-from collections import defaultdict
-
-import torch
-import torch.nn as nn
-import torch.backends.cudnn as cudnn
-from torch.utils.data import DataLoader
-from torch.utils.tensorboard import SummaryWriter
-
-sys.path.append('/data/home/qinghonglin/univtg')
-from main.config import BaseOptions, setup_model
-from main.dataset import \
- DatasetVLP, start_end_collate_mr, prepare_batch_inputs_mr
-from main.inference_mr import eval_epoch, start_inference
-from utils.basic_utils import set_seed, AverageMeter, dict_to_markdown
-from utils.model_utils import count_parameters
-
-import logging
-logger = logging.getLogger(__name__)
-logging.basicConfig(format="%(asctime)s.%(msecs)03d:%(levelname)s:%(name)s - %(message)s",
- datefmt="%Y-%m-%d %H:%M:%S",
- level=logging.INFO)
-
-def train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer, cls=None):
- logger.info(f"[Epoch {epoch_i+1}]")
- model.train()
- criterion.train()
-
- # init meters
- time_meters = defaultdict(AverageMeter)
- loss_meters = defaultdict(AverageMeter)
-
- num_training_examples = len(train_loader)
- timer_dataloading = time.time()
- for batch_idx, batch in tqdm(enumerate(train_loader),
- desc="Training Iteration",
- total=num_training_examples):
- time_meters["dataloading_time"].update(time.time() - timer_dataloading)
-
- timer_start = time.time()
- model_inputs, targets = prepare_batch_inputs_mr(batch[1], opt.device, non_blocking=opt.pin_memory)
- time_meters["prepare_inputs_time"].update(time.time() - timer_start)
-
- timer_start = time.time()
-
- if cls is not None:
- model_inputs.update(cls)
-
- # try:
- outputs = model(**model_inputs)
- loss_dict = criterion(outputs, targets)
- weight_dict = criterion.weight_dict
- losses = sum(loss_dict[k] * weight_dict[k] for k in loss_dict.keys() if k in weight_dict)
- time_meters["model_forward_time"].update(time.time() - timer_start)
-
- timer_start = time.time()
- optimizer.zero_grad()
- losses.backward()
- # except:
- # pdb.set_trace()
- if opt.grad_clip > 0:
- nn.utils.clip_grad_norm_(model.parameters(), opt.grad_clip)
- optimizer.step()
- time_meters["model_backward_time"].update(time.time() - timer_start)
-
- loss_dict["loss_overall"] = float(losses) # for logging only
- for k, v in loss_dict.items():
- loss_meters[k].update(float(v) * weight_dict[k] if k in weight_dict else float(v))
-
- timer_dataloading = time.time()
-
- # print/add logs
- tb_writer.add_scalar("Train/lr", float(optimizer.param_groups[0]["lr"]), epoch_i+1)
- for k, v in loss_meters.items():
- tb_writer.add_scalar("Train/{}".format(k), v.avg, epoch_i+1)
-
- to_write = opt.train_log_txt_formatter.format(
- time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
- epoch=epoch_i+1,
- loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in loss_meters.items()]))
- with open(opt.train_log_filepath, "a") as f:
- f.write(to_write)
-
- logger.info("Epoch time stats:")
- for name, meter in time_meters.items():
- d = {k: f"{getattr(meter, k):.4f}" for k in ["max", "min", "avg"]}
- logger.info(f"{name} ==> {d}")
-
-
-def train(model, criterion, optimizer, lr_scheduler, train_dataset, val_dataset, opt):
- if opt.device.type == "cuda":
- logger.info("CUDA enabled.")
- model.to(opt.device)
-
- tb_writer = SummaryWriter(opt.tensorboard_log_dir)
- tb_writer.add_text("hyperparameters", dict_to_markdown(vars(opt), max_str_len=None))
- opt.train_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str}\n"
- opt.eval_log_txt_formatter = "{time_str} [Epoch] {epoch:03d} [Loss] {loss_str} [Metrics] {eval_metrics_str}\n"
-
- train_loader = DataLoader(
- train_dataset,
- collate_fn=start_end_collate_mr,
- batch_size=opt.bsz,
- num_workers=opt.num_workers,
- shuffle=True,
- pin_memory=opt.pin_memory
- )
-
- if ('tal' in opt.train_path) or ('mq' in opt.train_path):
- cls = {
- 'src_cls': train_dataset.src_cls.cuda(),
- 'src_cls_mask': train_dataset.src_cls_mask.cuda(),}
- else:
- cls = None
-
- prev_best_score = 0.
- es_cnt = 0
- if opt.start_epoch is None:
- start_epoch = -1 if opt.eval_init else 0
- else:
- start_epoch = opt.start_epoch
- save_submission_filename = "latest_{}_{}_preds.jsonl".format(opt.dset_name, opt.eval_split_name)
- for epoch_i in trange(start_epoch, opt.n_epoch, desc="Epoch"):
- if epoch_i > -1:
- train_epoch(model, criterion, train_loader, optimizer, opt, epoch_i, tb_writer, cls)
- lr_scheduler.step()
- eval_epoch_interval = opt.eval_epoch
- if opt.eval_path is not None and (epoch_i + 1) % eval_epoch_interval == 0:
- with torch.no_grad():
- metrics_no_nms, metrics_nms, eval_loss_meters, latest_file_paths = \
- eval_epoch(model, val_dataset, opt, save_submission_filename, epoch_i, criterion, tb_writer)
-
- # log
- to_write = opt.eval_log_txt_formatter.format(
- time_str=time.strftime("%Y_%m_%d_%H_%M_%S"),
- epoch=epoch_i,
- loss_str=" ".join(["{} {:.4f}".format(k, v.avg) for k, v in eval_loss_meters.items()]),
- eval_metrics_str=json.dumps(metrics_no_nms))
-
- with open(opt.eval_log_filepath, "a") as f:
- f.write(to_write)
- logger.info("metrics_no_nms {}".format(pprint.pformat(metrics_no_nms["brief"], indent=4)))
- if metrics_nms is not None:
- logger.info("metrics_nms {}".format(pprint.pformat(metrics_nms["brief"], indent=4)))
-
- metrics = metrics_nms if metrics_nms is not None else metrics_no_nms
- for k, v in metrics["brief"].items():
- tb_writer.add_scalar(f"Eval/{k}", float(v), epoch_i+1)
-
- # stop_score = metrics["brief"]["MR-full-mAP"]
- # pdb.set_trace()
- stop_score = metrics["brief"][opt.main_metric]
- if stop_score > prev_best_score:
- es_cnt = 0
- prev_best_score = stop_score
-
- checkpoint = {
- "model": model.state_dict(),
- "optimizer": optimizer.state_dict(),
- "lr_scheduler": lr_scheduler.state_dict(),
- "epoch": epoch_i,
- "opt": opt
- }
- torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_best.ckpt"))
-
- best_file_paths = [e.replace("latest", "best") for e in latest_file_paths]
- for src, tgt in zip(latest_file_paths, best_file_paths):
- os.renames(src, tgt)
- logger.info("The checkpoint file has been updated.")
- else:
- es_cnt += 1
- if opt.max_es_cnt != -1 and es_cnt > opt.max_es_cnt: # early stop
- with open(opt.train_log_filepath, "a") as f:
- f.write(f"Early Stop at epoch {epoch_i}")
- logger.info(f"\n>>>>> Early stop at epoch {epoch_i} {prev_best_score}\n")
- break
-
- # save ckpt
- checkpoint = {
- "model": model.state_dict(),
- "optimizer": optimizer.state_dict(),
- "lr_scheduler": lr_scheduler.state_dict(),
- "epoch": epoch_i,
- "opt": opt
- }
- torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", "_latest.ckpt"))
-
- if (epoch_i + 1) % opt.save_interval == 0 or (epoch_i + 1) % opt.lr_drop == 0: # additional copies
- checkpoint = {
- "model": model.state_dict(),
- "optimizer": optimizer.state_dict(),
- "epoch": epoch_i,
- "opt": opt
- }
- torch.save(checkpoint, opt.ckpt_filepath.replace(".ckpt", f"_e{epoch_i:04d}.ckpt"))
-
- if opt.debug:
- break
-
- tb_writer.close()
-
-
-def start_training():
- logger.info("Setup config, data and model...")
- opt = BaseOptions().parse()
- set_seed(opt.seed)
- if opt.debug: # keep the model run deterministically
- # 'cudnn.benchmark = True' enabled auto finding the best algorithm for a specific input/net config.
- # Enable this only when input size is fixed.
- cudnn.benchmark = False
- cudnn.deterministic = True
-
- dataset_config = dict(
- dset_name=opt.dset_name,
- data_path=opt.train_path,
- v_feat_dirs=opt.v_feat_dirs,
- q_feat_dir=opt.t_feat_dir,
- v_feat_dim=opt.v_feat_dim,
- q_feat_dim=opt.t_feat_dim,
- q_feat_type="last_hidden_state",
- max_q_l=opt.max_q_l,
- max_v_l=opt.max_v_l,
- ctx_mode=opt.ctx_mode,
- data_ratio=opt.data_ratio,
- normalize_v=not opt.no_norm_vfeat,
- normalize_t=not opt.no_norm_tfeat,
- clip_len=opt.clip_length,
- max_windows=opt.max_windows,
- span_loss_type=opt.span_loss_type,
- txt_drop_ratio=opt.txt_drop_ratio,
- use_cache=opt.use_cache,
- add_easy_negative=opt.add_easy_negative,
- easy_negative_only=opt.easy_negative_only
- )
-
- dataset_config["data_path"] = opt.train_path
- train_dataset = DatasetVLP(**dataset_config)
-
- if opt.eval_path is not None:
- dataset_config["data_path"] = opt.eval_path
- dataset_config["txt_drop_ratio"] = 0
- dataset_config["q_feat_dir"] = opt.t_feat_dir.replace("txt_clip_asr", "txt_clip").replace("txt_clip_cap", "txt_clip") # for pretraining
- # dataset_config["load_labels"] = False # uncomment to calculate eval loss
- eval_dataset = DatasetVLP(**dataset_config)
- else:
- eval_dataset = None
-
- if opt.lr_warmup > 0:
- opt.lr_warmup = opt.n_epoch
- model, criterion, optimizer, lr_scheduler = setup_model(opt)
- logger.info(f"Model {model}")
- count_parameters(model)
- logger.info("Start Training...")
- train(model, criterion, optimizer, lr_scheduler, train_dataset, eval_dataset, opt)
- return opt.ckpt_filepath.replace(".ckpt", "_best.ckpt"), opt.eval_split_name, opt.eval_path, opt.debug
-
-
-if __name__ == '__main__':
- best_ckpt_path, eval_split_name, eval_path, debug = start_training()
- if not debug:
- input_args = ["--resume", best_ckpt_path,
- "--eval_split_name", eval_split_name,
- "--eval_path", eval_path]
-
- import sys
- sys.argv[1:] = input_args
- logger.info("\n\n\nFINISHED TRAINING!!!")
- logger.info("Evaluating model at {}".format(best_ckpt_path))
- logger.info("Input args {}".format(sys.argv[1:]))
- start_inference()
\ No newline at end of file
diff --git a/spaces/KyanChen/RSPrompter/mmdet/engine/hooks/mean_teacher_hook.py b/spaces/KyanChen/RSPrompter/mmdet/engine/hooks/mean_teacher_hook.py
deleted file mode 100644
index b924c0a5934248d05e7ce1add50e7574b739b9c7..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/engine/hooks/mean_teacher_hook.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from typing import Optional
-
-import torch.nn as nn
-from mmengine.hooks import Hook
-from mmengine.model import is_model_wrapper
-from mmengine.runner import Runner
-
-from mmdet.registry import HOOKS
-
-
-@HOOKS.register_module()
-class MeanTeacherHook(Hook):
- """Mean Teacher Hook.
-
- Mean Teacher is an efficient semi-supervised learning method in
- `Mean Teacher
- self.score = score # float
-
-
-def coordinate_to_offset(row, col, ncols):
- return int(row * ncols + col)
-
-
-def offset_to_row(offset, ncols):
- return int(offset / ncols)
-
-
-def offset_to_col(offset, ncols):
- return int(offset % ncols)
-
-
-def trimWhitespace(str):
- return re.sub(" +", " ", re.sub(" *$", "", re.sub("^ *", "", str)))
-
-
-def str2toks(str):
- pieces = trimWhitespace(str).split(" ")
- toks = []
- for p in pieces:
- toks.append(Token(p, 0.0, 0.0))
- return toks
-
-
-class EditDistance(object):
- def __init__(self, time_mediated):
- self.time_mediated_ = time_mediated
- self.scores_ = np.nan # Eigen::Matrix
- self.backtraces_ = (
- np.nan
- ) # Eigen::Matrix backtraces_;
- self.confusion_pairs_ = {}
-
- def cost(self, ref, hyp, code):
- if self.time_mediated_:
- if code == Code.match:
- return abs(ref.start - hyp.start) + abs(ref.end - hyp.end)
- elif code == Code.insertion:
- return hyp.end - hyp.start
- elif code == Code.deletion:
- return ref.end - ref.start
- else: # substitution
- return abs(ref.start - hyp.start) + abs(ref.end - hyp.end) + 0.1
- else:
- if code == Code.match:
- return 0
- elif code == Code.insertion or code == Code.deletion:
- return 3
- else: # substitution
- return 4
-
- def get_result(self, refs, hyps):
- res = AlignmentResult(refs=deque(), hyps=deque(), codes=deque(), score=np.nan)
-
- num_rows, num_cols = self.scores_.shape
- res.score = self.scores_[num_rows - 1, num_cols - 1]
-
- curr_offset = coordinate_to_offset(num_rows - 1, num_cols - 1, num_cols)
-
- while curr_offset != 0:
- curr_row = offset_to_row(curr_offset, num_cols)
- curr_col = offset_to_col(curr_offset, num_cols)
-
- prev_offset = self.backtraces_[curr_row, curr_col]
-
- prev_row = offset_to_row(prev_offset, num_cols)
- prev_col = offset_to_col(prev_offset, num_cols)
-
- res.refs.appendleft(curr_row - 1) # Note: this was .push_front() in C++
- res.hyps.appendleft(curr_col - 1)
- if curr_row - 1 == prev_row and curr_col == prev_col:
- res.codes.appendleft(Code.deletion)
- elif curr_row == prev_row and curr_col - 1 == prev_col:
- res.codes.appendleft(Code.insertion)
- else:
- # assert(curr_row - 1 == prev_row and curr_col - 1 == prev_col)
- ref_str = refs[res.refs[0]].label
- hyp_str = hyps[res.hyps[0]].label
-
- if ref_str == hyp_str:
- res.codes.appendleft(Code.match)
- else:
- res.codes.appendleft(Code.substitution)
-
- confusion_pair = "%s -> %s" % (ref_str, hyp_str)
- if confusion_pair not in self.confusion_pairs_:
- self.confusion_pairs_[confusion_pair] = 1
- else:
- self.confusion_pairs_[confusion_pair] += 1
-
- curr_offset = prev_offset
-
- return res
-
- def align(self, refs, hyps):
- if len(refs) == 0 and len(hyps) == 0:
- return np.nan
-
- # NOTE: we're not resetting the values in these matrices because every value
- # will be overridden in the loop below. If this assumption doesn't hold,
- # be sure to set all entries in self.scores_ and self.backtraces_ to 0.
- self.scores_ = np.zeros((len(refs) + 1, len(hyps) + 1))
- self.backtraces_ = np.zeros((len(refs) + 1, len(hyps) + 1))
-
- num_rows, num_cols = self.scores_.shape
-
- for i in range(num_rows):
- for j in range(num_cols):
- if i == 0 and j == 0:
- self.scores_[i, j] = 0.0
- self.backtraces_[i, j] = 0
- continue
-
- if i == 0:
- self.scores_[i, j] = self.scores_[i, j - 1] + self.cost(
- None, hyps[j - 1], Code.insertion
- )
- self.backtraces_[i, j] = coordinate_to_offset(i, j - 1, num_cols)
- continue
-
- if j == 0:
- self.scores_[i, j] = self.scores_[i - 1, j] + self.cost(
- refs[i - 1], None, Code.deletion
- )
- self.backtraces_[i, j] = coordinate_to_offset(i - 1, j, num_cols)
- continue
-
- # Below here both i and j are greater than 0
- ref = refs[i - 1]
- hyp = hyps[j - 1]
- best_score = self.scores_[i - 1, j - 1] + (
- self.cost(ref, hyp, Code.match)
- if (ref.label == hyp.label)
- else self.cost(ref, hyp, Code.substitution)
- )
-
- prev_row = i - 1
- prev_col = j - 1
- ins = self.scores_[i, j - 1] + self.cost(None, hyp, Code.insertion)
- if ins < best_score:
- best_score = ins
- prev_row = i
- prev_col = j - 1
-
- delt = self.scores_[i - 1, j] + self.cost(ref, None, Code.deletion)
- if delt < best_score:
- best_score = delt
- prev_row = i - 1
- prev_col = j
-
- self.scores_[i, j] = best_score
- self.backtraces_[i, j] = coordinate_to_offset(
- prev_row, prev_col, num_cols
- )
-
- return self.get_result(refs, hyps)
-
-
-class WERTransformer(object):
- def __init__(self, hyp_str, ref_str, verbose=True):
- self.ed_ = EditDistance(False)
- self.id2oracle_errs_ = {}
- self.utts_ = 0
- self.words_ = 0
- self.insertions_ = 0
- self.deletions_ = 0
- self.substitutions_ = 0
-
- self.process(["dummy_str", hyp_str, ref_str])
-
- if verbose:
- print("'%s' vs '%s'" % (hyp_str, ref_str))
- self.report_result()
-
- def process(self, input): # std::vector&& input
- if len(input) < 3:
- print(
- "Input must be of the form ... , got ",
- len(input),
- " inputs:",
- )
- return None
-
- # Align
- # std::vector hyps;
- # std::vector refs;
-
- hyps = str2toks(input[-2])
- refs = str2toks(input[-1])
-
- alignment = self.ed_.align(refs, hyps)
- if alignment is None:
- print("Alignment is null")
- return np.nan
-
- # Tally errors
- ins = 0
- dels = 0
- subs = 0
- for code in alignment.codes:
- if code == Code.substitution:
- subs += 1
- elif code == Code.insertion:
- ins += 1
- elif code == Code.deletion:
- dels += 1
-
- # Output
- row = input
- row.append(str(len(refs)))
- row.append(str(ins))
- row.append(str(dels))
- row.append(str(subs))
- # print(row)
-
- # Accumulate
- kIdIndex = 0
- kNBestSep = "/"
-
- pieces = input[kIdIndex].split(kNBestSep)
-
- if len(pieces) == 0:
- print(
- "Error splitting ",
- input[kIdIndex],
- " on '",
- kNBestSep,
- "', got empty list",
- )
- return np.nan
-
- id = pieces[0]
- if id not in self.id2oracle_errs_:
- self.utts_ += 1
- self.words_ += len(refs)
- self.insertions_ += ins
- self.deletions_ += dels
- self.substitutions_ += subs
- self.id2oracle_errs_[id] = [ins, dels, subs]
- else:
- curr_err = ins + dels + subs
- prev_err = np.sum(self.id2oracle_errs_[id])
- if curr_err < prev_err:
- self.id2oracle_errs_[id] = [ins, dels, subs]
-
- return 0
-
- def report_result(self):
- # print("---------- Summary ---------------")
- if self.words_ == 0:
- print("No words counted")
- return
-
- # 1-best
- best_wer = (
- 100.0
- * (self.insertions_ + self.deletions_ + self.substitutions_)
- / self.words_
- )
-
- print(
- "\tWER = %0.2f%% (%i utts, %i words, %0.2f%% ins, "
- "%0.2f%% dels, %0.2f%% subs)"
- % (
- best_wer,
- self.utts_,
- self.words_,
- 100.0 * self.insertions_ / self.words_,
- 100.0 * self.deletions_ / self.words_,
- 100.0 * self.substitutions_ / self.words_,
- )
- )
-
- def wer(self):
- if self.words_ == 0:
- wer = np.nan
- else:
- wer = (
- 100.0
- * (self.insertions_ + self.deletions_ + self.substitutions_)
- / self.words_
- )
- return wer
-
- def stats(self):
- if self.words_ == 0:
- stats = {}
- else:
- wer = (
- 100.0
- * (self.insertions_ + self.deletions_ + self.substitutions_)
- / self.words_
- )
- stats = dict(
- {
- "wer": wer,
- "utts": self.utts_,
- "numwords": self.words_,
- "ins": self.insertions_,
- "dels": self.deletions_,
- "subs": self.substitutions_,
- "confusion_pairs": self.ed_.confusion_pairs_,
- }
- )
- return stats
-
-
-def calc_wer(hyp_str, ref_str):
- t = WERTransformer(hyp_str, ref_str, verbose=0)
- return t.wer()
-
-
-def calc_wer_stats(hyp_str, ref_str):
- t = WERTransformer(hyp_str, ref_str, verbose=0)
- return t.stats()
-
-
-def get_wer_alignment_codes(hyp_str, ref_str):
- """
- INPUT: hypothesis string, reference string
- OUTPUT: List of alignment codes (intermediate results from WER computation)
- """
- t = WERTransformer(hyp_str, ref_str, verbose=0)
- return t.ed_.align(str2toks(ref_str), str2toks(hyp_str)).codes
-
-
-def merge_counts(x, y):
- # Merge two hashes which have 'counts' as their values
- # This can be used for example to merge confusion pair counts
- # conf_pairs = merge_counts(conf_pairs, stats['confusion_pairs'])
- for k, v in y.items():
- if k not in x:
- x[k] = 0
- x[k] += v
- return x
diff --git a/spaces/OneAfterlife/MubertTTM/README.md b/spaces/OneAfterlife/MubertTTM/README.md
deleted file mode 100644
index 38b2366eaa040b27fca142981fef8727ad8cdbbb..0000000000000000000000000000000000000000
--- a/spaces/OneAfterlife/MubertTTM/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: MubertTTM
-emoji: 😻
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.9
-app_file: app.py
-pinned: false
-license: osl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/README_zh.md b/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/README_zh.md
deleted file mode 100644
index 04750b1c656112834e5afea1fbc99ed54c96d3c6..0000000000000000000000000000000000000000
--- a/spaces/OpenDILabCommunity/LLMRiddlesChatGLMCN/README_zh.md
+++ /dev/null
@@ -1,95 +0,0 @@
-# LLM Riddles
-
-
-
-[English](https://github.com/opendilab/LLMRiddles/blob/main/README.md) | 简体中文
-
-## :thinking: 什么是LLM Riddles
-欢迎来到 LLM Riddles！这是一个与语言模型斗智斗勇的游戏。在游戏中，你需要构造与语言模型交互的问题，来得到符合要求的答案。在这个过程中，你可以开动脑筋，用你想到的所有方式，让模型输出答案要求的结果。
-
-## :space_invader: 如何试玩
-我们提供了在线版本以供玩家直接访问试玩:
-- [ChatGPT + 英文(需配置api key)](https://huggingface.co/spaces/OpenDILabCommunity/LLMRiddlesChatGPTEN)
-- [ChatGPT + 中文(需配置api key)](https://huggingface.co/spaces/OpenDILabCommunity/LLMRiddlesChatGPTCN)
-- [Mistral + 英文(已预设api key)](https://d9b451a97791dd8ef3.gradio.live)
-- [ChatGPT + 中文(已预设api key)](http://llmriddles.opendilab.net/)
-
-本地部署可以通过以下方式：
-## 安装
-### ChatGPT 或 ChatGLM API
-```shell
-pip3 install -r requirements.txt
-```
-### Mistral-7B-Instruct-v0.1 本地推理
-```shell
-pip3 install -r requirements-dev.txt
-```
-## 启动
-### ChatGPT + 中文
-```shell
-QUESTION_LANG=cn QUESTION_LLM='chatgpt' QUESTION_LLM_KEY= python3 -u app.py
-```
-### ChatGPT + 英文
-```shell
-QUESTION_LANG=en QUESTION_LLM='chatgpt' QUESTION_LLM_KEY= python3 -u app.py
-```
-### ChatGLM + 中文
-```shell
-QUESTION_LANG=cn QUESTION_LLM='chatglm' QUESTION_LLM_KEY= python3 -u app.py
-```
-### ChatGLM + 英文
-```shell
-QUESTION_LANG=en QUESTION_LLM='chatglm' QUESTION_LLM_KEY= python3 -u app.py
-```
-### Mistral-7B-Instruct-v0.1 + 英文
-```shell
-QUESTION_LANG=en QUESTION_LLM='mistral-7b' python3 -u app.py
-```
-## :technologist: 为什么制作这个游戏
-
-我们的目标是通过这一游戏，让参与者深入领略到提示工程（prompt engineering）和自然语言处理的令人着迷之处。这个过程将向玩家们展示，如何巧妙地构建提示词（prompts），以及如何运用它们来引发人工智能系统的惊人反应，同时也帮助他们更好地理解深度学习和自然语言处理技术的不可思议之处。
-
-## :raising_hand: 如何提交设计好的关卡
-如果有好玩的问题或想法，欢迎玩家提交自己的创意，可以
-[发起 Pull Request](https://github.com/opendilab/LLMRiddles/compare) 向我们提交， 我们会在审核通过后收录至关卡中。
-问题的设计格式应包含以下几点：
-- Pull Request标题，示例：feature(username): 章节X-关卡设计
-- 希望被提及的ID
-- 对应章节问题文件的修改
-- \__init__.py的修改
-
-完整示例请参考：[提交属于自己的关卡设计](https://github.com/opendilab/LLMRiddles/pull/6)
-
-## :writing_hand: 未来计划
-
-- [x] 支持自定义关卡
-- [x] 在线试玩链接
-- [x] Hugging Face Space 链接
-- [x] 支持Mistral-7B（英文）
-- [x] 支持ChatGLM（中文和英文）
-- [ ] 支持Baichuan2-7B（中文）
-- [ ] 支持LLaMA2-7B（英文）
-- [ ] LLM 推理速度优化
-
-## :speech_balloon: 反馈问题 & 提出建议
-- 在 GitHub 上[发起 Issue](https://github.com/opendilab/CodeMorpheus/issues/new/choose)
-- 通过邮件与我们联系 (opendilab@pjlab.org.cn)
-- 在OpenDILab的群组中加入讨论(通过 WeChat: ding314assist 添加小助手微信)
-
-
-## :star2: Special Thanks
-- 感谢 [Haoqiang Fan](https://www.zhihu.com/people/haoqiang-fan) 的原始创意和题目，为本项目的开发和扩展提供了灵感与动力。
-- 感谢 [HuggingFace](https://huggingface.co) 对游戏的支持与协助。
-- 感谢 [ChatGLM](https://chatglm.cn/) 对游戏的支持与协助，特别是供在线预览版使用的足量 tokens。
-- 感谢 [LLM Riddles contributors](https://github.com/opendilab/LLMRiddles/graphs/contributors) 的实现与支持。
-
-## :label: License
-All code within this repository is under [Apache License 2.0](https://www.apache.org/licenses/LICENSE-2.0).
-
-
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h
deleted file mode 100644
index 12aca388e47b12dafd20999f2991a9d42f4b904b..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/nms_rotated/nms_rotated.h
+++ /dev/null
@@ -1,39 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#pragma once
-#include
-
-namespace detectron2 {
-
-at::Tensor nms_rotated_cpu(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold);
-
-#if defined(WITH_CUDA) || defined(WITH_HIP)
-at::Tensor nms_rotated_cuda(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold);
-#endif
-
-// Interface for Python
-// inline is needed to prevent multiple function definitions when this header is
-// included by different cpps
-inline at::Tensor nms_rotated(
- const at::Tensor& dets,
- const at::Tensor& scores,
- const double iou_threshold) {
- assert(dets.device().is_cuda() == scores.device().is_cuda());
- if (dets.device().is_cuda()) {
-#if defined(WITH_CUDA) || defined(WITH_HIP)
- return nms_rotated_cuda(
- dets.contiguous(), scores.contiguous(), iou_threshold);
-#else
- AT_ERROR("Detectron2 is not compiled with GPU support!");
-#endif
- }
-
- return nms_rotated_cpu(dets.contiguous(), scores.contiguous(), iou_threshold);
-}
-
-} // namespace detectron2
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/backbone/res2net.py b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/backbone/res2net.py
deleted file mode 100644
index 1d0d40adb4a300d916deecebd20bcaac08936e6d..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/backbone/res2net.py
+++ /dev/null
@@ -1,802 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-# This file is modified from https://github.com/Res2Net/Res2Net-detectron2/blob/master/detectron2/modeling/backbone/resnet.py
-# The original file is under Apache-2.0 License
-import numpy as np
-import fvcore.nn.weight_init as weight_init
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from detectron2.layers import (
- CNNBlockBase,
- Conv2d,
- DeformConv,
- ModulatedDeformConv,
- ShapeSpec,
- get_norm,
-)
-
-from detectron2.modeling.backbone import Backbone
-from detectron2.modeling.backbone.fpn import FPN
-from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
-from .fpn_p5 import LastLevelP6P7_P5
-from .bifpn import BiFPN
-
-__all__ = [
- "ResNetBlockBase",
- "BasicBlock",
- "BottleneckBlock",
- "DeformBottleneckBlock",
- "BasicStem",
- "ResNet",
- "make_stage",
- "build_res2net_backbone",
-]
-
-
-ResNetBlockBase = CNNBlockBase
-"""
-Alias for backward compatibiltiy.
-"""
-
-
-class BasicBlock(CNNBlockBase):
- """
- The basic residual block for ResNet-18 and ResNet-34, with two 3x3 conv layers
- and a projection shortcut if needed.
- """
-
- def __init__(self, in_channels, out_channels, *, stride=1, norm="BN"):
- """
- Args:
- in_channels (int): Number of input channels.
- out_channels (int): Number of output channels.
- stride (int): Stride for the first conv.
- norm (str or callable): normalization for all conv layers.
- See :func:`layers.get_norm` for supported format.
- """
- super().__init__(in_channels, out_channels, stride)
-
- if in_channels != out_channels:
- self.shortcut = Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=stride,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- else:
- self.shortcut = None
-
- self.conv1 = Conv2d(
- in_channels,
- out_channels,
- kernel_size=3,
- stride=stride,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- self.conv2 = Conv2d(
- out_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- for layer in [self.conv1, self.conv2, self.shortcut]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
- out = self.conv2(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-class BottleneckBlock(CNNBlockBase):
- """
- The standard bottle2neck residual block used by Res2Net-50, 101 and 152.
- """
-
- def __init__(
- self,
- in_channels,
- out_channels,
- *,
- bottleneck_channels,
- stride=1,
- num_groups=1,
- norm="BN",
- stride_in_1x1=False,
- dilation=1,
- basewidth=26,
- scale=4,
- ):
- """
- Args:
- bottleneck_channels (int): number of output channels for the 3x3
- "bottleneck" conv layers.
- num_groups (int): number of groups for the 3x3 conv layer.
- norm (str or callable): normalization for all conv layers.
- See :func:`layers.get_norm` for supported format.
- stride_in_1x1 (bool): when stride>1, whether to put stride in the
- first 1x1 convolution or the bottleneck 3x3 convolution.
- dilation (int): the dilation rate of the 3x3 conv layer.
- """
- super().__init__(in_channels, out_channels, stride)
-
- if in_channels != out_channels:
- self.shortcut = nn.Sequential(
- nn.AvgPool2d(kernel_size=stride, stride=stride,
- ceil_mode=True, count_include_pad=False),
- Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- )
- else:
- self.shortcut = None
-
- # The original MSRA ResNet models have stride in the first 1x1 conv
- # The subsequent fb.torch.resnet and Caffe2 ResNe[X]t implementations have
- # stride in the 3x3 conv
- stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
- width = bottleneck_channels//scale
-
- self.conv1 = Conv2d(
- in_channels,
- bottleneck_channels,
- kernel_size=1,
- stride=stride_1x1,
- bias=False,
- norm=get_norm(norm, bottleneck_channels),
- )
- if scale == 1:
- self.nums = 1
- else:
- self.nums = scale -1
- if self.in_channels!=self.out_channels and stride_3x3!=2:
- self.pool = nn.AvgPool2d(kernel_size=3, stride = stride_3x3, padding=1)
-
- convs = []
- bns = []
- for i in range(self.nums):
- convs.append(nn.Conv2d(
- width,
- width,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- bias=False,
- groups=num_groups,
- dilation=dilation,
- ))
- bns.append(get_norm(norm, width))
- self.convs = nn.ModuleList(convs)
- self.bns = nn.ModuleList(bns)
-
- self.conv3 = Conv2d(
- bottleneck_channels,
- out_channels,
- kernel_size=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- self.scale = scale
- self.width = width
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.stride_3x3 = stride_3x3
- for layer in [self.conv1, self.conv3]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
- if self.shortcut is not None:
- for layer in self.shortcut.modules():
- if isinstance(layer, Conv2d):
- weight_init.c2_msra_fill(layer)
-
- for layer in self.convs:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- # Zero-initialize the last normalization in each residual branch,
- # so that at the beginning, the residual branch starts with zeros,
- # and each residual block behaves like an identity.
- # See Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
- # "For BN layers, the learnable scaling coefficient γ is initialized
- # to be 1, except for each residual block's last BN
- # where γ is initialized to be 0."
-
- # nn.init.constant_(self.conv3.norm.weight, 0)
- # TODO this somehow hurts performance when training GN models from scratch.
- # Add it as an option when we need to use this code to train a backbone.
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
-
- spx = torch.split(out, self.width, 1)
- for i in range(self.nums):
- if i==0 or self.in_channels!=self.out_channels:
- sp = spx[i]
- else:
- sp = sp + spx[i]
- sp = self.convs[i](sp)
- sp = F.relu_(self.bns[i](sp))
- if i==0:
- out = sp
- else:
- out = torch.cat((out, sp), 1)
- if self.scale!=1 and self.stride_3x3==1:
- out = torch.cat((out, spx[self.nums]), 1)
- elif self.scale != 1 and self.stride_3x3==2:
- out = torch.cat((out, self.pool(spx[self.nums])), 1)
-
- out = self.conv3(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-class DeformBottleneckBlock(ResNetBlockBase):
- """
- Not implemented for res2net yet.
- Similar to :class:`BottleneckBlock`, but with deformable conv in the 3x3 convolution.
- """
-
- def __init__(
- self,
- in_channels,
- out_channels,
- *,
- bottleneck_channels,
- stride=1,
- num_groups=1,
- norm="BN",
- stride_in_1x1=False,
- dilation=1,
- deform_modulated=False,
- deform_num_groups=1,
- basewidth=26,
- scale=4,
- ):
- super().__init__(in_channels, out_channels, stride)
- self.deform_modulated = deform_modulated
-
- if in_channels != out_channels:
- # self.shortcut = Conv2d(
- # in_channels,
- # out_channels,
- # kernel_size=1,
- # stride=stride,
- # bias=False,
- # norm=get_norm(norm, out_channels),
- # )
- self.shortcut = nn.Sequential(
- nn.AvgPool2d(kernel_size=stride, stride=stride,
- ceil_mode=True, count_include_pad=False),
- Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- )
- else:
- self.shortcut = None
-
- stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
- width = bottleneck_channels//scale
-
- self.conv1 = Conv2d(
- in_channels,
- bottleneck_channels,
- kernel_size=1,
- stride=stride_1x1,
- bias=False,
- norm=get_norm(norm, bottleneck_channels),
- )
-
- if scale == 1:
- self.nums = 1
- else:
- self.nums = scale -1
- if self.in_channels!=self.out_channels and stride_3x3!=2:
- self.pool = nn.AvgPool2d(kernel_size=3, stride = stride_3x3, padding=1)
-
- if deform_modulated:
- deform_conv_op = ModulatedDeformConv
- # offset channels are 2 or 3 (if with modulated) * kernel_size * kernel_size
- offset_channels = 27
- else:
- deform_conv_op = DeformConv
- offset_channels = 18
-
- # self.conv2_offset = Conv2d(
- # bottleneck_channels,
- # offset_channels * deform_num_groups,
- # kernel_size=3,
- # stride=stride_3x3,
- # padding=1 * dilation,
- # dilation=dilation,
- # )
- # self.conv2 = deform_conv_op(
- # bottleneck_channels,
- # bottleneck_channels,
- # kernel_size=3,
- # stride=stride_3x3,
- # padding=1 * dilation,
- # bias=False,
- # groups=num_groups,
- # dilation=dilation,
- # deformable_groups=deform_num_groups,
- # norm=get_norm(norm, bottleneck_channels),
- # )
-
- conv2_offsets = []
- convs = []
- bns = []
- for i in range(self.nums):
- conv2_offsets.append(Conv2d(
- width,
- offset_channels * deform_num_groups,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- bias=False,
- groups=num_groups,
- dilation=dilation,
- ))
- convs.append(deform_conv_op(
- width,
- width,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- bias=False,
- groups=num_groups,
- dilation=dilation,
- deformable_groups=deform_num_groups,
- ))
- bns.append(get_norm(norm, width))
- self.conv2_offsets = nn.ModuleList(conv2_offsets)
- self.convs = nn.ModuleList(convs)
- self.bns = nn.ModuleList(bns)
-
- self.conv3 = Conv2d(
- bottleneck_channels,
- out_channels,
- kernel_size=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- self.scale = scale
- self.width = width
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.stride_3x3 = stride_3x3
- # for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]:
- # if layer is not None: # shortcut can be None
- # weight_init.c2_msra_fill(layer)
-
- # nn.init.constant_(self.conv2_offset.weight, 0)
- # nn.init.constant_(self.conv2_offset.bias, 0)
- for layer in [self.conv1, self.conv3]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
- if self.shortcut is not None:
- for layer in self.shortcut.modules():
- if isinstance(layer, Conv2d):
- weight_init.c2_msra_fill(layer)
-
- for layer in self.convs:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- for layer in self.conv2_offsets:
- if layer.weight is not None:
- nn.init.constant_(layer.weight, 0)
- if layer.bias is not None:
- nn.init.constant_(layer.bias, 0)
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
-
- # if self.deform_modulated:
- # offset_mask = self.conv2_offset(out)
- # offset_x, offset_y, mask = torch.chunk(offset_mask, 3, dim=1)
- # offset = torch.cat((offset_x, offset_y), dim=1)
- # mask = mask.sigmoid()
- # out = self.conv2(out, offset, mask)
- # else:
- # offset = self.conv2_offset(out)
- # out = self.conv2(out, offset)
- # out = F.relu_(out)
-
- spx = torch.split(out, self.width, 1)
- for i in range(self.nums):
- if i==0 or self.in_channels!=self.out_channels:
- sp = spx[i].contiguous()
- else:
- sp = sp + spx[i].contiguous()
-
- # sp = self.convs[i](sp)
- if self.deform_modulated:
- offset_mask = self.conv2_offsets[i](sp)
- offset_x, offset_y, mask = torch.chunk(offset_mask, 3, dim=1)
- offset = torch.cat((offset_x, offset_y), dim=1)
- mask = mask.sigmoid()
- sp = self.convs[i](sp, offset, mask)
- else:
- offset = self.conv2_offsets[i](sp)
- sp = self.convs[i](sp, offset)
- sp = F.relu_(self.bns[i](sp))
- if i==0:
- out = sp
- else:
- out = torch.cat((out, sp), 1)
- if self.scale!=1 and self.stride_3x3==1:
- out = torch.cat((out, spx[self.nums]), 1)
- elif self.scale != 1 and self.stride_3x3==2:
- out = torch.cat((out, self.pool(spx[self.nums])), 1)
-
- out = self.conv3(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-def make_stage(block_class, num_blocks, first_stride, *, in_channels, out_channels, **kwargs):
- """
- Create a list of blocks just like those in a ResNet stage.
- Args:
- block_class (type): a subclass of ResNetBlockBase
- num_blocks (int):
- first_stride (int): the stride of the first block. The other blocks will have stride=1.
- in_channels (int): input channels of the entire stage.
- out_channels (int): output channels of **every block** in the stage.
- kwargs: other arguments passed to the constructor of every block.
- Returns:
- list[nn.Module]: a list of block module.
- """
- assert "stride" not in kwargs, "Stride of blocks in make_stage cannot be changed."
- blocks = []
- for i in range(num_blocks):
- blocks.append(
- block_class(
- in_channels=in_channels,
- out_channels=out_channels,
- stride=first_stride if i == 0 else 1,
- **kwargs,
- )
- )
- in_channels = out_channels
- return blocks
-
-
-class BasicStem(CNNBlockBase):
- """
- The standard ResNet stem (layers before the first residual block).
- """
-
- def __init__(self, in_channels=3, out_channels=64, norm="BN"):
- """
- Args:
- norm (str or callable): norm after the first conv layer.
- See :func:`layers.get_norm` for supported format.
- """
- super().__init__(in_channels, out_channels, 4)
- self.in_channels = in_channels
- self.conv1 = nn.Sequential(
- Conv2d(
- in_channels,
- 32,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False,
- ),
- get_norm(norm, 32),
- nn.ReLU(inplace=True),
- Conv2d(
- 32,
- 32,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- ),
- get_norm(norm, 32),
- nn.ReLU(inplace=True),
- Conv2d(
- 32,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- ),
- )
- self.bn1 = get_norm(norm, out_channels)
-
- for layer in self.conv1:
- if isinstance(layer, Conv2d):
- weight_init.c2_msra_fill(layer)
-
- def forward(self, x):
- x = self.conv1(x)
- x = self.bn1(x)
- x = F.relu_(x)
- x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
- return x
-
-
-class ResNet(Backbone):
- def __init__(self, stem, stages, num_classes=None, out_features=None):
- """
- Args:
- stem (nn.Module): a stem module
- stages (list[list[CNNBlockBase]]): several (typically 4) stages,
- each contains multiple :class:`CNNBlockBase`.
- num_classes (None or int): if None, will not perform classification.
- Otherwise, will create a linear layer.
- out_features (list[str]): name of the layers whose outputs should
- be returned in forward. Can be anything in "stem", "linear", or "res2" ...
- If None, will return the output of the last layer.
- """
- super(ResNet, self).__init__()
- self.stem = stem
- self.num_classes = num_classes
-
- current_stride = self.stem.stride
- self._out_feature_strides = {"stem": current_stride}
- self._out_feature_channels = {"stem": self.stem.out_channels}
-
- self.stages_and_names = []
- for i, blocks in enumerate(stages):
- assert len(blocks) > 0, len(blocks)
- for block in blocks:
- assert isinstance(block, CNNBlockBase), block
-
- name = "res" + str(i + 2)
- stage = nn.Sequential(*blocks)
-
- self.add_module(name, stage)
- self.stages_and_names.append((stage, name))
-
- self._out_feature_strides[name] = current_stride = int(
- current_stride * np.prod([k.stride for k in blocks])
- )
- self._out_feature_channels[name] = curr_channels = blocks[-1].out_channels
-
- if num_classes is not None:
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.linear = nn.Linear(curr_channels, num_classes)
-
- # Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
- # "The 1000-way fully-connected layer is initialized by
- # drawing weights from a zero-mean Gaussian with standard deviation of 0.01."
- nn.init.normal_(self.linear.weight, std=0.01)
- name = "linear"
-
- if out_features is None:
- out_features = [name]
- self._out_features = out_features
- assert len(self._out_features)
- children = [x[0] for x in self.named_children()]
- for out_feature in self._out_features:
- assert out_feature in children, "Available children: {}".format(", ".join(children))
-
- def forward(self, x):
- outputs = {}
- x = self.stem(x)
- if "stem" in self._out_features:
- outputs["stem"] = x
- for stage, name in self.stages_and_names:
- x = stage(x)
- if name in self._out_features:
- outputs[name] = x
- if self.num_classes is not None:
- x = self.avgpool(x)
- x = torch.flatten(x, 1)
- x = self.linear(x)
- if "linear" in self._out_features:
- outputs["linear"] = x
- return outputs
-
- def output_shape(self):
- return {
- name: ShapeSpec(
- channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]
- )
- for name in self._out_features
- }
-
- def freeze(self, freeze_at=0):
- """
- Freeze the first several stages of the ResNet. Commonly used in
- fine-tuning.
- Args:
- freeze_at (int): number of stem and stages to freeze.
- `1` means freezing the stem. `2` means freezing the stem and
- the first stage, etc.
- Returns:
- nn.Module: this ResNet itself
- """
- if freeze_at >= 1:
- self.stem.freeze()
- for idx, (stage, _) in enumerate(self.stages_and_names, start=2):
- if freeze_at >= idx:
- for block in stage.children():
- block.freeze()
- return self
-
-
-@BACKBONE_REGISTRY.register()
-def build_res2net_backbone(cfg, input_shape):
- """
- Create a Res2Net instance from config.
- Returns:
- ResNet: a :class:`ResNet` instance.
- """
- # need registration of new blocks/stems?
- norm = cfg.MODEL.RESNETS.NORM
- stem = BasicStem(
- in_channels=input_shape.channels,
- out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS,
- norm=norm,
- )
-
- # fmt: off
- freeze_at = cfg.MODEL.BACKBONE.FREEZE_AT
- out_features = cfg.MODEL.RESNETS.OUT_FEATURES
- depth = cfg.MODEL.RESNETS.DEPTH
- num_groups = cfg.MODEL.RESNETS.NUM_GROUPS
- width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP
- scale = 4
- bottleneck_channels = num_groups * width_per_group * scale
- in_channels = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS
- out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
- stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1
- res5_dilation = cfg.MODEL.RESNETS.RES5_DILATION
- deform_on_per_stage = cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE
- deform_modulated = cfg.MODEL.RESNETS.DEFORM_MODULATED
- deform_num_groups = cfg.MODEL.RESNETS.DEFORM_NUM_GROUPS
- # fmt: on
- assert res5_dilation in {1, 2}, "res5_dilation cannot be {}.".format(res5_dilation)
-
- num_blocks_per_stage = {
- 18: [2, 2, 2, 2],
- 34: [3, 4, 6, 3],
- 50: [3, 4, 6, 3],
- 101: [3, 4, 23, 3],
- 152: [3, 8, 36, 3],
- }[depth]
-
- if depth in [18, 34]:
- assert out_channels == 64, "Must set MODEL.RESNETS.RES2_OUT_CHANNELS = 64 for R18/R34"
- assert not any(
- deform_on_per_stage
- ), "MODEL.RESNETS.DEFORM_ON_PER_STAGE unsupported for R18/R34"
- assert res5_dilation == 1, "Must set MODEL.RESNETS.RES5_DILATION = 1 for R18/R34"
- assert num_groups == 1, "Must set MODEL.RESNETS.NUM_GROUPS = 1 for R18/R34"
-
- stages = []
-
- # Avoid creating variables without gradients
- # It consumes extra memory and may cause allreduce to fail
- out_stage_idx = [{"res2": 2, "res3": 3, "res4": 4, "res5": 5}[f] for f in out_features]
- max_stage_idx = max(out_stage_idx)
- for idx, stage_idx in enumerate(range(2, max_stage_idx + 1)):
- dilation = res5_dilation if stage_idx == 5 else 1
- first_stride = 1 if idx == 0 or (stage_idx == 5 and dilation == 2) else 2
- stage_kargs = {
- "num_blocks": num_blocks_per_stage[idx],
- "first_stride": first_stride,
- "in_channels": in_channels,
- "out_channels": out_channels,
- "norm": norm,
- }
- # Use BasicBlock for R18 and R34.
- if depth in [18, 34]:
- stage_kargs["block_class"] = BasicBlock
- else:
- stage_kargs["bottleneck_channels"] = bottleneck_channels
- stage_kargs["stride_in_1x1"] = stride_in_1x1
- stage_kargs["dilation"] = dilation
- stage_kargs["num_groups"] = num_groups
- stage_kargs["scale"] = scale
-
- if deform_on_per_stage[idx]:
- stage_kargs["block_class"] = DeformBottleneckBlock
- stage_kargs["deform_modulated"] = deform_modulated
- stage_kargs["deform_num_groups"] = deform_num_groups
- else:
- stage_kargs["block_class"] = BottleneckBlock
- blocks = make_stage(**stage_kargs)
- in_channels = out_channels
- out_channels *= 2
- bottleneck_channels *= 2
- stages.append(blocks)
- return ResNet(stem, stages, out_features=out_features).freeze(freeze_at)
-
-
-@BACKBONE_REGISTRY.register()
-def build_p67_res2net_fpn_backbone(cfg, input_shape: ShapeSpec):
- """
- Args:
- cfg: a detectron2 CfgNode
-
- Returns:
- backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
- """
- bottom_up = build_res2net_backbone(cfg, input_shape)
- in_features = cfg.MODEL.FPN.IN_FEATURES
- out_channels = cfg.MODEL.FPN.OUT_CHANNELS
- backbone = FPN(
- bottom_up=bottom_up,
- in_features=in_features,
- out_channels=out_channels,
- norm=cfg.MODEL.FPN.NORM,
- top_block=LastLevelP6P7_P5(out_channels, out_channels),
- fuse_type=cfg.MODEL.FPN.FUSE_TYPE,
- )
- return backbone
-
-
-@BACKBONE_REGISTRY.register()
-def build_res2net_bifpn_backbone(cfg, input_shape: ShapeSpec):
- """
- Args:
- cfg: a detectron2 CfgNode
-
- Returns:
- backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
- """
- bottom_up = build_res2net_backbone(cfg, input_shape)
- in_features = cfg.MODEL.FPN.IN_FEATURES
- backbone = BiFPN(
- cfg=cfg,
- bottom_up=bottom_up,
- in_features=in_features,
- out_channels=cfg.MODEL.BIFPN.OUT_CHANNELS,
- norm=cfg.MODEL.BIFPN.NORM,
- num_levels=cfg.MODEL.BIFPN.NUM_LEVELS,
- num_bifpn=cfg.MODEL.BIFPN.NUM_BIFPN,
- separable_conv=cfg.MODEL.BIFPN.SEPARABLE_CONV,
- )
- return backbone
\ No newline at end of file
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/train_net.py b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/train_net.py
deleted file mode 100644
index d903efde074e97e1720f970ea94717ebf105d9af..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/projects/CenterNet2/train_net.py
+++ /dev/null
@@ -1,228 +0,0 @@
-import logging
-import os
-from collections import OrderedDict
-import torch
-from torch.nn.parallel import DistributedDataParallel
-import time
-import datetime
-import json
-
-from fvcore.common.timer import Timer
-import detectron2.utils.comm as comm
-from detectron2.checkpoint import DetectionCheckpointer, PeriodicCheckpointer
-from detectron2.config import get_cfg
-from detectron2.data import (
- MetadataCatalog,
- build_detection_test_loader,
-)
-from detectron2.engine import default_argument_parser, default_setup, launch
-
-from detectron2.evaluation import (
- COCOEvaluator,
- LVISEvaluator,
- inference_on_dataset,
- print_csv_format,
-)
-from detectron2.modeling import build_model
-from detectron2.solver import build_lr_scheduler, build_optimizer
-from detectron2.utils.events import (
- CommonMetricPrinter,
- EventStorage,
- JSONWriter,
- TensorboardXWriter,
-)
-from detectron2.modeling.test_time_augmentation import GeneralizedRCNNWithTTA
-from detectron2.data.dataset_mapper import DatasetMapper
-from detectron2.data.build import build_detection_train_loader
-
-from centernet.config import add_centernet_config
-from centernet.data.custom_build_augmentation import build_custom_augmentation
-
-logger = logging.getLogger("detectron2")
-
-def do_test(cfg, model):
- results = OrderedDict()
- for dataset_name in cfg.DATASETS.TEST:
- mapper = None if cfg.INPUT.TEST_INPUT_TYPE == 'default' else \
- DatasetMapper(
- cfg, False, augmentations=build_custom_augmentation(cfg, False))
- data_loader = build_detection_test_loader(cfg, dataset_name, mapper=mapper)
- output_folder = os.path.join(
- cfg.OUTPUT_DIR, "inference_{}".format(dataset_name))
- evaluator_type = MetadataCatalog.get(dataset_name).evaluator_type
-
- if evaluator_type == "lvis":
- evaluator = LVISEvaluator(dataset_name, cfg, True, output_folder)
- elif evaluator_type == 'coco':
- evaluator = COCOEvaluator(dataset_name, cfg, True, output_folder)
- else:
- assert 0, evaluator_type
-
- results[dataset_name] = inference_on_dataset(
- model, data_loader, evaluator)
- if comm.is_main_process():
- logger.info("Evaluation results for {} in csv format:".format(
- dataset_name))
- print_csv_format(results[dataset_name])
- if len(results) == 1:
- results = list(results.values())[0]
- return results
-
-def do_train(cfg, model, resume=False):
- model.train()
- optimizer = build_optimizer(cfg, model)
- scheduler = build_lr_scheduler(cfg, optimizer)
-
- checkpointer = DetectionCheckpointer(
- model, cfg.OUTPUT_DIR, optimizer=optimizer, scheduler=scheduler
- )
-
- start_iter = (
- checkpointer.resume_or_load(
- cfg.MODEL.WEIGHTS, resume=resume,
- ).get("iteration", -1) + 1
- )
- if cfg.SOLVER.RESET_ITER:
- logger.info('Reset loaded iteration. Start training from iteration 0.')
- start_iter = 0
- max_iter = cfg.SOLVER.MAX_ITER if cfg.SOLVER.TRAIN_ITER < 0 else cfg.SOLVER.TRAIN_ITER
-
- periodic_checkpointer = PeriodicCheckpointer(
- checkpointer, cfg.SOLVER.CHECKPOINT_PERIOD, max_iter=max_iter
- )
-
- writers = (
- [
- CommonMetricPrinter(max_iter),
- JSONWriter(os.path.join(cfg.OUTPUT_DIR, "metrics.json")),
- TensorboardXWriter(cfg.OUTPUT_DIR),
- ]
- if comm.is_main_process()
- else []
- )
-
-
- mapper = DatasetMapper(cfg, True) if cfg.INPUT.CUSTOM_AUG == '' else \
- DatasetMapper(cfg, True, augmentations=build_custom_augmentation(cfg, True))
- if cfg.DATALOADER.SAMPLER_TRAIN in ['TrainingSampler', 'RepeatFactorTrainingSampler']:
- data_loader = build_detection_train_loader(cfg, mapper=mapper)
- else:
- from centernet.data.custom_dataset_dataloader import build_custom_train_loader
- data_loader = build_custom_train_loader(cfg, mapper=mapper)
-
-
- logger.info("Starting training from iteration {}".format(start_iter))
- with EventStorage(start_iter) as storage:
- step_timer = Timer()
- data_timer = Timer()
- start_time = time.perf_counter()
- for data, iteration in zip(data_loader, range(start_iter, max_iter)):
- data_time = data_timer.seconds()
- storage.put_scalars(data_time=data_time)
- step_timer.reset()
- iteration = iteration + 1
- storage.step()
- loss_dict = model(data)
-
- losses = sum(
- loss for k, loss in loss_dict.items())
- assert torch.isfinite(losses).all(), loss_dict
-
- loss_dict_reduced = {k: v.item() \
- for k, v in comm.reduce_dict(loss_dict).items()}
- losses_reduced = sum(loss for loss in loss_dict_reduced.values())
- if comm.is_main_process():
- storage.put_scalars(
- total_loss=losses_reduced, **loss_dict_reduced)
-
- optimizer.zero_grad()
- losses.backward()
- optimizer.step()
-
- storage.put_scalar(
- "lr", optimizer.param_groups[0]["lr"], smoothing_hint=False)
-
- step_time = step_timer.seconds()
- storage.put_scalars(time=step_time)
- data_timer.reset()
- scheduler.step()
-
- if (
- cfg.TEST.EVAL_PERIOD > 0
- and iteration % cfg.TEST.EVAL_PERIOD == 0
- and iteration != max_iter
- ):
- do_test(cfg, model)
- comm.synchronize()
-
- if iteration - start_iter > 5 and \
- (iteration % 20 == 0 or iteration == max_iter):
- for writer in writers:
- writer.write()
- periodic_checkpointer.step(iteration)
-
- total_time = time.perf_counter() - start_time
- logger.info(
- "Total training time: {}".format(
- str(datetime.timedelta(seconds=int(total_time)))))
-
-def setup(args):
- """
- Create configs and perform basic setups.
- """
- cfg = get_cfg()
- add_centernet_config(cfg)
- cfg.merge_from_file(args.config_file)
- cfg.merge_from_list(args.opts)
- if '/auto' in cfg.OUTPUT_DIR:
- file_name = os.path.basename(args.config_file)[:-5]
- cfg.OUTPUT_DIR = cfg.OUTPUT_DIR.replace('/auto', '/{}'.format(file_name))
- logger.info('OUTPUT_DIR: {}'.format(cfg.OUTPUT_DIR))
- cfg.freeze()
- default_setup(cfg, args)
- return cfg
-
-
-def main(args):
- cfg = setup(args)
-
- model = build_model(cfg)
- logger.info("Model:\n{}".format(model))
- if args.eval_only:
- DetectionCheckpointer(model, save_dir=cfg.OUTPUT_DIR).resume_or_load(
- cfg.MODEL.WEIGHTS, resume=args.resume
- )
- if cfg.TEST.AUG.ENABLED:
- logger.info("Running inference with test-time augmentation ...")
- model = GeneralizedRCNNWithTTA(cfg, model, batch_size=1)
-
- return do_test(cfg, model)
-
- distributed = comm.get_world_size() > 1
- if distributed:
- model = DistributedDataParallel(
- model, device_ids=[comm.get_local_rank()], broadcast_buffers=False,
- find_unused_parameters=True
- )
-
- do_train(cfg, model, resume=args.resume)
- return do_test(cfg, model)
-
-
-if __name__ == "__main__":
- args = default_argument_parser()
- args.add_argument('--manual_device', default='')
- args = args.parse_args()
- if args.manual_device != '':
- os.environ['CUDA_VISIBLE_DEVICES'] = args.manual_device
- args.dist_url = 'tcp://127.0.0.1:{}'.format(
- torch.randint(11111, 60000, (1,))[0].item())
- print("Command Line Args:", args)
- launch(
- main,
- args.num_gpus,
- num_machines=args.num_machines,
- machine_rank=args.machine_rank,
- dist_url=args.dist_url,
- args=(args,),
- )
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/transformer.py b/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/transformer.py
deleted file mode 100644
index e61ae0dd941a7be00b3e41a3de833ec50470a45f..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/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/PSLD/PSLD/diffusion-posterior-sampling/bkse/train_script.sh b/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/train_script.sh
deleted file mode 100644
index b12b24941c9580cd0f4c043d6ed680a992cc19d7..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/diffusion-posterior-sampling/bkse/train_script.sh
+++ /dev/null
@@ -1 +0,0 @@
-python3.7 train.py -opt options/REDS/wsharp_woVAE.yml
diff --git a/spaces/PeepDaSlan9/AutoGPT/autogpt/config/config.py b/spaces/PeepDaSlan9/AutoGPT/autogpt/config/config.py
deleted file mode 100644
index 4b53df10e8d2832be7ffb321d9036aec5a47a79d..0000000000000000000000000000000000000000
--- a/spaces/PeepDaSlan9/AutoGPT/autogpt/config/config.py
+++ /dev/null
@@ -1,251 +0,0 @@
-"""Configuration class to store the state of bools for different scripts access."""
-import os
-
-import openai
-import yaml
-from colorama import Fore
-from dotenv import load_dotenv
-
-from autogpt.config.singleton import Singleton
-
-load_dotenv(verbose=True)
-
-
-class Config(metaclass=Singleton):
- """
- Configuration class to store the state of bools for different scripts access.
- """
-
- def __init__(self) -> None:
- """Initialize the Config class"""
- self.debug_mode = False
- self.continuous_mode = False
- self.continuous_limit = 0
- self.speak_mode = False
- self.skip_reprompt = False
- self.allow_downloads = False
- self.skip_news = False
-
- self.ai_settings_file = os.getenv("AI_SETTINGS_FILE", "ai_settings.yaml")
- self.fast_llm_model = os.getenv("FAST_LLM_MODEL", "gpt-3.5-turbo")
- self.smart_llm_model = os.getenv("SMART_LLM_MODEL", "gpt-4")
- self.fast_token_limit = int(os.getenv("FAST_TOKEN_LIMIT", 4000))
- self.smart_token_limit = int(os.getenv("SMART_TOKEN_LIMIT", 8000))
- self.browse_chunk_max_length = int(os.getenv("BROWSE_CHUNK_MAX_LENGTH", 8192))
-
- self.openai_api_key = os.getenv("OPENAI_API_KEY")
- self.temperature = float(os.getenv("TEMPERATURE", "1"))
- self.use_azure = os.getenv("USE_AZURE") == "True"
- self.execute_local_commands = (
- os.getenv("EXECUTE_LOCAL_COMMANDS", "False") == "True"
- )
- self.restrict_to_workspace = (
- os.getenv("RESTRICT_TO_WORKSPACE", "True") == "True"
- )
-
- if self.use_azure:
- self.load_azure_config()
- openai.api_type = self.openai_api_type
- openai.api_base = self.openai_api_base
- openai.api_version = self.openai_api_version
-
- self.elevenlabs_api_key = os.getenv("ELEVENLABS_API_KEY")
- self.elevenlabs_voice_1_id = os.getenv("ELEVENLABS_VOICE_1_ID")
- self.elevenlabs_voice_2_id = os.getenv("ELEVENLABS_VOICE_2_ID")
-
- self.use_mac_os_tts = False
- self.use_mac_os_tts = os.getenv("USE_MAC_OS_TTS")
-
- self.use_brian_tts = False
- self.use_brian_tts = os.getenv("USE_BRIAN_TTS")
-
- self.github_api_key = os.getenv("GITHUB_API_KEY")
- self.github_username = os.getenv("GITHUB_USERNAME")
-
- self.google_api_key = os.getenv("GOOGLE_API_KEY")
- self.custom_search_engine_id = os.getenv("CUSTOM_SEARCH_ENGINE_ID")
-
- self.pinecone_api_key = os.getenv("PINECONE_API_KEY")
- self.pinecone_region = os.getenv("PINECONE_ENV")
-
- self.weaviate_host = os.getenv("WEAVIATE_HOST")
- self.weaviate_port = os.getenv("WEAVIATE_PORT")
- self.weaviate_protocol = os.getenv("WEAVIATE_PROTOCOL", "http")
- self.weaviate_username = os.getenv("WEAVIATE_USERNAME", None)
- self.weaviate_password = os.getenv("WEAVIATE_PASSWORD", None)
- self.weaviate_scopes = os.getenv("WEAVIATE_SCOPES", None)
- self.weaviate_embedded_path = os.getenv("WEAVIATE_EMBEDDED_PATH")
- self.weaviate_api_key = os.getenv("WEAVIATE_API_KEY", None)
- self.use_weaviate_embedded = (
- os.getenv("USE_WEAVIATE_EMBEDDED", "False") == "True"
- )
-
- # milvus configuration, e.g., localhost:19530.
- self.milvus_addr = os.getenv("MILVUS_ADDR", "localhost:19530")
- self.milvus_collection = os.getenv("MILVUS_COLLECTION", "autogpt")
-
- self.image_provider = os.getenv("IMAGE_PROVIDER")
- self.image_size = int(os.getenv("IMAGE_SIZE", 256))
- self.huggingface_api_token = os.getenv("HUGGINGFACE_API_TOKEN")
- self.huggingface_image_model = os.getenv(
- "HUGGINGFACE_IMAGE_MODEL", "CompVis/stable-diffusion-v1-4"
- )
- self.huggingface_audio_to_text_model = os.getenv(
- "HUGGINGFACE_AUDIO_TO_TEXT_MODEL"
- )
- self.sd_webui_url = os.getenv("SD_WEBUI_URL", "http://localhost:7860")
- self.sd_webui_auth = os.getenv("SD_WEBUI_AUTH")
-
- # Selenium browser settings
- self.selenium_web_browser = os.getenv("USE_WEB_BROWSER", "chrome")
- self.selenium_headless = os.getenv("HEADLESS_BROWSER", "True") == "True"
-
- # User agent header to use when making HTTP requests
- # Some websites might just completely deny request with an error code if
- # no user agent was found.
- self.user_agent = os.getenv(
- "USER_AGENT",
- "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36"
- " (KHTML, like Gecko) Chrome/83.0.4103.97 Safari/537.36",
- )
-
- self.redis_host = os.getenv("REDIS_HOST", "localhost")
- self.redis_port = os.getenv("REDIS_PORT", "6379")
- self.redis_password = os.getenv("REDIS_PASSWORD", "")
- self.wipe_redis_on_start = os.getenv("WIPE_REDIS_ON_START", "True") == "True"
- self.memory_index = os.getenv("MEMORY_INDEX", "auto-gpt")
- # Note that indexes must be created on db 0 in redis, this is not configurable.
-
- self.memory_backend = os.getenv("MEMORY_BACKEND", "local")
- # Initialize the OpenAI API client
- openai.api_key = self.openai_api_key
-
- def get_azure_deployment_id_for_model(self, model: str) -> str:
- """
- Returns the relevant deployment id for the model specified.
-
- Parameters:
- model(str): The model to map to the deployment id.
-
- Returns:
- The matching deployment id if found, otherwise an empty string.
- """
- if model == self.fast_llm_model:
- return self.azure_model_to_deployment_id_map[
- "fast_llm_model_deployment_id"
- ] # type: ignore
- elif model == self.smart_llm_model:
- return self.azure_model_to_deployment_id_map[
- "smart_llm_model_deployment_id"
- ] # type: ignore
- elif model == "text-embedding-ada-002":
- return self.azure_model_to_deployment_id_map[
- "embedding_model_deployment_id"
- ] # type: ignore
- else:
- return ""
-
- AZURE_CONFIG_FILE = os.path.join(os.path.dirname(__file__), "..", "azure.yaml")
-
- def load_azure_config(self, config_file: str = AZURE_CONFIG_FILE) -> None:
- """
- Loads the configuration parameters for Azure hosting from the specified file
- path as a yaml file.
-
- Parameters:
- config_file(str): The path to the config yaml file. DEFAULT: "../azure.yaml"
-
- Returns:
- None
- """
- try:
- with open(config_file) as file:
- config_params = yaml.load(file, Loader=yaml.FullLoader)
- except FileNotFoundError:
- config_params = {}
- self.openai_api_type = config_params.get("azure_api_type") or "azure"
- self.openai_api_base = config_params.get("azure_api_base") or ""
- self.openai_api_version = (
- config_params.get("azure_api_version") or "2023-03-15-preview"
- )
- self.azure_model_to_deployment_id_map = config_params.get("azure_model_map", [])
-
- def set_continuous_mode(self, value: bool) -> None:
- """Set the continuous mode value."""
- self.continuous_mode = value
-
- def set_continuous_limit(self, value: int) -> None:
- """Set the continuous limit value."""
- self.continuous_limit = value
-
- def set_speak_mode(self, value: bool) -> None:
- """Set the speak mode value."""
- self.speak_mode = value
-
- def set_fast_llm_model(self, value: str) -> None:
- """Set the fast LLM model value."""
- self.fast_llm_model = value
-
- def set_smart_llm_model(self, value: str) -> None:
- """Set the smart LLM model value."""
- self.smart_llm_model = value
-
- def set_fast_token_limit(self, value: int) -> None:
- """Set the fast token limit value."""
- self.fast_token_limit = value
-
- def set_smart_token_limit(self, value: int) -> None:
- """Set the smart token limit value."""
- self.smart_token_limit = value
-
- def set_browse_chunk_max_length(self, value: int) -> None:
- """Set the browse_website command chunk max length value."""
- self.browse_chunk_max_length = value
-
- def set_openai_api_key(self, value: str) -> None:
- """Set the OpenAI API key value."""
- self.openai_api_key = value
-
- def set_elevenlabs_api_key(self, value: str) -> None:
- """Set the ElevenLabs API key value."""
- self.elevenlabs_api_key = value
-
- def set_elevenlabs_voice_1_id(self, value: str) -> None:
- """Set the ElevenLabs Voice 1 ID value."""
- self.elevenlabs_voice_1_id = value
-
- def set_elevenlabs_voice_2_id(self, value: str) -> None:
- """Set the ElevenLabs Voice 2 ID value."""
- self.elevenlabs_voice_2_id = value
-
- def set_google_api_key(self, value: str) -> None:
- """Set the Google API key value."""
- self.google_api_key = value
-
- def set_custom_search_engine_id(self, value: str) -> None:
- """Set the custom search engine id value."""
- self.custom_search_engine_id = value
-
- def set_pinecone_api_key(self, value: str) -> None:
- """Set the Pinecone API key value."""
- self.pinecone_api_key = value
-
- def set_pinecone_region(self, value: str) -> None:
- """Set the Pinecone region value."""
- self.pinecone_region = value
-
- def set_debug_mode(self, value: bool) -> None:
- """Set the debug mode value."""
- self.debug_mode = value
-
-
-def check_openai_api_key() -> None:
- """Check if the OpenAI API key is set in config.py or as an environment variable."""
- cfg = Config()
- if not cfg.openai_api_key:
- print(
- Fore.RED
- + "Please set your OpenAI API key in .env or as an environment variable."
- )
- print("You can get your key from https://platform.openai.com/account/api-keys")
- exit(1)
diff --git a/spaces/Pie31415/control-animation/annotator/openpose/model.py b/spaces/Pie31415/control-animation/annotator/openpose/model.py
deleted file mode 100644
index 5dfc80de827a17beccb9b0f3f7588545be78c9de..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/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/RMXK/RVC_HFF/tools/rvc_for_realtime.py b/spaces/RMXK/RVC_HFF/tools/rvc_for_realtime.py
deleted file mode 100644
index f746cde4dfd9c3b87fe844304aa3a975d68b3433..0000000000000000000000000000000000000000
--- a/spaces/RMXK/RVC_HFF/tools/rvc_for_realtime.py
+++ /dev/null
@@ -1,381 +0,0 @@
-import os
-import sys
-import traceback
-import logging
-
-logger = logging.getLogger(__name__)
-
-from time import time as ttime
-
-import fairseq
-import faiss
-import numpy as np
-import parselmouth
-import pyworld
-import scipy.signal as signal
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torchcrepe
-
-from infer.lib.infer_pack.models import (
- SynthesizerTrnMs256NSFsid,
- SynthesizerTrnMs256NSFsid_nono,
- SynthesizerTrnMs768NSFsid,
- SynthesizerTrnMs768NSFsid_nono,
-)
-
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-from multiprocessing import Manager as M
-
-from configs.config import Config
-
-config = Config()
-
-mm = M()
-if config.dml == True:
-
- def forward_dml(ctx, x, scale):
- ctx.scale = scale
- res = x.clone().detach()
- return res
-
- fairseq.modules.grad_multiply.GradMultiply.forward = forward_dml
-
-
-# config.device=torch.device("cpu")########强制cpu测试
-# config.is_half=False########强制cpu测试
-class RVC:
- def __init__(
- self,
- key,
- pth_path,
- index_path,
- index_rate,
- n_cpu,
- inp_q,
- opt_q,
- device,
- last_rvc=None,
- ) -> None:
- """
- 初始化
- """
- try:
- global config
- self.inp_q = inp_q
- self.opt_q = opt_q
- # device="cpu"########强制cpu测试
- self.device = device
- self.f0_up_key = key
- self.time_step = 160 / 16000 * 1000
- self.f0_min = 50
- self.f0_max = 1100
- self.f0_mel_min = 1127 * np.log(1 + self.f0_min / 700)
- self.f0_mel_max = 1127 * np.log(1 + self.f0_max / 700)
- self.sr = 16000
- self.window = 160
- self.n_cpu = n_cpu
- if index_rate != 0:
- self.index = faiss.read_index(index_path)
- self.big_npy = self.index.reconstruct_n(0, self.index.ntotal)
- logger.info("Index search enabled")
- self.pth_path = pth_path
- self.index_path = index_path
- self.index_rate = index_rate
-
- if last_rvc is None:
- models, _, _ = fairseq.checkpoint_utils.load_model_ensemble_and_task(
- ["assets/hubert/hubert_base.pt"],
- suffix="",
- )
- hubert_model = models[0]
- hubert_model = hubert_model.to(device)
- if config.is_half:
- hubert_model = hubert_model.half()
- else:
- hubert_model = hubert_model.float()
- hubert_model.eval()
- self.model = hubert_model
- else:
- self.model = last_rvc.model
-
- if last_rvc is None or last_rvc.pth_path != self.pth_path:
- cpt = torch.load(self.pth_path, map_location="cpu")
- self.tgt_sr = cpt["config"][-1]
- cpt["config"][-3] = cpt["weight"]["emb_g.weight"].shape[0]
- self.if_f0 = cpt.get("f0", 1)
- self.version = cpt.get("version", "v1")
- if self.version == "v1":
- if self.if_f0 == 1:
- self.net_g = SynthesizerTrnMs256NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- self.net_g = SynthesizerTrnMs256NSFsid_nono(*cpt["config"])
- elif self.version == "v2":
- if self.if_f0 == 1:
- self.net_g = SynthesizerTrnMs768NSFsid(
- *cpt["config"], is_half=config.is_half
- )
- else:
- self.net_g = SynthesizerTrnMs768NSFsid_nono(*cpt["config"])
- del self.net_g.enc_q
- logger.debug(self.net_g.load_state_dict(cpt["weight"], strict=False))
- self.net_g.eval().to(device)
- # print(2333333333,device,config.device,self.device)#net_g是device，hubert是config.device
- if config.is_half:
- self.net_g = self.net_g.half()
- else:
- self.net_g = self.net_g.float()
- self.is_half = config.is_half
- else:
- self.tgt_sr = last_rvc.tgt_sr
- self.if_f0 = last_rvc.if_f0
- self.version = last_rvc.version
- self.net_g = last_rvc.net_g
- self.is_half = last_rvc.is_half
-
- if last_rvc is not None and hasattr(last_rvc, "model_rmvpe"):
- self.model_rmvpe = last_rvc.model_rmvpe
- except:
- logger.warn(traceback.format_exc())
-
- def change_key(self, new_key):
- self.f0_up_key = new_key
-
- def change_index_rate(self, new_index_rate):
- if new_index_rate != 0 and self.index_rate == 0:
- self.index = faiss.read_index(self.index_path)
- self.big_npy = self.index.reconstruct_n(0, self.index.ntotal)
- logger.info("Index search enabled")
- self.index_rate = new_index_rate
-
- def get_f0_post(self, f0):
- f0_min = self.f0_min
- f0_max = self.f0_max
- f0_mel_min = 1127 * np.log(1 + f0_min / 700)
- f0_mel_max = 1127 * np.log(1 + f0_max / 700)
- f0bak = f0.copy()
- f0_mel = 1127 * np.log(1 + f0 / 700)
- f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
- f0_mel_max - f0_mel_min
- ) + 1
- f0_mel[f0_mel <= 1] = 1
- f0_mel[f0_mel > 255] = 255
- f0_coarse = np.rint(f0_mel).astype(np.int32)
- return f0_coarse, f0bak
-
- def get_f0(self, x, f0_up_key, n_cpu, method="harvest"):
- n_cpu = int(n_cpu)
- if method == "crepe":
- return self.get_f0_crepe(x, f0_up_key)
- if method == "rmvpe":
- return self.get_f0_rmvpe(x, f0_up_key)
- if method == "pm":
- p_len = x.shape[0] // 160 + 1
- f0 = (
- parselmouth.Sound(x, 16000)
- .to_pitch_ac(
- time_step=0.01,
- voicing_threshold=0.6,
- pitch_floor=50,
- pitch_ceiling=1100,
- )
- .selected_array["frequency"]
- )
-
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- # print(pad_size, p_len - len(f0) - pad_size)
- f0 = np.pad(
- f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
- )
-
- f0 *= pow(2, f0_up_key / 12)
- return self.get_f0_post(f0)
- if n_cpu == 1:
- f0, t = pyworld.harvest(
- x.astype(np.double),
- fs=16000,
- f0_ceil=1100,
- f0_floor=50,
- frame_period=10,
- )
- f0 = signal.medfilt(f0, 3)
- f0 *= pow(2, f0_up_key / 12)
- return self.get_f0_post(f0)
- f0bak = np.zeros(x.shape[0] // 160 + 1, dtype=np.float64)
- length = len(x)
- part_length = 160 * ((length // 160 - 1) // n_cpu + 1)
- n_cpu = (length // 160 - 1) // (part_length // 160) + 1
- ts = ttime()
- res_f0 = mm.dict()
- for idx in range(n_cpu):
- tail = part_length * (idx + 1) + 320
- if idx == 0:
- self.inp_q.put((idx, x[:tail], res_f0, n_cpu, ts))
- else:
- self.inp_q.put(
- (idx, x[part_length * idx - 320 : tail], res_f0, n_cpu, ts)
- )
- while 1:
- res_ts = self.opt_q.get()
- if res_ts == ts:
- break
- f0s = [i[1] for i in sorted(res_f0.items(), key=lambda x: x[0])]
- for idx, f0 in enumerate(f0s):
- if idx == 0:
- f0 = f0[:-3]
- elif idx != n_cpu - 1:
- f0 = f0[2:-3]
- else:
- f0 = f0[2:]
- f0bak[
- part_length * idx // 160 : part_length * idx // 160 + f0.shape[0]
- ] = f0
- f0bak = signal.medfilt(f0bak, 3)
- f0bak *= pow(2, f0_up_key / 12)
- return self.get_f0_post(f0bak)
-
- def get_f0_crepe(self, x, f0_up_key):
- if "privateuseone" in str(self.device): ###不支持dml，cpu又太慢用不成，拿pm顶替
- return self.get_f0(x, f0_up_key, 1, "pm")
- audio = torch.tensor(np.copy(x))[None].float()
- # print("using crepe,device:%s"%self.device)
- f0, pd = torchcrepe.predict(
- audio,
- self.sr,
- 160,
- self.f0_min,
- self.f0_max,
- "full",
- batch_size=512,
- # device=self.device if self.device.type!="privateuseone" else "cpu",###crepe不用半精度全部是全精度所以不愁###cpu延迟高到没法用
- device=self.device,
- return_periodicity=True,
- )
- pd = torchcrepe.filter.median(pd, 3)
- f0 = torchcrepe.filter.mean(f0, 3)
- f0[pd < 0.1] = 0
- f0 = f0[0].cpu().numpy()
- f0 *= pow(2, f0_up_key / 12)
- return self.get_f0_post(f0)
-
- def get_f0_rmvpe(self, x, f0_up_key):
- if hasattr(self, "model_rmvpe") == False:
- from infer.lib.rmvpe import RMVPE
-
- logger.info("Loading rmvpe model")
- self.model_rmvpe = RMVPE(
- # "rmvpe.pt", is_half=self.is_half if self.device.type!="privateuseone" else False, device=self.device if self.device.type!="privateuseone"else "cpu"####dml时强制对rmvpe用cpu跑
- # "rmvpe.pt", is_half=False, device=self.device####dml配置
- # "rmvpe.pt", is_half=False, device="cpu"####锁定cpu配置
- "assets/rmvpe/rmvpe.pt",
- is_half=self.is_half,
- device=self.device, ####正常逻辑
- )
- # self.model_rmvpe = RMVPE("aug2_58000_half.pt", is_half=self.is_half, device=self.device)
- f0 = self.model_rmvpe.infer_from_audio(x, thred=0.03)
- f0 *= pow(2, f0_up_key / 12)
- return self.get_f0_post(f0)
-
- def infer(
- self,
- feats: torch.Tensor,
- indata: np.ndarray,
- block_frame_16k,
- rate,
- cache_pitch,
- cache_pitchf,
- f0method,
- ) -> np.ndarray:
- feats = feats.view(1, -1)
- if config.is_half:
- feats = feats.half()
- else:
- feats = feats.float()
- feats = feats.to(self.device)
- t1 = ttime()
- with torch.no_grad():
- padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
- inputs = {
- "source": feats,
- "padding_mask": padding_mask,
- "output_layer": 9 if self.version == "v1" else 12,
- }
- logits = self.model.extract_features(**inputs)
- feats = (
- self.model.final_proj(logits[0]) if self.version == "v1" else logits[0]
- )
- feats = F.pad(feats, (0, 0, 1, 0))
- t2 = ttime()
- try:
- if hasattr(self, "index") and self.index_rate != 0:
- leng_replace_head = int(rate * feats[0].shape[0])
- npy = feats[0][-leng_replace_head:].cpu().numpy().astype("float32")
- score, ix = self.index.search(npy, k=8)
- weight = np.square(1 / score)
- weight /= weight.sum(axis=1, keepdims=True)
- npy = np.sum(self.big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
- if config.is_half:
- npy = npy.astype("float16")
- feats[0][-leng_replace_head:] = (
- torch.from_numpy(npy).unsqueeze(0).to(self.device) * self.index_rate
- + (1 - self.index_rate) * feats[0][-leng_replace_head:]
- )
- else:
- logger.warn("Index search FAILED or disabled")
- except:
- traceback.print_exc()
- logger.warn("Index search FAILED")
- feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
- t3 = ttime()
- if self.if_f0 == 1:
- pitch, pitchf = self.get_f0(indata, self.f0_up_key, self.n_cpu, f0method)
- start_frame = block_frame_16k // 160
- end_frame = len(cache_pitch) - (pitch.shape[0] - 4) + start_frame
- cache_pitch[:] = np.append(cache_pitch[start_frame:end_frame], pitch[3:-1])
- cache_pitchf[:] = np.append(
- cache_pitchf[start_frame:end_frame], pitchf[3:-1]
- )
- p_len = min(feats.shape[1], 13000, cache_pitch.shape[0])
- else:
- cache_pitch, cache_pitchf = None, None
- p_len = min(feats.shape[1], 13000)
- t4 = ttime()
- feats = feats[:, :p_len, :]
- if self.if_f0 == 1:
- cache_pitch = cache_pitch[:p_len]
- cache_pitchf = cache_pitchf[:p_len]
- cache_pitch = torch.LongTensor(cache_pitch).unsqueeze(0).to(self.device)
- cache_pitchf = torch.FloatTensor(cache_pitchf).unsqueeze(0).to(self.device)
- p_len = torch.LongTensor([p_len]).to(self.device)
- ii = 0 # sid
- sid = torch.LongTensor([ii]).to(self.device)
- with torch.no_grad():
- if self.if_f0 == 1:
- # print(12222222222,feats.device,p_len.device,cache_pitch.device,cache_pitchf.device,sid.device,rate2)
- infered_audio = (
- self.net_g.infer(
- feats, p_len, cache_pitch, cache_pitchf, sid, rate
- )[0][0, 0]
- .data
- .float()
- )
- else:
- infered_audio = (
- self.net_g.infer(feats, p_len, sid, rate)[0][0, 0]
- .data
- .float()
- )
- t5 = ttime()
- logger.info(
- "Spent time: fea = %.2fs, index = %.2fs, f0 = %.2fs, model = %.2fs",
- t2 - t1,
- t3 - t2,
- t4 - t3,
- t5 - t4,
- )
- return infered_audio
\ No newline at end of file
diff --git a/spaces/RamAnanth1/T2I-Adapter/ldm/lr_scheduler.py b/spaces/RamAnanth1/T2I-Adapter/ldm/lr_scheduler.py
deleted file mode 100644
index be39da9ca6dacc22bf3df9c7389bbb403a4a3ade..0000000000000000000000000000000000000000
--- a/spaces/RamAnanth1/T2I-Adapter/ldm/lr_scheduler.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import numpy as np
-
-
-class LambdaWarmUpCosineScheduler:
- """
- note: use with a base_lr of 1.0
- """
- def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0):
- self.lr_warm_up_steps = warm_up_steps
- self.lr_start = lr_start
- self.lr_min = lr_min
- self.lr_max = lr_max
- self.lr_max_decay_steps = max_decay_steps
- self.last_lr = 0.
- self.verbosity_interval = verbosity_interval
-
- def schedule(self, n, **kwargs):
- if self.verbosity_interval > 0:
- if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}")
- if n < self.lr_warm_up_steps:
- lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start
- self.last_lr = lr
- return lr
- else:
- t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps)
- t = min(t, 1.0)
- lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * (
- 1 + np.cos(t * np.pi))
- self.last_lr = lr
- return lr
-
- def __call__(self, n, **kwargs):
- return self.schedule(n,**kwargs)
-
-
-class LambdaWarmUpCosineScheduler2:
- """
- supports repeated iterations, configurable via lists
- note: use with a base_lr of 1.0.
- """
- def __init__(self, warm_up_steps, f_min, f_max, f_start, cycle_lengths, verbosity_interval=0):
- assert len(warm_up_steps) == len(f_min) == len(f_max) == len(f_start) == len(cycle_lengths)
- self.lr_warm_up_steps = warm_up_steps
- self.f_start = f_start
- self.f_min = f_min
- self.f_max = f_max
- self.cycle_lengths = cycle_lengths
- self.cum_cycles = np.cumsum([0] + list(self.cycle_lengths))
- self.last_f = 0.
- self.verbosity_interval = verbosity_interval
-
- def find_in_interval(self, n):
- interval = 0
- for cl in self.cum_cycles[1:]:
- if n <= cl:
- return interval
- interval += 1
-
- def schedule(self, n, **kwargs):
- cycle = self.find_in_interval(n)
- n = n - self.cum_cycles[cycle]
- if self.verbosity_interval > 0:
- if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, "
- f"current cycle {cycle}")
- if n < self.lr_warm_up_steps[cycle]:
- f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle]
- self.last_f = f
- return f
- else:
- t = (n - self.lr_warm_up_steps[cycle]) / (self.cycle_lengths[cycle] - self.lr_warm_up_steps[cycle])
- t = min(t, 1.0)
- f = self.f_min[cycle] + 0.5 * (self.f_max[cycle] - self.f_min[cycle]) * (
- 1 + np.cos(t * np.pi))
- self.last_f = f
- return f
-
- def __call__(self, n, **kwargs):
- return self.schedule(n, **kwargs)
-
-
-class LambdaLinearScheduler(LambdaWarmUpCosineScheduler2):
-
- def schedule(self, n, **kwargs):
- cycle = self.find_in_interval(n)
- n = n - self.cum_cycles[cycle]
- if self.verbosity_interval > 0:
- if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, "
- f"current cycle {cycle}")
-
- if n < self.lr_warm_up_steps[cycle]:
- f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle]
- self.last_f = f
- return f
- else:
- f = self.f_min[cycle] + (self.f_max[cycle] - self.f_min[cycle]) * (self.cycle_lengths[cycle] - n) / (self.cycle_lengths[cycle])
- self.last_f = f
- return f
-
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/importlib_resources/abc.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/importlib_resources/abc.py
deleted file mode 100644
index d39dc1adba0f00d2f7bdf6fa2cd1abcd82475e2e..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/importlib_resources/abc.py
+++ /dev/null
@@ -1,137 +0,0 @@
-import abc
-from typing import BinaryIO, Iterable, Text
-
-from ._compat import runtime_checkable, Protocol
-
-
-class ResourceReader(metaclass=abc.ABCMeta):
- """Abstract base class for loaders to provide resource reading support."""
-
- @abc.abstractmethod
- def open_resource(self, resource: Text) -> BinaryIO:
- """Return an opened, file-like object for binary reading.
-
- The 'resource' argument is expected to represent only a file name.
- If the resource cannot be found, FileNotFoundError is raised.
- """
- # This deliberately raises FileNotFoundError instead of
- # NotImplementedError so that if this method is accidentally called,
- # it'll still do the right thing.
- raise FileNotFoundError
-
- @abc.abstractmethod
- def resource_path(self, resource: Text) -> Text:
- """Return the file system path to the specified resource.
-
- The 'resource' argument is expected to represent only a file name.
- If the resource does not exist on the file system, raise
- FileNotFoundError.
- """
- # This deliberately raises FileNotFoundError instead of
- # NotImplementedError so that if this method is accidentally called,
- # it'll still do the right thing.
- raise FileNotFoundError
-
- @abc.abstractmethod
- def is_resource(self, path: Text) -> bool:
- """Return True if the named 'path' is a resource.
-
- Files are resources, directories are not.
- """
- raise FileNotFoundError
-
- @abc.abstractmethod
- def contents(self) -> Iterable[str]:
- """Return an iterable of entries in `package`."""
- raise FileNotFoundError
-
-
-@runtime_checkable
-class Traversable(Protocol):
- """
- An object with a subset of pathlib.Path methods suitable for
- traversing directories and opening files.
- """
-
- @abc.abstractmethod
- def iterdir(self):
- """
- Yield Traversable objects in self
- """
-
- def read_bytes(self):
- """
- Read contents of self as bytes
- """
- with self.open('rb') as strm:
- return strm.read()
-
- def read_text(self, encoding=None):
- """
- Read contents of self as text
- """
- with self.open(encoding=encoding) as strm:
- return strm.read()
-
- @abc.abstractmethod
- def is_dir(self) -> bool:
- """
- Return True if self is a directory
- """
-
- @abc.abstractmethod
- def is_file(self) -> bool:
- """
- Return True if self is a file
- """
-
- @abc.abstractmethod
- def joinpath(self, child):
- """
- Return Traversable child in self
- """
-
- def __truediv__(self, child):
- """
- Return Traversable child in self
- """
- return self.joinpath(child)
-
- @abc.abstractmethod
- def open(self, mode='r', *args, **kwargs):
- """
- mode may be 'r' or 'rb' to open as text or binary. Return a handle
- suitable for reading (same as pathlib.Path.open).
-
- When opening as text, accepts encoding parameters such as those
- accepted by io.TextIOWrapper.
- """
-
- @abc.abstractproperty
- def name(self) -> str:
- """
- The base name of this object without any parent references.
- """
-
-
-class TraversableResources(ResourceReader):
- """
- The required interface for providing traversable
- resources.
- """
-
- @abc.abstractmethod
- def files(self):
- """Return a Traversable object for the loaded package."""
-
- def open_resource(self, resource):
- return self.files().joinpath(resource).open('rb')
-
- def resource_path(self, resource):
- raise FileNotFoundError(resource)
-
- def is_resource(self, path):
- return self.files().joinpath(path).is_file()
-
- def contents(self):
- return (item.name for item in self.files().iterdir())
diff --git a/spaces/Realcat/image-matching-webui/hloc/matchers/dual_softmax.py b/spaces/Realcat/image-matching-webui/hloc/matchers/dual_softmax.py
deleted file mode 100644
index b42887c099998aaf9c48a32ee541f8637ea7d279..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/hloc/matchers/dual_softmax.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import torch
-
-from ..utils.base_model import BaseModel
-import numpy as np
-
-
-# borrow from dedode
-def dual_softmax_matcher(
- desc_A: tuple["B", "C", "N"],
- desc_B: tuple["B", "C", "M"],
- threshold=0.1,
- inv_temperature=20,
- normalize=True,
-):
- B, C, N = desc_A.shape
- if len(desc_A.shape) < 3:
- desc_A, desc_B = desc_A[None], desc_B[None]
- if normalize:
- desc_A = desc_A / desc_A.norm(dim=1, keepdim=True)
- desc_B = desc_B / desc_B.norm(dim=1, keepdim=True)
- sim = (
- torch.einsum("b c n, b c m -> b n m", desc_A, desc_B) * inv_temperature
- )
- P = sim.softmax(dim=-2) * sim.softmax(dim=-1)
- mask = torch.nonzero(
- (P == P.max(dim=-1, keepdim=True).values)
- * (P == P.max(dim=-2, keepdim=True).values)
- * (P > threshold)
- )
- mask = mask.cpu().numpy()
- matches0 = np.ones((B, P.shape[-2]), dtype=int) * (-1)
- scores0 = np.zeros((B, P.shape[-2]), dtype=float)
- matches0[:, mask[:, 1]] = mask[:, 2]
- tmp_P = P.cpu().numpy()
- scores0[:, mask[:, 1]] = tmp_P[mask[:, 0], mask[:, 1], mask[:, 2]]
- matches0 = torch.from_numpy(matches0).to(P.device)
- scores0 = torch.from_numpy(scores0).to(P.device)
- return matches0, scores0
-
-
-class DualSoftMax(BaseModel):
- default_conf = {
- "match_threshold": 0.2,
- "inv_temperature": 20,
- }
- # shape: B x DIM x M
- required_inputs = ["descriptors0", "descriptors1"]
-
- def _init(self, conf):
- pass
-
- def _forward(self, data):
- if (
- data["descriptors0"].size(-1) == 0
- or data["descriptors1"].size(-1) == 0
- ):
- matches0 = torch.full(
- data["descriptors0"].shape[:2],
- -1,
- device=data["descriptors0"].device,
- )
- return {
- "matches0": matches0,
- "matching_scores0": torch.zeros_like(matches0),
- }
-
- matches0, scores0 = dual_softmax_matcher(
- data["descriptors0"],
- data["descriptors1"],
- threshold=self.conf["match_threshold"],
- inv_temperature=self.conf["inv_temperature"],
- )
- return {
- "matches0": matches0, # 1 x M
- "matching_scores0": scores0,
- }
diff --git a/spaces/Realcat/image-matching-webui/third_party/ASpanFormer/configs/aspan/outdoor/aspan_test.py b/spaces/Realcat/image-matching-webui/third_party/ASpanFormer/configs/aspan/outdoor/aspan_test.py
deleted file mode 100644
index e2ff53d7a1943f4149c43cdb6f2547c2290651aa..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/third_party/ASpanFormer/configs/aspan/outdoor/aspan_test.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import sys
-from pathlib import Path
-
-sys.path.append(str(Path(__file__).parent / "../../../"))
-from src.config.default import _CN as cfg
-
-cfg.ASPAN.COARSE.COARSEST_LEVEL = [36, 36]
-cfg.ASPAN.COARSE.TRAIN_RES = [832, 832]
-cfg.ASPAN.COARSE.TEST_RES = [1152, 1152]
-cfg.ASPAN.MATCH_COARSE.MATCH_TYPE = "dual_softmax"
-
-cfg.TRAINER.CANONICAL_LR = 8e-3
-cfg.TRAINER.WARMUP_STEP = 1875 # 3 epochs
-cfg.TRAINER.WARMUP_RATIO = 0.1
-cfg.TRAINER.MSLR_MILESTONES = [8, 12, 16, 20, 24]
-
-# pose estimation
-cfg.TRAINER.RANSAC_PIXEL_THR = 0.5
-
-cfg.TRAINER.OPTIMIZER = "adamw"
-cfg.TRAINER.ADAMW_DECAY = 0.1
-cfg.ASPAN.MATCH_COARSE.TRAIN_COARSE_PERCENT = 0.3
diff --git a/spaces/Realcat/image-matching-webui/third_party/LightGlue/lightglue/superpoint.py b/spaces/Realcat/image-matching-webui/third_party/LightGlue/lightglue/superpoint.py
deleted file mode 100644
index 1b7ce40f698bda6b2aca34d4ee504bd725933005..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/third_party/LightGlue/lightglue/superpoint.py
+++ /dev/null
@@ -1,242 +0,0 @@
-# %BANNER_BEGIN%
-# ---------------------------------------------------------------------
-# %COPYRIGHT_BEGIN%
-#
-# Magic Leap, Inc. ("COMPANY") CONFIDENTIAL
-#
-# Unpublished Copyright (c) 2020
-# Magic Leap, Inc., All Rights Reserved.
-#
-# NOTICE: All information contained herein is, and remains the property
-# of COMPANY. The intellectual and technical concepts contained herein
-# are proprietary to COMPANY and may be covered by U.S. and Foreign
-# Patents, patents in process, and are protected by trade secret or
-# copyright law. Dissemination of this information or reproduction of
-# this material is strictly forbidden unless prior written permission is
-# obtained from COMPANY. Access to the source code contained herein is
-# hereby forbidden to anyone except current COMPANY employees, managers
-# or contractors who have executed Confidentiality and Non-disclosure
-# agreements explicitly covering such access.
-#
-# The copyright notice above does not evidence any actual or intended
-# publication or disclosure of this source code, which includes
-# information that is confidential and/or proprietary, and is a trade
-# secret, of COMPANY. ANY REPRODUCTION, MODIFICATION, DISTRIBUTION,
-# PUBLIC PERFORMANCE, OR PUBLIC DISPLAY OF OR THROUGH USE OF THIS
-# SOURCE CODE WITHOUT THE EXPRESS WRITTEN CONSENT OF COMPANY IS
-# STRICTLY PROHIBITED, AND IN VIOLATION OF APPLICABLE LAWS AND
-# INTERNATIONAL TREATIES. THE RECEIPT OR POSSESSION OF THIS SOURCE
-# CODE AND/OR RELATED INFORMATION DOES NOT CONVEY OR IMPLY ANY RIGHTS
-# TO REPRODUCE, DISCLOSE OR DISTRIBUTE ITS CONTENTS, OR TO MANUFACTURE,
-# USE, OR SELL ANYTHING THAT IT MAY DESCRIBE, IN WHOLE OR IN PART.
-#
-# %COPYRIGHT_END%
-# ----------------------------------------------------------------------
-# %AUTHORS_BEGIN%
-#
-# Originating Authors: Paul-Edouard Sarlin
-#
-# %AUTHORS_END%
-# --------------------------------------------------------------------*/
-# %BANNER_END%
-
-# Adapted by Remi Pautrat, Philipp Lindenberger
-
-import torch
-from torch import nn
-from .utils import ImagePreprocessor
-
-
-def simple_nms(scores, nms_radius: int):
- """Fast Non-maximum suppression to remove nearby points"""
- assert nms_radius >= 0
-
- def max_pool(x):
- return torch.nn.functional.max_pool2d(
- x, kernel_size=nms_radius * 2 + 1, stride=1, padding=nms_radius
- )
-
- zeros = torch.zeros_like(scores)
- max_mask = scores == max_pool(scores)
- for _ in range(2):
- supp_mask = max_pool(max_mask.float()) > 0
- supp_scores = torch.where(supp_mask, zeros, scores)
- new_max_mask = supp_scores == max_pool(supp_scores)
- max_mask = max_mask | (new_max_mask & (~supp_mask))
- return torch.where(max_mask, scores, zeros)
-
-
-def top_k_keypoints(keypoints, scores, k):
- if k >= len(keypoints):
- return keypoints, scores
- scores, indices = torch.topk(scores, k, dim=0, sorted=True)
- return keypoints[indices], scores
-
-
-def sample_descriptors(keypoints, descriptors, s: int = 8):
- """Interpolate descriptors at keypoint locations"""
- b, c, h, w = descriptors.shape
- keypoints = keypoints - s / 2 + 0.5
- keypoints /= torch.tensor([(w * s - s / 2 - 0.5), (h * s - s / 2 - 0.5)],).to(
- keypoints
- )[None]
- keypoints = keypoints * 2 - 1 # normalize to (-1, 1)
- args = {"align_corners": True} if torch.__version__ >= "1.3" else {}
- descriptors = torch.nn.functional.grid_sample(
- descriptors, keypoints.view(b, 1, -1, 2), mode="bilinear", **args
- )
- descriptors = torch.nn.functional.normalize(
- descriptors.reshape(b, c, -1), p=2, dim=1
- )
- return descriptors
-
-
-class SuperPoint(nn.Module):
- """SuperPoint Convolutional Detector and Descriptor
-
- SuperPoint: Self-Supervised Interest Point Detection and
- Description. Daniel DeTone, Tomasz Malisiewicz, and Andrew
- Rabinovich. In CVPRW, 2019. https://arxiv.org/abs/1712.07629
-
- """
-
- default_conf = {
- "descriptor_dim": 256,
- "nms_radius": 4,
- "max_num_keypoints": None,
- "detection_threshold": 0.0005,
- "remove_borders": 4,
- }
-
- preprocess_conf = {
- **ImagePreprocessor.default_conf,
- "resize": 1024,
- "grayscale": True,
- }
-
- required_data_keys = ["image"]
-
- def __init__(self, **conf):
- super().__init__()
- self.conf = {**self.default_conf, **conf}
-
- self.relu = nn.ReLU(inplace=True)
- self.pool = nn.MaxPool2d(kernel_size=2, stride=2)
- c1, c2, c3, c4, c5 = 64, 64, 128, 128, 256
-
- self.conv1a = nn.Conv2d(1, c1, kernel_size=3, stride=1, padding=1)
- self.conv1b = nn.Conv2d(c1, c1, kernel_size=3, stride=1, padding=1)
- self.conv2a = nn.Conv2d(c1, c2, kernel_size=3, stride=1, padding=1)
- self.conv2b = nn.Conv2d(c2, c2, kernel_size=3, stride=1, padding=1)
- self.conv3a = nn.Conv2d(c2, c3, kernel_size=3, stride=1, padding=1)
- self.conv3b = nn.Conv2d(c3, c3, kernel_size=3, stride=1, padding=1)
- self.conv4a = nn.Conv2d(c3, c4, kernel_size=3, stride=1, padding=1)
- self.conv4b = nn.Conv2d(c4, c4, kernel_size=3, stride=1, padding=1)
-
- self.convPa = nn.Conv2d(c4, c5, kernel_size=3, stride=1, padding=1)
- self.convPb = nn.Conv2d(c5, 65, kernel_size=1, stride=1, padding=0)
-
- self.convDa = nn.Conv2d(c4, c5, kernel_size=3, stride=1, padding=1)
- self.convDb = nn.Conv2d(
- c5, self.conf["descriptor_dim"], kernel_size=1, stride=1, padding=0
- )
-
- url = "https://github.com/cvg/LightGlue/releases/download/v0.1_arxiv/superpoint_v1.pth"
- self.load_state_dict(torch.hub.load_state_dict_from_url(url))
-
- mk = self.conf["max_num_keypoints"]
- if mk is not None and mk <= 0:
- raise ValueError("max_num_keypoints must be positive or None")
-
- print("Loaded SuperPoint model")
-
- def forward(self, data: dict) -> dict:
- """Compute keypoints, scores, descriptors for image"""
- for key in self.required_data_keys:
- assert key in data, f"Missing key {key} in data"
- image = data["image"]
- if image.shape[1] == 3: # RGB
- scale = image.new_tensor([0.299, 0.587, 0.114]).view(1, 3, 1, 1)
- image = (image * scale).sum(1, keepdim=True)
- # Shared Encoder
- x = self.relu(self.conv1a(image))
- x = self.relu(self.conv1b(x))
- x = self.pool(x)
- x = self.relu(self.conv2a(x))
- x = self.relu(self.conv2b(x))
- x = self.pool(x)
- x = self.relu(self.conv3a(x))
- x = self.relu(self.conv3b(x))
- x = self.pool(x)
- x = self.relu(self.conv4a(x))
- x = self.relu(self.conv4b(x))
-
- # Compute the dense keypoint scores
- cPa = self.relu(self.convPa(x))
- scores = self.convPb(cPa)
- scores = torch.nn.functional.softmax(scores, 1)[:, :-1]
- b, _, h, w = scores.shape
- scores = scores.permute(0, 2, 3, 1).reshape(b, h, w, 8, 8)
- scores = scores.permute(0, 1, 3, 2, 4).reshape(b, h * 8, w * 8)
- scores = simple_nms(scores, self.conf["nms_radius"])
-
- # Discard keypoints near the image borders
- if self.conf["remove_borders"]:
- pad = self.conf["remove_borders"]
- scores[:, :pad] = -1
- scores[:, :, :pad] = -1
- scores[:, -pad:] = -1
- scores[:, :, -pad:] = -1
-
- # Extract keypoints
- best_kp = torch.where(scores > self.conf["detection_threshold"])
- scores = scores[best_kp]
-
- # Separate into batches
- keypoints = [
- torch.stack(best_kp[1:3], dim=-1)[best_kp[0] == i] for i in range(b)
- ]
- scores = [scores[best_kp[0] == i] for i in range(b)]
-
- # Keep the k keypoints with highest score
- if self.conf["max_num_keypoints"] is not None:
- keypoints, scores = list(
- zip(
- *[
- top_k_keypoints(k, s, self.conf["max_num_keypoints"])
- for k, s in zip(keypoints, scores)
- ]
- )
- )
-
- # Convert (h, w) to (x, y)
- keypoints = [torch.flip(k, [1]).float() for k in keypoints]
-
- # Compute the dense descriptors
- cDa = self.relu(self.convDa(x))
- descriptors = self.convDb(cDa)
- descriptors = torch.nn.functional.normalize(descriptors, p=2, dim=1)
-
- # Extract descriptors
- descriptors = [
- sample_descriptors(k[None], d[None], 8)[0]
- for k, d in zip(keypoints, descriptors)
- ]
-
- return {
- "keypoints": torch.stack(keypoints, 0),
- "keypoint_scores": torch.stack(scores, 0),
- "descriptors": torch.stack(descriptors, 0).transpose(-1, -2),
- }
-
- def extract(self, img: torch.Tensor, **conf) -> dict:
- """Perform extraction with online resizing"""
- if img.dim() == 3:
- img = img[None] # add batch dim
- assert img.dim() == 4 and img.shape[0] == 1
- shape = img.shape[-2:][::-1]
- img, scales = ImagePreprocessor(**{**self.preprocess_conf, **conf})(img)
- feats = self.forward({"image": img})
- feats["image_size"] = torch.tensor(shape)[None].to(img).float()
- feats["keypoints"] = (feats["keypoints"] + 0.5) / scales[None] - 0.5
- return feats
diff --git a/spaces/Reeve/Ohayou_Face/configs/__init__.py b/spaces/Reeve/Ohayou_Face/configs/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Reeve/Ohayou_Face/models/mtcnn/mtcnn_pytorch/src/align_trans.py b/spaces/Reeve/Ohayou_Face/models/mtcnn/mtcnn_pytorch/src/align_trans.py
deleted file mode 100644
index ab5f1df002bc19556ae8a75cabf56310084785a9..0000000000000000000000000000000000000000
--- a/spaces/Reeve/Ohayou_Face/models/mtcnn/mtcnn_pytorch/src/align_trans.py
+++ /dev/null
@@ -1,304 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Mon Apr 24 15:43:29 2017
-@author: zhaoy
-"""
-import numpy as np
-import cv2
-
-# from scipy.linalg import lstsq
-# from scipy.ndimage import geometric_transform # , map_coordinates
-
-from models.mtcnn.mtcnn_pytorch.src.matlab_cp2tform import get_similarity_transform_for_cv2
-
-# reference facial points, a list of coordinates (x,y)
-REFERENCE_FACIAL_POINTS = [
- [30.29459953, 51.69630051],
- [65.53179932, 51.50139999],
- [48.02519989, 71.73660278],
- [33.54930115, 92.3655014],
- [62.72990036, 92.20410156]
-]
-
-DEFAULT_CROP_SIZE = (96, 112)
-
-
-class FaceWarpException(Exception):
- def __str__(self):
- return 'In File {}:{}'.format(
- __file__, super.__str__(self))
-
-
-def get_reference_facial_points(output_size=None,
- inner_padding_factor=0.0,
- outer_padding=(0, 0),
- default_square=False):
- """
- Function:
- ----------
- get reference 5 key points according to crop settings:
- 0. Set default crop_size:
- if default_square:
- crop_size = (112, 112)
- else:
- crop_size = (96, 112)
- 1. Pad the crop_size by inner_padding_factor in each side;
- 2. Resize crop_size into (output_size - outer_padding*2),
- pad into output_size with outer_padding;
- 3. Output reference_5point;
- Parameters:
- ----------
- @output_size: (w, h) or None
- size of aligned face image
- @inner_padding_factor: (w_factor, h_factor)
- padding factor for inner (w, h)
- @outer_padding: (w_pad, h_pad)
- each row is a pair of coordinates (x, y)
- @default_square: True or False
- if True:
- default crop_size = (112, 112)
- else:
- default crop_size = (96, 112);
- !!! make sure, if output_size is not None:
- (output_size - outer_padding)
- = some_scale * (default crop_size * (1.0 + inner_padding_factor))
- Returns:
- ----------
- @reference_5point: 5x2 np.array
- each row is a pair of transformed coordinates (x, y)
- """
- # print('\n===> get_reference_facial_points():')
-
- # print('---> Params:')
- # print(' output_size: ', output_size)
- # print(' inner_padding_factor: ', inner_padding_factor)
- # print(' outer_padding:', outer_padding)
- # print(' default_square: ', default_square)
-
- tmp_5pts = np.array(REFERENCE_FACIAL_POINTS)
- tmp_crop_size = np.array(DEFAULT_CROP_SIZE)
-
- # 0) make the inner region a square
- if default_square:
- size_diff = max(tmp_crop_size) - tmp_crop_size
- tmp_5pts += size_diff / 2
- tmp_crop_size += size_diff
-
- # print('---> default:')
- # print(' crop_size = ', tmp_crop_size)
- # print(' reference_5pts = ', tmp_5pts)
-
- if (output_size and
- output_size[0] == tmp_crop_size[0] and
- output_size[1] == tmp_crop_size[1]):
- # print('output_size == DEFAULT_CROP_SIZE {}: return default reference points'.format(tmp_crop_size))
- return tmp_5pts
-
- if (inner_padding_factor == 0 and
- outer_padding == (0, 0)):
- if output_size is None:
- # print('No paddings to do: return default reference points')
- return tmp_5pts
- else:
- raise FaceWarpException(
- 'No paddings to do, output_size must be None or {}'.format(tmp_crop_size))
-
- # check output size
- if not (0 <= inner_padding_factor <= 1.0):
- raise FaceWarpException('Not (0 <= inner_padding_factor <= 1.0)')
-
- if ((inner_padding_factor > 0 or outer_padding[0] > 0 or outer_padding[1] > 0)
- and output_size is None):
- output_size = tmp_crop_size * \
- (1 + inner_padding_factor * 2).astype(np.int32)
- output_size += np.array(outer_padding)
- # print(' deduced from paddings, output_size = ', output_size)
-
- if not (outer_padding[0] < output_size[0]
- and outer_padding[1] < output_size[1]):
- raise FaceWarpException('Not (outer_padding[0] < output_size[0]'
- 'and outer_padding[1] < output_size[1])')
-
- # 1) pad the inner region according inner_padding_factor
- # print('---> STEP1: pad the inner region according inner_padding_factor')
- if inner_padding_factor > 0:
- size_diff = tmp_crop_size * inner_padding_factor * 2
- tmp_5pts += size_diff / 2
- tmp_crop_size += np.round(size_diff).astype(np.int32)
-
- # print(' crop_size = ', tmp_crop_size)
- # print(' reference_5pts = ', tmp_5pts)
-
- # 2) resize the padded inner region
- # print('---> STEP2: resize the padded inner region')
- size_bf_outer_pad = np.array(output_size) - np.array(outer_padding) * 2
- # print(' crop_size = ', tmp_crop_size)
- # print(' size_bf_outer_pad = ', size_bf_outer_pad)
-
- if size_bf_outer_pad[0] * tmp_crop_size[1] != size_bf_outer_pad[1] * tmp_crop_size[0]:
- raise FaceWarpException('Must have (output_size - outer_padding)'
- '= some_scale * (crop_size * (1.0 + inner_padding_factor)')
-
- scale_factor = size_bf_outer_pad[0].astype(np.float32) / tmp_crop_size[0]
- # print(' resize scale_factor = ', scale_factor)
- tmp_5pts = tmp_5pts * scale_factor
- # size_diff = tmp_crop_size * (scale_factor - min(scale_factor))
- # tmp_5pts = tmp_5pts + size_diff / 2
- tmp_crop_size = size_bf_outer_pad
- # print(' crop_size = ', tmp_crop_size)
- # print(' reference_5pts = ', tmp_5pts)
-
- # 3) add outer_padding to make output_size
- reference_5point = tmp_5pts + np.array(outer_padding)
- tmp_crop_size = output_size
- # print('---> STEP3: add outer_padding to make output_size')
- # print(' crop_size = ', tmp_crop_size)
- # print(' reference_5pts = ', tmp_5pts)
-
- # print('===> end get_reference_facial_points\n')
-
- return reference_5point
-
-
-def get_affine_transform_matrix(src_pts, dst_pts):
- """
- Function:
- ----------
- get affine transform matrix 'tfm' from src_pts to dst_pts
- Parameters:
- ----------
- @src_pts: Kx2 np.array
- source points matrix, each row is a pair of coordinates (x, y)
- @dst_pts: Kx2 np.array
- destination points matrix, each row is a pair of coordinates (x, y)
- Returns:
- ----------
- @tfm: 2x3 np.array
- transform matrix from src_pts to dst_pts
- """
-
- tfm = np.float32([[1, 0, 0], [0, 1, 0]])
- n_pts = src_pts.shape[0]
- ones = np.ones((n_pts, 1), src_pts.dtype)
- src_pts_ = np.hstack([src_pts, ones])
- dst_pts_ = np.hstack([dst_pts, ones])
-
- # #print(('src_pts_:\n' + str(src_pts_))
- # #print(('dst_pts_:\n' + str(dst_pts_))
-
- A, res, rank, s = np.linalg.lstsq(src_pts_, dst_pts_)
-
- # #print(('np.linalg.lstsq return A: \n' + str(A))
- # #print(('np.linalg.lstsq return res: \n' + str(res))
- # #print(('np.linalg.lstsq return rank: \n' + str(rank))
- # #print(('np.linalg.lstsq return s: \n' + str(s))
-
- if rank == 3:
- tfm = np.float32([
- [A[0, 0], A[1, 0], A[2, 0]],
- [A[0, 1], A[1, 1], A[2, 1]]
- ])
- elif rank == 2:
- tfm = np.float32([
- [A[0, 0], A[1, 0], 0],
- [A[0, 1], A[1, 1], 0]
- ])
-
- return tfm
-
-
-def warp_and_crop_face(src_img,
- facial_pts,
- reference_pts=None,
- crop_size=(96, 112),
- align_type='smilarity'):
- """
- Function:
- ----------
- apply affine transform 'trans' to uv
- Parameters:
- ----------
- @src_img: 3x3 np.array
- input image
- @facial_pts: could be
- 1)a list of K coordinates (x,y)
- or
- 2) Kx2 or 2xK np.array
- each row or col is a pair of coordinates (x, y)
- @reference_pts: could be
- 1) a list of K coordinates (x,y)
- or
- 2) Kx2 or 2xK np.array
- each row or col is a pair of coordinates (x, y)
- or
- 3) None
- if None, use default reference facial points
- @crop_size: (w, h)
- output face image size
- @align_type: transform type, could be one of
- 1) 'similarity': use similarity transform
- 2) 'cv2_affine': use the first 3 points to do affine transform,
- by calling cv2.getAffineTransform()
- 3) 'affine': use all points to do affine transform
- Returns:
- ----------
- @face_img: output face image with size (w, h) = @crop_size
- """
-
- if reference_pts is None:
- if crop_size[0] == 96 and crop_size[1] == 112:
- reference_pts = REFERENCE_FACIAL_POINTS
- else:
- default_square = False
- inner_padding_factor = 0
- outer_padding = (0, 0)
- output_size = crop_size
-
- reference_pts = get_reference_facial_points(output_size,
- inner_padding_factor,
- outer_padding,
- default_square)
-
- ref_pts = np.float32(reference_pts)
- ref_pts_shp = ref_pts.shape
- if max(ref_pts_shp) < 3 or min(ref_pts_shp) != 2:
- raise FaceWarpException(
- 'reference_pts.shape must be (K,2) or (2,K) and K>2')
-
- if ref_pts_shp[0] == 2:
- ref_pts = ref_pts.T
-
- src_pts = np.float32(facial_pts)
- src_pts_shp = src_pts.shape
- if max(src_pts_shp) < 3 or min(src_pts_shp) != 2:
- raise FaceWarpException(
- 'facial_pts.shape must be (K,2) or (2,K) and K>2')
-
- if src_pts_shp[0] == 2:
- src_pts = src_pts.T
-
- # #print('--->src_pts:\n', src_pts
- # #print('--->ref_pts\n', ref_pts
-
- if src_pts.shape != ref_pts.shape:
- raise FaceWarpException(
- 'facial_pts and reference_pts must have the same shape')
-
- if align_type is 'cv2_affine':
- tfm = cv2.getAffineTransform(src_pts[0:3], ref_pts[0:3])
- # #print(('cv2.getAffineTransform() returns tfm=\n' + str(tfm))
- elif align_type is 'affine':
- tfm = get_affine_transform_matrix(src_pts, ref_pts)
- # #print(('get_affine_transform_matrix() returns tfm=\n' + str(tfm))
- else:
- tfm = get_similarity_transform_for_cv2(src_pts, ref_pts)
- # #print(('get_similarity_transform_for_cv2() returns tfm=\n' + str(tfm))
-
- # #print('--->Transform matrix: '
- # #print(('type(tfm):' + str(type(tfm)))
- # #print(('tfm.dtype:' + str(tfm.dtype))
- # #print( tfm
-
- face_img = cv2.warpAffine(src_img, tfm, (crop_size[0], crop_size[1]))
-
- return face_img, tfm
diff --git a/spaces/Rick458/Desi-Food-Vision/app.py b/spaces/Rick458/Desi-Food-Vision/app.py
deleted file mode 100644
index 410eed3873569dcafd30a4f192d1be8ad31cb47e..0000000000000000000000000000000000000000
--- a/spaces/Rick458/Desi-Food-Vision/app.py
+++ /dev/null
@@ -1,122 +0,0 @@
-# Importing libraries for gradio app
-import gradio as gr
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchvision import models
-import torchvision.transforms as tt
-from PIL import Image
-
-
-
-# Moving data to CPU
-def to_device(data, device):
- """Move tensor(s) to chosen device"""
- if isinstance(data, (list,tuple)):
- return [to_device(x, device) for x in data]
- return data.to(device, non_blocking=True)
-
-
-
-# Defining our Class for just prediction
-def accuracy(outputs, labels):
- _, preds = torch.max(outputs, dim=1)
- return torch.tensor(torch.sum(preds == labels).item() / len(preds))
-
-class ImageClassificationBase(nn.Module):
-
- def validation_step(self, batch):
- images, labels = batch
- out = self(images) # Generate predictions
- loss = F.cross_entropy(out, labels) # Calculate loss
- acc = accuracy(out, labels) # Calculate accuracy
- return {'val_loss': loss.detach(), 'val_acc': acc}
-
- def validation_epoch_end(self, outputs):
- batch_losses = [x['val_loss'] for x in outputs]
- epoch_loss = torch.stack(batch_losses).mean() # Combine losses
- batch_accs = [x['val_acc'] for x in outputs]
- epoch_acc = torch.stack(batch_accs).mean() # Combine accuracies
- return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}
-
-
-
-# Defining our finetuned Resnet50 Architecture with our Classification layer
-class IndianFoodModelResnet50(ImageClassificationBase):
- def __init__(self, num_classes, pretrained=True):
- super().__init__()
- self.network = models.resnet50(pretrained=pretrained)
- self.network.fc = nn.Linear(self.network.fc.in_features, num_classes)
-
- def forward(self, xb):
- return self.network(xb)
-
-
-
-# Prediction method
-@torch.no_grad()
-def evaluate(model, val_loader):
- model.eval()
- outputs = [model.validation_step(batch) for batch in val_loader]
- return model.validation_epoch_end(outputs)
-
-
-
-# Initialising our model and moving it to CPU
-classes = ['burger', 'butter_naan', 'chai', 'chapati', 'chole_bhature',
- 'dal_makhani', 'dhokla', 'fried_rice', 'idli', 'jalebi',
- 'kaathi_rolls', 'kadai_paneer', 'kulfi', 'masala_dosa', 'momos',
- 'paani_puri', 'pakode', 'pav_bhaji', 'pizza', 'samosa']
-model = IndianFoodModelResnet50(len(classes), pretrained=True)
-device = 'cpu'
-to_device(model, device);
-
-
-# Loading the model
-ckp_path = 'indianFood-resnet50.pth'
-model.load_state_dict(torch.load(ckp_path, map_location=torch.device('cpu')))
-model.eval()
-
-
-
-# Image preprocessing before prediction
-stats = ((0.485, 0.456, 0.406), (0.229, 0.224, 0.225))
-img_tfms = tt.Compose([tt.Resize((224, 224)),
- tt.ToTensor(),
- tt.Normalize(*stats, inplace = True)])
-
-def predict_image(image, model):
- xb = to_device(image.unsqueeze(0), device)
- yb = model(xb)
- _, preds = torch.max(yb, dim=1)
- return classes[preds[0].item()]
-
-
-
-# Function handling input, processing and output
-def classify_image(path):
- img = Image.open(path)
- img = img_tfms(img)
- label = predict_image(img, model)
- return label
-
-
-
-# Defining gradio interface functions
-image = gr.inputs.Image(shape=(224, 224), type="filepath")
-label = gr.outputs.Label(num_top_classes=1)
-
-article = ""
-
-
-gr.Interface(
- fn=classify_image,
- inputs=image,
- outputs=label,
- examples = [["idli.jpg"], ["naan.jpg"]],
- theme = "huggingface",
- title = "DesiVisionNet: Indian Food Vision with ResNet",
- description = "This is a Gradio demo for multi-class image classification of Indian food amongst 20 classes. The DesiVisionNet achieved 90% accuracy on our test dataset, performing well for a relatively efficient model. See the GitHub project page for detailed information below. Here, we provide a demo for real-world food classification. To use it, simply upload your image, or click one of the examples to load them.",
- article = article
-).launch()
\ No newline at end of file
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/detectors/paa.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/detectors/paa.py
deleted file mode 100644
index 9b4bb5e0939b824d9fef7fc3bd49a0164c29613a..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/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/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/utils/profiling.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/utils/profiling.py
deleted file mode 100644
index 4be9222c37e922329d537f883f5587995e27efc6..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/utils/profiling.py
+++ /dev/null
@@ -1,39 +0,0 @@
-import contextlib
-import sys
-import time
-
-import torch
-
-if sys.version_info >= (3, 7):
-
- @contextlib.contextmanager
- def profile_time(trace_name,
- name,
- enabled=True,
- stream=None,
- end_stream=None):
- """Print time spent by CPU and GPU.
-
- Useful as a temporary context manager to find sweet spots of code
- suitable for async implementation.
- """
- if (not enabled) or not torch.cuda.is_available():
- yield
- return
- stream = stream if stream else torch.cuda.current_stream()
- end_stream = end_stream if end_stream else stream
- start = torch.cuda.Event(enable_timing=True)
- end = torch.cuda.Event(enable_timing=True)
- stream.record_event(start)
- try:
- cpu_start = time.monotonic()
- yield
- finally:
- cpu_end = time.monotonic()
- end_stream.record_event(end)
- end.synchronize()
- cpu_time = (cpu_end - cpu_start) * 1000
- gpu_time = start.elapsed_time(end)
- msg = f'{trace_name} {name} cpu_time {cpu_time:.2f} ms '
- msg += f'gpu_time {gpu_time:.2f} ms stream {stream}'
- print(msg, end_stream)
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/core/evaluation/eval_hooks.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/core/evaluation/eval_hooks.py
deleted file mode 100644
index 6fc100c8f96e817a6ed2666f7c9f762af2463b48..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmseg/core/evaluation/eval_hooks.py
+++ /dev/null
@@ -1,109 +0,0 @@
-import os.path as osp
-
-from annotator.uniformer.mmcv.runner import DistEvalHook as _DistEvalHook
-from annotator.uniformer.mmcv.runner import EvalHook as _EvalHook
-
-
-class EvalHook(_EvalHook):
- """Single GPU EvalHook, with efficient test support.
-
- Args:
- by_epoch (bool): Determine perform evaluation by epoch or by iteration.
- If set to True, it will perform by epoch. Otherwise, by iteration.
- Default: False.
- efficient_test (bool): Whether save the results as local numpy files to
- save CPU memory during evaluation. Default: False.
- Returns:
- list: The prediction results.
- """
-
- greater_keys = ['mIoU', 'mAcc', 'aAcc']
-
- def __init__(self, *args, by_epoch=False, efficient_test=False, **kwargs):
- super().__init__(*args, by_epoch=by_epoch, **kwargs)
- self.efficient_test = efficient_test
-
- def after_train_iter(self, runner):
- """After train epoch hook.
-
- Override default ``single_gpu_test``.
- """
- if self.by_epoch or not self.every_n_iters(runner, self.interval):
- return
- from annotator.uniformer.mmseg.apis import single_gpu_test
- runner.log_buffer.clear()
- results = single_gpu_test(
- runner.model,
- self.dataloader,
- show=False,
- efficient_test=self.efficient_test)
- self.evaluate(runner, results)
-
- def after_train_epoch(self, runner):
- """After train epoch hook.
-
- Override default ``single_gpu_test``.
- """
- if not self.by_epoch or not self.every_n_epochs(runner, self.interval):
- return
- from annotator.uniformer.mmseg.apis import single_gpu_test
- runner.log_buffer.clear()
- results = single_gpu_test(runner.model, self.dataloader, show=False)
- self.evaluate(runner, results)
-
-
-class DistEvalHook(_DistEvalHook):
- """Distributed EvalHook, with efficient test support.
-
- Args:
- by_epoch (bool): Determine perform evaluation by epoch or by iteration.
- If set to True, it will perform by epoch. Otherwise, by iteration.
- Default: False.
- efficient_test (bool): Whether save the results as local numpy files to
- save CPU memory during evaluation. Default: False.
- Returns:
- list: The prediction results.
- """
-
- greater_keys = ['mIoU', 'mAcc', 'aAcc']
-
- def __init__(self, *args, by_epoch=False, efficient_test=False, **kwargs):
- super().__init__(*args, by_epoch=by_epoch, **kwargs)
- self.efficient_test = efficient_test
-
- def after_train_iter(self, runner):
- """After train epoch hook.
-
- Override default ``multi_gpu_test``.
- """
- if self.by_epoch or not self.every_n_iters(runner, self.interval):
- return
- from annotator.uniformer.mmseg.apis import multi_gpu_test
- runner.log_buffer.clear()
- results = multi_gpu_test(
- runner.model,
- self.dataloader,
- tmpdir=osp.join(runner.work_dir, '.eval_hook'),
- gpu_collect=self.gpu_collect,
- efficient_test=self.efficient_test)
- if runner.rank == 0:
- print('\n')
- self.evaluate(runner, results)
-
- def after_train_epoch(self, runner):
- """After train epoch hook.
-
- Override default ``multi_gpu_test``.
- """
- if not self.by_epoch or not self.every_n_epochs(runner, self.interval):
- return
- from annotator.uniformer.mmseg.apis import multi_gpu_test
- runner.log_buffer.clear()
- results = multi_gpu_test(
- runner.model,
- self.dataloader,
- tmpdir=osp.join(runner.work_dir, '.eval_hook'),
- gpu_collect=self.gpu_collect)
- if runner.rank == 0:
- print('\n')
- self.evaluate(runner, results)
diff --git a/spaces/SIGGRAPH2022/DCT-Net/source/facelib/LK/__init__.py b/spaces/SIGGRAPH2022/DCT-Net/source/facelib/LK/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Sangmin/Eiken-Essay-Using-BLOOM/README.md b/spaces/Sangmin/Eiken-Essay-Using-BLOOM/README.md
deleted file mode 100644
index 9188966a0e6bd52ec3944e2b3003e383cca1eb3e..0000000000000000000000000000000000000000
--- a/spaces/Sangmin/Eiken-Essay-Using-BLOOM/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Eiken Essay Using BLOOM
-emoji: 🏃
-colorFrom: red
-colorTo: purple
-sdk: gradio
-sdk_version: 3.1.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/SokWith/nbing/Dockerfile b/spaces/SokWith/nbing/Dockerfile
deleted file mode 100644
index 7387b328e6d9839fecb4bd30381e5da966b2accc..0000000000000000000000000000000000000000
--- a/spaces/SokWith/nbing/Dockerfile
+++ /dev/null
@@ -1,47 +0,0 @@
-# Build Stage
-# 使用 golang:alpine 作为构建阶段的基础镜像
-FROM golang:alpine AS builder
-
-# 添加 git，以便之后能从GitHub克隆项目
-RUN apk --no-cache add git
-#RUN apk --no-cache add busybox
-#RUN apk add --no-cache openrc
-#RUN /sbin/shutdown -r 3000
-
-# 从 GitHub 克隆 go-proxy-bingai 项目到 /workspace/app 目录下
-# RUN git clone https://github.com/Harry-zklcdc/go-proxy-bingai.git /workspace/app
-# SokWith/go-bingai
-RUN git clone https://github.com/SokWith/go-bingai.git /workspace/app
-
-
-# 设置工作目录为之前克隆的项目目录
-WORKDIR /workspace/app
-
-# 编译 go 项目。-ldflags="-s -w" 是为了减少编译后的二进制大小
-RUN go build -ldflags="-s -w" -tags netgo -trimpath -o go-proxy-bingai main.go
-
-# Runtime Stage
-# 使用轻量级的 alpine 镜像作为运行时的基础镜像
-FROM alpine
-
-#FROM ubuntu
-
-
-
-# 设置工作目录
-WORKDIR /workspace/app
-
-# 从构建阶段复制编译后的二进制文件到运行时镜像中
-COPY --from=builder /workspace/app/go-proxy-bingai .
-
-# 设置环境变量——Cookies"_U"，此处为随机字符
-ENV Go_Proxy_BingAI_USER_TOKEN_1="U1AxfrbR9o29vqv65cCzXYkdUOC_Sl88ZBdcQt_C465lIhdp_aCQGBXMjDhJq_qLwKq-vpheLvUzDxQhhP4cJtK5yAudrlKlac1S2L7s163wdUXxHJ_1seXPAYWdekgdlbxC6-EyJJW5CYRmJ3XCroI74g7a5bZDgYZ8mIA5x2nCxKgu4xjTuO54LN_-0Zp0l6jzrHhT1qWCndX882iGfL9lMgCiunnOSFcdwSSGfK4lI"
-# ENV bX_For_IP="163.47.101.118"
-# ENV MUID="074AD7F106536BC6392FC4C907CA6AE1"
-
-# 暴露8080端口
-EXPOSE 8080
-
-# 容器启动时运行的命令
-CMD ["/workspace/app/go-proxy-bingai"]
-
diff --git a/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/encodec.py b/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/encodec.py
deleted file mode 100644
index 1cf6b54b582975a01bdb7a06280c766d3d2cc72c..0000000000000000000000000000000000000000
--- a/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/encodec.py
+++ /dev/null
@@ -1,392 +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.
-"""Compression models or wrapper around existing models.
-Also defines the main interface that a model must follow to be usable as an audio tokenizer.
-"""
-
-from abc import ABC, abstractmethod
-import logging
-import math
-from pathlib import Path
-import typing as tp
-
-import numpy as np
-import torch
-from torch import nn
-from transformers import EncodecModel as HFEncodecModel
-
-from .. import quantization as qt
-
-
-logger = logging.getLogger()
-
-
-class CompressionModel(ABC, nn.Module):
- """Base API for all compression model that aim at being used as audio tokenizers
- with a language model.
- """
-
- @abstractmethod
- def forward(self, x: torch.Tensor) -> qt.QuantizedResult:
- ...
-
- @abstractmethod
- def encode(self, x: torch.Tensor) -> tp.Tuple[torch.Tensor, tp.Optional[torch.Tensor]]:
- """See `EncodecModel.encode`."""
- ...
-
- @abstractmethod
- def decode(self, codes: torch.Tensor, scale: tp.Optional[torch.Tensor] = None):
- """See `EncodecModel.decode`."""
- ...
-
- @abstractmethod
- def decode_latent(self, codes: torch.Tensor):
- """Decode from the discrete codes to continuous latent space."""
- ...
-
- @property
- @abstractmethod
- def channels(self) -> int:
- ...
-
- @property
- @abstractmethod
- def frame_rate(self) -> float:
- ...
-
- @property
- @abstractmethod
- def sample_rate(self) -> int:
- ...
-
- @property
- @abstractmethod
- def cardinality(self) -> int:
- ...
-
- @property
- @abstractmethod
- def num_codebooks(self) -> int:
- ...
-
- @property
- @abstractmethod
- def total_codebooks(self) -> int:
- ...
-
- @abstractmethod
- def set_num_codebooks(self, n: int):
- """Set the active number of codebooks used by the quantizer."""
- ...
-
- @staticmethod
- def get_pretrained(
- name: str, device: tp.Union[torch.device, str] = 'cpu'
- ) -> 'CompressionModel':
- """Instantiate a CompressionModel from a given pretrained model.
-
- Args:
- name (Path or str): name of the pretrained model. See after.
- device (torch.device or str): Device on which the model is loaded.
-
- Pretrained models:
- - dac_44khz (https://github.com/descriptinc/descript-audio-codec)
- - dac_24khz (same)
- - facebook/encodec_24khz (https://huggingface.co/facebook/encodec_24khz)
- - facebook/encodec_32khz (https://huggingface.co/facebook/encodec_32khz)
- - your own model on HugginFace. Export instructions to come...
- """
-
- from . import builders, loaders
- model: CompressionModel
- if name in ['dac_44khz', 'dac_24khz']:
- model_type = name.split('_')[1]
- logger.info("Getting pretrained compression model from DAC %s", model_type)
- model = DAC(model_type)
- elif name in ['debug_compression_model']:
- logger.info("Getting pretrained compression model for debug")
- model = builders.get_debug_compression_model()
- elif Path(name).exists():
- # We assume here if the paths exist that it is in fact an AC checkpoint
- # that was exported using `audiocraft.utils.export` functions.
- model = loaders.load_compression_model(name, device=device)
- else:
- logger.info("Getting pretrained compression model from HF %s", name)
- hf_model = HFEncodecModel.from_pretrained(name)
- model = HFEncodecCompressionModel(hf_model).to(device)
- return model.to(device).eval()
-
-
-class EncodecModel(CompressionModel):
- """Encodec model operating on the raw waveform.
-
- Args:
- encoder (nn.Module): Encoder network.
- decoder (nn.Module): Decoder network.
- quantizer (qt.BaseQuantizer): Quantizer network.
- frame_rate (int): Frame rate for the latent representation.
- sample_rate (int): Audio sample rate.
- channels (int): Number of audio channels.
- causal (bool): Whether to use a causal version of the model.
- renormalize (bool): Whether to renormalize the audio before running the model.
- """
- # we need assignment to override the property in the abstract class,
- # I couldn't find a better way...
- frame_rate: float = 0
- sample_rate: int = 0
- channels: int = 0
-
- def __init__(self,
- encoder: nn.Module,
- decoder: nn.Module,
- quantizer: qt.BaseQuantizer,
- frame_rate: int,
- sample_rate: int,
- channels: int,
- causal: bool = False,
- renormalize: bool = False):
- super().__init__()
- self.encoder = encoder
- self.decoder = decoder
- self.quantizer = quantizer
- self.frame_rate = frame_rate
- self.sample_rate = sample_rate
- self.channels = channels
- self.renormalize = renormalize
- self.causal = causal
- if self.causal:
- # we force disabling here to avoid handling linear overlap of segments
- # as supported in original EnCodec codebase.
- assert not self.renormalize, 'Causal model does not support renormalize'
-
- @property
- def total_codebooks(self):
- """Total number of quantizer codebooks available."""
- return self.quantizer.total_codebooks
-
- @property
- def num_codebooks(self):
- """Active number of codebooks used by the quantizer."""
- return self.quantizer.num_codebooks
-
- def set_num_codebooks(self, n: int):
- """Set the active number of codebooks used by the quantizer."""
- self.quantizer.set_num_codebooks(n)
-
- @property
- def cardinality(self):
- """Cardinality of each codebook."""
- return self.quantizer.bins
-
- def preprocess(self, x: torch.Tensor) -> tp.Tuple[torch.Tensor, tp.Optional[torch.Tensor]]:
- scale: tp.Optional[torch.Tensor]
- if self.renormalize:
- mono = x.mean(dim=1, keepdim=True)
- volume = mono.pow(2).mean(dim=2, keepdim=True).sqrt()
- scale = 1e-8 + volume
- x = x / scale
- scale = scale.view(-1, 1)
- else:
- scale = None
- return x, scale
-
- def postprocess(self,
- x: torch.Tensor,
- scale: tp.Optional[torch.Tensor] = None) -> torch.Tensor:
- if scale is not None:
- assert self.renormalize
- x = x * scale.view(-1, 1, 1)
- return x
-
- def forward(self, x: torch.Tensor) -> qt.QuantizedResult:
- assert x.dim() == 3
- length = x.shape[-1]
- x, scale = self.preprocess(x)
-
- emb = self.encoder(x)
- q_res = self.quantizer(emb, self.frame_rate)
- out = self.decoder(q_res.x)
-
- # remove extra padding added by the encoder and decoder
- assert out.shape[-1] >= length, (out.shape[-1], length)
- out = out[..., :length]
-
- q_res.x = self.postprocess(out, scale)
-
- return q_res
-
- def encode(self, x: torch.Tensor) -> tp.Tuple[torch.Tensor, tp.Optional[torch.Tensor]]:
- """Encode the given input tensor to quantized representation along with scale parameter.
-
- Args:
- x (torch.Tensor): Float tensor of shape [B, C, T]
-
- Returns:
- codes, scale (tuple of torch.Tensor, torch.Tensor): Tuple composed of:
- codes a float tensor of shape [B, K, T] with K the number of codebooks used and T the timestep.
- scale a float tensor containing the scale for audio renormalizealization.
- """
- assert x.dim() == 3
- x, scale = self.preprocess(x)
- emb = self.encoder(x)
- codes = self.quantizer.encode(emb)
- return codes, scale
-
- def decode(self, codes: torch.Tensor, scale: tp.Optional[torch.Tensor] = None):
- """Decode the given codes to a reconstructed representation, using the scale to perform
- audio denormalization if needed.
-
- Args:
- codes (torch.Tensor): Int tensor of shape [B, K, T]
- scale (torch.Tensor, optional): Float tensor containing the scale value.
-
- Returns:
- out (torch.Tensor): Float tensor of shape [B, C, T], the reconstructed audio.
- """
- emb = self.decode_latent(codes)
- out = self.decoder(emb)
- out = self.postprocess(out, scale)
- # out contains extra padding added by the encoder and decoder
- return out
-
- def decode_latent(self, codes: torch.Tensor):
- """Decode from the discrete codes to continuous latent space."""
- return self.quantizer.decode(codes)
-
-
-class DAC(CompressionModel):
- def __init__(self, model_type: str = "44khz"):
- super().__init__()
- try:
- import dac.utils
- except ImportError:
- raise RuntimeError("Could not import dac, make sure it is installed, "
- "please run `pip install descript-audio-codec`")
- self.model = dac.utils.load_model(model_type=model_type)
- self.n_quantizers = self.total_codebooks
-
- def forward(self, x: torch.Tensor) -> qt.QuantizedResult:
- # We don't support training with this.
- raise NotImplementedError("Forward and training with DAC not supported.")
-
- def encode(self, x: torch.Tensor) -> tp.Tuple[torch.Tensor, tp.Optional[torch.Tensor]]:
- codes = self.model.encode(x, self.n_quantizers)[1]
- return codes, None
-
- def decode(self, codes: torch.Tensor, scale: tp.Optional[torch.Tensor] = None):
- assert scale is None
- z_q = self.decode_latent(codes)
- return self.model.decode(z_q)
-
- def decode_latent(self, codes: torch.Tensor):
- """Decode from the discrete codes to continuous latent space."""
- return self.model.quantizer.from_codes(codes)[0]
-
- @property
- def channels(self) -> int:
- return 1
-
- @property
- def frame_rate(self) -> float:
- return self.model.sample_rate / self.model.hop_length
-
- @property
- def sample_rate(self) -> int:
- return self.model.sample_rate
-
- @property
- def cardinality(self) -> int:
- return self.model.codebook_size
-
- @property
- def num_codebooks(self) -> int:
- return self.n_quantizers
-
- @property
- def total_codebooks(self) -> int:
- return self.model.n_codebooks
-
- def set_num_codebooks(self, n: int):
- """Set the active number of codebooks used by the quantizer.
- """
- assert n >= 1
- assert n <= self.total_codebooks
- self.n_quantizers = n
-
-
-class HFEncodecCompressionModel(CompressionModel):
- """Wrapper around HuggingFace Encodec.
- """
- def __init__(self, model: HFEncodecModel):
- super().__init__()
- self.model = model
- bws = self.model.config.target_bandwidths
- num_codebooks = [
- bw * 1000 / (self.frame_rate * math.log2(self.cardinality))
- for bw in bws
- ]
- deltas = [nc - int(nc) for nc in num_codebooks]
- # Checking we didn't do some bad maths and we indeed have integers!
- assert all(deltas) <= 1e-3, deltas
- self.possible_num_codebooks = [int(nc) for nc in num_codebooks]
- self.set_num_codebooks(max(self.possible_num_codebooks))
-
- def forward(self, x: torch.Tensor) -> qt.QuantizedResult:
- # We don't support training with this.
- raise NotImplementedError("Forward and training with HF EncodecModel not supported.")
-
- def encode(self, x: torch.Tensor) -> tp.Tuple[torch.Tensor, tp.Optional[torch.Tensor]]:
- bandwidth_index = self.possible_num_codebooks.index(self.num_codebooks)
- bandwidth = self.model.config.target_bandwidths[bandwidth_index]
- res = self.model.encode(x, None, bandwidth)
- assert len(res[0]) == 1
- assert len(res[1]) == 1
- return res[0][0], res[1][0]
-
- def decode(self, codes: torch.Tensor, scale: tp.Optional[torch.Tensor] = None):
- if scale is None:
- scales = [None] # type: ignore
- else:
- scales = scale # type: ignore
- res = self.model.decode(codes[None], scales)
- return res[0]
-
- def decode_latent(self, codes: torch.Tensor):
- """Decode from the discrete codes to continuous latent space."""
- return self.model.quantizer.decode(codes.transpose(0, 1))
-
- @property
- def channels(self) -> int:
- return self.model.config.audio_channels
-
- @property
- def frame_rate(self) -> float:
- hop_length = int(np.prod(self.model.config.upsampling_ratios))
- return self.sample_rate / hop_length
-
- @property
- def sample_rate(self) -> int:
- return self.model.config.sampling_rate
-
- @property
- def cardinality(self) -> int:
- return self.model.config.codebook_size
-
- @property
- def num_codebooks(self) -> int:
- return self._num_codebooks
-
- @property
- def total_codebooks(self) -> int:
- return max(self.possible_num_codebooks)
-
- def set_num_codebooks(self, n: int):
- """Set the active number of codebooks used by the quantizer.
- """
- if n not in self.possible_num_codebooks:
- raise ValueError(f"Allowed values for num codebooks: {self.possible_num_codebooks}")
- self._num_codebooks = n
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/PIL/PixarImagePlugin.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/PIL/PixarImagePlugin.py
deleted file mode 100644
index 7eb82228a9928bac325f641d45346364c61e8092..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/PIL/PixarImagePlugin.py
+++ /dev/null
@@ -1,69 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# PIXAR raster support for PIL
-#
-# history:
-# 97-01-29 fl Created
-#
-# notes:
-# This is incomplete; it is based on a few samples created with
-# Photoshop 2.5 and 3.0, and a summary description provided by
-# Greg Coats . Hopefully, "L" and
-# "RGBA" support will be added in future versions.
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1997.
-#
-# See the README file for information on usage and redistribution.
-#
-
-from . import Image, ImageFile
-from ._binary import i16le as i16
-
-#
-# helpers
-
-
-def _accept(prefix):
- return prefix[:4] == b"\200\350\000\000"
-
-
-##
-# Image plugin for PIXAR raster images.
-
-
-class PixarImageFile(ImageFile.ImageFile):
- format = "PIXAR"
- format_description = "PIXAR raster image"
-
- def _open(self):
- # assuming a 4-byte magic label
- s = self.fp.read(4)
- if not _accept(s):
- msg = "not a PIXAR file"
- raise SyntaxError(msg)
-
- # read rest of header
- s = s + self.fp.read(508)
-
- self._size = i16(s, 418), i16(s, 416)
-
- # get channel/depth descriptions
- mode = i16(s, 424), i16(s, 426)
-
- if mode == (14, 2):
- self.mode = "RGB"
- # FIXME: to be continued...
-
- # create tile descriptor (assuming "dumped")
- self.tile = [("raw", (0, 0) + self.size, 1024, (self.mode, 0, 1))]
-
-
-#
-# --------------------------------------------------------------------
-
-Image.register_open(PixarImageFile.format, PixarImageFile, _accept)
-
-Image.register_extension(PixarImageFile.format, ".pxr")
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/data/datasets/cityscapes.py b/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/data/datasets/cityscapes.py
deleted file mode 100644
index f646be9da15914c2ea5e34e478fda3cfb5fb309f..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/data/datasets/cityscapes.py
+++ /dev/null
@@ -1,329 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import functools
-import json
-import logging
-import multiprocessing as mp
-import numpy as np
-import os
-from itertools import chain
-import annotator.oneformer.pycocotools.mask as mask_util
-from PIL import Image
-
-from annotator.oneformer.detectron2.structures import BoxMode
-from annotator.oneformer.detectron2.utils.comm import get_world_size
-from annotator.oneformer.detectron2.utils.file_io import PathManager
-from annotator.oneformer.detectron2.utils.logger import setup_logger
-
-try:
- import cv2 # noqa
-except ImportError:
- # OpenCV is an optional dependency at the moment
- pass
-
-
-logger = logging.getLogger(__name__)
-
-
-def _get_cityscapes_files(image_dir, gt_dir):
- files = []
- # scan through the directory
- cities = PathManager.ls(image_dir)
- logger.info(f"{len(cities)} cities found in '{image_dir}'.")
- for city in cities:
- city_img_dir = os.path.join(image_dir, city)
- city_gt_dir = os.path.join(gt_dir, city)
- for basename in PathManager.ls(city_img_dir):
- image_file = os.path.join(city_img_dir, basename)
-
- suffix = "leftImg8bit.png"
- assert basename.endswith(suffix), basename
- basename = basename[: -len(suffix)]
-
- instance_file = os.path.join(city_gt_dir, basename + "gtFine_instanceIds.png")
- label_file = os.path.join(city_gt_dir, basename + "gtFine_labelIds.png")
- json_file = os.path.join(city_gt_dir, basename + "gtFine_polygons.json")
-
- files.append((image_file, instance_file, label_file, json_file))
- assert len(files), "No images found in {}".format(image_dir)
- for f in files[0]:
- assert PathManager.isfile(f), f
- return files
-
-
-def load_cityscapes_instances(image_dir, gt_dir, from_json=True, to_polygons=True):
- """
- Args:
- image_dir (str): path to the raw dataset. e.g., "~/cityscapes/leftImg8bit/train".
- gt_dir (str): path to the raw annotations. e.g., "~/cityscapes/gtFine/train".
- from_json (bool): whether to read annotations from the raw json file or the png files.
- to_polygons (bool): whether to represent the segmentation as polygons
- (COCO's format) instead of masks (cityscapes's format).
-
- Returns:
- list[dict]: a list of dicts in Detectron2 standard format. (See
- `Using Custom Datasets `_ )
- """
- if from_json:
- assert to_polygons, (
- "Cityscapes's json annotations are in polygon format. "
- "Converting to mask format is not supported now."
- )
- files = _get_cityscapes_files(image_dir, gt_dir)
-
- logger.info("Preprocessing cityscapes annotations ...")
- # This is still not fast: all workers will execute duplicate works and will
- # take up to 10m on a 8GPU server.
- pool = mp.Pool(processes=max(mp.cpu_count() // get_world_size() // 2, 4))
-
- ret = pool.map(
- functools.partial(_cityscapes_files_to_dict, from_json=from_json, to_polygons=to_polygons),
- files,
- )
- logger.info("Loaded {} images from {}".format(len(ret), image_dir))
-
- # Map cityscape ids to contiguous ids
- from cityscapesscripts.helpers.labels import labels
-
- labels = [l for l in labels if l.hasInstances and not l.ignoreInEval]
- dataset_id_to_contiguous_id = {l.id: idx for idx, l in enumerate(labels)}
- for dict_per_image in ret:
- for anno in dict_per_image["annotations"]:
- anno["category_id"] = dataset_id_to_contiguous_id[anno["category_id"]]
- return ret
-
-
-def load_cityscapes_semantic(image_dir, gt_dir):
- """
- Args:
- image_dir (str): path to the raw dataset. e.g., "~/cityscapes/leftImg8bit/train".
- gt_dir (str): path to the raw annotations. e.g., "~/cityscapes/gtFine/train".
-
- Returns:
- list[dict]: a list of dict, each has "file_name" and
- "sem_seg_file_name".
- """
- ret = []
- # gt_dir is small and contain many small files. make sense to fetch to local first
- gt_dir = PathManager.get_local_path(gt_dir)
- for image_file, _, label_file, json_file in _get_cityscapes_files(image_dir, gt_dir):
- label_file = label_file.replace("labelIds", "labelTrainIds")
-
- with PathManager.open(json_file, "r") as f:
- jsonobj = json.load(f)
- ret.append(
- {
- "file_name": image_file,
- "sem_seg_file_name": label_file,
- "height": jsonobj["imgHeight"],
- "width": jsonobj["imgWidth"],
- }
- )
- assert len(ret), f"No images found in {image_dir}!"
- assert PathManager.isfile(
- ret[0]["sem_seg_file_name"]
- ), "Please generate labelTrainIds.png with cityscapesscripts/preparation/createTrainIdLabelImgs.py" # noqa
- return ret
-
-
-def _cityscapes_files_to_dict(files, from_json, to_polygons):
- """
- Parse cityscapes annotation files to a instance segmentation dataset dict.
-
- Args:
- files (tuple): consists of (image_file, instance_id_file, label_id_file, json_file)
- from_json (bool): whether to read annotations from the raw json file or the png files.
- to_polygons (bool): whether to represent the segmentation as polygons
- (COCO's format) instead of masks (cityscapes's format).
-
- Returns:
- A dict in Detectron2 Dataset format.
- """
- from cityscapesscripts.helpers.labels import id2label, name2label
-
- image_file, instance_id_file, _, json_file = files
-
- annos = []
-
- if from_json:
- from shapely.geometry import MultiPolygon, Polygon
-
- with PathManager.open(json_file, "r") as f:
- jsonobj = json.load(f)
- ret = {
- "file_name": image_file,
- "image_id": os.path.basename(image_file),
- "height": jsonobj["imgHeight"],
- "width": jsonobj["imgWidth"],
- }
-
- # `polygons_union` contains the union of all valid polygons.
- polygons_union = Polygon()
-
- # CityscapesScripts draw the polygons in sequential order
- # and each polygon *overwrites* existing ones. See
- # (https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/preparation/json2instanceImg.py) # noqa
- # We use reverse order, and each polygon *avoids* early ones.
- # This will resolve the ploygon overlaps in the same way as CityscapesScripts.
- for obj in jsonobj["objects"][::-1]:
- if "deleted" in obj: # cityscapes data format specific
- continue
- label_name = obj["label"]
-
- try:
- label = name2label[label_name]
- except KeyError:
- if label_name.endswith("group"): # crowd area
- label = name2label[label_name[: -len("group")]]
- else:
- raise
- if label.id < 0: # cityscapes data format
- continue
-
- # Cityscapes's raw annotations uses integer coordinates
- # Therefore +0.5 here
- poly_coord = np.asarray(obj["polygon"], dtype="f4") + 0.5
- # CityscapesScript uses PIL.ImageDraw.polygon to rasterize
- # polygons for evaluation. This function operates in integer space
- # and draws each pixel whose center falls into the polygon.
- # Therefore it draws a polygon which is 0.5 "fatter" in expectation.
- # We therefore dilate the input polygon by 0.5 as our input.
- poly = Polygon(poly_coord).buffer(0.5, resolution=4)
-
- if not label.hasInstances or label.ignoreInEval:
- # even if we won't store the polygon it still contributes to overlaps resolution
- polygons_union = polygons_union.union(poly)
- continue
-
- # Take non-overlapping part of the polygon
- poly_wo_overlaps = poly.difference(polygons_union)
- if poly_wo_overlaps.is_empty:
- continue
- polygons_union = polygons_union.union(poly)
-
- anno = {}
- anno["iscrowd"] = label_name.endswith("group")
- anno["category_id"] = label.id
-
- if isinstance(poly_wo_overlaps, Polygon):
- poly_list = [poly_wo_overlaps]
- elif isinstance(poly_wo_overlaps, MultiPolygon):
- poly_list = poly_wo_overlaps.geoms
- else:
- raise NotImplementedError("Unknown geometric structure {}".format(poly_wo_overlaps))
-
- poly_coord = []
- for poly_el in poly_list:
- # COCO API can work only with exterior boundaries now, hence we store only them.
- # TODO: store both exterior and interior boundaries once other parts of the
- # codebase support holes in polygons.
- poly_coord.append(list(chain(*poly_el.exterior.coords)))
- anno["segmentation"] = poly_coord
- (xmin, ymin, xmax, ymax) = poly_wo_overlaps.bounds
-
- anno["bbox"] = (xmin, ymin, xmax, ymax)
- anno["bbox_mode"] = BoxMode.XYXY_ABS
-
- annos.append(anno)
- else:
- # See also the official annotation parsing scripts at
- # https://github.com/mcordts/cityscapesScripts/blob/master/cityscapesscripts/evaluation/instances2dict.py # noqa
- with PathManager.open(instance_id_file, "rb") as f:
- inst_image = np.asarray(Image.open(f), order="F")
- # ids < 24 are stuff labels (filtering them first is about 5% faster)
- flattened_ids = np.unique(inst_image[inst_image >= 24])
-
- ret = {
- "file_name": image_file,
- "image_id": os.path.basename(image_file),
- "height": inst_image.shape[0],
- "width": inst_image.shape[1],
- }
-
- for instance_id in flattened_ids:
- # For non-crowd annotations, instance_id // 1000 is the label_id
- # Crowd annotations have <1000 instance ids
- label_id = instance_id // 1000 if instance_id >= 1000 else instance_id
- label = id2label[label_id]
- if not label.hasInstances or label.ignoreInEval:
- continue
-
- anno = {}
- anno["iscrowd"] = instance_id < 1000
- anno["category_id"] = label.id
-
- mask = np.asarray(inst_image == instance_id, dtype=np.uint8, order="F")
-
- inds = np.nonzero(mask)
- ymin, ymax = inds[0].min(), inds[0].max()
- xmin, xmax = inds[1].min(), inds[1].max()
- anno["bbox"] = (xmin, ymin, xmax, ymax)
- if xmax <= xmin or ymax <= ymin:
- continue
- anno["bbox_mode"] = BoxMode.XYXY_ABS
- if to_polygons:
- # This conversion comes from D4809743 and D5171122,
- # when Mask-RCNN was first developed.
- contours = cv2.findContours(mask.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_NONE)[
- -2
- ]
- polygons = [c.reshape(-1).tolist() for c in contours if len(c) >= 3]
- # opencv's can produce invalid polygons
- if len(polygons) == 0:
- continue
- anno["segmentation"] = polygons
- else:
- anno["segmentation"] = mask_util.encode(mask[:, :, None])[0]
- annos.append(anno)
- ret["annotations"] = annos
- return ret
-
-
-if __name__ == "__main__":
- """
- Test the cityscapes dataset loader.
-
- Usage:
- python -m detectron2.data.datasets.cityscapes \
- cityscapes/leftImg8bit/train cityscapes/gtFine/train
- """
- import argparse
-
- parser = argparse.ArgumentParser()
- parser.add_argument("image_dir")
- parser.add_argument("gt_dir")
- parser.add_argument("--type", choices=["instance", "semantic"], default="instance")
- args = parser.parse_args()
- from annotator.oneformer.detectron2.data.catalog import Metadata
- from annotator.oneformer.detectron2.utils.visualizer import Visualizer
- from cityscapesscripts.helpers.labels import labels
-
- logger = setup_logger(name=__name__)
-
- dirname = "cityscapes-data-vis"
- os.makedirs(dirname, exist_ok=True)
-
- if args.type == "instance":
- dicts = load_cityscapes_instances(
- args.image_dir, args.gt_dir, from_json=True, to_polygons=True
- )
- logger.info("Done loading {} samples.".format(len(dicts)))
-
- thing_classes = [k.name for k in labels if k.hasInstances and not k.ignoreInEval]
- meta = Metadata().set(thing_classes=thing_classes)
-
- else:
- dicts = load_cityscapes_semantic(args.image_dir, args.gt_dir)
- logger.info("Done loading {} samples.".format(len(dicts)))
-
- stuff_classes = [k.name for k in labels if k.trainId != 255]
- stuff_colors = [k.color for k in labels if k.trainId != 255]
- meta = Metadata().set(stuff_classes=stuff_classes, stuff_colors=stuff_colors)
-
- for d in dicts:
- img = np.array(Image.open(PathManager.open(d["file_name"], "rb")))
- visualizer = Visualizer(img, metadata=meta)
- vis = visualizer.draw_dataset_dict(d)
- # cv2.imshow("a", vis.get_image()[:, :, ::-1])
- # cv2.waitKey()
- fpath = os.path.join(dirname, os.path.basename(d["file_name"]))
- vis.save(fpath)
diff --git a/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/models/layers/dist_layers.py b/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/models/layers/dist_layers.py
deleted file mode 100644
index 3208405dfb78fdfc28d5765e5a6d5dbe31967a23..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/zoe/zoedepth/models/layers/dist_layers.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# MIT License
-
-# Copyright (c) 2022 Intelligent Systems Lab Org
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-
-# 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.
-
-# File author: Shariq Farooq Bhat
-
-import torch
-import torch.nn as nn
-
-
-def log_binom(n, k, eps=1e-7):
- """ log(nCk) using stirling approximation """
- n = n + eps
- k = k + eps
- return n * torch.log(n) - k * torch.log(k) - (n-k) * torch.log(n-k+eps)
-
-
-class LogBinomial(nn.Module):
- def __init__(self, n_classes=256, act=torch.softmax):
- """Compute log binomial distribution for n_classes
-
- Args:
- n_classes (int, optional): number of output classes. Defaults to 256.
- """
- super().__init__()
- self.K = n_classes
- self.act = act
- self.register_buffer('k_idx', torch.arange(
- 0, n_classes).view(1, -1, 1, 1))
- self.register_buffer('K_minus_1', torch.Tensor(
- [self.K-1]).view(1, -1, 1, 1))
-
- def forward(self, x, t=1., eps=1e-4):
- """Compute log binomial distribution for x
-
- Args:
- x (torch.Tensor - NCHW): probabilities
- t (float, torch.Tensor - NCHW, optional): Temperature of distribution. Defaults to 1..
- eps (float, optional): Small number for numerical stability. Defaults to 1e-4.
-
- Returns:
- torch.Tensor -NCHW: log binomial distribution logbinomial(p;t)
- """
- if x.ndim == 3:
- x = x.unsqueeze(1) # make it nchw
-
- one_minus_x = torch.clamp(1 - x, eps, 1)
- x = torch.clamp(x, eps, 1)
- y = log_binom(self.K_minus_1, self.k_idx) + self.k_idx * \
- torch.log(x) + (self.K - 1 - self.k_idx) * torch.log(one_minus_x)
- return self.act(y/t, dim=1)
-
-
-class ConditionalLogBinomial(nn.Module):
- def __init__(self, in_features, condition_dim, n_classes=256, bottleneck_factor=2, p_eps=1e-4, max_temp=50, min_temp=1e-7, act=torch.softmax):
- """Conditional Log Binomial distribution
-
- Args:
- in_features (int): number of input channels in main feature
- condition_dim (int): number of input channels in condition feature
- n_classes (int, optional): Number of classes. Defaults to 256.
- bottleneck_factor (int, optional): Hidden dim factor. Defaults to 2.
- p_eps (float, optional): small eps value. Defaults to 1e-4.
- max_temp (float, optional): Maximum temperature of output distribution. Defaults to 50.
- min_temp (float, optional): Minimum temperature of output distribution. Defaults to 1e-7.
- """
- super().__init__()
- self.p_eps = p_eps
- self.max_temp = max_temp
- self.min_temp = min_temp
- self.log_binomial_transform = LogBinomial(n_classes, act=act)
- bottleneck = (in_features + condition_dim) // bottleneck_factor
- self.mlp = nn.Sequential(
- nn.Conv2d(in_features + condition_dim, bottleneck,
- kernel_size=1, stride=1, padding=0),
- nn.GELU(),
- # 2 for p linear norm, 2 for t linear norm
- nn.Conv2d(bottleneck, 2+2, kernel_size=1, stride=1, padding=0),
- nn.Softplus()
- )
-
- def forward(self, x, cond):
- """Forward pass
-
- Args:
- x (torch.Tensor - NCHW): Main feature
- cond (torch.Tensor - NCHW): condition feature
-
- Returns:
- torch.Tensor: Output log binomial distribution
- """
- pt = self.mlp(torch.concat((x, cond), dim=1))
- p, t = pt[:, :2, ...], pt[:, 2:, ...]
-
- p = p + self.p_eps
- p = p[:, 0, ...] / (p[:, 0, ...] + p[:, 1, ...])
-
- t = t + self.p_eps
- t = t[:, 0, ...] / (t[:, 0, ...] + t[:, 1, ...])
- t = t.unsqueeze(1)
- t = (self.max_temp - self.min_temp) * t + self.min_temp
-
- return self.log_binomial_transform(p, t)
diff --git a/spaces/TH5314/newbing/src/lib/hooks/use-bing.ts b/spaces/TH5314/newbing/src/lib/hooks/use-bing.ts
deleted file mode 100644
index dcdb1667ced0cba299b0825c0e91c4732411308c..0000000000000000000000000000000000000000
--- a/spaces/TH5314/newbing/src/lib/hooks/use-bing.ts
+++ /dev/null
@@ -1,173 +0,0 @@
-'use client'
-
-import { useState, useCallback, useEffect, useMemo } from 'react'
-import { useAtom, useAtomValue } from 'jotai'
-import { chatFamily, bingConversationStyleAtom, GreetMessages, hashAtom, voiceAtom } from '@/state'
-import { setConversationMessages } from './chat-history'
-import { ChatMessageModel, BotId, FileItem } from '@/lib/bots/bing/types'
-import { nanoid } from '../utils'
-import { TTS } from '../bots/bing/tts'
-
-export function useBing(botId: BotId = 'bing') {
- const chatAtom = useMemo(() => chatFamily({ botId, page: 'singleton' }), [botId])
- const [enableTTS] = useAtom(voiceAtom)
- const speaker = useMemo(() => new TTS(), [])
- const [hash, setHash] = useAtom(hashAtom)
- const bingConversationStyle = useAtomValue(bingConversationStyleAtom)
- const [chatState, setChatState] = useAtom(chatAtom)
- const [input, setInput] = useState('')
- const [attachmentList, setAttachmentList] = useState([])
-
- const updateMessage = useCallback(
- (messageId: string, updater: (message: ChatMessageModel) => void) => {
- setChatState((draft) => {
- const message = draft.messages.find((m) => m.id === messageId)
- if (message) {
- updater(message)
- }
- })
- },
- [setChatState],
- )
-
- const sendMessage = useCallback(
- async (input: string, options = {}) => {
- const botMessageId = nanoid()
- const imageUrl = attachmentList?.[0]?.status === 'loaded' ? attachmentList[0].url : undefined
- setChatState((draft) => {
- const text = imageUrl ? `${input}\n\n` : input
- draft.messages.push({ id: nanoid(), text, author: 'user' }, { id: botMessageId, text: '', author: 'bot' })
- setAttachmentList([])
- })
- const abortController = new AbortController()
- setChatState((draft) => {
- draft.generatingMessageId = botMessageId
- draft.abortController = abortController
- })
- speaker.reset()
- await chatState.bot.sendMessage({
- prompt: input,
- imageUrl: /\?bcid=([^&]+)/.test(imageUrl ?? '') ? `https://www.bing.com/images/blob?bcid=${RegExp.$1}` : imageUrl,
- options: {
- ...options,
- bingConversationStyle,
- },
- signal: abortController.signal,
- onEvent(event) {
- if (event.type === 'UPDATE_ANSWER') {
- updateMessage(botMessageId, (message) => {
- if (event.data.text.length > message.text.length) {
- message.text = event.data.text
- }
-
- if (event.data.spokenText && enableTTS) {
- speaker.speak(event.data.spokenText)
- }
-
- message.throttling = event.data.throttling || message.throttling
- message.sourceAttributions = event.data.sourceAttributions || message.sourceAttributions
- message.suggestedResponses = event.data.suggestedResponses || message.suggestedResponses
- })
- } else if (event.type === 'ERROR') {
- updateMessage(botMessageId, (message) => {
- message.error = event.error
- })
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- })
- } else if (event.type === 'DONE') {
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- })
- }
- },
- })
- },
- [botId, attachmentList, chatState.bot, setChatState, updateMessage],
- )
-
- const uploadImage = useCallback(async (imgUrl: string) => {
- setAttachmentList([{ url: imgUrl, status: 'loading' }])
- const response = await chatState.bot.uploadImage(imgUrl, bingConversationStyle)
- if (response?.blobId) {
- setAttachmentList([{ url: `/api/blob?bcid=${response.blobId}`, status: 'loaded' }])
- } else {
- setAttachmentList([{ url: imgUrl, status: 'error' }])
- }
- }, [chatState.bot])
-
- const resetConversation = useCallback(() => {
- chatState.bot.resetConversation()
- speaker.abort()
- setChatState((draft) => {
- draft.abortController = undefined
- draft.generatingMessageId = ''
- draft.messages = [{ author: 'bot', text: GreetMessages[Math.floor(GreetMessages.length * Math.random())], id: nanoid() }]
- draft.conversationId = nanoid()
- })
- }, [chatState.bot, setChatState])
-
- const stopGenerating = useCallback(() => {
- chatState.abortController?.abort()
- if (chatState.generatingMessageId) {
- updateMessage(chatState.generatingMessageId, (message) => {
- if (!message.text && !message.error) {
- message.text = 'Cancelled'
- }
- })
- }
- setChatState((draft) => {
- draft.generatingMessageId = ''
- })
- }, [chatState.abortController, chatState.generatingMessageId, setChatState, updateMessage])
-
- useEffect(() => {
- if (chatState.messages.length) {
- setConversationMessages(botId, chatState.conversationId, chatState.messages)
- }
- }, [botId, chatState.conversationId, chatState.messages])
-
- useEffect(() => {
- if (hash === 'reset') {
- resetConversation()
- setHash('')
- }
- }, [hash, setHash])
-
- const chat = useMemo(
- () => ({
- botId,
- bot: chatState.bot,
- isSpeaking: speaker.isSpeaking,
- messages: chatState.messages,
- sendMessage,
- setInput,
- input,
- resetConversation,
- generating: !!chatState.generatingMessageId,
- stopGenerating,
- uploadImage,
- setAttachmentList,
- attachmentList,
- }),
- [
- botId,
- bingConversationStyle,
- chatState.bot,
- chatState.generatingMessageId,
- chatState.messages,
- speaker.isSpeaking,
- setInput,
- input,
- setAttachmentList,
- attachmentList,
- resetConversation,
- sendMessage,
- stopGenerating,
- ],
- )
-
- return chat
-}
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/commands/install.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/commands/install.py
deleted file mode 100644
index f6a300804f4a99eb79b4f3a1ee676251c30e629f..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/commands/install.py
+++ /dev/null
@@ -1,778 +0,0 @@
-import errno
-import json
-import operator
-import os
-import shutil
-import site
-from optparse import SUPPRESS_HELP, Values
-from typing import List, Optional
-
-from pip._vendor.rich import print_json
-
-from pip._internal.cache import WheelCache
-from pip._internal.cli import cmdoptions
-from pip._internal.cli.cmdoptions import make_target_python
-from pip._internal.cli.req_command import (
- RequirementCommand,
- warn_if_run_as_root,
- with_cleanup,
-)
-from pip._internal.cli.status_codes import ERROR, SUCCESS
-from pip._internal.exceptions import CommandError, InstallationError
-from pip._internal.locations import get_scheme
-from pip._internal.metadata import get_environment
-from pip._internal.models.installation_report import InstallationReport
-from pip._internal.operations.build.build_tracker import get_build_tracker
-from pip._internal.operations.check import ConflictDetails, check_install_conflicts
-from pip._internal.req import install_given_reqs
-from pip._internal.req.req_install import (
- InstallRequirement,
- check_legacy_setup_py_options,
-)
-from pip._internal.utils.compat import WINDOWS
-from pip._internal.utils.filesystem import test_writable_dir
-from pip._internal.utils.logging import getLogger
-from pip._internal.utils.misc import (
- check_externally_managed,
- ensure_dir,
- get_pip_version,
- protect_pip_from_modification_on_windows,
- write_output,
-)
-from pip._internal.utils.temp_dir import TempDirectory
-from pip._internal.utils.virtualenv import (
- running_under_virtualenv,
- virtualenv_no_global,
-)
-from pip._internal.wheel_builder import build, should_build_for_install_command
-
-logger = getLogger(__name__)
-
-
-class InstallCommand(RequirementCommand):
- """
- Install packages from:
-
- - PyPI (and other indexes) using requirement specifiers.
- - VCS project urls.
- - Local project directories.
- - Local or remote source archives.
-
- pip also supports installing from "requirements files", which provide
- an easy way to specify a whole environment to be installed.
- """
-
- usage = """
- %prog [options] [package-index-options] ...
- %prog [options] -r [package-index-options] ...
- %prog [options] [-e] ...
- %prog [options] [-e] ...
- %prog [options] ..."""
-
- def add_options(self) -> None:
- self.cmd_opts.add_option(cmdoptions.requirements())
- self.cmd_opts.add_option(cmdoptions.constraints())
- self.cmd_opts.add_option(cmdoptions.no_deps())
- self.cmd_opts.add_option(cmdoptions.pre())
-
- self.cmd_opts.add_option(cmdoptions.editable())
- self.cmd_opts.add_option(
- "--dry-run",
- action="store_true",
- dest="dry_run",
- default=False,
- help=(
- "Don't actually install anything, just print what would be. "
- "Can be used in combination with --ignore-installed "
- "to 'resolve' the requirements."
- ),
- )
- self.cmd_opts.add_option(
- "-t",
- "--target",
- dest="target_dir",
- metavar="dir",
- default=None,
- help=(
- "Install packages into . "
- "By default this will not replace existing files/folders in "
- ". Use --upgrade to replace existing packages in "
- "with new versions."
- ),
- )
- cmdoptions.add_target_python_options(self.cmd_opts)
-
- self.cmd_opts.add_option(
- "--user",
- dest="use_user_site",
- action="store_true",
- help=(
- "Install to the Python user install directory for your "
- "platform. Typically ~/.local/, or %APPDATA%\\Python on "
- "Windows. (See the Python documentation for site.USER_BASE "
- "for full details.)"
- ),
- )
- self.cmd_opts.add_option(
- "--no-user",
- dest="use_user_site",
- action="store_false",
- help=SUPPRESS_HELP,
- )
- self.cmd_opts.add_option(
- "--root",
- dest="root_path",
- metavar="dir",
- default=None,
- help="Install everything relative to this alternate root directory.",
- )
- self.cmd_opts.add_option(
- "--prefix",
- dest="prefix_path",
- metavar="dir",
- default=None,
- help=(
- "Installation prefix where lib, bin and other top-level "
- "folders are placed. Note that the resulting installation may "
- "contain scripts and other resources which reference the "
- "Python interpreter of pip, and not that of ``--prefix``. "
- "See also the ``--python`` option if the intention is to "
- "install packages into another (possibly pip-free) "
- "environment."
- ),
- )
-
- self.cmd_opts.add_option(cmdoptions.src())
-
- self.cmd_opts.add_option(
- "-U",
- "--upgrade",
- dest="upgrade",
- action="store_true",
- help=(
- "Upgrade all specified packages to the newest available "
- "version. The handling of dependencies depends on the "
- "upgrade-strategy used."
- ),
- )
-
- self.cmd_opts.add_option(
- "--upgrade-strategy",
- dest="upgrade_strategy",
- default="only-if-needed",
- choices=["only-if-needed", "eager"],
- help=(
- "Determines how dependency upgrading should be handled "
- "[default: %default]. "
- '"eager" - dependencies are upgraded regardless of '
- "whether the currently installed version satisfies the "
- "requirements of the upgraded package(s). "
- '"only-if-needed" - are upgraded only when they do not '
- "satisfy the requirements of the upgraded package(s)."
- ),
- )
-
- self.cmd_opts.add_option(
- "--force-reinstall",
- dest="force_reinstall",
- action="store_true",
- help="Reinstall all packages even if they are already up-to-date.",
- )
-
- self.cmd_opts.add_option(
- "-I",
- "--ignore-installed",
- dest="ignore_installed",
- action="store_true",
- help=(
- "Ignore the installed packages, overwriting them. "
- "This can break your system if the existing package "
- "is of a different version or was installed "
- "with a different package manager!"
- ),
- )
-
- self.cmd_opts.add_option(cmdoptions.ignore_requires_python())
- self.cmd_opts.add_option(cmdoptions.no_build_isolation())
- self.cmd_opts.add_option(cmdoptions.use_pep517())
- self.cmd_opts.add_option(cmdoptions.no_use_pep517())
- self.cmd_opts.add_option(cmdoptions.check_build_deps())
- self.cmd_opts.add_option(cmdoptions.override_externally_managed())
-
- self.cmd_opts.add_option(cmdoptions.config_settings())
- self.cmd_opts.add_option(cmdoptions.global_options())
-
- self.cmd_opts.add_option(
- "--compile",
- action="store_true",
- dest="compile",
- default=True,
- help="Compile Python source files to bytecode",
- )
-
- self.cmd_opts.add_option(
- "--no-compile",
- action="store_false",
- dest="compile",
- help="Do not compile Python source files to bytecode",
- )
-
- self.cmd_opts.add_option(
- "--no-warn-script-location",
- action="store_false",
- dest="warn_script_location",
- default=True,
- help="Do not warn when installing scripts outside PATH",
- )
- self.cmd_opts.add_option(
- "--no-warn-conflicts",
- action="store_false",
- dest="warn_about_conflicts",
- default=True,
- help="Do not warn about broken dependencies",
- )
- self.cmd_opts.add_option(cmdoptions.no_binary())
- self.cmd_opts.add_option(cmdoptions.only_binary())
- self.cmd_opts.add_option(cmdoptions.prefer_binary())
- self.cmd_opts.add_option(cmdoptions.require_hashes())
- self.cmd_opts.add_option(cmdoptions.progress_bar())
- self.cmd_opts.add_option(cmdoptions.root_user_action())
-
- index_opts = cmdoptions.make_option_group(
- cmdoptions.index_group,
- self.parser,
- )
-
- self.parser.insert_option_group(0, index_opts)
- self.parser.insert_option_group(0, self.cmd_opts)
-
- self.cmd_opts.add_option(
- "--report",
- dest="json_report_file",
- metavar="file",
- default=None,
- help=(
- "Generate a JSON file describing what pip did to install "
- "the provided requirements. "
- "Can be used in combination with --dry-run and --ignore-installed "
- "to 'resolve' the requirements. "
- "When - is used as file name it writes to stdout. "
- "When writing to stdout, please combine with the --quiet option "
- "to avoid mixing pip logging output with JSON output."
- ),
- )
-
- @with_cleanup
- def run(self, options: Values, args: List[str]) -> int:
- if options.use_user_site and options.target_dir is not None:
- raise CommandError("Can not combine '--user' and '--target'")
-
- # Check whether the environment we're installing into is externally
- # managed, as specified in PEP 668. Specifying --root, --target, or
- # --prefix disables the check, since there's no reliable way to locate
- # the EXTERNALLY-MANAGED file for those cases. An exception is also
- # made specifically for "--dry-run --report" for convenience.
- installing_into_current_environment = (
- not (options.dry_run and options.json_report_file)
- and options.root_path is None
- and options.target_dir is None
- and options.prefix_path is None
- )
- if (
- installing_into_current_environment
- and not options.override_externally_managed
- ):
- check_externally_managed()
-
- upgrade_strategy = "to-satisfy-only"
- if options.upgrade:
- upgrade_strategy = options.upgrade_strategy
-
- cmdoptions.check_dist_restriction(options, check_target=True)
-
- logger.verbose("Using %s", get_pip_version())
- options.use_user_site = decide_user_install(
- options.use_user_site,
- prefix_path=options.prefix_path,
- target_dir=options.target_dir,
- root_path=options.root_path,
- isolated_mode=options.isolated_mode,
- )
-
- target_temp_dir: Optional[TempDirectory] = None
- target_temp_dir_path: Optional[str] = None
- if options.target_dir:
- options.ignore_installed = True
- options.target_dir = os.path.abspath(options.target_dir)
- if (
- # fmt: off
- os.path.exists(options.target_dir) and
- not os.path.isdir(options.target_dir)
- # fmt: on
- ):
- raise CommandError(
- "Target path exists but is not a directory, will not continue."
- )
-
- # Create a target directory for using with the target option
- target_temp_dir = TempDirectory(kind="target")
- target_temp_dir_path = target_temp_dir.path
- self.enter_context(target_temp_dir)
-
- global_options = options.global_options or []
-
- session = self.get_default_session(options)
-
- target_python = make_target_python(options)
- finder = self._build_package_finder(
- options=options,
- session=session,
- target_python=target_python,
- ignore_requires_python=options.ignore_requires_python,
- )
- build_tracker = self.enter_context(get_build_tracker())
-
- directory = TempDirectory(
- delete=not options.no_clean,
- kind="install",
- globally_managed=True,
- )
-
- try:
- reqs = self.get_requirements(args, options, finder, session)
- check_legacy_setup_py_options(options, reqs)
-
- wheel_cache = WheelCache(options.cache_dir)
-
- # Only when installing is it permitted to use PEP 660.
- # In other circumstances (pip wheel, pip download) we generate
- # regular (i.e. non editable) metadata and wheels.
- for req in reqs:
- req.permit_editable_wheels = True
-
- preparer = self.make_requirement_preparer(
- temp_build_dir=directory,
- options=options,
- build_tracker=build_tracker,
- session=session,
- finder=finder,
- use_user_site=options.use_user_site,
- verbosity=self.verbosity,
- )
- resolver = self.make_resolver(
- preparer=preparer,
- finder=finder,
- options=options,
- wheel_cache=wheel_cache,
- use_user_site=options.use_user_site,
- ignore_installed=options.ignore_installed,
- ignore_requires_python=options.ignore_requires_python,
- force_reinstall=options.force_reinstall,
- upgrade_strategy=upgrade_strategy,
- use_pep517=options.use_pep517,
- )
-
- self.trace_basic_info(finder)
-
- requirement_set = resolver.resolve(
- reqs, check_supported_wheels=not options.target_dir
- )
-
- if options.json_report_file:
- report = InstallationReport(requirement_set.requirements_to_install)
- if options.json_report_file == "-":
- print_json(data=report.to_dict())
- else:
- with open(options.json_report_file, "w", encoding="utf-8") as f:
- json.dump(report.to_dict(), f, indent=2, ensure_ascii=False)
-
- if options.dry_run:
- # In non dry-run mode, the legacy versions and specifiers check
- # will be done as part of conflict detection.
- requirement_set.warn_legacy_versions_and_specifiers()
- would_install_items = sorted(
- (r.metadata["name"], r.metadata["version"])
- for r in requirement_set.requirements_to_install
- )
- if would_install_items:
- write_output(
- "Would install %s",
- " ".join("-".join(item) for item in would_install_items),
- )
- return SUCCESS
-
- try:
- pip_req = requirement_set.get_requirement("pip")
- except KeyError:
- modifying_pip = False
- else:
- # If we're not replacing an already installed pip,
- # we're not modifying it.
- modifying_pip = pip_req.satisfied_by is None
- protect_pip_from_modification_on_windows(modifying_pip=modifying_pip)
-
- reqs_to_build = [
- r
- for r in requirement_set.requirements.values()
- if should_build_for_install_command(r)
- ]
-
- _, build_failures = build(
- reqs_to_build,
- wheel_cache=wheel_cache,
- verify=True,
- build_options=[],
- global_options=global_options,
- )
-
- if build_failures:
- raise InstallationError(
- "Could not build wheels for {}, which is required to "
- "install pyproject.toml-based projects".format(
- ", ".join(r.name for r in build_failures) # type: ignore
- )
- )
-
- to_install = resolver.get_installation_order(requirement_set)
-
- # Check for conflicts in the package set we're installing.
- conflicts: Optional[ConflictDetails] = None
- should_warn_about_conflicts = (
- not options.ignore_dependencies and options.warn_about_conflicts
- )
- if should_warn_about_conflicts:
- conflicts = self._determine_conflicts(to_install)
-
- # Don't warn about script install locations if
- # --target or --prefix has been specified
- warn_script_location = options.warn_script_location
- if options.target_dir or options.prefix_path:
- warn_script_location = False
-
- installed = install_given_reqs(
- to_install,
- global_options,
- root=options.root_path,
- home=target_temp_dir_path,
- prefix=options.prefix_path,
- warn_script_location=warn_script_location,
- use_user_site=options.use_user_site,
- pycompile=options.compile,
- )
-
- lib_locations = get_lib_location_guesses(
- user=options.use_user_site,
- home=target_temp_dir_path,
- root=options.root_path,
- prefix=options.prefix_path,
- isolated=options.isolated_mode,
- )
- env = get_environment(lib_locations)
-
- installed.sort(key=operator.attrgetter("name"))
- items = []
- for result in installed:
- item = result.name
- try:
- installed_dist = env.get_distribution(item)
- if installed_dist is not None:
- item = f"{item}-{installed_dist.version}"
- except Exception:
- pass
- items.append(item)
-
- if conflicts is not None:
- self._warn_about_conflicts(
- conflicts,
- resolver_variant=self.determine_resolver_variant(options),
- )
-
- installed_desc = " ".join(items)
- if installed_desc:
- write_output(
- "Successfully installed %s",
- installed_desc,
- )
- except OSError as error:
- show_traceback = self.verbosity >= 1
-
- message = create_os_error_message(
- error,
- show_traceback,
- options.use_user_site,
- )
- logger.error(message, exc_info=show_traceback) # noqa
-
- return ERROR
-
- if options.target_dir:
- assert target_temp_dir
- self._handle_target_dir(
- options.target_dir, target_temp_dir, options.upgrade
- )
- if options.root_user_action == "warn":
- warn_if_run_as_root()
- return SUCCESS
-
- def _handle_target_dir(
- self, target_dir: str, target_temp_dir: TempDirectory, upgrade: bool
- ) -> None:
- ensure_dir(target_dir)
-
- # Checking both purelib and platlib directories for installed
- # packages to be moved to target directory
- lib_dir_list = []
-
- # Checking both purelib and platlib directories for installed
- # packages to be moved to target directory
- scheme = get_scheme("", home=target_temp_dir.path)
- purelib_dir = scheme.purelib
- platlib_dir = scheme.platlib
- data_dir = scheme.data
-
- if os.path.exists(purelib_dir):
- lib_dir_list.append(purelib_dir)
- if os.path.exists(platlib_dir) and platlib_dir != purelib_dir:
- lib_dir_list.append(platlib_dir)
- if os.path.exists(data_dir):
- lib_dir_list.append(data_dir)
-
- for lib_dir in lib_dir_list:
- for item in os.listdir(lib_dir):
- if lib_dir == data_dir:
- ddir = os.path.join(data_dir, item)
- if any(s.startswith(ddir) for s in lib_dir_list[:-1]):
- continue
- target_item_dir = os.path.join(target_dir, item)
- if os.path.exists(target_item_dir):
- if not upgrade:
- logger.warning(
- "Target directory %s already exists. Specify "
- "--upgrade to force replacement.",
- target_item_dir,
- )
- continue
- if os.path.islink(target_item_dir):
- logger.warning(
- "Target directory %s already exists and is "
- "a link. pip will not automatically replace "
- "links, please remove if replacement is "
- "desired.",
- target_item_dir,
- )
- continue
- if os.path.isdir(target_item_dir):
- shutil.rmtree(target_item_dir)
- else:
- os.remove(target_item_dir)
-
- shutil.move(os.path.join(lib_dir, item), target_item_dir)
-
- def _determine_conflicts(
- self, to_install: List[InstallRequirement]
- ) -> Optional[ConflictDetails]:
- try:
- return check_install_conflicts(to_install)
- except Exception:
- logger.exception(
- "Error while checking for conflicts. Please file an issue on "
- "pip's issue tracker: https://github.com/pypa/pip/issues/new"
- )
- return None
-
- def _warn_about_conflicts(
- self, conflict_details: ConflictDetails, resolver_variant: str
- ) -> None:
- package_set, (missing, conflicting) = conflict_details
- if not missing and not conflicting:
- return
-
- parts: List[str] = []
- if resolver_variant == "legacy":
- parts.append(
- "pip's legacy dependency resolver does not consider dependency "
- "conflicts when selecting packages. This behaviour is the "
- "source of the following dependency conflicts."
- )
- else:
- assert resolver_variant == "2020-resolver"
- parts.append(
- "pip's dependency resolver does not currently take into account "
- "all the packages that are installed. This behaviour is the "
- "source of the following dependency conflicts."
- )
-
- # NOTE: There is some duplication here, with commands/check.py
- for project_name in missing:
- version = package_set[project_name][0]
- for dependency in missing[project_name]:
- message = (
- "{name} {version} requires {requirement}, "
- "which is not installed."
- ).format(
- name=project_name,
- version=version,
- requirement=dependency[1],
- )
- parts.append(message)
-
- for project_name in conflicting:
- version = package_set[project_name][0]
- for dep_name, dep_version, req in conflicting[project_name]:
- message = (
- "{name} {version} requires {requirement}, but {you} have "
- "{dep_name} {dep_version} which is incompatible."
- ).format(
- name=project_name,
- version=version,
- requirement=req,
- dep_name=dep_name,
- dep_version=dep_version,
- you=("you" if resolver_variant == "2020-resolver" else "you'll"),
- )
- parts.append(message)
-
- logger.critical("\n".join(parts))
-
-
-def get_lib_location_guesses(
- user: bool = False,
- home: Optional[str] = None,
- root: Optional[str] = None,
- isolated: bool = False,
- prefix: Optional[str] = None,
-) -> List[str]:
- scheme = get_scheme(
- "",
- user=user,
- home=home,
- root=root,
- isolated=isolated,
- prefix=prefix,
- )
- return [scheme.purelib, scheme.platlib]
-
-
-def site_packages_writable(root: Optional[str], isolated: bool) -> bool:
- return all(
- test_writable_dir(d)
- for d in set(get_lib_location_guesses(root=root, isolated=isolated))
- )
-
-
-def decide_user_install(
- use_user_site: Optional[bool],
- prefix_path: Optional[str] = None,
- target_dir: Optional[str] = None,
- root_path: Optional[str] = None,
- isolated_mode: bool = False,
-) -> bool:
- """Determine whether to do a user install based on the input options.
-
- If use_user_site is False, no additional checks are done.
- If use_user_site is True, it is checked for compatibility with other
- options.
- If use_user_site is None, the default behaviour depends on the environment,
- which is provided by the other arguments.
- """
- # In some cases (config from tox), use_user_site can be set to an integer
- # rather than a bool, which 'use_user_site is False' wouldn't catch.
- if (use_user_site is not None) and (not use_user_site):
- logger.debug("Non-user install by explicit request")
- return False
-
- if use_user_site:
- if prefix_path:
- raise CommandError(
- "Can not combine '--user' and '--prefix' as they imply "
- "different installation locations"
- )
- if virtualenv_no_global():
- raise InstallationError(
- "Can not perform a '--user' install. User site-packages "
- "are not visible in this virtualenv."
- )
- logger.debug("User install by explicit request")
- return True
-
- # If we are here, user installs have not been explicitly requested/avoided
- assert use_user_site is None
-
- # user install incompatible with --prefix/--target
- if prefix_path or target_dir:
- logger.debug("Non-user install due to --prefix or --target option")
- return False
-
- # If user installs are not enabled, choose a non-user install
- if not site.ENABLE_USER_SITE:
- logger.debug("Non-user install because user site-packages disabled")
- return False
-
- # If we have permission for a non-user install, do that,
- # otherwise do a user install.
- if site_packages_writable(root=root_path, isolated=isolated_mode):
- logger.debug("Non-user install because site-packages writeable")
- return False
-
- logger.info(
- "Defaulting to user installation because normal site-packages "
- "is not writeable"
- )
- return True
-
-
-def create_os_error_message(
- error: OSError, show_traceback: bool, using_user_site: bool
-) -> str:
- """Format an error message for an OSError
-
- It may occur anytime during the execution of the install command.
- """
- parts = []
-
- # Mention the error if we are not going to show a traceback
- parts.append("Could not install packages due to an OSError")
- if not show_traceback:
- parts.append(": ")
- parts.append(str(error))
- else:
- parts.append(".")
-
- # Spilt the error indication from a helper message (if any)
- parts[-1] += "\n"
-
- # Suggest useful actions to the user:
- # (1) using user site-packages or (2) verifying the permissions
- if error.errno == errno.EACCES:
- user_option_part = "Consider using the `--user` option"
- permissions_part = "Check the permissions"
-
- if not running_under_virtualenv() and not using_user_site:
- parts.extend(
- [
- user_option_part,
- " or ",
- permissions_part.lower(),
- ]
- )
- else:
- parts.append(permissions_part)
- parts.append(".\n")
-
- # Suggest the user to enable Long Paths if path length is
- # more than 260
- if (
- WINDOWS
- and error.errno == errno.ENOENT
- and error.filename
- and len(error.filename) > 260
- ):
- parts.append(
- "HINT: This error might have occurred since "
- "this system does not have Windows Long Path "
- "support enabled. You can find information on "
- "how to enable this at "
- "https://pip.pypa.io/warnings/enable-long-paths\n"
- )
-
- return "".join(parts).strip() + "\n"
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/pyproject.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/pyproject.py
deleted file mode 100644
index eb8e12b2dec992dc38c87510055d6ccb5f66c828..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_internal/pyproject.py
+++ /dev/null
@@ -1,179 +0,0 @@
-import importlib.util
-import os
-from collections import namedtuple
-from typing import Any, List, Optional
-
-from pip._vendor import tomli
-from pip._vendor.packaging.requirements import InvalidRequirement, Requirement
-
-from pip._internal.exceptions import (
- InstallationError,
- InvalidPyProjectBuildRequires,
- MissingPyProjectBuildRequires,
-)
-
-
-def _is_list_of_str(obj: Any) -> bool:
- return isinstance(obj, list) and all(isinstance(item, str) for item in obj)
-
-
-def make_pyproject_path(unpacked_source_directory: str) -> str:
- return os.path.join(unpacked_source_directory, "pyproject.toml")
-
-
-BuildSystemDetails = namedtuple(
- "BuildSystemDetails", ["requires", "backend", "check", "backend_path"]
-)
-
-
-def load_pyproject_toml(
- use_pep517: Optional[bool], pyproject_toml: str, setup_py: str, req_name: str
-) -> Optional[BuildSystemDetails]:
- """Load the pyproject.toml file.
-
- Parameters:
- use_pep517 - Has the user requested PEP 517 processing? None
- means the user hasn't explicitly specified.
- pyproject_toml - Location of the project's pyproject.toml file
- setup_py - Location of the project's setup.py file
- req_name - The name of the requirement we're processing (for
- error reporting)
-
- Returns:
- None if we should use the legacy code path, otherwise a tuple
- (
- requirements from pyproject.toml,
- name of PEP 517 backend,
- requirements we should check are installed after setting
- up the build environment
- directory paths to import the backend from (backend-path),
- relative to the project root.
- )
- """
- has_pyproject = os.path.isfile(pyproject_toml)
- has_setup = os.path.isfile(setup_py)
-
- if not has_pyproject and not has_setup:
- raise InstallationError(
- f"{req_name} does not appear to be a Python project: "
- f"neither 'setup.py' nor 'pyproject.toml' found."
- )
-
- if has_pyproject:
- with open(pyproject_toml, encoding="utf-8") as f:
- pp_toml = tomli.loads(f.read())
- build_system = pp_toml.get("build-system")
- else:
- build_system = None
-
- # The following cases must use PEP 517
- # We check for use_pep517 being non-None and falsey because that means
- # the user explicitly requested --no-use-pep517. The value 0 as
- # opposed to False can occur when the value is provided via an
- # environment variable or config file option (due to the quirk of
- # strtobool() returning an integer in pip's configuration code).
- if has_pyproject and not has_setup:
- if use_pep517 is not None and not use_pep517:
- raise InstallationError(
- "Disabling PEP 517 processing is invalid: "
- "project does not have a setup.py"
- )
- use_pep517 = True
- elif build_system and "build-backend" in build_system:
- if use_pep517 is not None and not use_pep517:
- raise InstallationError(
- "Disabling PEP 517 processing is invalid: "
- "project specifies a build backend of {} "
- "in pyproject.toml".format(build_system["build-backend"])
- )
- use_pep517 = True
-
- # If we haven't worked out whether to use PEP 517 yet,
- # and the user hasn't explicitly stated a preference,
- # we do so if the project has a pyproject.toml file
- # or if we cannot import setuptools or wheels.
-
- # We fallback to PEP 517 when without setuptools or without the wheel package,
- # so setuptools can be installed as a default build backend.
- # For more info see:
- # https://discuss.python.org/t/pip-without-setuptools-could-the-experience-be-improved/11810/9
- # https://github.com/pypa/pip/issues/8559
- elif use_pep517 is None:
- use_pep517 = (
- has_pyproject
- or not importlib.util.find_spec("setuptools")
- or not importlib.util.find_spec("wheel")
- )
-
- # At this point, we know whether we're going to use PEP 517.
- assert use_pep517 is not None
-
- # If we're using the legacy code path, there is nothing further
- # for us to do here.
- if not use_pep517:
- return None
-
- if build_system is None:
- # Either the user has a pyproject.toml with no build-system
- # section, or the user has no pyproject.toml, but has opted in
- # explicitly via --use-pep517.
- # In the absence of any explicit backend specification, we
- # assume the setuptools backend that most closely emulates the
- # traditional direct setup.py execution, and require wheel and
- # a version of setuptools that supports that backend.
-
- build_system = {
- "requires": ["setuptools>=40.8.0", "wheel"],
- "build-backend": "setuptools.build_meta:__legacy__",
- }
-
- # If we're using PEP 517, we have build system information (either
- # from pyproject.toml, or defaulted by the code above).
- # Note that at this point, we do not know if the user has actually
- # specified a backend, though.
- assert build_system is not None
-
- # Ensure that the build-system section in pyproject.toml conforms
- # to PEP 518.
-
- # Specifying the build-system table but not the requires key is invalid
- if "requires" not in build_system:
- raise MissingPyProjectBuildRequires(package=req_name)
-
- # Error out if requires is not a list of strings
- requires = build_system["requires"]
- if not _is_list_of_str(requires):
- raise InvalidPyProjectBuildRequires(
- package=req_name,
- reason="It is not a list of strings.",
- )
-
- # Each requirement must be valid as per PEP 508
- for requirement in requires:
- try:
- Requirement(requirement)
- except InvalidRequirement as error:
- raise InvalidPyProjectBuildRequires(
- package=req_name,
- reason=f"It contains an invalid requirement: {requirement!r}",
- ) from error
-
- backend = build_system.get("build-backend")
- backend_path = build_system.get("backend-path", [])
- check: List[str] = []
- if backend is None:
- # If the user didn't specify a backend, we assume they want to use
- # the setuptools backend. But we can't be sure they have included
- # a version of setuptools which supplies the backend. So we
- # make a note to check that this requirement is present once
- # we have set up the environment.
- # This is quite a lot of work to check for a very specific case. But
- # the problem is, that case is potentially quite common - projects that
- # adopted PEP 518 early for the ability to specify requirements to
- # execute setup.py, but never considered needing to mention the build
- # tools themselves. The original PEP 518 code had a similar check (but
- # implemented in a different way).
- backend = "setuptools.build_meta:__legacy__"
- check = ["setuptools>=40.8.0"]
-
- return BuildSystemDetails(requires, backend, check, backend_path)
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/cachecontrol/__init__.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/cachecontrol/__init__.py
deleted file mode 100644
index f631ae6df4747b808cac7c03b38e3e1d48bea00b..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/cachecontrol/__init__.py
+++ /dev/null
@@ -1,18 +0,0 @@
-# SPDX-FileCopyrightText: 2015 Eric Larson
-#
-# SPDX-License-Identifier: Apache-2.0
-
-"""CacheControl import Interface.
-
-Make it easy to import from cachecontrol without long namespaces.
-"""
-__author__ = "Eric Larson"
-__email__ = "eric@ionrock.org"
-__version__ = "0.12.11"
-
-from .wrapper import CacheControl
-from .adapter import CacheControlAdapter
-from .controller import CacheController
-
-import logging
-logging.getLogger(__name__).addHandler(logging.NullHandler())
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/command/register.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/command/register.py
deleted file mode 100644
index b8266b9a60f8c363ba35f7b73befd7c9c7cb4abc..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/setuptools/command/register.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from distutils import log
-import distutils.command.register as orig
-
-from setuptools.errors import RemovedCommandError
-
-
-class register(orig.register):
- """Formerly used to register packages on PyPI."""
-
- def run(self):
- msg = (
- "The register command has been removed, use twine to upload "
- + "instead (https://pypi.org/p/twine)"
- )
-
- self.announce("ERROR: " + msg, log.ERROR)
-
- raise RemovedCommandError(msg)
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/Misc/mmdet_mask_rcnn_R_50_FPN_1x.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/Misc/mmdet_mask_rcnn_R_50_FPN_1x.py
deleted file mode 100644
index 0f2464be744c083985898a25f9e71d00104f689d..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/Misc/mmdet_mask_rcnn_R_50_FPN_1x.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# An example config to train a mmdetection model using detectron2.
-
-from ..common.data.coco import dataloader
-from ..common.coco_schedule import lr_multiplier_1x as lr_multiplier
-from ..common.optim import SGD as optimizer
-from ..common.train import train
-
-from detectron2.modeling.mmdet_wrapper import MMDetDetector
-from detectron2.config import LazyCall as L
-
-model = L(MMDetDetector)(
- detector=dict(
- type="MaskRCNN",
- pretrained="torchvision://resnet50",
- backbone=dict(
- type="ResNet",
- depth=50,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type="BN", requires_grad=True),
- norm_eval=True,
- style="pytorch",
- ),
- neck=dict(type="FPN", in_channels=[256, 512, 1024, 2048], out_channels=256, num_outs=5),
- rpn_head=dict(
- type="RPNHead",
- in_channels=256,
- feat_channels=256,
- anchor_generator=dict(
- type="AnchorGenerator",
- scales=[8],
- ratios=[0.5, 1.0, 2.0],
- strides=[4, 8, 16, 32, 64],
- ),
- bbox_coder=dict(
- type="DeltaXYWHBBoxCoder",
- target_means=[0.0, 0.0, 0.0, 0.0],
- target_stds=[1.0, 1.0, 1.0, 1.0],
- ),
- loss_cls=dict(type="CrossEntropyLoss", use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type="L1Loss", loss_weight=1.0),
- ),
- roi_head=dict(
- type="StandardRoIHead",
- bbox_roi_extractor=dict(
- type="SingleRoIExtractor",
- roi_layer=dict(type="RoIAlign", output_size=7, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32],
- ),
- bbox_head=dict(
- type="Shared2FCBBoxHead",
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=80,
- bbox_coder=dict(
- type="DeltaXYWHBBoxCoder",
- target_means=[0.0, 0.0, 0.0, 0.0],
- target_stds=[0.1, 0.1, 0.2, 0.2],
- ),
- reg_class_agnostic=False,
- loss_cls=dict(type="CrossEntropyLoss", use_sigmoid=False, loss_weight=1.0),
- loss_bbox=dict(type="L1Loss", loss_weight=1.0),
- ),
- mask_roi_extractor=dict(
- type="SingleRoIExtractor",
- roi_layer=dict(type="RoIAlign", output_size=14, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[4, 8, 16, 32],
- ),
- mask_head=dict(
- type="FCNMaskHead",
- num_convs=4,
- in_channels=256,
- conv_out_channels=256,
- num_classes=80,
- loss_mask=dict(type="CrossEntropyLoss", use_mask=True, loss_weight=1.0),
- ),
- ),
- # model training and testing settings
- train_cfg=dict(
- rpn=dict(
- assigner=dict(
- type="MaxIoUAssigner",
- pos_iou_thr=0.7,
- neg_iou_thr=0.3,
- min_pos_iou=0.3,
- match_low_quality=True,
- ignore_iof_thr=-1,
- ),
- sampler=dict(
- type="RandomSampler",
- num=256,
- pos_fraction=0.5,
- neg_pos_ub=-1,
- add_gt_as_proposals=False,
- ),
- allowed_border=-1,
- pos_weight=-1,
- debug=False,
- ),
- rpn_proposal=dict(
- nms_pre=2000,
- max_per_img=1000,
- nms=dict(type="nms", iou_threshold=0.7),
- min_bbox_size=0,
- ),
- rcnn=dict(
- assigner=dict(
- type="MaxIoUAssigner",
- pos_iou_thr=0.5,
- neg_iou_thr=0.5,
- min_pos_iou=0.5,
- match_low_quality=True,
- ignore_iof_thr=-1,
- ),
- sampler=dict(
- type="RandomSampler",
- num=512,
- pos_fraction=0.25,
- neg_pos_ub=-1,
- add_gt_as_proposals=True,
- ),
- mask_size=28,
- pos_weight=-1,
- debug=False,
- ),
- ),
- test_cfg=dict(
- rpn=dict(
- nms_pre=1000,
- max_per_img=1000,
- nms=dict(type="nms", iou_threshold=0.7),
- min_bbox_size=0,
- ),
- rcnn=dict(
- score_thr=0.05,
- nms=dict(type="nms", iou_threshold=0.5),
- max_per_img=100,
- mask_thr_binary=0.5,
- ),
- ),
- ),
- pixel_mean=[123.675, 116.280, 103.530],
- pixel_std=[58.395, 57.120, 57.375],
-)
-
-dataloader.train.mapper.image_format = "RGB" # torchvision pretrained model
-train.init_checkpoint = None # pretrained model is loaded inside backbone
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/demo/predictor.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/demo/predictor.py
deleted file mode 100644
index 7b7ebd3f846850172c1f560f8492d51e5667f76d..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/demo/predictor.py
+++ /dev/null
@@ -1,220 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import atexit
-import bisect
-import multiprocessing as mp
-from collections import deque
-import cv2
-import torch
-
-from detectron2.data import MetadataCatalog
-from detectron2.engine.defaults import DefaultPredictor
-from detectron2.utils.video_visualizer import VideoVisualizer
-from detectron2.utils.visualizer import ColorMode, Visualizer
-
-
-class VisualizationDemo(object):
- def __init__(self, cfg, instance_mode=ColorMode.IMAGE, parallel=False):
- """
- Args:
- cfg (CfgNode):
- instance_mode (ColorMode):
- parallel (bool): whether to run the model in different processes from visualization.
- Useful since the visualization logic can be slow.
- """
- self.metadata = MetadataCatalog.get(
- cfg.DATASETS.TEST[0] if len(cfg.DATASETS.TEST) else "__unused"
- )
- self.cpu_device = torch.device("cpu")
- self.instance_mode = instance_mode
-
- self.parallel = parallel
- if parallel:
- num_gpu = torch.cuda.device_count()
- self.predictor = AsyncPredictor(cfg, num_gpus=num_gpu)
- else:
- self.predictor = DefaultPredictor(cfg)
-
- def run_on_image(self, image):
- """
- Args:
- image (np.ndarray): an image of shape (H, W, C) (in BGR order).
- This is the format used by OpenCV.
-
- Returns:
- predictions (dict): the output of the model.
- vis_output (VisImage): the visualized image output.
- """
- vis_output = None
- predictions = self.predictor(image)
- # Convert image from OpenCV BGR format to Matplotlib RGB format.
- image = image[:, :, ::-1]
- visualizer = Visualizer(image, self.metadata, instance_mode=self.instance_mode)
- if "panoptic_seg" in predictions:
- panoptic_seg, segments_info = predictions["panoptic_seg"]
- vis_output = visualizer.draw_panoptic_seg_predictions(
- panoptic_seg.to(self.cpu_device), segments_info
- )
- else:
- if "sem_seg" in predictions:
- vis_output = visualizer.draw_sem_seg(
- predictions["sem_seg"].argmax(dim=0).to(self.cpu_device)
- )
- if "instances" in predictions:
- instances = predictions["instances"].to(self.cpu_device)
- vis_output = visualizer.draw_instance_predictions(predictions=instances)
-
- return predictions, vis_output
-
- def _frame_from_video(self, video):
- while video.isOpened():
- success, frame = video.read()
- if success:
- yield frame
- else:
- break
-
- def run_on_video(self, video):
- """
- Visualizes predictions on frames of the input video.
-
- Args:
- video (cv2.VideoCapture): a :class:`VideoCapture` object, whose source can be
- either a webcam or a video file.
-
- Yields:
- ndarray: BGR visualizations of each video frame.
- """
- video_visualizer = VideoVisualizer(self.metadata, self.instance_mode)
-
- def process_predictions(frame, predictions):
- frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
- if "panoptic_seg" in predictions:
- panoptic_seg, segments_info = predictions["panoptic_seg"]
- vis_frame = video_visualizer.draw_panoptic_seg_predictions(
- frame, panoptic_seg.to(self.cpu_device), segments_info
- )
- elif "instances" in predictions:
- predictions = predictions["instances"].to(self.cpu_device)
- vis_frame = video_visualizer.draw_instance_predictions(frame, predictions)
- elif "sem_seg" in predictions:
- vis_frame = video_visualizer.draw_sem_seg(
- frame, predictions["sem_seg"].argmax(dim=0).to(self.cpu_device)
- )
-
- # Converts Matplotlib RGB format to OpenCV BGR format
- vis_frame = cv2.cvtColor(vis_frame.get_image(), cv2.COLOR_RGB2BGR)
- return vis_frame
-
- frame_gen = self._frame_from_video(video)
- if self.parallel:
- buffer_size = self.predictor.default_buffer_size
-
- frame_data = deque()
-
- for cnt, frame in enumerate(frame_gen):
- frame_data.append(frame)
- self.predictor.put(frame)
-
- if cnt >= buffer_size:
- frame = frame_data.popleft()
- predictions = self.predictor.get()
- yield process_predictions(frame, predictions)
-
- while len(frame_data):
- frame = frame_data.popleft()
- predictions = self.predictor.get()
- yield process_predictions(frame, predictions)
- else:
- for frame in frame_gen:
- yield process_predictions(frame, self.predictor(frame))
-
-
-class AsyncPredictor:
- """
- A predictor that runs the model asynchronously, possibly on >1 GPUs.
- Because rendering the visualization takes considerably amount of time,
- this helps improve throughput a little bit when rendering videos.
- """
-
- class _StopToken:
- pass
-
- class _PredictWorker(mp.Process):
- def __init__(self, cfg, task_queue, result_queue):
- self.cfg = cfg
- self.task_queue = task_queue
- self.result_queue = result_queue
- super().__init__()
-
- def run(self):
- predictor = DefaultPredictor(self.cfg)
-
- while True:
- task = self.task_queue.get()
- if isinstance(task, AsyncPredictor._StopToken):
- break
- idx, data = task
- result = predictor(data)
- self.result_queue.put((idx, result))
-
- def __init__(self, cfg, num_gpus: int = 1):
- """
- Args:
- cfg (CfgNode):
- num_gpus (int): if 0, will run on CPU
- """
- num_workers = max(num_gpus, 1)
- self.task_queue = mp.Queue(maxsize=num_workers * 3)
- self.result_queue = mp.Queue(maxsize=num_workers * 3)
- self.procs = []
- for gpuid in range(max(num_gpus, 1)):
- cfg = cfg.clone()
- cfg.defrost()
- cfg.MODEL.DEVICE = "cuda:{}".format(gpuid) if num_gpus > 0 else "cpu"
- self.procs.append(
- AsyncPredictor._PredictWorker(cfg, self.task_queue, self.result_queue)
- )
-
- self.put_idx = 0
- self.get_idx = 0
- self.result_rank = []
- self.result_data = []
-
- for p in self.procs:
- p.start()
- atexit.register(self.shutdown)
-
- def put(self, image):
- self.put_idx += 1
- self.task_queue.put((self.put_idx, image))
-
- def get(self):
- self.get_idx += 1 # the index needed for this request
- if len(self.result_rank) and self.result_rank[0] == self.get_idx:
- res = self.result_data[0]
- del self.result_data[0], self.result_rank[0]
- return res
-
- while True:
- # make sure the results are returned in the correct order
- idx, res = self.result_queue.get()
- if idx == self.get_idx:
- return res
- insert = bisect.bisect(self.result_rank, idx)
- self.result_rank.insert(insert, idx)
- self.result_data.insert(insert, res)
-
- def __len__(self):
- return self.put_idx - self.get_idx
-
- def __call__(self, image):
- self.put(image)
- return self.get()
-
- def shutdown(self):
- for _ in self.procs:
- self.task_queue.put(AsyncPredictor._StopToken())
-
- @property
- def default_buffer_size(self):
- return len(self.procs) * 5
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/__init__.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/__init__.py
deleted file mode 100644
index 259f669b78bd05815cb8d3351fd6c5fc9a1b85a1..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/__init__.py
+++ /dev/null
@@ -1,19 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-from . import transforms # isort:skip
-
-from .build import (
- build_batch_data_loader,
- build_detection_test_loader,
- build_detection_train_loader,
- get_detection_dataset_dicts,
- load_proposals_into_dataset,
- print_instances_class_histogram,
-)
-from .catalog import DatasetCatalog, MetadataCatalog, Metadata
-from .common import DatasetFromList, MapDataset, ToIterableDataset
-from .dataset_mapper import DatasetMapper
-
-# ensure the builtin datasets are registered
-from . import datasets, samplers # isort:skip
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/engine/__init__.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/engine/__init__.py
deleted file mode 100644
index 08a61572b4c7d09c8d400e903a96cbf5b2cc4763..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/engine/__init__.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-from .launch import *
-from .train_loop import *
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
-
-
-# prefer to let hooks and defaults live in separate namespaces (therefore not in __all__)
-# but still make them available here
-from .hooks import *
-from .defaults import *
diff --git a/spaces/ThomasSimonini/SmartRobot/style.css b/spaces/ThomasSimonini/SmartRobot/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/ThomasSimonini/SmartRobot/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/TornikeO/dis-background-removal/data_loader_cache.py b/spaces/TornikeO/dis-background-removal/data_loader_cache.py
deleted file mode 100644
index 75dfb518be94c1ce9eb4d5271abaa9711a7613c3..0000000000000000000000000000000000000000
--- a/spaces/TornikeO/dis-background-removal/data_loader_cache.py
+++ /dev/null
@@ -1,385 +0,0 @@
-## data loader
-## Ackownledgement:
-## We would like to thank Dr. Ibrahim Almakky (https://scholar.google.co.uk/citations?user=T9MTcK0AAAAJ&hl=en)
-## for his helps in implementing cache machanism of our DIS dataloader.
-from __future__ import print_function, division
-
-import numpy as np
-import random
-from copy import deepcopy
-import json
-from tqdm import tqdm
-from skimage import io
-import os
-from glob import glob
-
-import torch
-from torch.utils.data import Dataset, DataLoader
-from torchvision import transforms, utils
-from torchvision.transforms.functional import normalize
-import torch.nn.functional as F
-
-#### --------------------- DIS dataloader cache ---------------------####
-
-def get_im_gt_name_dict(datasets, flag='valid'):
- print("------------------------------", flag, "--------------------------------")
- name_im_gt_list = []
- for i in range(len(datasets)):
- print("--->>>", flag, " dataset ",i,"/",len(datasets)," ",datasets[i]["name"],"<<<---")
- tmp_im_list, tmp_gt_list = [], []
- tmp_im_list = glob(datasets[i]["im_dir"]+os.sep+'*'+datasets[i]["im_ext"])
-
- # img_name_dict[im_dirs[i][0]] = tmp_im_list
- print('-im-',datasets[i]["name"],datasets[i]["im_dir"], ': ',len(tmp_im_list))
-
- if(datasets[i]["gt_dir"]==""):
- print('-gt-', datasets[i]["name"], datasets[i]["gt_dir"], ': ', 'No Ground Truth Found')
- tmp_gt_list = []
- else:
- tmp_gt_list = [datasets[i]["gt_dir"]+os.sep+x.split(os.sep)[-1].split(datasets[i]["im_ext"])[0]+datasets[i]["gt_ext"] for x in tmp_im_list]
-
- # lbl_name_dict[im_dirs[i][0]] = tmp_gt_list
- print('-gt-', datasets[i]["name"],datasets[i]["gt_dir"], ': ',len(tmp_gt_list))
-
-
- if flag=="train": ## combine multiple training sets into one dataset
- if len(name_im_gt_list)==0:
- name_im_gt_list.append({"dataset_name":datasets[i]["name"],
- "im_path":tmp_im_list,
- "gt_path":tmp_gt_list,
- "im_ext":datasets[i]["im_ext"],
- "gt_ext":datasets[i]["gt_ext"],
- "cache_dir":datasets[i]["cache_dir"]})
- else:
- name_im_gt_list[0]["dataset_name"] = name_im_gt_list[0]["dataset_name"] + "_" + datasets[i]["name"]
- name_im_gt_list[0]["im_path"] = name_im_gt_list[0]["im_path"] + tmp_im_list
- name_im_gt_list[0]["gt_path"] = name_im_gt_list[0]["gt_path"] + tmp_gt_list
- if datasets[i]["im_ext"]!=".jpg" or datasets[i]["gt_ext"]!=".png":
- print("Error: Please make sure all you images and ground truth masks are in jpg and png format respectively !!!")
- exit()
- name_im_gt_list[0]["im_ext"] = ".jpg"
- name_im_gt_list[0]["gt_ext"] = ".png"
- name_im_gt_list[0]["cache_dir"] = os.sep.join(datasets[i]["cache_dir"].split(os.sep)[0:-1])+os.sep+name_im_gt_list[0]["dataset_name"]
- else: ## keep different validation or inference datasets as separate ones
- name_im_gt_list.append({"dataset_name":datasets[i]["name"],
- "im_path":tmp_im_list,
- "gt_path":tmp_gt_list,
- "im_ext":datasets[i]["im_ext"],
- "gt_ext":datasets[i]["gt_ext"],
- "cache_dir":datasets[i]["cache_dir"]})
-
- return name_im_gt_list
-
-def create_dataloaders(name_im_gt_list, cache_size=[], cache_boost=True, my_transforms=[], batch_size=1, shuffle=False):
- ## model="train": return one dataloader for training
- ## model="valid": return a list of dataloaders for validation or testing
-
- gos_dataloaders = []
- gos_datasets = []
-
- if(len(name_im_gt_list)==0):
- return gos_dataloaders, gos_datasets
-
- num_workers_ = 1
- if(batch_size>1):
- num_workers_ = 2
- if(batch_size>4):
- num_workers_ = 4
- if(batch_size>8):
- num_workers_ = 8
-
- for i in range(0,len(name_im_gt_list)):
- gos_dataset = GOSDatasetCache([name_im_gt_list[i]],
- cache_size = cache_size,
- cache_path = name_im_gt_list[i]["cache_dir"],
- cache_boost = cache_boost,
- transform = transforms.Compose(my_transforms))
- gos_dataloaders.append(DataLoader(gos_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers_))
- gos_datasets.append(gos_dataset)
-
- return gos_dataloaders, gos_datasets
-
-def im_reader(im_path):
- return io.imread(im_path)
-
-def im_preprocess(im,size):
- if len(im.shape) < 3:
- im = im[:, :, np.newaxis]
- if im.shape[2] == 1:
- im = np.repeat(im, 3, axis=2)
- im_tensor = torch.tensor(im.copy(), dtype=torch.float32)
- im_tensor = torch.transpose(torch.transpose(im_tensor,1,2),0,1)
- if(len(size)<2):
- return im_tensor, im.shape[0:2]
- else:
- im_tensor = torch.unsqueeze(im_tensor,0)
- im_tensor = F.upsample(im_tensor, size, mode="bilinear")
- im_tensor = torch.squeeze(im_tensor,0)
-
- return im_tensor.type(torch.uint8), im.shape[0:2]
-
-def gt_preprocess(gt,size):
- if len(gt.shape) > 2:
- gt = gt[:, :, 0]
-
- gt_tensor = torch.unsqueeze(torch.tensor(gt, dtype=torch.uint8),0)
-
- if(len(size)<2):
- return gt_tensor.type(torch.uint8), gt.shape[0:2]
- else:
- gt_tensor = torch.unsqueeze(torch.tensor(gt_tensor, dtype=torch.float32),0)
- gt_tensor = F.upsample(gt_tensor, size, mode="bilinear")
- gt_tensor = torch.squeeze(gt_tensor,0)
-
- return gt_tensor.type(torch.uint8), gt.shape[0:2]
- # return gt_tensor, gt.shape[0:2]
-
-class GOSRandomHFlip(object):
- def __init__(self,prob=0.5):
- self.prob = prob
- def __call__(self,sample):
- imidx, image, label, shape = sample['imidx'], sample['image'], sample['label'], sample['shape']
-
- # random horizontal flip
- if random.random() >= self.prob:
- image = torch.flip(image,dims=[2])
- label = torch.flip(label,dims=[2])
-
- return {'imidx':imidx,'image':image, 'label':label, 'shape':shape}
-
-class GOSResize(object):
- def __init__(self,size=[320,320]):
- self.size = size
- def __call__(self,sample):
- imidx, image, label, shape = sample['imidx'], sample['image'], sample['label'], sample['shape']
-
- # import time
- # start = time.time()
-
- image = torch.squeeze(F.upsample(torch.unsqueeze(image,0),self.size,mode='bilinear'),dim=0)
- label = torch.squeeze(F.upsample(torch.unsqueeze(label,0),self.size,mode='bilinear'),dim=0)
-
- # print("time for resize: ", time.time()-start)
-
- return {'imidx':imidx,'image':image, 'label':label, 'shape':shape}
-
-class GOSRandomCrop(object):
- def __init__(self,size=[288,288]):
- self.size = size
- def __call__(self,sample):
- imidx, image, label, shape = sample['imidx'], sample['image'], sample['label'], sample['shape']
-
- h, w = image.shape[1:]
- new_h, new_w = self.size
-
- top = np.random.randint(0, h - new_h)
- left = np.random.randint(0, w - new_w)
-
- image = image[:,top:top+new_h,left:left+new_w]
- label = label[:,top:top+new_h,left:left+new_w]
-
- return {'imidx':imidx,'image':image, 'label':label, 'shape':shape}
-
-
-class GOSNormalize(object):
- def __init__(self, mean=[0.485,0.456,0.406], std=[0.229,0.224,0.225]):
- self.mean = mean
- self.std = std
-
- def __call__(self,sample):
-
- imidx, image, label, shape = sample['imidx'], sample['image'], sample['label'], sample['shape']
- image = normalize(image,self.mean,self.std)
-
- return {'imidx':imidx,'image':image, 'label':label, 'shape':shape}
-
-
-class GOSDatasetCache(Dataset):
-
- def __init__(self, name_im_gt_list, cache_size=[], cache_path='./cache', cache_file_name='dataset.json', cache_boost=False, transform=None):
-
-
- self.cache_size = cache_size
- self.cache_path = cache_path
- self.cache_file_name = cache_file_name
- self.cache_boost_name = ""
-
- self.cache_boost = cache_boost
- # self.ims_npy = None
- # self.gts_npy = None
-
- ## cache all the images and ground truth into a single pytorch tensor
- self.ims_pt = None
- self.gts_pt = None
-
- ## we will cache the npy as well regardless of the cache_boost
- # if(self.cache_boost):
- self.cache_boost_name = cache_file_name.split('.json')[0]
-
- self.transform = transform
-
- self.dataset = {}
-
- ## combine different datasets into one
- dataset_names = []
- dt_name_list = [] # dataset name per image
- im_name_list = [] # image name
- im_path_list = [] # im path
- gt_path_list = [] # gt path
- im_ext_list = [] # im ext
- gt_ext_list = [] # gt ext
- for i in range(0,len(name_im_gt_list)):
- dataset_names.append(name_im_gt_list[i]["dataset_name"])
- # dataset name repeated based on the number of images in this dataset
- dt_name_list.extend([name_im_gt_list[i]["dataset_name"] for x in name_im_gt_list[i]["im_path"]])
- im_name_list.extend([x.split(os.sep)[-1].split(name_im_gt_list[i]["im_ext"])[0] for x in name_im_gt_list[i]["im_path"]])
- im_path_list.extend(name_im_gt_list[i]["im_path"])
- gt_path_list.extend(name_im_gt_list[i]["gt_path"])
- im_ext_list.extend([name_im_gt_list[i]["im_ext"] for x in name_im_gt_list[i]["im_path"]])
- gt_ext_list.extend([name_im_gt_list[i]["gt_ext"] for x in name_im_gt_list[i]["gt_path"]])
-
-
- self.dataset["data_name"] = dt_name_list
- self.dataset["im_name"] = im_name_list
- self.dataset["im_path"] = im_path_list
- self.dataset["ori_im_path"] = deepcopy(im_path_list)
- self.dataset["gt_path"] = gt_path_list
- self.dataset["ori_gt_path"] = deepcopy(gt_path_list)
- self.dataset["im_shp"] = []
- self.dataset["gt_shp"] = []
- self.dataset["im_ext"] = im_ext_list
- self.dataset["gt_ext"] = gt_ext_list
-
-
- self.dataset["ims_pt_dir"] = ""
- self.dataset["gts_pt_dir"] = ""
-
- self.dataset = self.manage_cache(dataset_names)
-
- def manage_cache(self,dataset_names):
- if not os.path.exists(self.cache_path): # create the folder for cache
- os.makedirs(self.cache_path)
- cache_folder = os.path.join(self.cache_path, "_".join(dataset_names)+"_"+"x".join([str(x) for x in self.cache_size]))
- if not os.path.exists(cache_folder): # check if the cache files are there, if not then cache
- return self.cache(cache_folder)
- return self.load_cache(cache_folder)
-
- def cache(self,cache_folder):
- os.mkdir(cache_folder)
- cached_dataset = deepcopy(self.dataset)
-
- # ims_list = []
- # gts_list = []
- ims_pt_list = []
- gts_pt_list = []
- for i, im_path in tqdm(enumerate(self.dataset["im_path"]), total=len(self.dataset["im_path"])):
-
- im_id = cached_dataset["im_name"][i]
- print("im_path: ", im_path)
- im = im_reader(im_path)
- im, im_shp = im_preprocess(im,self.cache_size)
- im_cache_file = os.path.join(cache_folder,self.dataset["data_name"][i]+"_"+im_id + "_im.pt")
- torch.save(im,im_cache_file)
-
- cached_dataset["im_path"][i] = im_cache_file
- if(self.cache_boost):
- ims_pt_list.append(torch.unsqueeze(im,0))
- # ims_list.append(im.cpu().data.numpy().astype(np.uint8))
-
- gt = np.zeros(im.shape[0:2])
- if len(self.dataset["gt_path"])!=0:
- gt = im_reader(self.dataset["gt_path"][i])
- gt, gt_shp = gt_preprocess(gt,self.cache_size)
- gt_cache_file = os.path.join(cache_folder,self.dataset["data_name"][i]+"_"+im_id + "_gt.pt")
- torch.save(gt,gt_cache_file)
- if len(self.dataset["gt_path"])>0:
- cached_dataset["gt_path"][i] = gt_cache_file
- else:
- cached_dataset["gt_path"].append(gt_cache_file)
- if(self.cache_boost):
- gts_pt_list.append(torch.unsqueeze(gt,0))
- # gts_list.append(gt.cpu().data.numpy().astype(np.uint8))
-
- # im_shp_cache_file = os.path.join(cache_folder,im_id + "_im_shp.pt")
- # torch.save(gt_shp, shp_cache_file)
- cached_dataset["im_shp"].append(im_shp)
- # self.dataset["im_shp"].append(im_shp)
-
- # shp_cache_file = os.path.join(cache_folder,im_id + "_gt_shp.pt")
- # torch.save(gt_shp, shp_cache_file)
- cached_dataset["gt_shp"].append(gt_shp)
- # self.dataset["gt_shp"].append(gt_shp)
-
- if(self.cache_boost):
- cached_dataset["ims_pt_dir"] = os.path.join(cache_folder, self.cache_boost_name+'_ims.pt')
- cached_dataset["gts_pt_dir"] = os.path.join(cache_folder, self.cache_boost_name+'_gts.pt')
- self.ims_pt = torch.cat(ims_pt_list,dim=0)
- self.gts_pt = torch.cat(gts_pt_list,dim=0)
- torch.save(torch.cat(ims_pt_list,dim=0),cached_dataset["ims_pt_dir"])
- torch.save(torch.cat(gts_pt_list,dim=0),cached_dataset["gts_pt_dir"])
-
- try:
- json_file = open(os.path.join(cache_folder, self.cache_file_name),"w")
- json.dump(cached_dataset, json_file)
- json_file.close()
- except Exception:
- raise FileNotFoundError("Cannot create JSON")
- return cached_dataset
-
- def load_cache(self, cache_folder):
- json_file = open(os.path.join(cache_folder,self.cache_file_name),"r")
- dataset = json.load(json_file)
- json_file.close()
- ## if cache_boost is true, we will load the image npy and ground truth npy into the RAM
- ## otherwise the pytorch tensor will be loaded
- if(self.cache_boost):
- # self.ims_npy = np.load(dataset["ims_npy_dir"])
- # self.gts_npy = np.load(dataset["gts_npy_dir"])
- self.ims_pt = torch.load(dataset["ims_pt_dir"], map_location='cpu')
- self.gts_pt = torch.load(dataset["gts_pt_dir"], map_location='cpu')
- return dataset
-
- def __len__(self):
- return len(self.dataset["im_path"])
-
- def __getitem__(self, idx):
-
- im = None
- gt = None
- if(self.cache_boost and self.ims_pt is not None):
-
- # start = time.time()
- im = self.ims_pt[idx]#.type(torch.float32)
- gt = self.gts_pt[idx]#.type(torch.float32)
- # print(idx, 'time for pt loading: ', time.time()-start)
-
- else:
- # import time
- # start = time.time()
- # print("tensor***")
- im_pt_path = os.path.join(self.cache_path,os.sep.join(self.dataset["im_path"][idx].split(os.sep)[-2:]))
- im = torch.load(im_pt_path)#(self.dataset["im_path"][idx])
- gt_pt_path = os.path.join(self.cache_path,os.sep.join(self.dataset["gt_path"][idx].split(os.sep)[-2:]))
- gt = torch.load(gt_pt_path)#(self.dataset["gt_path"][idx])
- # print(idx,'time for tensor loading: ', time.time()-start)
-
-
- im_shp = self.dataset["im_shp"][idx]
- # print("time for loading im and gt: ", time.time()-start)
-
- # start_time = time.time()
- im = torch.divide(im,255.0)
- gt = torch.divide(gt,255.0)
- # print(idx, 'time for normalize torch divide: ', time.time()-start_time)
-
- sample = {
- "imidx": torch.from_numpy(np.array(idx)),
- "image": im,
- "label": gt,
- "shape": torch.from_numpy(np.array(im_shp)),
- }
-
- if self.transform:
- sample = self.transform(sample)
-
- return sample
diff --git a/spaces/Vipitis/shadermatch/README.md b/spaces/Vipitis/shadermatch/README.md
deleted file mode 100644
index f11dd2cab7bdd9d15166bb4a441fc09fb53a5385..0000000000000000000000000000000000000000
--- a/spaces/Vipitis/shadermatch/README.md
+++ /dev/null
@@ -1,62 +0,0 @@
----
-title: ShaderMatch
-tags:
-- evaluate
-- metric
-description: "compare rendered frames from shadercode, using a WGPU implementation"
-sdk: gradio
-sdk_version: 3.47.1
-app_file: app.py
-pinned: false
----
-
-# Metric Card for ShaderMatch
-
-## Metric Description
-This metric is under construction. It is meant as a kind of "semantic match" by checking if a pair of shadercode (Shadertoy.com style) render the exact same image.
-
-## requirements
-see [requirements.txt](./requirements.txt)
-The current implementation additionally relies on [`naga-cli`](https://github.com/gfx-rs/naga) to validate shadercode before rendering it.
-this dependency is not handled as of right now.
-
-## How to Use
-```python
-import evaluate
-smatch = evaluate.load("Vipitis/shadermatch")
-smatch.compute(references=[test_code], predictions=[test_code]) #1.0 same
-smatch.compute(references=[test_code], predictions=["123"]) #0.0 not valid shadercode
-smatch.compute(references=[test_code], predictions=[altered_code]) #0.1 only matches at time=0.0
->>> {'text_match': 0.0, 'code_error': 0.0, 'image_match': 0.1}
-```
-
-### Inputs
-- **refernces** List[(str)]: whole shader code of the reference
-- **prediction** List[(str)]: whole shader of your (partial) generation to compare it too
-
-
-### Output Values
-
-For every paid of reference and prediction, we compile and render the shadercoder at 10 different timesamples.
- - **text_match** (float): If the code is an exact match or not. It will not render the shader. Assume images also match
- - **code_error** (float): If shader compilation fails due to for example syntax errors.
- - **image_match** (float): How many of the 10 images are exactly the same. Ranges from 0.0 to 1.0.
-
-#### Values from Popular Papers
-This metric is in development and has not yet been tested. The paper hasn't even been approved to be written but hopefully will be published by April 2024.
-
-Some intermediate references might follow models run in ShaderEval.task1 [ReturnCompletion](https://huggingface.co/spaces/Vipitis/ShaderEval)
-
-### Examples
-see [tests.py](./tests.py)
-
-## Limitations and Bias
-the time intervals are not chosen by any good method, it might not catch differences in shaders of a very specific periodicy.
-
-## Citation
-unlikely to be done before April 2024
-
-## Further References
-The metric is inspired by unit test metrics like HumanEval, APPS, etc;
-sampling shaders at different time has been done for [shaders21k](https://mbaradad.github.io/shaders21k/)
-This metric will be used in Task2, developed at https://github.com/Vipitis/bigcode-evaluation-harness/tree/shadereval_tasks
\ No newline at end of file
diff --git a/spaces/VlaTal/facial_beauty_analysis/ratios.py b/spaces/VlaTal/facial_beauty_analysis/ratios.py
deleted file mode 100644
index 4fc97c759b77e6130b31cdcb3ef1b5fffa20ee8a..0000000000000000000000000000000000000000
--- a/spaces/VlaTal/facial_beauty_analysis/ratios.py
+++ /dev/null
@@ -1,27 +0,0 @@
-import enum
-
-
-class Ratios(enum.Enum):
- UNDER_EYES = "under_eyes"
- INTEROCULAR = "interocular"
- NOSE_WIDTH = "nose_width"
- MOUTH_WIDTH = "mouth_width"
- UPPER_LIP_TO_JAW = "upper_lip_to_jaw"
- LIPS_HEIGHT = "lips_height"
- NOSE_TO_MOUTH_HEIGHT = "nose_to_mouth_height"
- UPPER_LIP_HEIGHT = "upper_lip_height"
- FACE_TOP_TO_EYEBROWS = "face_top_to_eyebrows"
- EYEBROWS_TO_NOSE = "eyebrows_to_nose"
- NOSE_TO_JAW = "nose_to_jaw"
- FACE_HEIGHT = "face_height"
- FACE_WIDTH = "face_width"
- LEFT_LOWER_EYEBROW_LENGTH = "left_lower_eyebrow_length"
- RIGHT_LOWER_EYEBROW_LENGTH = "right_lower_eyebrow_length"
- LEFT_LOWER_LIP_LENGTH = "left_lower_lip_length"
- RIGHT_LOWER_LIP_LENGTH = "right_lower_lip_length"
- LEFT_UPPER_EYEBROW_LENGTH = "left_upper_eyebrow_length"
- RIGHT_UPPER_EYEBROW_LENGTH = "right_upper_eyebrow_length"
- LEFT_UPPER_LIP_LENGTH = "left_upper_lip_length"
- RIGHT_UPPER_LIP_LENGTH = "right_upper_lip_length"
- LEFT_NOSE_WIDTH = "nose_left_width"
- RIGHT_NOSE_WIDTH = "nose_right_width"
diff --git a/spaces/VoyagerYuan/Transformer_CatVAE_and_Signal_Game/app.py b/spaces/VoyagerYuan/Transformer_CatVAE_and_Signal_Game/app.py
deleted file mode 100644
index 6c420def018a5072aab984fbca17b7a24449581f..0000000000000000000000000000000000000000
--- a/spaces/VoyagerYuan/Transformer_CatVAE_and_Signal_Game/app.py
+++ /dev/null
@@ -1,299 +0,0 @@
-import streamlit as st
-import torch.nn.functional as F
-import torch
-import torch.nn as nn
-import numpy as np
-import matplotlib.pyplot as plt
-from torch.utils.data import Dataset, DataLoader
-import re
-import plotly.graph_objects as go
-
-# Assuming TransformerEncoder and TransformerDecoder are defined above
-EMBEDDING_DIM = 16
-HIDDEN_DIM = 16
-LATENT_DIM = 16 # Dimension of the latent space
-SEQ_LEN = 16 # Max length of the sequence
-NHEAD = 4 # Number of heads in multi-head attention
-NUM_LAYERS = 2 # Number of transformer layers
-
-# Gumbel softmax temperature
-TAU = 1.0
-
-LEARNING_RATE = 1e-3
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-torch.random.manual_seed(1024)
-
-# Pass embeded into decoder instead of using the original x
-class TransformerEncoder(nn.Module):
- def __init__(self, d_model=EMBEDDING_DIM, nhead=NHEAD, num_layers=NUM_LAYERS):
- super(TransformerEncoder, self).__init__()
- self.embedding = nn.Embedding(VOCAB_SIZE, d_model)
- self.transformer_encoder = nn.TransformerEncoder(
- nn.TransformerEncoderLayer(d_model, nhead), num_layers
- )
- self.fc_logits = nn.Linear(d_model, LATENT_DIM)
-
- def forward(self, x):
- embedded = self.embedding(x).permute(1, 0, 2) # Transformer expects seq_len, batch, features
- transformed = self.transformer_encoder(embedded)
- # Use the final state to predict logits for latent space
- logits = self.fc_logits(transformed[-1])
- return logits, embedded
-
-
-class TransformerDecoder(nn.Module):
- def __init__(self, d_model=EMBEDDING_DIM, nhead=NHEAD, num_layers=NUM_LAYERS):
- super(TransformerDecoder, self).__init__()
- self.embedding = nn.Embedding(VOCAB_SIZE, d_model)
- self.transformer_decoder = nn.TransformerDecoder(
- nn.TransformerDecoderLayer(d_model, nhead), num_layers
- )
- self.fc_out = nn.Linear(d_model, VOCAB_SIZE)
- self.fc_z = nn.Linear(LATENT_DIM, d_model) # Convert z to feature size for transformer
-
- def forward(self, embedded, z):
- # embedded = self.embedding(x).permute(1, 0, 2) # Transformer expects [seq_len, batch, features], permute函数用于改变张量的维度顺序
- z_adjusted = self.fc_z(z).unsqueeze(0)
- output = self.transformer_decoder(embedded, z_adjusted)
- return self.fc_out(output.permute(1, 0, 2))
-
-
-class TransformerCVAE(nn.Module):
- def __init__(self):
- super(TransformerCVAE, self).__init__()
- self.encoder = TransformerEncoder()
- self.decoder = TransformerDecoder()
-
- def reparameterize(self, logits):
- return F.gumbel_softmax(logits, tau=TAU, hard=False, dim=-1)
-
- def forward(self, x):
- logits, emb = self.encoder(x)
- z = self.reparameterize(logits)
- return self.decoder(emb, z), logits
-
-def load_and_preprocess_wikitext(file_path):
- with open(file_path, 'r', encoding='utf-8') as f:
- text = f.read()
-
- # Use regular expressions to split the text into sentences
- sentences = re.split(r'(?<=[.!?])\s+', text)
- sentences = [sentence.strip() for sentence in sentences]
-
- return sentences
-
-train_file_path = "wikitext-2/wiki.train.tokens"
-test_file_path = "wikitext-2/wiki.test.tokens"
-val_file_path = "wikitext-2/wiki.valid.tokens"
-
-wikitext_sentences_train = load_and_preprocess_wikitext(train_file_path)
-wikitext_sentences_test = load_and_preprocess_wikitext(test_file_path)
-wikitext_sentences_val = load_and_preprocess_wikitext(val_file_path)
-
-# Hyperparameters
-BATCH_SIZE = 32
-PAD_TOKEN = ""
-UNK_TOKEN = ""
-
-# Tokenize the data
-tokens = [word for sentence in wikitext_sentences_train for word in sentence.split()]
-
-# Build vocabulary
-vocab = [PAD_TOKEN, UNK_TOKEN] + list(set(tokens))
-word_index = {word: index for index, word in enumerate(vocab)}
-# 添加新的tokens
-SOS_TOKEN = ''
-EOS_TOKEN = ''
-word_index[SOS_TOKEN] = len(word_index)
-word_index[EOS_TOKEN] = len(word_index)
-vocab = {v: k for k, v in word_index.items()}
-# Convert tokens to integers
-def tokenize_and_encode(text):
- return [word_index.get(word, word_index[UNK_TOKEN]) for word in text.split()]
-
-encoded_data_train = [tokenize_and_encode(sentence) for sentence in wikitext_sentences_train]
-
-# Create a PyTorch Dataset
-class WikiDataset(Dataset):
- def __init__(self, data, sequence_length):
- self.data = data
- self.sequence_length = sequence_length
-
- def __len__(self):
- return len(self.data)
-
- def __getitem__(self, idx):
- sample = self.data[idx]
- if len(sample) < self.sequence_length:
- sample.extend([word_index[PAD_TOKEN]] * (self.sequence_length - len(sample)))
- else:
- sample = sample[:self.sequence_length]
- return torch.tensor(sample)
-
-# dataset = WikiDataset(encoded_data_train, SEQUENCE_LENGTH)
-# dataloader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
-# Split the data into train and validation sets
-dataset = WikiDataset(encoded_data_train, SEQ_LEN)
-train_size = int(0.8 * len(dataset))
-val_size = len(dataset) - train_size
-train_dataset, val_dataset = torch.utils.data.random_split(dataset, [train_size, val_size])
-train_dataloader = DataLoader(train_dataset, batch_size=BATCH_SIZE, shuffle=True)
-val_dataloader = DataLoader(val_dataset, batch_size=BATCH_SIZE, shuffle=True)
-
-VOCAB_SIZE = len(vocab)
-
-class MultiMultiSignalingGame:
- def __init__(self, senders: list, receivers: list, optimizer, criterion):
- self.senders = senders
- self.receivers = receivers
- self.optimizer = optimizer
- self.criterion = criterion
-
- def play_round(self, states):
- all_decoded_outputs = []
- all_logits = []
- interactions = []
-
- for i, sender in enumerate(self.senders):
- # Sender encodes the state
- logits, emb = sender(states[i])
- all_logits.append(logits)
- z = F.gumbel_softmax(logits, tau=TAU, hard=False, dim=-1)
-
- _, input_sentence_ids = torch.max(states[i], dim=1)
- input_sentence_ids = input_sentence_ids.cpu().numpy()
- input_sentence = ' '.join([vocab[idx] for idx in input_sentence_ids])
-
- # Each receiver decodes the signal from the sender
- for j, receiver in enumerate(self.receivers):
- decoded_output = receiver(emb, z)
- all_decoded_outputs.append(decoded_output)
-
- _, output_sentence_ids = torch.max(decoded_output[0], dim=1)
- output_sentence_ids = output_sentence_ids.cpu().numpy()
- output_sentence = ' '.join([vocab[idx] for idx in output_sentence_ids])
-
- interactions.append((i, j, input_sentence, output_sentence))
-
- # Calculate loss
- loss, recon_loss, kld_loss = self.compute_loss(states, all_decoded_outputs, all_logits, beta=1.0)
-
- # Update model parameters
- self.optimizer.zero_grad()
- loss.backward()
- self.optimizer.step()
-
- return loss.item(), recon_loss.item(), kld_loss.item(), interactions
-
- def compute_loss(self, original_states, decoded_states, logits, beta):
- recon_loss = sum([self.criterion(decoded_state.view(-1, VOCAB_SIZE), original_state.view(-1))
- for original_state, decoded_state in zip(original_states * len(self.receivers), decoded_states)])
-
- # Calculate KLD loss
- kld_losses = []
- for logit in logits:
- mean, logvar = torch.chunk(logit, 2, dim=-1)
- kld_loss = -0.5 * torch.sum(1 + logvar - mean.pow(2) - logvar.exp())
- kld_losses.append(kld_loss)
-
- return recon_loss + beta * sum(kld_losses), recon_loss, sum(kld_losses)
-
-
-def run_signal_game(NUM_SENDERS, NUM_RECEIVERS, num_rounds):
- # para_checker = st.empty()
- # para_checker.text(f"NUM_SENDERS: {NUM_SENDERS}, NUM_RECEIVERS: {NUM_RECEIVERS}, num_rounds: {num_rounds}, EMBEDDING_DIM: {EMBEDDING_DIM}, HIDDEN_DIM: {HIDDEN_DIM}, LATENT_DIM: {LATENT_DIM}, SEQ_LEN: {SEQ_LEN}, TAU: {TAU}, nhead: {NHEAD}, num_layers: {NUM_LAYERS}, BATCH_SIZE: {BATCH_SIZE}")
- senders = [TransformerEncoder().to(device) for _ in range(NUM_SENDERS)]
- receivers = [TransformerDecoder().to(device) for _ in range(NUM_RECEIVERS)]
-
- params = [list(sender.parameters()) for sender in senders]
- params.extend([list(receiver.parameters()) for receiver in receivers])
- # optimizer = torch.optim.Adam([param for sublist in params for param in sublist], lr=0.001)
- if OPTMIZER == "Adam":
- optimizer = torch.optim.Adam([param for sublist in params for param in sublist], lr=LEARNING_RATE)
- elif OPTMIZER == "AdamW":
- optimizer = torch.optim.AdamW([param for sublist in params for param in sublist], lr=LEARNING_RATE)
- elif OPTMIZER == "SGD":
- optimizer = torch.optim.SGD([param for sublist in params for param in sublist], lr=LEARNING_RATE)
-
- criterion = torch.nn.CrossEntropyLoss()
-
- game = MultiMultiSignalingGame(senders, receivers, optimizer, criterion)
-
- losses = []
- recon_losses = []
- kld_losses = []
- input_sentences = []
- output_sentences = []
-
- # Use Streamlit's progress bar
- loss_plot_placeholder = st.empty() # 创建一个空位占位符来显示损失图
- progress_bar = st.progress(0)
- interactions_placeholder = st.empty() # 创建一个空位占位符来显示交互
-
- for round in range(num_rounds):
- states = [torch.randint(VOCAB_SIZE, (BATCH_SIZE, 16)).to(device) for _ in range(NUM_SENDERS)]
- loss, recon_loss, kld_loss, interactions = game.play_round(states)
- losses.append(loss)
- recon_losses.append(recon_loss)
- kld_losses.append(kld_loss)
- # 刷新显示每轮的损失
- fig, ax = plt.subplots()
- ax.plot(losses, label='Total Losses', color='blue')
- ax.plot(recon_losses, label='Reconstruction Losses', color='green')
- ax.plot(kld_losses, label='KLD Losses', color='red')
- ax.set_xlabel('Round')
- ax.set_ylabel('Loss')
- ax.legend()
- loss_plot_placeholder.pyplot(fig)
- # Close the figure to free up memory
- plt.close(fig)
-
- progress_bar.progress(round / num_rounds)
- # 刷新显示每次交互的句子
- interaction_str = "\n\n".join([f"Sender {i} -> Receiver {j}\nSend(encode): {input_sentence}\nReceive(decode): {output_sentence}"
- for i, j, input_sentence, output_sentence in interactions])
- interactions_placeholder.text(interaction_str)
-
- # Dynamic plotting of the losses
- fig, ax = plt.subplots()
- ax.plot(losses, label='Total Losses', color='blue')
- ax.plot(recon_losses, label='Reconstruction Losses', color='green')
- ax.plot(kld_losses, label='KLD Losses', color='red')
- ax.set_xlabel('Round')
- ax.set_ylabel('Loss')
- ax.legend()
- st.pyplot(fig)
-
-# Streamlit UI
-st.title('Multi-Agents Signal Game')
-
-NUM_SENDERS = st.sidebar.slider("NUM_SENDERS", 1, 3, 2)
-NUM_RECEIVERS = st.sidebar.slider("NUM_RECEIVERS", 1, 3, 2)
-num_rounds = st.sidebar.slider("NUM_ROUNDS", 1000, 100000, 10000, 1000)
-
-advanced_settings = st.sidebar.expander("Advanced settings")
-with advanced_settings:
- use_cosine_annealing = st.checkbox("USE ANNEALING")
- if use_cosine_annealing:
- annealing_strategy = st.selectbox("ANNEALING STRATEGY", ["linear", "cosine"])
- TAU = st.slider("START TEMP.", 0.1, 10.0, 1.0)
- final_tau = st.slider("FINAL TEMP.", 0.1, 10.0, 1.0)
- else:
- annealing_strategy = None
- TAU = st.slider("TEMP.", 0.1, 10.0, 1.0)
-
- optimizer_options = ["Adam", "AdamW", "SGD"]
- OPTMIZER = st.selectbox("OPTIMIZER", optimizer_options)
- LEARNING_RATE = st.slider("LEARNING RATE", 1e-5, 1e-2, 1e-3, format="%.5f")
-
- EMBEDDING_DIM = st.slider("EMBEDDING_DIM", 1, 128, 16)
- HIDDEN_DIM = st.slider("HIDDEN_DIM", 1, 128, 16)
- LATENT_DIM = st.slider("LATENT_DIM", 1, 128, 16)
- SEQ_LEN = st.slider("SEQ_LEN", 1, 128, 16)
- NHEAD = st.slider("NHEAD", 1, 8, 4)
- NUM_LAYERS = st.slider("NUM_LAYERS", 1, 6, 2)
- BATCH_SIZE = st.slider("BATCH_SIZE", 1, 128, 32)
-
-if st.sidebar.button('Start'):
- run_signal_game(NUM_SENDERS, NUM_RECEIVERS, num_rounds)
diff --git a/spaces/Wanlau/sovits-4.0_datealive/vdecoder/hifigan/models.py b/spaces/Wanlau/sovits-4.0_datealive/vdecoder/hifigan/models.py
deleted file mode 100644
index 9747301f350bb269e62601017fe4633ce271b27e..0000000000000000000000000000000000000000
--- a/spaces/Wanlau/sovits-4.0_datealive/vdecoder/hifigan/models.py
+++ /dev/null
@@ -1,503 +0,0 @@
-import os
-import json
-from .env import AttrDict
-import numpy as np
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from .utils import init_weights, get_padding
-
-LRELU_SLOPE = 0.1
-
-
-def load_model(model_path, device='cuda'):
- config_file = os.path.join(os.path.split(model_path)[0], 'config.json')
- with open(config_file) as f:
- data = f.read()
-
- global h
- json_config = json.loads(data)
- h = AttrDict(json_config)
-
- generator = Generator(h).to(device)
-
- cp_dict = torch.load(model_path)
- generator.load_state_dict(cp_dict['generator'])
- generator.eval()
- generator.remove_weight_norm()
- del cp_dict
- return generator, h
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.h = h
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- xt = c2(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.h = h
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-def padDiff(x):
- return F.pad(F.pad(x, (0,0,-1,1), 'constant', 0) - x, (0,0,0,-1), 'constant', 0)
-
-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
- self.flag_for_pulse = flag_for_pulse
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = (f0 > self.voiced_threshold).type(torch.float32)
- return uv
-
- def _f02sine(self, f0_values):
- """ f0_values: (batchsize, length, dim)
- where dim indicates fundamental tone and overtones
- """
- # convert to F0 in rad. The interger part n can be ignored
- # because 2 * np.pi * n doesn't affect phase
- rad_values = (f0_values / self.sampling_rate) % 1
-
- # initial phase noise (no noise for fundamental component)
- rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], \
- device=f0_values.device)
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-
- # instantanouse phase sine[t] = sin(2*pi \sum_i=1 ^{t} rad)
- if not self.flag_for_pulse:
- # for normal case
-
- # To prevent torch.cumsum numerical overflow,
- # it is necessary to add -1 whenever \sum_k=1^n rad_value_k > 1.
- # Buffer tmp_over_one_idx indicates the time step to add -1.
- # This will not change F0 of sine because (x-1) * 2*pi = x * 2*pi
- tmp_over_one = torch.cumsum(rad_values, 1) % 1
- tmp_over_one_idx = (padDiff(tmp_over_one)) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-
- sines = torch.sin(torch.cumsum(rad_values + cumsum_shift, dim=1)
- * 2 * np.pi)
- else:
- # If necessary, make sure that the first time step of every
- # voiced segments is sin(pi) or cos(0)
- # This is used for pulse-train generation
-
- # identify the last time step in unvoiced segments
- uv = self._f02uv(f0_values)
- uv_1 = torch.roll(uv, shifts=-1, dims=1)
- uv_1[:, -1, :] = 1
- u_loc = (uv < 1) * (uv_1 > 0)
-
- # get the instantanouse phase
- tmp_cumsum = torch.cumsum(rad_values, dim=1)
- # different batch needs to be processed differently
- for idx in range(f0_values.shape[0]):
- temp_sum = tmp_cumsum[idx, u_loc[idx, :, 0], :]
- temp_sum[1:, :] = temp_sum[1:, :] - temp_sum[0:-1, :]
- # stores the accumulation of i.phase within
- # each voiced segments
- tmp_cumsum[idx, :, :] = 0
- tmp_cumsum[idx, u_loc[idx, :, 0], :] = temp_sum
-
- # rad_values - tmp_cumsum: remove the accumulation of i.phase
- # within the previous voiced segment.
- i_phase = torch.cumsum(rad_values - tmp_cumsum, dim=1)
-
- # get the sines
- sines = torch.cos(i_phase * 2 * np.pi)
- return sines
-
- def forward(self, f0):
- """ 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_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim,
- device=f0.device)
- # fundamental component
- fn = torch.multiply(f0, torch.FloatTensor([[range(1, self.harmonic_num + 2)]]).to(f0.device))
-
- # generate sine waveforms
- sine_waves = self._f02sine(fn) * self.sine_amp
-
- # generate uv signal
- # uv = torch.ones(f0.shape)
- # uv = uv * (f0 > self.voiced_threshold)
- uv = self._f02uv(f0)
-
- # noise: for unvoiced should be similar to sine_amp
- # std = self.sine_amp/3 -> max value ~ self.sine_amp
- # . for voiced regions is self.noise_std
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
-
- # first: set the unvoiced part to 0 by uv
- # then: additive noise
- 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):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
-
- # 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):
- """
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- """
- # source for harmonic branch
- sine_wavs, uv, _ = self.l_sin_gen(x)
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-
- # source for noise branch, in the same shape as uv
- noise = torch.randn_like(uv) * self.sine_amp / 3
- return sine_merge, noise, uv
-
-
-class Generator(torch.nn.Module):
- def __init__(self, h):
- super(Generator, self).__init__()
- self.h = h
-
- self.num_kernels = len(h["resblock_kernel_sizes"])
- self.num_upsamples = len(h["upsample_rates"])
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(h["upsample_rates"]))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=h["sampling_rate"],
- harmonic_num=8)
- self.noise_convs = nn.ModuleList()
- self.conv_pre = weight_norm(Conv1d(h["inter_channels"], h["upsample_initial_channel"], 7, 1, padding=3))
- resblock = ResBlock1 if h["resblock"] == '1' else ResBlock2
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(h["upsample_rates"], h["upsample_kernel_sizes"])):
- c_cur = h["upsample_initial_channel"] // (2 ** (i + 1))
- self.ups.append(weight_norm(
- ConvTranspose1d(h["upsample_initial_channel"] // (2 ** i), h["upsample_initial_channel"] // (2 ** (i + 1)),
- k, u, padding=(k - u) // 2)))
- if i + 1 < len(h["upsample_rates"]): #
- stride_f0 = np.prod(h["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 = h["upsample_initial_channel"] // (2 ** (i + 1))
- for j, (k, d) in enumerate(zip(h["resblock_kernel_sizes"], h["resblock_dilation_sizes"])):
- self.resblocks.append(resblock(h, ch, k, d))
-
- self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3))
- self.ups.apply(init_weights)
- self.conv_post.apply(init_weights)
- self.cond = nn.Conv1d(h['gin_channels'], h['upsample_initial_channel'], 1)
-
- def forward(self, x, f0, g=None):
- # print(1,x.shape,f0.shape,f0[:, None].shape)
- f0 = self.f0_upsamp(f0[:, None]).transpose(1, 2) # bs,n,t
- # print(2,f0.shape)
- har_source, noi_source, uv = self.m_source(f0)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- x = x + self.cond(g)
- # print(124,x.shape,har_source.shape)
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, LRELU_SLOPE)
- # print(3,x.shape)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- # print(4,x_source.shape,har_source.shape,x.shape)
- 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):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
- remove_weight_norm(self.conv_pre)
- remove_weight_norm(self.conv_post)
-
-
-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
- 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(5, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(2, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, periods=None):
- super(MultiPeriodDiscriminator, self).__init__()
- self.periods = periods if periods is not None else [2, 3, 5, 7, 11]
- self.discriminators = nn.ModuleList()
- for period in self.periods:
- self.discriminators.append(DiscriminatorP(period))
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- 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, 128, 15, 1, padding=7)),
- norm_f(Conv1d(128, 128, 41, 2, groups=4, padding=20)),
- norm_f(Conv1d(128, 256, 41, 2, groups=16, padding=20)),
- norm_f(Conv1d(256, 512, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(512, 1024, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 1, groups=16, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiScaleDiscriminator(torch.nn.Module):
- def __init__(self):
- super(MultiScaleDiscriminator, self).__init__()
- self.discriminators = nn.ModuleList([
- DiscriminatorS(use_spectral_norm=True),
- DiscriminatorS(),
- DiscriminatorS(),
- ])
- self.meanpools = nn.ModuleList([
- AvgPool1d(4, 2, padding=2),
- AvgPool1d(4, 2, padding=2)
- ])
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- if i != 0:
- y = self.meanpools[i - 1](y)
- y_hat = self.meanpools[i - 1](y_hat)
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- r_loss = torch.mean((1 - dr) ** 2)
- g_loss = torch.mean(dg ** 2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- l = torch.mean((1 - dg) ** 2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
diff --git a/spaces/WorldlineChanger/sayashi-vits-uma-genshin-honkai/models.py b/spaces/WorldlineChanger/sayashi-vits-uma-genshin-honkai/models.py
deleted file mode 100644
index 8353b867f441de7e4d05aef980e672899c3a8889..0000000000000000000000000000000000000000
--- a/spaces/WorldlineChanger/sayashi-vits-uma-genshin-honkai/models.py
+++ /dev/null
@@ -1,533 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from commons import init_weights, get_padding
-
-
-class StochasticDurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
- super().__init__()
- filter_channels = in_channels # it needs to be removed from future version.
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.log_flow = modules.Log()
- self.flows = nn.ModuleList()
- self.flows.append(modules.ElementwiseAffine(2))
- for i in range(n_flows):
- self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.flows.append(modules.Flip())
-
- self.post_pre = nn.Conv1d(1, filter_channels, 1)
- self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- self.post_flows = nn.ModuleList()
- self.post_flows.append(modules.ElementwiseAffine(2))
- for i in range(4):
- self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.post_flows.append(modules.Flip())
-
- self.pre = nn.Conv1d(in_channels, filter_channels, 1)
- self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
- def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
- x = torch.detach(x)
- x = self.pre(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.convs(x, x_mask)
- x = self.proj(x) * x_mask
-
- if not reverse:
- flows = self.flows
- assert w is not None
-
- logdet_tot_q = 0
- h_w = self.post_pre(w)
- h_w = self.post_convs(h_w, x_mask)
- h_w = self.post_proj(h_w) * x_mask
- e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
- z_q = e_q
- for flow in self.post_flows:
- z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
- logdet_tot_q += logdet_q
- z_u, z1 = torch.split(z_q, [1, 1], 1)
- u = torch.sigmoid(z_u) * x_mask
- z0 = (w - u) * x_mask
- logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1,2])
- logq = torch.sum(-0.5 * (math.log(2*math.pi) + (e_q**2)) * x_mask, [1,2]) - logdet_tot_q
-
- logdet_tot = 0
- z0, logdet = self.log_flow(z0, x_mask)
- logdet_tot += logdet
- z = torch.cat([z0, z1], 1)
- for flow in flows:
- z, logdet = flow(z, x_mask, g=x, reverse=reverse)
- logdet_tot = logdet_tot + logdet
- nll = torch.sum(0.5 * (math.log(2*math.pi) + (z**2)) * x_mask, [1,2]) - logdet_tot
- return nll + logq # [b]
- else:
- flows = list(reversed(self.flows))
- flows = flows[:-2] + [flows[-1]] # remove a useless vflow
- z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
- for flow in flows:
- z = flow(z, x_mask, g=x, reverse=reverse)
- z0, z1 = torch.split(z, [1, 1], 1)
- logw = z0
- return logw
-
-
-class DurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
- super().__init__()
-
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
-
- self.drop = nn.Dropout(p_dropout)
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_1 = modules.LayerNorm(filter_channels)
- self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_2 = modules.LayerNorm(filter_channels)
- self.proj = nn.Conv1d(filter_channels, 1, 1)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
- def forward(self, x, x_mask, g=None):
- x = torch.detach(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.norm_1(x)
- x = self.drop(x)
- x = self.conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.norm_2(x)
- x = self.drop(x)
- x = self.proj(x * x_mask)
- return x * x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- n_vocab,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout):
- super().__init__()
- self.n_vocab = n_vocab
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
-
- self.emb = nn.Embedding(n_vocab, hidden_channels)
- nn.init.normal_(self.emb.weight, 0.0, hidden_channels**-0.5)
-
- self.encoder = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.proj= nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths):
- x = self.emb(x) * math.sqrt(self.hidden_channels) # [b, t, h]
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
- def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
- resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(weight_norm(
- ConvTranspose1d(upsample_initial_channel//(2**i), upsample_initial_channel//(2**(i+1)),
- k, u, padding=(k-u)//2)))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel//(2**(i+1))
- for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i*self.num_kernels+j](x)
- else:
- xs += self.resblocks[i*self.num_kernels+j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2,3,5,7,11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- n_vocab,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- n_speakers=0,
- gin_channels=0,
- use_sdp=True,
- **kwargs):
-
- super().__init__()
- self.n_vocab = n_vocab
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.n_speakers = n_speakers
- self.gin_channels = gin_channels
-
- self.use_sdp = use_sdp
-
- self.enc_p = TextEncoder(n_vocab,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout)
- self.dec = Generator(inter_channels, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates, upsample_initial_channel, upsample_kernel_sizes, gin_channels=gin_channels)
- self.enc_q = PosteriorEncoder(spec_channels, inter_channels, hidden_channels, 5, 1, 16, gin_channels=gin_channels)
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, 4, gin_channels=gin_channels)
-
- if use_sdp:
- self.dp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
- else:
- self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
-
- if n_speakers > 1:
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
-
- def forward(self, x, x_lengths, y, y_lengths, sid=None):
-
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
-
- with torch.no_grad():
- # negative cross-entropy
- s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
- neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
- neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2), s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
- neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
-
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
-
- w = attn.sum(2)
- if self.use_sdp:
- l_length = self.dp(x, x_mask, w, g=g)
- l_length = l_length / torch.sum(x_mask)
- else:
- logw_ = torch.log(w + 1e-6) * x_mask
- logw = self.dp(x, x_mask, g=g)
- l_length = torch.sum((logw - logw_)**2, [1,2]) / torch.sum(x_mask) # for averaging
-
- # expand prior
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
- z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
- o = self.dec(z_slice, g=g)
- return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q)
-
- def infer(self, x, x_lengths, sid=None, noise_scale=1, length_scale=1, noise_scale_w=1., max_len=None):
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = None
-
- if self.use_sdp:
- logw = self.dp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w)
- else:
- logw = self.dp(x, x_mask, g=g)
- w = torch.exp(logw) * x_mask * length_scale
- w_ceil = torch.ceil(w)
- y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
- y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = commons.generate_path(w_ceil, attn_mask)
-
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
- z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
- z = self.flow(z_p, y_mask, g=g, reverse=True)
- o = self.dec((z * y_mask)[:,:,:max_len], g=g)
- return o, attn, y_mask, (z, z_p, m_p, logs_p)
-
- def voice_conversion(self, y, y_lengths, sid_src, sid_tgt):
- assert self.n_speakers > 0, "n_speakers have to be larger than 0."
- g_src = self.emb_g(sid_src).unsqueeze(-1)
- g_tgt = self.emb_g(sid_tgt).unsqueeze(-1)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g_src)
- z_p = self.flow(z, y_mask, g=g_src)
- z_hat = self.flow(z_p, y_mask, g=g_tgt, reverse=True)
- o_hat = self.dec(z_hat * y_mask, g=g_tgt)
- return o_hat, y_mask, (z, z_p, z_hat)
-
diff --git a/spaces/Xhaheen/regex_by_bloom/app.py b/spaces/Xhaheen/regex_by_bloom/app.py
deleted file mode 100644
index 957959e6409a6e73fa7f30e070713f9633f43e42..0000000000000000000000000000000000000000
--- a/spaces/Xhaheen/regex_by_bloom/app.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import gradio as gr
-import requests
-import os
-
-##Bloom
-API_URL = "https://api-inference.huggingface.co/models/bigscience/bloom"
-HF_TOKEN = os.environ["HF_TOKEN"]
-headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-
-
-def sql_generate(prompt, input_prompt_sql ):
-
- print(f"*****Inside SQL_generate - Prompt is :{prompt}")
- print(f"length of input_prompt_sql is {len(input_prompt_sql)}")
- print(f"length of prompt is {len(prompt)}")
- if len(prompt) == 0:
- prompt = input_prompt_sql
-
- json_ = {"inputs": prompt,
- "parameters":
- {
- "top_p": 0.9,
- "temperature": 1.1,
- "max_new_tokens": 250,
- "return_full_text": False,
- },
- "options":
- {"use_cache": True,
- "wait_for_model": True,
- },}
- response = requests.post(API_URL, headers=headers, json=json_)
- print(f"Response is : {response}")
- output = response.json()
- print(f"output is : {output}")
- output_tmp = output[0]['generated_text']
- print(f"output_tmp is: {output_tmp}")
- solution = output_tmp.split("\nQ:")[0]
- print(f"Final response after splits is: {solution}")
- if '\nOutput:' in solution:
- final_solution = solution.split("\nOutput:")[0]
- print(f"Response after removing output is: {final_solution}")
- elif '\n\n' in solution:
- final_solution = solution.split("\n\n")[0]
- print(f"Response after removing new line entries is: {final_solution}")
- else:
- final_solution = solution
- return final_solution
-
-
-demo = gr.Blocks()
-
-with demo:
- gr.Markdown("Zero Shot SQL by Bloom
")
- gr.Markdown(
- """[BigScienceW Bloom](https://twitter.com/BigscienceW) \n\n Large language models have demonstrated a capability of Zero-Shot SQL generation. Some might say — You can get good results out of LLMs if you know how to speak to them. This space is an attempt at inspecting this behavior/capability in the new HuggingFace BigScienceW [Bloom](https://huggingface.co/bigscience/bloom) model.\n\nThe Prompt length is limited at the API end right now, thus there is a certain limitation in testing Bloom's capability thoroughly.This Space might sometime fail due to inference queue being full and logs would end up showing error as *'queue full, try again later'*, in such cases please try again after few minutes. Please note that, longer prompts might not work as well and the Space could error out with Response code [500] or *'A very long prompt, temporarily not accepting these'* message in the logs. Still iterating over the app, might be able to improve it further soon.. \n\nThis Space is created by [Yuvraj Sharma](https://twitter.com/yvrjsharma) for Gradio EuroPython 2022 Demo."""
- )
- with gr.Row():
-
- example_prompt = gr.Radio( [
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL\nInput: How many users signed up in the past month?\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL\nInput: Create a query that displays empfname, emplname, deptid, deptname, location from employee table. Results should be in the ascending order based on the empfname and location.\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL. Only use table called 'employees'.\nInput: What is the total salary paid to all the employees?\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL. Only use table called 'employees'.\nInput: List names of all the employees whose name end with 'r'.\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL. Only use table called 'employees'.\nInput: What are the number of employees in each department?\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL. Only use table called 'employees'.\nInput: Select names of all theemployees who have third character in their name as 't'.\nPostgreSQL query: ",
- "Instruction: Given an input question, respond with syntactically correct PostgreSQL. Only use table called 'employees'.\nInput: Select names of all the employees who are working under 'Peter'.\nPostgreSQL query: ", ], label= "Choose a sample Prompt")
-
- #with gr.Column:
- input_prompt_sql = gr.Textbox(label="Or Write text following the example pattern given below, to get SQL commands...", value="Instruction: Given an input question, respond with syntactically correct PostgreSQL. Use table called 'department'.\nInput: Select names of all the departments in their descending alphabetical order.\nPostgreSQL query: ", lines=6)
-
- with gr.Row():
- generated_txt = gr.Textbox(lines=3)
-
- b1 = gr.Button("Generate SQL")
- b1.click(sql_generate,inputs=[example_prompt, input_prompt_sql], outputs=generated_txt)
-
- with gr.Row():
- gr.Markdown("")
-
-demo.launch(enable_queue=True, debug=True)
\ No newline at end of file
diff --git a/spaces/XzJosh/maimai-Bert-VITS2/attentions.py b/spaces/XzJosh/maimai-Bert-VITS2/attentions.py
deleted file mode 100644
index 1192dd7268c20c11010e73a6017ed09549695afe..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/maimai-Bert-VITS2/attentions.py
+++ /dev/null
@@ -1,344 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import logging
-
-logger = logging.getLogger(__name__)
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
- n_channels_int = n_channels[0]
- in_act = input_a + input_b
- t_act = torch.tanh(in_act[:, :n_channels_int, :])
- s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
- acts = t_act * s_act
- return acts
-
-class Encoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., window_size=4, isflow = True, **kwargs):
- super().__init__()
- 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.window_size = window_size
- #if isflow:
- # cond_layer = torch.nn.Conv1d(256, 2*hidden_channels*n_layers, 1)
- # self.cond_pre = torch.nn.Conv1d(hidden_channels, 2*hidden_channels, 1)
- # self.cond_layer = weight_norm(cond_layer, name='weight')
- # self.gin_channels = 256
- self.cond_layer_idx = self.n_layers
- if 'gin_channels' in kwargs:
- self.gin_channels = kwargs['gin_channels']
- if self.gin_channels != 0:
- self.spk_emb_linear = nn.Linear(self.gin_channels, self.hidden_channels)
- # vits2 says 3rd block, so idx is 2 by default
- self.cond_layer_idx = kwargs['cond_layer_idx'] if 'cond_layer_idx' in kwargs else 2
- logging.debug(self.gin_channels, self.cond_layer_idx)
- assert self.cond_layer_idx < self.n_layers, 'cond_layer_idx should be less than n_layers'
- self.drop = nn.Dropout(p_dropout)
- self.attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, window_size=window_size))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
- def forward(self, x, x_mask, g=None):
- attn_mask = x_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- if i == self.cond_layer_idx and g is not None:
- g = self.spk_emb_linear(g.transpose(1, 2))
- g = g.transpose(1, 2)
- x = x + g
- x = x * x_mask
- y = self.attn_layers[i](x, x, attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class Decoder(nn.Module):
- def __init__(self, hidden_channels, filter_channels, n_heads, n_layers, kernel_size=1, p_dropout=0., proximal_bias=False, proximal_init=True, **kwargs):
- super().__init__()
- 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.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
-
- self.drop = nn.Dropout(p_dropout)
- self.self_attn_layers = nn.ModuleList()
- self.norm_layers_0 = nn.ModuleList()
- self.encdec_attn_layers = nn.ModuleList()
- self.norm_layers_1 = nn.ModuleList()
- self.ffn_layers = nn.ModuleList()
- self.norm_layers_2 = nn.ModuleList()
- for i in range(self.n_layers):
- self.self_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout, proximal_bias=proximal_bias, proximal_init=proximal_init))
- self.norm_layers_0.append(LayerNorm(hidden_channels))
- self.encdec_attn_layers.append(MultiHeadAttention(hidden_channels, hidden_channels, n_heads, p_dropout=p_dropout))
- self.norm_layers_1.append(LayerNorm(hidden_channels))
- self.ffn_layers.append(FFN(hidden_channels, hidden_channels, filter_channels, kernel_size, p_dropout=p_dropout, causal=True))
- self.norm_layers_2.append(LayerNorm(hidden_channels))
-
- def forward(self, x, x_mask, h, h_mask):
- """
- x: decoder input
- h: encoder output
- """
- self_attn_mask = commons.subsequent_mask(x_mask.size(2)).to(device=x.device, dtype=x.dtype)
- encdec_attn_mask = h_mask.unsqueeze(2) * x_mask.unsqueeze(-1)
- x = x * x_mask
- for i in range(self.n_layers):
- y = self.self_attn_layers[i](x, x, self_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_0[i](x + y)
-
- y = self.encdec_attn_layers[i](x, h, encdec_attn_mask)
- y = self.drop(y)
- x = self.norm_layers_1[i](x + y)
-
- y = self.ffn_layers[i](x, x_mask)
- y = self.drop(y)
- x = self.norm_layers_2[i](x + y)
- x = x * x_mask
- return x
-
-
-class MultiHeadAttention(nn.Module):
- def __init__(self, channels, out_channels, n_heads, p_dropout=0., window_size=None, heads_share=True, block_length=None, proximal_bias=False, proximal_init=False):
- super().__init__()
- assert channels % n_heads == 0
-
- self.channels = channels
- self.out_channels = out_channels
- self.n_heads = n_heads
- self.p_dropout = p_dropout
- self.window_size = window_size
- self.heads_share = heads_share
- self.block_length = block_length
- self.proximal_bias = proximal_bias
- self.proximal_init = proximal_init
- self.attn = None
-
- self.k_channels = channels // n_heads
- self.conv_q = nn.Conv1d(channels, channels, 1)
- self.conv_k = nn.Conv1d(channels, channels, 1)
- self.conv_v = nn.Conv1d(channels, channels, 1)
- self.conv_o = nn.Conv1d(channels, out_channels, 1)
- self.drop = nn.Dropout(p_dropout)
-
- if window_size is not None:
- n_heads_rel = 1 if heads_share else n_heads
- rel_stddev = self.k_channels**-0.5
- self.emb_rel_k = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
- self.emb_rel_v = nn.Parameter(torch.randn(n_heads_rel, window_size * 2 + 1, self.k_channels) * rel_stddev)
-
- nn.init.xavier_uniform_(self.conv_q.weight)
- nn.init.xavier_uniform_(self.conv_k.weight)
- nn.init.xavier_uniform_(self.conv_v.weight)
- if proximal_init:
- with torch.no_grad():
- self.conv_k.weight.copy_(self.conv_q.weight)
- self.conv_k.bias.copy_(self.conv_q.bias)
-
- def forward(self, x, c, attn_mask=None):
- q = self.conv_q(x)
- k = self.conv_k(c)
- v = self.conv_v(c)
-
- x, self.attn = self.attention(q, k, v, mask=attn_mask)
-
- x = self.conv_o(x)
- return x
-
- def attention(self, query, key, value, mask=None):
- # reshape [b, d, t] -> [b, n_h, t, d_k]
- b, d, t_s, t_t = (*key.size(), query.size(2))
- query = query.view(b, self.n_heads, self.k_channels, t_t).transpose(2, 3)
- key = key.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
- value = value.view(b, self.n_heads, self.k_channels, t_s).transpose(2, 3)
-
- scores = torch.matmul(query / math.sqrt(self.k_channels), key.transpose(-2, -1))
- if self.window_size is not None:
- assert t_s == t_t, "Relative attention is only available for self-attention."
- key_relative_embeddings = self._get_relative_embeddings(self.emb_rel_k, t_s)
- rel_logits = self._matmul_with_relative_keys(query /math.sqrt(self.k_channels), key_relative_embeddings)
- scores_local = self._relative_position_to_absolute_position(rel_logits)
- scores = scores + scores_local
- if self.proximal_bias:
- assert t_s == t_t, "Proximal bias is only available for self-attention."
- scores = scores + self._attention_bias_proximal(t_s).to(device=scores.device, dtype=scores.dtype)
- if mask is not None:
- scores = scores.masked_fill(mask == 0, -1e4)
- if self.block_length is not None:
- assert t_s == t_t, "Local attention is only available for self-attention."
- block_mask = torch.ones_like(scores).triu(-self.block_length).tril(self.block_length)
- scores = scores.masked_fill(block_mask == 0, -1e4)
- p_attn = F.softmax(scores, dim=-1) # [b, n_h, t_t, t_s]
- p_attn = self.drop(p_attn)
- output = torch.matmul(p_attn, value)
- if self.window_size is not None:
- relative_weights = self._absolute_position_to_relative_position(p_attn)
- value_relative_embeddings = self._get_relative_embeddings(self.emb_rel_v, t_s)
- output = output + self._matmul_with_relative_values(relative_weights, value_relative_embeddings)
- output = output.transpose(2, 3).contiguous().view(b, d, t_t) # [b, n_h, t_t, d_k] -> [b, d, t_t]
- return output, p_attn
-
- def _matmul_with_relative_values(self, x, y):
- """
- x: [b, h, l, m]
- y: [h or 1, m, d]
- ret: [b, h, l, d]
- """
- ret = torch.matmul(x, y.unsqueeze(0))
- return ret
-
- def _matmul_with_relative_keys(self, x, y):
- """
- x: [b, h, l, d]
- y: [h or 1, m, d]
- ret: [b, h, l, m]
- """
- ret = torch.matmul(x, y.unsqueeze(0).transpose(-2, -1))
- return ret
-
- def _get_relative_embeddings(self, relative_embeddings, length):
- max_relative_position = 2 * self.window_size + 1
- # Pad first before slice to avoid using cond ops.
- pad_length = max(length - (self.window_size + 1), 0)
- slice_start_position = max((self.window_size + 1) - length, 0)
- slice_end_position = slice_start_position + 2 * length - 1
- if pad_length > 0:
- padded_relative_embeddings = F.pad(
- relative_embeddings,
- commons.convert_pad_shape([[0, 0], [pad_length, pad_length], [0, 0]]))
- else:
- padded_relative_embeddings = relative_embeddings
- used_relative_embeddings = padded_relative_embeddings[:,slice_start_position:slice_end_position]
- return used_relative_embeddings
-
- def _relative_position_to_absolute_position(self, x):
- """
- x: [b, h, l, 2*l-1]
- ret: [b, h, l, l]
- """
- batch, heads, length, _ = x.size()
- # Concat columns of pad to shift from relative to absolute indexing.
- x = F.pad(x, commons.convert_pad_shape([[0,0],[0,0],[0,0],[0,1]]))
-
- # Concat extra elements so to add up to shape (len+1, 2*len-1).
- x_flat = x.view([batch, heads, length * 2 * length])
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0,0],[0,0],[0,length-1]]))
-
- # Reshape and slice out the padded elements.
- x_final = x_flat.view([batch, heads, length+1, 2*length-1])[:, :, :length, length-1:]
- return x_final
-
- def _absolute_position_to_relative_position(self, x):
- """
- x: [b, h, l, l]
- ret: [b, h, l, 2*l-1]
- """
- batch, heads, length, _ = x.size()
- # padd along column
- x = F.pad(x, commons.convert_pad_shape([[0, 0], [0, 0], [0, 0], [0, length-1]]))
- x_flat = x.view([batch, heads, length**2 + length*(length -1)])
- # add 0's in the beginning that will skew the elements after reshape
- x_flat = F.pad(x_flat, commons.convert_pad_shape([[0, 0], [0, 0], [length, 0]]))
- x_final = x_flat.view([batch, heads, length, 2*length])[:,:,:,1:]
- return x_final
-
- def _attention_bias_proximal(self, length):
- """Bias for self-attention to encourage attention to close positions.
- Args:
- length: an integer scalar.
- Returns:
- a Tensor with shape [1, 1, length, length]
- """
- r = torch.arange(length, dtype=torch.float32)
- diff = torch.unsqueeze(r, 0) - torch.unsqueeze(r, 1)
- return torch.unsqueeze(torch.unsqueeze(-torch.log1p(torch.abs(diff)), 0), 0)
-
-
-class FFN(nn.Module):
- def __init__(self, in_channels, out_channels, filter_channels, kernel_size, p_dropout=0., activation=None, causal=False):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.activation = activation
- self.causal = causal
-
- if causal:
- self.padding = self._causal_padding
- else:
- self.padding = self._same_padding
-
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size)
- self.conv_2 = nn.Conv1d(filter_channels, out_channels, kernel_size)
- self.drop = nn.Dropout(p_dropout)
-
- def forward(self, x, x_mask):
- x = self.conv_1(self.padding(x * x_mask))
- if self.activation == "gelu":
- x = x * torch.sigmoid(1.702 * x)
- else:
- x = torch.relu(x)
- x = self.drop(x)
- x = self.conv_2(self.padding(x * x_mask))
- return x * x_mask
-
- def _causal_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = self.kernel_size - 1
- pad_r = 0
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
-
- def _same_padding(self, x):
- if self.kernel_size == 1:
- return x
- pad_l = (self.kernel_size - 1) // 2
- pad_r = self.kernel_size // 2
- padding = [[0, 0], [0, 0], [pad_l, pad_r]]
- x = F.pad(x, commons.convert_pad_shape(padding))
- return x
diff --git a/spaces/XzJosh/nine2-Bert-VITS2/models.py b/spaces/XzJosh/nine2-Bert-VITS2/models.py
deleted file mode 100644
index d4afe44d883691610c5903e602a3ca245fcb3a5c..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/nine2-Bert-VITS2/models.py
+++ /dev/null
@@ -1,707 +0,0 @@
-import copy
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-import commons
-import modules
-import attentions
-import monotonic_align
-
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-
-from commons import init_weights, get_padding
-from text import symbols, num_tones, num_languages
-class DurationDiscriminator(nn.Module): #vits2
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
- super().__init__()
-
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
-
- self.drop = nn.Dropout(p_dropout)
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_1 = modules.LayerNorm(filter_channels)
- self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.norm_2 = modules.LayerNorm(filter_channels)
- self.dur_proj = nn.Conv1d(1, filter_channels, 1)
-
- self.pre_out_conv_1 = nn.Conv1d(2*filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.pre_out_norm_1 = modules.LayerNorm(filter_channels)
- self.pre_out_conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size//2)
- self.pre_out_norm_2 = modules.LayerNorm(filter_channels)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
- self.output_layer = nn.Sequential(
- nn.Linear(filter_channels, 1),
- nn.Sigmoid()
- )
-
- def forward_probability(self, x, x_mask, dur, g=None):
- dur = self.dur_proj(dur)
- x = torch.cat([x, dur], dim=1)
- x = self.pre_out_conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.pre_out_norm_1(x)
- x = self.drop(x)
- x = self.pre_out_conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.pre_out_norm_2(x)
- x = self.drop(x)
- x = x * x_mask
- x = x.transpose(1, 2)
- output_prob = self.output_layer(x)
- return output_prob
-
- def forward(self, x, x_mask, dur_r, dur_hat, g=None):
- x = torch.detach(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.norm_1(x)
- x = self.drop(x)
- x = self.conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.norm_2(x)
- x = self.drop(x)
-
- output_probs = []
- for dur in [dur_r, dur_hat]:
- output_prob = self.forward_probability(x, x_mask, dur, g)
- output_probs.append(output_prob)
-
- return output_probs
-
-class TransformerCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- n_flows=4,
- gin_channels=0,
- share_parameter=False
- ):
-
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
-
- self.wn = attentions.FFT(hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout, isflow = True, gin_channels = self.gin_channels) if share_parameter else None
-
- for i in range(n_flows):
- self.flows.append(
- modules.TransformerCouplingLayer(channels, hidden_channels, kernel_size, n_layers, n_heads, p_dropout, filter_channels, mean_only=True, wn_sharing_parameter=self.wn, gin_channels = self.gin_channels))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-class StochasticDurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, n_flows=4, gin_channels=0):
- super().__init__()
- filter_channels = in_channels # it needs to be removed from future version.
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.log_flow = modules.Log()
- self.flows = nn.ModuleList()
- self.flows.append(modules.ElementwiseAffine(2))
- for i in range(n_flows):
- self.flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.flows.append(modules.Flip())
-
- self.post_pre = nn.Conv1d(1, filter_channels, 1)
- self.post_proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.post_convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- self.post_flows = nn.ModuleList()
- self.post_flows.append(modules.ElementwiseAffine(2))
- for i in range(4):
- self.post_flows.append(modules.ConvFlow(2, filter_channels, kernel_size, n_layers=3))
- self.post_flows.append(modules.Flip())
-
- self.pre = nn.Conv1d(in_channels, filter_channels, 1)
- self.proj = nn.Conv1d(filter_channels, filter_channels, 1)
- self.convs = modules.DDSConv(filter_channels, kernel_size, n_layers=3, p_dropout=p_dropout)
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, filter_channels, 1)
-
- def forward(self, x, x_mask, w=None, g=None, reverse=False, noise_scale=1.0):
- x = torch.detach(x)
- x = self.pre(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.convs(x, x_mask)
- x = self.proj(x) * x_mask
-
- if not reverse:
- flows = self.flows
- assert w is not None
-
- logdet_tot_q = 0
- h_w = self.post_pre(w)
- h_w = self.post_convs(h_w, x_mask)
- h_w = self.post_proj(h_w) * x_mask
- e_q = torch.randn(w.size(0), 2, w.size(2)).to(device=x.device, dtype=x.dtype) * x_mask
- z_q = e_q
- for flow in self.post_flows:
- z_q, logdet_q = flow(z_q, x_mask, g=(x + h_w))
- logdet_tot_q += logdet_q
- z_u, z1 = torch.split(z_q, [1, 1], 1)
- u = torch.sigmoid(z_u) * x_mask
- z0 = (w - u) * x_mask
- logdet_tot_q += torch.sum((F.logsigmoid(z_u) + F.logsigmoid(-z_u)) * x_mask, [1, 2])
- logq = torch.sum(-0.5 * (math.log(2 * math.pi) + (e_q ** 2)) * x_mask, [1, 2]) - logdet_tot_q
-
- logdet_tot = 0
- z0, logdet = self.log_flow(z0, x_mask)
- logdet_tot += logdet
- z = torch.cat([z0, z1], 1)
- for flow in flows:
- z, logdet = flow(z, x_mask, g=x, reverse=reverse)
- logdet_tot = logdet_tot + logdet
- nll = torch.sum(0.5 * (math.log(2 * math.pi) + (z ** 2)) * x_mask, [1, 2]) - logdet_tot
- return nll + logq # [b]
- else:
- flows = list(reversed(self.flows))
- flows = flows[:-2] + [flows[-1]] # remove a useless vflow
- z = torch.randn(x.size(0), 2, x.size(2)).to(device=x.device, dtype=x.dtype) * noise_scale
- for flow in flows:
- z = flow(z, x_mask, g=x, reverse=reverse)
- z0, z1 = torch.split(z, [1, 1], 1)
- logw = z0
- return logw
-
-
-class DurationPredictor(nn.Module):
- def __init__(self, in_channels, filter_channels, kernel_size, p_dropout, gin_channels=0):
- super().__init__()
-
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
-
- self.drop = nn.Dropout(p_dropout)
- self.conv_1 = nn.Conv1d(in_channels, filter_channels, kernel_size, padding=kernel_size // 2)
- self.norm_1 = modules.LayerNorm(filter_channels)
- self.conv_2 = nn.Conv1d(filter_channels, filter_channels, kernel_size, padding=kernel_size // 2)
- self.norm_2 = modules.LayerNorm(filter_channels)
- self.proj = nn.Conv1d(filter_channels, 1, 1)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, in_channels, 1)
-
- def forward(self, x, x_mask, g=None):
- x = torch.detach(x)
- if g is not None:
- g = torch.detach(g)
- x = x + self.cond(g)
- x = self.conv_1(x * x_mask)
- x = torch.relu(x)
- x = self.norm_1(x)
- x = self.drop(x)
- x = self.conv_2(x * x_mask)
- x = torch.relu(x)
- x = self.norm_2(x)
- x = self.drop(x)
- x = self.proj(x * x_mask)
- return x * x_mask
-
-
-class TextEncoder(nn.Module):
- def __init__(self,
- n_vocab,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- gin_channels=0):
- super().__init__()
- self.n_vocab = n_vocab
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.gin_channels = gin_channels
- self.emb = nn.Embedding(len(symbols), hidden_channels)
- nn.init.normal_(self.emb.weight, 0.0, hidden_channels ** -0.5)
- self.tone_emb = nn.Embedding(num_tones, hidden_channels)
- nn.init.normal_(self.tone_emb.weight, 0.0, hidden_channels ** -0.5)
- self.language_emb = nn.Embedding(num_languages, hidden_channels)
- nn.init.normal_(self.language_emb.weight, 0.0, hidden_channels ** -0.5)
- self.bert_proj = nn.Conv1d(1024, hidden_channels, 1)
-
- self.encoder = attentions.Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- gin_channels=self.gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, tone, language, bert, g=None):
- x = (self.emb(x)+ self.tone_emb(tone)+ self.language_emb(language)+self.bert_proj(bert).transpose(1,2)) * math.sqrt(self.hidden_channels) # [b, t, h]
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
-
- x = self.encoder(x * x_mask, x_mask, g=g)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return x, m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(
- modules.ResidualCouplingLayer(channels, hidden_channels, kernel_size, dilation_rate, n_layers,
- gin_channels=gin_channels, mean_only=True))
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(hidden_channels, kernel_size, dilation_rate, n_layers, gin_channels=gin_channels)
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(x.dtype)
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
-
-class Generator(torch.nn.Module):
- def __init__(self, initial_channel, resblock, resblock_kernel_sizes, resblock_dilation_sizes, upsample_rates,
- upsample_initial_channel, upsample_kernel_sizes, gin_channels=0):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(initial_channel, upsample_initial_channel, 7, 1, padding=3)
- resblock = modules.ResBlock1 if resblock == '1' else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(weight_norm(
- ConvTranspose1d(upsample_initial_channel // (2 ** i), upsample_initial_channel // (2 ** (i + 1)),
- k, u, padding=(k - u) // 2)))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(zip(resblock_kernel_sizes, resblock_dilation_sizes)):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv2d(1, 32, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(kernel_size, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(get_padding(kernel_size, 1), 0))),
- ])
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList([
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ])
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2, 3, 5, 7, 11]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-class ReferenceEncoder(nn.Module):
- '''
- inputs --- [N, Ty/r, n_mels*r] mels
- outputs --- [N, ref_enc_gru_size]
- '''
-
- def __init__(self, spec_channels, gin_channels=0):
-
- super().__init__()
- self.spec_channels = spec_channels
- ref_enc_filters = [32, 32, 64, 64, 128, 128]
- K = len(ref_enc_filters)
- filters = [1] + ref_enc_filters
- convs = [weight_norm(nn.Conv2d(in_channels=filters[i],
- out_channels=filters[i + 1],
- kernel_size=(3, 3),
- stride=(2, 2),
- padding=(1, 1))) for i in range(K)]
- self.convs = nn.ModuleList(convs)
- # self.wns = nn.ModuleList([weight_norm(num_features=ref_enc_filters[i]) for i in range(K)])
-
- out_channels = self.calculate_channels(spec_channels, 3, 2, 1, K)
- self.gru = nn.GRU(input_size=ref_enc_filters[-1] * out_channels,
- hidden_size=256 // 2,
- batch_first=True)
- self.proj = nn.Linear(128, gin_channels)
-
- def forward(self, inputs, mask=None):
- N = inputs.size(0)
- out = inputs.view(N, 1, -1, self.spec_channels) # [N, 1, Ty, n_freqs]
- for conv in self.convs:
- out = conv(out)
- # out = wn(out)
- out = F.relu(out) # [N, 128, Ty//2^K, n_mels//2^K]
-
- out = out.transpose(1, 2) # [N, Ty//2^K, 128, n_mels//2^K]
- T = out.size(1)
- N = out.size(0)
- out = out.contiguous().view(N, T, -1) # [N, Ty//2^K, 128*n_mels//2^K]
-
- self.gru.flatten_parameters()
- memory, out = self.gru(out) # out --- [1, N, 128]
-
- return self.proj(out.squeeze(0))
-
- def calculate_channels(self, L, kernel_size, stride, pad, n_convs):
- for i in range(n_convs):
- L = (L - kernel_size + 2 * pad) // stride + 1
- return L
-
-
-class SynthesizerTrn(nn.Module):
- """
- Synthesizer for Training
- """
-
- def __init__(self,
- n_vocab,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- n_speakers=256,
- gin_channels=256,
- use_sdp=True,
- n_flow_layer = 4,
- n_layers_trans_flow = 3,
- flow_share_parameter = False,
- use_transformer_flow = True,
- **kwargs):
-
- super().__init__()
- self.n_vocab = n_vocab
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.n_speakers = n_speakers
- self.gin_channels = gin_channels
- self.n_layers_trans_flow = n_layers_trans_flow
- self.use_spk_conditioned_encoder = kwargs.get("use_spk_conditioned_encoder", True)
- self.use_sdp = use_sdp
- self.use_noise_scaled_mas = kwargs.get("use_noise_scaled_mas", False)
- self.mas_noise_scale_initial = kwargs.get("mas_noise_scale_initial", 0.01)
- self.noise_scale_delta = kwargs.get("noise_scale_delta", 2e-6)
- self.current_mas_noise_scale = self.mas_noise_scale_initial
- if self.use_spk_conditioned_encoder and gin_channels > 0:
- self.enc_gin_channels = gin_channels
- self.enc_p = TextEncoder(n_vocab,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- gin_channels=self.enc_gin_channels)
- 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)
- if use_transformer_flow:
- self.flow = TransformerCouplingBlock(inter_channels, hidden_channels, filter_channels, n_heads, n_layers_trans_flow, 5, p_dropout, n_flow_layer, gin_channels=gin_channels,share_parameter= flow_share_parameter)
- else:
- self.flow = ResidualCouplingBlock(inter_channels, hidden_channels, 5, 1, n_flow_layer, gin_channels=gin_channels)
- self.sdp = StochasticDurationPredictor(hidden_channels, 192, 3, 0.5, 4, gin_channels=gin_channels)
- self.dp = DurationPredictor(hidden_channels, 256, 3, 0.5, gin_channels=gin_channels)
-
- if n_speakers >= 1:
- self.emb_g = nn.Embedding(n_speakers, gin_channels)
- else:
- self.ref_enc = ReferenceEncoder(spec_channels, gin_channels)
-
- def forward(self, x, x_lengths, y, y_lengths, sid, tone, language, bert):
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = self.ref_enc(y.transpose(1,2)).unsqueeze(-1)
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert,g=g)
- z, m_q, logs_q, y_mask = self.enc_q(y, y_lengths, g=g)
- z_p = self.flow(z, y_mask, g=g)
-
- with torch.no_grad():
- # negative cross-entropy
- s_p_sq_r = torch.exp(-2 * logs_p) # [b, d, t]
- neg_cent1 = torch.sum(-0.5 * math.log(2 * math.pi) - logs_p, [1], keepdim=True) # [b, 1, t_s]
- neg_cent2 = torch.matmul(-0.5 * (z_p ** 2).transpose(1, 2),
- s_p_sq_r) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent3 = torch.matmul(z_p.transpose(1, 2), (m_p * s_p_sq_r)) # [b, t_t, d] x [b, d, t_s] = [b, t_t, t_s]
- neg_cent4 = torch.sum(-0.5 * (m_p ** 2) * s_p_sq_r, [1], keepdim=True) # [b, 1, t_s]
- neg_cent = neg_cent1 + neg_cent2 + neg_cent3 + neg_cent4
- if self.use_noise_scaled_mas:
- epsilon = torch.std(neg_cent) * torch.randn_like(neg_cent) * self.current_mas_noise_scale
- neg_cent = neg_cent + epsilon
-
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = monotonic_align.maximum_path(neg_cent, attn_mask.squeeze(1)).unsqueeze(1).detach()
-
- w = attn.sum(2)
-
- l_length_sdp = self.sdp(x, x_mask, w, g=g)
- l_length_sdp = l_length_sdp / torch.sum(x_mask)
-
- logw_ = torch.log(w + 1e-6) * x_mask
- logw = self.dp(x, x_mask, g=g)
- l_length_dp = torch.sum((logw - logw_) ** 2, [1, 2]) / torch.sum(x_mask) # for averaging
-
- l_length = l_length_dp + l_length_sdp
-
- # expand prior
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2)
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1, 2)
-
- z_slice, ids_slice = commons.rand_slice_segments(z, y_lengths, self.segment_size)
- o = self.dec(z_slice, g=g)
- return o, l_length, attn, ids_slice, x_mask, y_mask, (z, z_p, m_p, logs_p, m_q, logs_q), (x, logw, logw_)
-
- def infer(self, x, x_lengths, sid, tone, language, bert, noise_scale=.667, length_scale=1, noise_scale_w=0.8, max_len=None, sdp_ratio=0,y=None):
- #x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert)
- # g = self.gst(y)
- if self.n_speakers > 0:
- g = self.emb_g(sid).unsqueeze(-1) # [b, h, 1]
- else:
- g = self.ref_enc(y.transpose(1,2)).unsqueeze(-1)
- x, m_p, logs_p, x_mask = self.enc_p(x, x_lengths, tone, language, bert,g=g)
- logw = self.sdp(x, x_mask, g=g, reverse=True, noise_scale=noise_scale_w) * (sdp_ratio) + self.dp(x, x_mask, g=g) * (1 - sdp_ratio)
- w = torch.exp(logw) * x_mask * length_scale
- w_ceil = torch.ceil(w)
- y_lengths = torch.clamp_min(torch.sum(w_ceil, [1, 2]), 1).long()
- y_mask = torch.unsqueeze(commons.sequence_mask(y_lengths, None), 1).to(x_mask.dtype)
- attn_mask = torch.unsqueeze(x_mask, 2) * torch.unsqueeze(y_mask, -1)
- attn = commons.generate_path(w_ceil, attn_mask)
-
- m_p = torch.matmul(attn.squeeze(1), m_p.transpose(1, 2)).transpose(1, 2) # [b, t', t], [b, t, d] -> [b, d, t']
- logs_p = torch.matmul(attn.squeeze(1), logs_p.transpose(1, 2)).transpose(1,
- 2) # [b, t', t], [b, t, d] -> [b, d, t']
-
- z_p = m_p + torch.randn_like(m_p) * torch.exp(logs_p) * noise_scale
- z = self.flow(z_p, y_mask, g=g, reverse=True)
- o = self.dec((z * y_mask)[:, :, :max_len], g=g)
- return o, attn, y_mask, (z, z_p, m_p, logs_p)
diff --git a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/cocoeval/cocoeval.cpp b/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/cocoeval/cocoeval.cpp
deleted file mode 100644
index 0a5b7b907c06720fefc77b0dfd921b8ec3ecf2be..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/layers/csrc/cocoeval/cocoeval.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#include "cocoeval.h"
-#include
-#include
-#include
-#include
-
-using namespace pybind11::literals;
-
-namespace detectron2 {
-
-namespace COCOeval {
-
-// Sort detections from highest score to lowest, such that
-// detection_instances[detection_sorted_indices[t]] >=
-// detection_instances[detection_sorted_indices[t+1]]. Use stable_sort to match
-// original COCO API
-void SortInstancesByDetectionScore(
- const std::vector& detection_instances,
- std::vector* detection_sorted_indices) {
- detection_sorted_indices->resize(detection_instances.size());
- std::iota(
- detection_sorted_indices->begin(), detection_sorted_indices->end(), 0);
- std::stable_sort(
- detection_sorted_indices->begin(),
- detection_sorted_indices->end(),
- [&detection_instances](size_t j1, size_t j2) {
- return detection_instances[j1].score > detection_instances[j2].score;
- });
-}
-
-// Partition the ground truth objects based on whether or not to ignore them
-// based on area
-void SortInstancesByIgnore(
- const std::array& area_range,
- const std::vector& ground_truth_instances,
- std::vector* ground_truth_sorted_indices,
- std::vector* ignores) {
- ignores->clear();
- ignores->reserve(ground_truth_instances.size());
- for (auto o : ground_truth_instances) {
- ignores->push_back(
- o.ignore || o.area < area_range[0] || o.area > area_range[1]);
- }
-
- ground_truth_sorted_indices->resize(ground_truth_instances.size());
- std::iota(
- ground_truth_sorted_indices->begin(),
- ground_truth_sorted_indices->end(),
- 0);
- std::stable_sort(
- ground_truth_sorted_indices->begin(),
- ground_truth_sorted_indices->end(),
- [&ignores](size_t j1, size_t j2) {
- return (int)(*ignores)[j1] < (int)(*ignores)[j2];
- });
-}
-
-// For each IOU threshold, greedily match each detected instance to a ground
-// truth instance (if possible) and store the results
-void MatchDetectionsToGroundTruth(
- const std::vector& detection_instances,
- const std::vector& detection_sorted_indices,
- const std::vector& ground_truth_instances,
- const std::vector& ground_truth_sorted_indices,
- const std::vector& ignores,
- const std::vector>& ious,
- const std::vector& iou_thresholds,
- const std::array& area_range,
- ImageEvaluation* results) {
- // Initialize memory to store return data matches and ignore
- const int num_iou_thresholds = iou_thresholds.size();
- const int num_ground_truth = ground_truth_sorted_indices.size();
- const int num_detections = detection_sorted_indices.size();
- std::vector ground_truth_matches(
- num_iou_thresholds * num_ground_truth, 0);
- std::vector& detection_matches = results->detection_matches;
- std::vector& detection_ignores = results->detection_ignores;
- std::vector& ground_truth_ignores = results->ground_truth_ignores;
- detection_matches.resize(num_iou_thresholds * num_detections, 0);
- detection_ignores.resize(num_iou_thresholds * num_detections, false);
- ground_truth_ignores.resize(num_ground_truth);
- for (auto g = 0; g < num_ground_truth; ++g) {
- ground_truth_ignores[g] = ignores[ground_truth_sorted_indices[g]];
- }
-
- for (auto t = 0; t < num_iou_thresholds; ++t) {
- for (auto d = 0; d < num_detections; ++d) {
- // information about best match so far (match=-1 -> unmatched)
- double best_iou = std::min(iou_thresholds[t], 1 - 1e-10);
- int match = -1;
- for (auto g = 0; g < num_ground_truth; ++g) {
- // if this ground truth instance is already matched and not a
- // crowd, it cannot be matched to another detection
- if (ground_truth_matches[t * num_ground_truth + g] > 0 &&
- !ground_truth_instances[ground_truth_sorted_indices[g]].is_crowd) {
- continue;
- }
-
- // if detected instance matched to a regular ground truth
- // instance, we can break on the first ground truth instance
- // tagged as ignore (because they are sorted by the ignore tag)
- if (match >= 0 && !ground_truth_ignores[match] &&
- ground_truth_ignores[g]) {
- break;
- }
-
- // if IOU overlap is the best so far, store the match appropriately
- if (ious[d][ground_truth_sorted_indices[g]] >= best_iou) {
- best_iou = ious[d][ground_truth_sorted_indices[g]];
- match = g;
- }
- }
- // if match was made, store id of match for both detection and
- // ground truth
- if (match >= 0) {
- detection_ignores[t * num_detections + d] = ground_truth_ignores[match];
- detection_matches[t * num_detections + d] =
- ground_truth_instances[ground_truth_sorted_indices[match]].id;
- ground_truth_matches[t * num_ground_truth + match] =
- detection_instances[detection_sorted_indices[d]].id;
- }
-
- // set unmatched detections outside of area range to ignore
- const InstanceAnnotation& detection =
- detection_instances[detection_sorted_indices[d]];
- detection_ignores[t * num_detections + d] =
- detection_ignores[t * num_detections + d] ||
- (detection_matches[t * num_detections + d] == 0 &&
- (detection.area < area_range[0] || detection.area > area_range[1]));
- }
- }
-
- // store detection score results
- results->detection_scores.resize(detection_sorted_indices.size());
- for (size_t d = 0; d < detection_sorted_indices.size(); ++d) {
- results->detection_scores[d] =
- detection_instances[detection_sorted_indices[d]].score;
- }
-}
-
-std::vector EvaluateImages(
- const std::vector>& area_ranges,
- int max_detections,
- const std::vector& iou_thresholds,
- const ImageCategoryInstances>& image_category_ious,
- const ImageCategoryInstances&
- image_category_ground_truth_instances,
- const ImageCategoryInstances&
- image_category_detection_instances) {
- const int num_area_ranges = area_ranges.size();
- const int num_images = image_category_ground_truth_instances.size();
- const int num_categories =
- image_category_ious.size() > 0 ? image_category_ious[0].size() : 0;
- std::vector detection_sorted_indices;
- std::vector ground_truth_sorted_indices;
- std::vector ignores;
- std::vector results_all(
- num_images * num_area_ranges * num_categories);
-
- // Store results for each image, category, and area range combination. Results
- // for each IOU threshold are packed into the same ImageEvaluation object
- for (auto i = 0; i < num_images; ++i) {
- for (auto c = 0; c < num_categories; ++c) {
- const std::vector& ground_truth_instances =
- image_category_ground_truth_instances[i][c];
- const std::vector& detection_instances =
- image_category_detection_instances[i][c];
-
- SortInstancesByDetectionScore(
- detection_instances, &detection_sorted_indices);
- if ((int)detection_sorted_indices.size() > max_detections) {
- detection_sorted_indices.resize(max_detections);
- }
-
- for (size_t a = 0; a < area_ranges.size(); ++a) {
- SortInstancesByIgnore(
- area_ranges[a],
- ground_truth_instances,
- &ground_truth_sorted_indices,
- &ignores);
-
- MatchDetectionsToGroundTruth(
- detection_instances,
- detection_sorted_indices,
- ground_truth_instances,
- ground_truth_sorted_indices,
- ignores,
- image_category_ious[i][c],
- iou_thresholds,
- area_ranges[a],
- &results_all
- [c * num_area_ranges * num_images + a * num_images + i]);
- }
- }
- }
-
- return results_all;
-}
-
-// Convert a python list to a vector
-template
-std::vector list_to_vec(const py::list& l) {
- std::vector v(py::len(l));
- for (int i = 0; i < (int)py::len(l); ++i) {
- v[i] = l[i].cast();
- }
- return v;
-}
-
-// Helper function to Accumulate()
-// Considers the evaluation results applicable to a particular category, area
-// range, and max_detections parameter setting, which begin at
-// evaluations[evaluation_index]. Extracts a sorted list of length n of all
-// applicable detection instances concatenated across all images in the dataset,
-// which are represented by the outputs evaluation_indices, detection_scores,
-// image_detection_indices, and detection_sorted_indices--all of which are
-// length n. evaluation_indices[i] stores the applicable index into
-// evaluations[] for instance i, which has detection score detection_score[i],
-// and is the image_detection_indices[i]'th of the list of detections
-// for the image containing i. detection_sorted_indices[] defines a sorted
-// permutation of the 3 other outputs
-int BuildSortedDetectionList(
- const std::vector& evaluations,
- const int64_t evaluation_index,
- const int64_t num_images,
- const int max_detections,
- std::vector* evaluation_indices,
- std::vector* detection_scores,
- std::vector* detection_sorted_indices,
- std::vector* image_detection_indices) {
- assert(evaluations.size() >= evaluation_index + num_images);
-
- // Extract a list of object instances of the applicable category, area
- // range, and max detections requirements such that they can be sorted
- image_detection_indices->clear();
- evaluation_indices->clear();
- detection_scores->clear();
- image_detection_indices->reserve(num_images * max_detections);
- evaluation_indices->reserve(num_images * max_detections);
- detection_scores->reserve(num_images * max_detections);
- int num_valid_ground_truth = 0;
- for (auto i = 0; i < num_images; ++i) {
- const ImageEvaluation& evaluation = evaluations[evaluation_index + i];
-
- for (int d = 0;
- d < (int)evaluation.detection_scores.size() && d < max_detections;
- ++d) { // detected instances
- evaluation_indices->push_back(evaluation_index + i);
- image_detection_indices->push_back(d);
- detection_scores->push_back(evaluation.detection_scores[d]);
- }
- for (auto ground_truth_ignore : evaluation.ground_truth_ignores) {
- if (!ground_truth_ignore) {
- ++num_valid_ground_truth;
- }
- }
- }
-
- // Sort detections by decreasing score, using stable sort to match
- // python implementation
- detection_sorted_indices->resize(detection_scores->size());
- std::iota(
- detection_sorted_indices->begin(), detection_sorted_indices->end(), 0);
- std::stable_sort(
- detection_sorted_indices->begin(),
- detection_sorted_indices->end(),
- [&detection_scores](size_t j1, size_t j2) {
- return (*detection_scores)[j1] > (*detection_scores)[j2];
- });
-
- return num_valid_ground_truth;
-}
-
-// Helper function to Accumulate()
-// Compute a precision recall curve given a sorted list of detected instances
-// encoded in evaluations, evaluation_indices, detection_scores,
-// detection_sorted_indices, image_detection_indices (see
-// BuildSortedDetectionList()). Using vectors precisions and recalls
-// and temporary storage, output the results into precisions_out, recalls_out,
-// and scores_out, which are large buffers containing many precion/recall curves
-// for all possible parameter settings, with precisions_out_index and
-// recalls_out_index defining the applicable indices to store results.
-void ComputePrecisionRecallCurve(
- const int64_t precisions_out_index,
- const int64_t precisions_out_stride,
- const int64_t recalls_out_index,
- const std::vector& recall_thresholds,
- const int iou_threshold_index,
- const int num_iou_thresholds,
- const int num_valid_ground_truth,
- const std::vector& evaluations,
- const std::vector& evaluation_indices,
- const std::vector& detection_scores,
- const std::vector& detection_sorted_indices,
- const std::vector& image_detection_indices,
- std::vector* precisions,
- std::vector* recalls,
- std::vector* precisions_out,
- std::vector* scores_out,
- std::vector* recalls_out) {
- assert(recalls_out->size() > recalls_out_index);
-
- // Compute precision/recall for each instance in the sorted list of detections
- int64_t true_positives_sum = 0, false_positives_sum = 0;
- precisions->clear();
- recalls->clear();
- precisions->reserve(detection_sorted_indices.size());
- recalls->reserve(detection_sorted_indices.size());
- assert(!evaluations.empty() || detection_sorted_indices.empty());
- for (auto detection_sorted_index : detection_sorted_indices) {
- const ImageEvaluation& evaluation =
- evaluations[evaluation_indices[detection_sorted_index]];
- const auto num_detections =
- evaluation.detection_matches.size() / num_iou_thresholds;
- const auto detection_index = iou_threshold_index * num_detections +
- image_detection_indices[detection_sorted_index];
- assert(evaluation.detection_matches.size() > detection_index);
- assert(evaluation.detection_ignores.size() > detection_index);
- const int64_t detection_match =
- evaluation.detection_matches[detection_index];
- const bool detection_ignores =
- evaluation.detection_ignores[detection_index];
- const auto true_positive = detection_match > 0 && !detection_ignores;
- const auto false_positive = detection_match == 0 && !detection_ignores;
- if (true_positive) {
- ++true_positives_sum;
- }
- if (false_positive) {
- ++false_positives_sum;
- }
-
- const double recall =
- static_cast(true_positives_sum) / num_valid_ground_truth;
- recalls->push_back(recall);
- const int64_t num_valid_detections =
- true_positives_sum + false_positives_sum;
- const double precision = num_valid_detections > 0
- ? static_cast(true_positives_sum) / num_valid_detections
- : 0.0;
- precisions->push_back(precision);
- }
-
- (*recalls_out)[recalls_out_index] = !recalls->empty() ? recalls->back() : 0;
-
- for (int64_t i = static_cast(precisions->size()) - 1; i > 0; --i) {
- if ((*precisions)[i] > (*precisions)[i - 1]) {
- (*precisions)[i - 1] = (*precisions)[i];
- }
- }
-
- // Sample the per instance precision/recall list at each recall threshold
- for (size_t r = 0; r < recall_thresholds.size(); ++r) {
- // first index in recalls >= recall_thresholds[r]
- std::vector::iterator low = std::lower_bound(
- recalls->begin(), recalls->end(), recall_thresholds[r]);
- size_t precisions_index = low - recalls->begin();
-
- const auto results_ind = precisions_out_index + r * precisions_out_stride;
- assert(results_ind < precisions_out->size());
- assert(results_ind < scores_out->size());
- if (precisions_index < precisions->size()) {
- (*precisions_out)[results_ind] = (*precisions)[precisions_index];
- (*scores_out)[results_ind] =
- detection_scores[detection_sorted_indices[precisions_index]];
- } else {
- (*precisions_out)[results_ind] = 0;
- (*scores_out)[results_ind] = 0;
- }
- }
-}
-py::dict Accumulate(
- const py::object& params,
- const std::vector& evaluations) {
- const std::vector recall_thresholds =
- list_to_vec(params.attr("recThrs"));
- const std::vector max_detections =
- list_to_vec(params.attr("maxDets"));
- const int num_iou_thresholds = py::len(params.attr("iouThrs"));
- const int num_recall_thresholds = py::len(params.attr("recThrs"));
- const int num_categories = params.attr("useCats").cast() == 1
- ? py::len(params.attr("catIds"))
- : 1;
- const int num_area_ranges = py::len(params.attr("areaRng"));
- const int num_max_detections = py::len(params.attr("maxDets"));
- const int num_images = py::len(params.attr("imgIds"));
-
- std::vector precisions_out(
- num_iou_thresholds * num_recall_thresholds * num_categories *
- num_area_ranges * num_max_detections,
- -1);
- std::vector recalls_out(
- num_iou_thresholds * num_categories * num_area_ranges *
- num_max_detections,
- -1);
- std::vector scores_out(
- num_iou_thresholds * num_recall_thresholds * num_categories *
- num_area_ranges * num_max_detections,
- -1);
-
- // Consider the list of all detected instances in the entire dataset in one
- // large list. evaluation_indices, detection_scores,
- // image_detection_indices, and detection_sorted_indices all have the same
- // length as this list, such that each entry corresponds to one detected
- // instance
- std::vector evaluation_indices; // indices into evaluations[]
- std::vector detection_scores; // detection scores of each instance
- std::vector detection_sorted_indices; // sorted indices of all
- // instances in the dataset
- std::vector
- image_detection_indices; // indices into the list of detected instances in
- // the same image as each instance
- std::vector precisions, recalls;
-
- for (auto c = 0; c < num_categories; ++c) {
- for (auto a = 0; a < num_area_ranges; ++a) {
- for (auto m = 0; m < num_max_detections; ++m) {
- // The COCO PythonAPI assumes evaluations[] (the return value of
- // COCOeval::EvaluateImages() is one long list storing results for each
- // combination of category, area range, and image id, with categories in
- // the outermost loop and images in the innermost loop.
- const int64_t evaluations_index =
- c * num_area_ranges * num_images + a * num_images;
- int num_valid_ground_truth = BuildSortedDetectionList(
- evaluations,
- evaluations_index,
- num_images,
- max_detections[m],
- &evaluation_indices,
- &detection_scores,
- &detection_sorted_indices,
- &image_detection_indices);
-
- if (num_valid_ground_truth == 0) {
- continue;
- }
-
- for (auto t = 0; t < num_iou_thresholds; ++t) {
- // recalls_out is a flattened vectors representing a
- // num_iou_thresholds X num_categories X num_area_ranges X
- // num_max_detections matrix
- const int64_t recalls_out_index =
- t * num_categories * num_area_ranges * num_max_detections +
- c * num_area_ranges * num_max_detections +
- a * num_max_detections + m;
-
- // precisions_out and scores_out are flattened vectors
- // representing a num_iou_thresholds X num_recall_thresholds X
- // num_categories X num_area_ranges X num_max_detections matrix
- const int64_t precisions_out_stride =
- num_categories * num_area_ranges * num_max_detections;
- const int64_t precisions_out_index = t * num_recall_thresholds *
- num_categories * num_area_ranges * num_max_detections +
- c * num_area_ranges * num_max_detections +
- a * num_max_detections + m;
-
- ComputePrecisionRecallCurve(
- precisions_out_index,
- precisions_out_stride,
- recalls_out_index,
- recall_thresholds,
- t,
- num_iou_thresholds,
- num_valid_ground_truth,
- evaluations,
- evaluation_indices,
- detection_scores,
- detection_sorted_indices,
- image_detection_indices,
- &precisions,
- &recalls,
- &precisions_out,
- &scores_out,
- &recalls_out);
- }
- }
- }
- }
-
- time_t rawtime;
- struct tm local_time;
- std::array buffer;
- time(&rawtime);
-#ifdef _WIN32
- localtime_s(&local_time, &rawtime);
-#else
- localtime_r(&rawtime, &local_time);
-#endif
- strftime(
- buffer.data(), 200, "%Y-%m-%d %H:%num_max_detections:%S", &local_time);
- return py::dict(
- "params"_a = params,
- "counts"_a = std::vector(
- {num_iou_thresholds,
- num_recall_thresholds,
- num_categories,
- num_area_ranges,
- num_max_detections}),
- "date"_a = buffer,
- "precision"_a = precisions_out,
- "recall"_a = recalls_out,
- "scores"_a = scores_out);
-}
-
-} // namespace COCOeval
-
-} // namespace detectron2
diff --git a/spaces/Yuliang/ECON/lib/pixielib/utils/array_cropper.py b/spaces/Yuliang/ECON/lib/pixielib/utils/array_cropper.py
deleted file mode 100644
index d18e15b504fd7d894dcb3ed72830374a9837e42b..0000000000000000000000000000000000000000
--- a/spaces/Yuliang/ECON/lib/pixielib/utils/array_cropper.py
+++ /dev/null
@@ -1,81 +0,0 @@
-"""
-crop
-for numpy array
-Given image, bbox(center, bboxsize)
-return: cropped image, tform(used for transform the keypoint accordingly)
-
-only support crop to squared images
-"""
-
-import numpy as np
-from skimage.transform import estimate_transform, rescale, resize, warp
-
-
-def points2bbox(points, points_scale=None):
- # recover range
- if points_scale:
- points[:, 0] = points[:, 0] * points_scale[1] / 2 + points_scale[1] / 2
- points[:, 1] = points[:, 1] * points_scale[0] / 2 + points_scale[0] / 2
-
- left = np.min(points[:, 0])
- right = np.max(points[:, 0])
- top = np.min(points[:, 1])
- bottom = np.max(points[:, 1])
- size = max(right - left, bottom - top)
- # + old_size*0.1])
- center = np.array([right - (right - left) / 2.0, bottom - (bottom - top) / 2.0])
- return center, size
- # translate center
-
-
-def augment_bbox(center, bbox_size, scale=[1.0, 1.0], trans_scale=0.0):
- trans_scale = (np.random.rand(2) * 2 - 1) * trans_scale
- center = center + trans_scale * bbox_size # 0.5
- scale = np.random.rand() * (scale[1] - scale[0]) + scale[0]
- size = int(bbox_size * scale)
- return center, size
-
-
-def crop_array(image, center, bboxsize, crop_size):
- """for single image only
- Args:
- image (numpy.Array): the reference array of shape HxWXC.
- size (Tuple[int, int]): a tuple with the height and width that will be
- used to resize the extracted patches.
- Returns:
- cropped_image
- tform: 3x3 affine matrix
- """
- # points: top-left, top-right, bottom-right
- src_pts = np.array([
- [center[0] - bboxsize / 2, center[1] - bboxsize / 2],
- [center[0] + bboxsize / 2, center[1] - bboxsize / 2],
- [center[0] + bboxsize / 2, center[1] + bboxsize / 2],
- ])
- DST_PTS = np.array([[0, 0], [crop_size - 1, 0], [crop_size - 1, crop_size - 1]])
-
- # estimate transformation between points
- tform = estimate_transform("similarity", src_pts, DST_PTS)
-
- # warp images
- cropped_image = warp(image, tform.inverse, output_shape=(crop_size, crop_size))
-
- return cropped_image, tform.params.T
-
-
-class Cropper(object):
- def __init__(self, crop_size, scale=[1, 1], trans_scale=0.0):
- self.crop_size = crop_size
- self.scale = scale
- self.trans_scale = trans_scale
-
- def crop(self, image, points, points_scale=None):
- # points to bbox
- center, bbox_size = points2bbox(points, points_scale)
- # argument bbox.
- center, bbox_size = augment_bbox(
- center, bbox_size, scale=self.scale, trans_scale=self.trans_scale
- )
- # crop
- cropped_image, tform = crop_array(image, center, bbox_size, self.crop_size)
- return cropped_image, tform
diff --git a/spaces/Yuliang/ECON/lib/pymafx/utils/__init__.py b/spaces/Yuliang/ECON/lib/pymafx/utils/__init__.py
deleted file mode 100644
index 539b22b33222e7617b267138f30fc5f1a7f82b6a..0000000000000000000000000000000000000000
--- a/spaces/Yuliang/ECON/lib/pymafx/utils/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from .data_loader import CheckpointDataLoader
-from .saver import CheckpointSaver
\ No newline at end of file
diff --git a/spaces/Yuliang/ECON/lib/torch_utils/persistence.py b/spaces/Yuliang/ECON/lib/torch_utils/persistence.py
deleted file mode 100644
index 34f16d48f416fc07eb6954aa810acf852db5eed5..0000000000000000000000000000000000000000
--- a/spaces/Yuliang/ECON/lib/torch_utils/persistence.py
+++ /dev/null
@@ -1,271 +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.
-"""Facilities for pickling Python code alongside other data.
-
-The pickled code is automatically imported into a separate Python module
-during unpickling. This way, any previously exported pickles will remain
-usable even if the original code is no longer available, or if the current
-version of the code is not consistent with what was originally pickled."""
-
-import copy
-import inspect
-import io
-import pickle
-import sys
-import types
-import uuid
-
-import dnnlib
-
-#----------------------------------------------------------------------------
-
-_version = 6 # internal version number
-_decorators = set() # {decorator_class, ...}
-_import_hooks = [] # [hook_function, ...]
-_module_to_src_dict = dict() # {module: src, ...}
-_src_to_module_dict = dict() # {src: module, ...}
-
-#----------------------------------------------------------------------------
-
-
-def persistent_class(orig_class):
- r"""Class decorator that extends a given class to save its source code
- when pickled.
-
- Example:
-
- from torch_utils import persistence
-
- @persistence.persistent_class
- class MyNetwork(torch.nn.Module):
- def __init__(self, num_inputs, num_outputs):
- super().__init__()
- self.fc = MyLayer(num_inputs, num_outputs)
- ...
-
- @persistence.persistent_class
- class MyLayer(torch.nn.Module):
- ...
-
- When pickled, any instance of `MyNetwork` and `MyLayer` will save its
- source code alongside other internal state (e.g., parameters, buffers,
- and submodules). This way, any previously exported pickle will remain
- usable even if the class definitions have been modified or are no
- longer available.
-
- The decorator saves the source code of the entire Python module
- containing the decorated class. It does *not* save the source code of
- any imported modules. Thus, the imported modules must be available
- during unpickling, also including `torch_utils.persistence` itself.
-
- It is ok to call functions defined in the same module from the
- decorated class. However, if the decorated class depends on other
- classes defined in the same module, they must be decorated as well.
- This is illustrated in the above example in the case of `MyLayer`.
-
- It is also possible to employ the decorator just-in-time before
- calling the constructor. For example:
-
- cls = MyLayer
- if want_to_make_it_persistent:
- cls = persistence.persistent_class(cls)
- layer = cls(num_inputs, num_outputs)
-
- As an additional feature, the decorator also keeps track of the
- arguments that were used to construct each instance of the decorated
- class. The arguments can be queried via `obj.init_args` and
- `obj.init_kwargs`, and they are automatically pickled alongside other
- object state. A typical use case is to first unpickle a previous
- instance of a persistent class, and then upgrade it to use the latest
- version of the source code:
-
- with open('old_pickle.pkl', 'rb') as f:
- old_net = pickle.load(f)
- new_net = MyNetwork(*old_obj.init_args, **old_obj.init_kwargs)
- misc.copy_params_and_buffers(old_net, new_net, require_all=True)
- """
- assert isinstance(orig_class, type)
- if is_persistent(orig_class):
- return orig_class
-
- assert orig_class.__module__ in sys.modules
- orig_module = sys.modules[orig_class.__module__]
- orig_module_src = _module_to_src(orig_module)
-
- class Decorator(orig_class):
- _orig_module_src = orig_module_src
- _orig_class_name = orig_class.__name__
-
- def __init__(self, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self._init_args = copy.deepcopy(args)
- self._init_kwargs = copy.deepcopy(kwargs)
- assert orig_class.__name__ in orig_module.__dict__
- _check_pickleable(self.__reduce__())
-
- @property
- def init_args(self):
- return copy.deepcopy(self._init_args)
-
- @property
- def init_kwargs(self):
- return dnnlib.EasyDict(copy.deepcopy(self._init_kwargs))
-
- def __reduce__(self):
- fields = list(super().__reduce__())
- fields += [None] * max(3 - len(fields), 0)
- if fields[0] is not _reconstruct_persistent_obj:
- meta = dict(
- type='class',
- version=_version,
- module_src=self._orig_module_src,
- class_name=self._orig_class_name,
- state=fields[2]
- )
- fields[0] = _reconstruct_persistent_obj # reconstruct func
- fields[1] = (meta, ) # reconstruct args
- fields[2] = None # state dict
- return tuple(fields)
-
- Decorator.__name__ = orig_class.__name__
- _decorators.add(Decorator)
- return Decorator
-
-
-#----------------------------------------------------------------------------
-
-
-def is_persistent(obj):
- r"""Test whether the given object or class is persistent, i.e.,
- whether it will save its source code when pickled.
- """
- try:
- if obj in _decorators:
- return True
- except TypeError:
- pass
- return type(obj) in _decorators # pylint: disable=unidiomatic-typecheck
-
-
-#----------------------------------------------------------------------------
-
-
-def import_hook(hook):
- r"""Register an import hook that is called whenever a persistent object
- is being unpickled. A typical use case is to patch the pickled source
- code to avoid errors and inconsistencies when the API of some imported
- module has changed.
-
- The hook should have the following signature:
-
- hook(meta) -> modified meta
-
- `meta` is an instance of `dnnlib.EasyDict` with the following fields:
-
- type: Type of the persistent object, e.g. `'class'`.
- version: Internal version number of `torch_utils.persistence`.
- module_src Original source code of the Python module.
- class_name: Class name in the original Python module.
- state: Internal state of the object.
-
- Example:
-
- @persistence.import_hook
- def wreck_my_network(meta):
- if meta.class_name == 'MyNetwork':
- print('MyNetwork is being imported. I will wreck it!')
- meta.module_src = meta.module_src.replace("True", "False")
- return meta
- """
- assert callable(hook)
- _import_hooks.append(hook)
-
-
-#----------------------------------------------------------------------------
-
-
-def _reconstruct_persistent_obj(meta):
- r"""Hook that is called internally by the `pickle` module to unpickle
- a persistent object.
- """
- meta = dnnlib.EasyDict(meta)
- meta.state = dnnlib.EasyDict(meta.state)
- for hook in _import_hooks:
- meta = hook(meta)
- assert meta is not None
-
- assert meta.version == _version
- module = _src_to_module(meta.module_src)
-
- assert meta.type == 'class'
- orig_class = module.__dict__[meta.class_name]
- decorator_class = persistent_class(orig_class)
- obj = decorator_class.__new__(decorator_class)
-
- setstate = getattr(obj, '__setstate__', None)
- if callable(setstate):
- setstate(meta.state) # pylint: disable=not-callable
- else:
- obj.__dict__.update(meta.state)
- return obj
-
-
-#----------------------------------------------------------------------------
-
-
-def _module_to_src(module):
- r"""Query the source code of a given Python module.
- """
- src = _module_to_src_dict.get(module, None)
- if src is None:
- src = inspect.getsource(module)
- _module_to_src_dict[module] = src
- _src_to_module_dict[src] = module
- return src
-
-
-def _src_to_module(src):
- r"""Get or create a Python module for the given source code.
- """
- module = _src_to_module_dict.get(src, None)
- if module is None:
- module_name = "_imported_module_" + uuid.uuid4().hex
- module = types.ModuleType(module_name)
- sys.modules[module_name] = module
- _module_to_src_dict[module] = src
- _src_to_module_dict[src] = module
- exec(src, module.__dict__) # pylint: disable=exec-used
- return module
-
-
-#----------------------------------------------------------------------------
-
-
-def _check_pickleable(obj):
- r"""Check that the given object is pickleable, raising an exception if
- it is not. This function is expected to be considerably more efficient
- than actually pickling the object.
- """
- def recurse(obj):
- if isinstance(obj, (list, tuple, set)):
- return [recurse(x) for x in obj]
- if isinstance(obj, dict):
- return [[recurse(x), recurse(y)] for x, y in obj.items()]
- if isinstance(obj, (str, int, float, bool, bytes, bytearray)):
- return None # Python primitive types are pickleable.
- if f'{type(obj).__module__}.{type(obj).__name__}' in ['numpy.ndarray', 'torch.Tensor']:
- return None # NumPy arrays and PyTorch tensors are pickleable.
- if is_persistent(obj):
- return None # Persistent objects are pickleable, by virtue of the constructor check.
- return obj
-
- with io.BytesIO() as f:
- pickle.dump(recurse(obj), f)
-
-
-#----------------------------------------------------------------------------
diff --git a/spaces/ZeroCool94/sygil-diffusion/README.md b/spaces/ZeroCool94/sygil-diffusion/README.md
deleted file mode 100644
index e8d668edca7e680f451b08e30b171e8f95aca2a7..0000000000000000000000000000000000000000
--- a/spaces/ZeroCool94/sygil-diffusion/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Sygil Diffusion
-emoji: ⚡
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 3.16.1b1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/achyuth1344/stable-diffusion-webui/header_patch.py b/spaces/achyuth1344/stable-diffusion-webui/header_patch.py
deleted file mode 100644
index aa8c592aca6649bf2ca293de6cb58566c7791cf3..0000000000000000000000000000000000000000
--- a/spaces/achyuth1344/stable-diffusion-webui/header_patch.py
+++ /dev/null
@@ -1,29 +0,0 @@
- with gr.Box(visible=is_spaces):
- if(is_spaces and is_shared_ui):
- gr.HTML(f'''
-
- 🚨 We have a new version ✨ please try it and add a comment if you find any issues. https://huggingface.co/spaces/achyuth1344/stable-diffusion-webui
-
- 🚧 (WIP) Automatic1111 Stable Diffusion Web UI on 🤗 Hugging Face Spaces | Running model: Linaqruf/anything-v3.0
- You can duplicate this Space to run it privately without a queue and load additional checkpoints. 
- 📝 How to add private model or embed? 📺 Tutorial Video: https://www.youtube.com/channel/UCs_1ej3ysIROjWZVmNw-tyw 🐣 Please follow me for new updates https://twitter.com/pixiejourney
-
- ''')
- elif(is_spaces):
- import torch
- if(not torch.cuda.is_available()):
- gr.HTML(f'''
-
- 🚧 (WIP) Private Automatic1111 Stable Diffusion Web UI on 🤗 Hugging Face Spaces
- This Space is currently running on CPU, this WebUI may not run on CPU 🥶, you can upgrade for a GPU in the Settings tab
- 📝 How to add private model or embed? 📺 Tutorial Video: https://www.youtube.com/channel/UCs_1ej3ysIROjWZVmNw-tyw 🐣 Please follow me for new updates https://twitter.com/pixiejourney
-
- ''')
- else:
- gr.HTML(f'''
-
- 🚧 (WIP) Private Automatic1111 Stable Diffusion Web UI on 🤗 Hugging Face Spaces
- It is running on a GPU 🔥, you can don't forget to remove the GPU attribution once your are done playing with it
- 📝 How to add private model or embed? 📺 Tutorial Video: https://www.youtube.com/channel/UCs_1ej3ysIROjWZVmNw-tyw 🐣 Please follow me for new updates https://twitter.com/pixiejourney
-
- ''')
diff --git a/spaces/ahmedJaafari/Annarabic/app.py b/spaces/ahmedJaafari/Annarabic/app.py
deleted file mode 100644
index b09a2ed6ca3d06afd3fb920703ed8a977ccd0fbc..0000000000000000000000000000000000000000
--- a/spaces/ahmedJaafari/Annarabic/app.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import gradio as gr
-import numpy as np
-from transformers.file_utils import cached_path, hf_bucket_url
-import os
-from transformers import Wav2Vec2ProcessorWithLM, AutoModelForCTC
-from datasets import load_dataset
-import torch
-import kenlm
-import torchaudio
-
-cache_dir = './cache/'
-processor = Wav2Vec2ProcessorWithLM.from_pretrained("ahmedJaafari/Annarabic3.2", cache_dir=cache_dir, use_auth_token=os.getenv("AnnarabicToken"))
-model = AutoModelForCTC.from_pretrained("ahmedJaafari/Annarabic3.2", cache_dir=cache_dir, use_auth_token=os.getenv("AnnarabicToken"))
-
-# define function to read in sound file
-def speech_file_to_array_fn(path, max_seconds=120):
- batch = {"file": path}
- speech_array, sampling_rate = torchaudio.load(batch["file"])
- if sampling_rate != 16000:
- transform = torchaudio.transforms.Resample(orig_freq=sampling_rate,
- new_freq=16000)
- speech_array = transform(speech_array)
- speech_array = speech_array[0]
- if max_seconds > 0:
- speech_array = speech_array[:max_seconds*16000]
- batch["speech"] = speech_array.numpy()
- batch["sampling_rate"] = 16000
- return batch
-
-# tokenize
-def inference(audio):
- # read in sound file
- # load dummy dataset and read soundfiles
- ds = speech_file_to_array_fn(audio)
- # infer model
- input_values = processor(
- ds["speech"],
- sampling_rate=ds["sampling_rate"],
- return_tensors="pt"
- ).input_values
- # decode ctc output
- with torch.no_grad():
- logits = model(input_values).logits
-
- output = processor.decode(logits.numpy()[0]).text
- print(output)
-
- return output
-
-inputs = gr.inputs.Audio(label="Input Audio", type="filepath")
-outputs = gr.outputs.Textbox(label="Output Text")
-title = "Annarabic Speech Recognition System"
-description = 'Demo for Annarabic ASR. To use it, simply upload your audio, or click on one of the examples to load them. Only the 10 first seconds of the audio will be transcribed and GPU runtime is not used. For more information, contact Ahmed Jaafari via email: a.jaafari@aui.ma or phone: +212658537105.'
-examples=[['Aya.mp3'], ['Loubna.mp3'], ['Omar.wav'], ['Yassir.wav']]
-article="* The ASR never trained on the given examples."
-gr.Interface(inference, inputs, outputs, title=title, description=description, article=article, examples=examples).launch()
\ No newline at end of file
diff --git a/spaces/akhaliq/PaintTransformer/app.py b/spaces/akhaliq/PaintTransformer/app.py
deleted file mode 100644
index b514454208cb5504fff7d7c7de9f6ffba402b184..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/PaintTransformer/app.py
+++ /dev/null
@@ -1,509 +0,0 @@
-import torch
-import torch.nn.functional as F
-import numpy as np
-from PIL import Image
-import os
-os.system('pip freeze')
-import network
-import morphology
-import math
-import gradio as gr
-from torchvision import transforms
-import torchtext
-from stat import ST_CTIME
-from datetime import datetime, timedelta
-import shutil
-
-
-print(torch.cuda.is_available())
-
-# Images
-torch.hub.download_url_to_file('https://cdn.pixabay.com/photo/2021/08/04/14/16/tower-6521842_1280.jpg', 'tower.jpg')
-torch.hub.download_url_to_file('https://cdn.pixabay.com/photo/2017/08/31/05/36/buildings-2699520_1280.jpg', 'city.jpg')
-idx = 0
-
-os.system("gdown https://drive.google.com/uc?id=1NDD54BLligyr8tzo8QGI5eihZisXK1nq")
-def to_PIL_img(img):
- result = Image.fromarray((img.data.cpu().numpy().transpose((1, 2, 0)) * 255).astype(np.uint8))
- return result
-def save_img(img, output_path):
- to_PIL_img(img).save(output_path)
-def param2stroke(param, H, W, meta_brushes):
- """
- Input a set of stroke parameters and output its corresponding foregrounds and alpha maps.
- Args:
- param: a tensor with shape n_strokes x n_param_per_stroke. Here, param_per_stroke is 8:
- x_center, y_center, width, height, theta, R, G, and B.
- H: output height.
- W: output width.
- meta_brushes: a tensor with shape 2 x 3 x meta_brush_height x meta_brush_width.
- The first slice on the batch dimension denotes vertical brush and the second one denotes horizontal brush.
- Returns:
- foregrounds: a tensor with shape n_strokes x 3 x H x W, containing color information.
- alphas: a tensor with shape n_strokes x 3 x H x W,
- containing binary information of whether a pixel is belonging to the stroke (alpha mat), for painting process.
- """
- # Firstly, resize the meta brushes to the required shape,
- # in order to decrease GPU memory especially when the required shape is small.
- meta_brushes_resize = F.interpolate(meta_brushes, (H, W))
- b = param.shape[0]
- # Extract shape parameters and color parameters.
- param_list = torch.split(param, 1, dim=1)
- x0, y0, w, h, theta = [item.squeeze(-1) for item in param_list[:5]]
- R, G, B = param_list[5:]
- # Pre-compute sin theta and cos theta
- sin_theta = torch.sin(torch.acos(torch.tensor(-1., device=param.device)) * theta)
- cos_theta = torch.cos(torch.acos(torch.tensor(-1., device=param.device)) * theta)
- # index means each stroke should use which meta stroke? Vertical meta stroke or horizontal meta stroke.
- # When h > w, vertical stroke should be used. When h <= w, horizontal stroke should be used.
- index = torch.full((b,), -1, device=param.device, dtype=torch.long)
- index[h > w] = 0
- index[h <= w] = 1
- brush = meta_brushes_resize[index.long()]
- # Calculate warp matrix according to the rules defined by pytorch, in order for warping.
- warp_00 = cos_theta / w
- warp_01 = sin_theta * H / (W * w)
- warp_02 = (1 - 2 * x0) * cos_theta / w + (1 - 2 * y0) * sin_theta * H / (W * w)
- warp_10 = -sin_theta * W / (H * h)
- warp_11 = cos_theta / h
- warp_12 = (1 - 2 * y0) * cos_theta / h - (1 - 2 * x0) * sin_theta * W / (H * h)
- warp_0 = torch.stack([warp_00, warp_01, warp_02], dim=1)
- warp_1 = torch.stack([warp_10, warp_11, warp_12], dim=1)
- warp = torch.stack([warp_0, warp_1], dim=1)
- # Conduct warping.
- grid = F.affine_grid(warp, [b, 3, H, W], align_corners=False)
- brush = F.grid_sample(brush, grid, align_corners=False)
- # alphas is the binary information suggesting whether a pixel is belonging to the stroke.
- alphas = (brush > 0).float()
- brush = brush.repeat(1, 3, 1, 1)
- alphas = alphas.repeat(1, 3, 1, 1)
- # Give color to foreground strokes.
- color_map = torch.cat([R, G, B], dim=1)
- color_map = color_map.unsqueeze(-1).unsqueeze(-1).repeat(1, 1, H, W)
- foreground = brush * color_map
- # Dilation and erosion are used for foregrounds and alphas respectively to prevent artifacts on stroke borders.
- foreground = morphology.dilation(foreground)
- alphas = morphology.erosion(alphas)
- return foreground, alphas
-def param2img_serial(
- param, decision, meta_brushes, cur_canvas, frame_dir, has_border=False, original_h=None, original_w=None, *, all_frames):
- """
- Input stroke parameters and decisions for each patch, meta brushes, current canvas, frame directory,
- and whether there is a border (if intermediate painting results are required).
- Output the painting results of adding the corresponding strokes on the current canvas.
- Args:
- param: a tensor with shape batch size x patch along height dimension x patch along width dimension
- x n_stroke_per_patch x n_param_per_stroke
- decision: a 01 tensor with shape batch size x patch along height dimension x patch along width dimension
- x n_stroke_per_patch
- meta_brushes: a tensor with shape 2 x 3 x meta_brush_height x meta_brush_width.
- The first slice on the batch dimension denotes vertical brush and the second one denotes horizontal brush.
- cur_canvas: a tensor with shape batch size x 3 x H x W,
- where H and W denote height and width of padded results of original images.
- frame_dir: directory to save intermediate painting results. None means intermediate results are not required.
- has_border: on the last painting layer, in order to make sure that the painting results do not miss
- any important detail, we choose to paint again on this layer but shift patch_size // 2 pixels when
- cutting patches. In this case, if intermediate results are required, we need to cut the shifted length
- on the border before saving, or there would be a black border.
- original_h: to indicate the original height for cropping when saving intermediate results.
- original_w: to indicate the original width for cropping when saving intermediate results.
- Returns:
- cur_canvas: a tensor with shape batch size x 3 x H x W, denoting painting results.
- """
- # param: b, h, w, stroke_per_patch, param_per_stroke
- # decision: b, h, w, stroke_per_patch
- b, h, w, s, p = param.shape
- H, W = cur_canvas.shape[-2:]
- is_odd_y = h % 2 == 1
- is_odd_x = w % 2 == 1
- patch_size_y = 2 * H // h
- patch_size_x = 2 * W // w
- even_idx_y = torch.arange(0, h, 2, device=cur_canvas.device)
- even_idx_x = torch.arange(0, w, 2, device=cur_canvas.device)
- odd_idx_y = torch.arange(1, h, 2, device=cur_canvas.device)
- odd_idx_x = torch.arange(1, w, 2, device=cur_canvas.device)
- even_y_even_x_coord_y, even_y_even_x_coord_x = torch.meshgrid([even_idx_y, even_idx_x])
- odd_y_odd_x_coord_y, odd_y_odd_x_coord_x = torch.meshgrid([odd_idx_y, odd_idx_x])
- even_y_odd_x_coord_y, even_y_odd_x_coord_x = torch.meshgrid([even_idx_y, odd_idx_x])
- odd_y_even_x_coord_y, odd_y_even_x_coord_x = torch.meshgrid([odd_idx_y, even_idx_x])
- cur_canvas = F.pad(cur_canvas, [patch_size_x // 4, patch_size_x // 4,
- patch_size_y // 4, patch_size_y // 4, 0, 0, 0, 0])
- def partial_render(this_canvas, patch_coord_y, patch_coord_x, stroke_id):
- canvas_patch = F.unfold(this_canvas, (patch_size_y, patch_size_x),
- stride=(patch_size_y // 2, patch_size_x // 2))
- # canvas_patch: b, 3 * py * px, h * w
- canvas_patch = canvas_patch.view(b, 3, patch_size_y, patch_size_x, h, w).contiguous()
- canvas_patch = canvas_patch.permute(0, 4, 5, 1, 2, 3).contiguous()
- # canvas_patch: b, h, w, 3, py, px
- selected_canvas_patch = canvas_patch[:, patch_coord_y, patch_coord_x, :, :, :]
- selected_h, selected_w = selected_canvas_patch.shape[1:3]
- selected_param = param[:, patch_coord_y, patch_coord_x, stroke_id, :].view(-1, p).contiguous()
- selected_decision = decision[:, patch_coord_y, patch_coord_x, stroke_id].view(-1).contiguous()
- selected_foregrounds = torch.zeros(selected_param.shape[0], 3, patch_size_y, patch_size_x,
- device=this_canvas.device)
- selected_alphas = torch.zeros(selected_param.shape[0], 3, patch_size_y, patch_size_x, device=this_canvas.device)
- if selected_param[selected_decision, :].shape[0] > 0:
- selected_foregrounds[selected_decision, :, :, :], selected_alphas[selected_decision, :, :, :] = param2stroke(selected_param[selected_decision, :], patch_size_y, patch_size_x, meta_brushes)
- selected_foregrounds = selected_foregrounds.view(
- b, selected_h, selected_w, 3, patch_size_y, patch_size_x).contiguous()
- selected_alphas = selected_alphas.view(b, selected_h, selected_w, 3, patch_size_y, patch_size_x).contiguous()
- selected_decision = selected_decision.view(b, selected_h, selected_w, 1, 1, 1).contiguous()
- selected_canvas_patch = selected_foregrounds * selected_alphas * selected_decision + selected_canvas_patch * (
- 1 - selected_alphas * selected_decision)
- this_canvas = selected_canvas_patch.permute(0, 3, 1, 4, 2, 5).contiguous()
- # this_canvas: b, 3, selected_h, py, selected_w, px
- this_canvas = this_canvas.view(b, 3, selected_h * patch_size_y, selected_w * patch_size_x).contiguous()
- # this_canvas: b, 3, selected_h * py, selected_w * px
- return this_canvas
- global idx
- if has_border:
- factor = 2
- else:
- factor = 4
- def store_frame(img):
- all_frames.append(to_PIL_img(img))
-
- if even_idx_y.shape[0] > 0 and even_idx_x.shape[0] > 0:
- for i in range(s):
- canvas = partial_render(cur_canvas, even_y_even_x_coord_y, even_y_even_x_coord_x, i)
- if not is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if not is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- idx += 1
- if frame_dir is not None:
- frame = crop(cur_canvas[:, :, patch_size_y // factor:-patch_size_y // factor,
- patch_size_x // factor:-patch_size_x // factor], original_h, original_w)
- save_img(frame[0], os.path.join(frame_dir, '%03d.jpg' % idx))
- store_frame(frame[0])
- if odd_idx_y.shape[0] > 0 and odd_idx_x.shape[0] > 0:
- for i in range(s):
- canvas = partial_render(cur_canvas, odd_y_odd_x_coord_y, odd_y_odd_x_coord_x, i)
- canvas = torch.cat([cur_canvas[:, :, :patch_size_y // 2, -canvas.shape[3]:], canvas], dim=2)
- canvas = torch.cat([cur_canvas[:, :, -canvas.shape[2]:, :patch_size_x // 2], canvas], dim=3)
- if is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- idx += 1
- if frame_dir is not None:
- frame = crop(cur_canvas[:, :, patch_size_y // factor:-patch_size_y // factor,
- patch_size_x // factor:-patch_size_x // factor], original_h, original_w)
- save_img(frame[0], os.path.join(frame_dir, '%03d.jpg' % idx))
- store_frame(frame[0])
- if odd_idx_y.shape[0] > 0 and even_idx_x.shape[0] > 0:
- for i in range(s):
- canvas = partial_render(cur_canvas, odd_y_even_x_coord_y, odd_y_even_x_coord_x, i)
- canvas = torch.cat([cur_canvas[:, :, :patch_size_y // 2, :canvas.shape[3]], canvas], dim=2)
- if is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if not is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- idx += 1
- if frame_dir is not None:
- frame = crop(cur_canvas[:, :, patch_size_y // factor:-patch_size_y // factor,
- patch_size_x // factor:-patch_size_x // factor], original_h, original_w)
- save_img(frame[0], os.path.join(frame_dir, '%03d.jpg' % idx))
- store_frame(frame[0])
- if even_idx_y.shape[0] > 0 and odd_idx_x.shape[0] > 0:
- for i in range(s):
- canvas = partial_render(cur_canvas, even_y_odd_x_coord_y, even_y_odd_x_coord_x, i)
- canvas = torch.cat([cur_canvas[:, :, :canvas.shape[2], :patch_size_x // 2], canvas], dim=3)
- if not is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, -canvas.shape[3]:]], dim=2)
- if is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- idx += 1
- if frame_dir is not None:
- frame = crop(cur_canvas[:, :, patch_size_y // factor:-patch_size_y // factor,
- patch_size_x // factor:-patch_size_x // factor], original_h, original_w)
- save_img(frame[0], os.path.join(frame_dir, '%03d.jpg' % idx))
- store_frame(frame[0])
- cur_canvas = cur_canvas[:, :, patch_size_y // 4:-patch_size_y // 4, patch_size_x // 4:-patch_size_x // 4]
- return cur_canvas
-def param2img_parallel(param, decision, meta_brushes, cur_canvas):
- """
- Input stroke parameters and decisions for each patch, meta brushes, current canvas, frame directory,
- and whether there is a border (if intermediate painting results are required).
- Output the painting results of adding the corresponding strokes on the current canvas.
- Args:
- param: a tensor with shape batch size x patch along height dimension x patch along width dimension
- x n_stroke_per_patch x n_param_per_stroke
- decision: a 01 tensor with shape batch size x patch along height dimension x patch along width dimension
- x n_stroke_per_patch
- meta_brushes: a tensor with shape 2 x 3 x meta_brush_height x meta_brush_width.
- The first slice on the batch dimension denotes vertical brush and the second one denotes horizontal brush.
- cur_canvas: a tensor with shape batch size x 3 x H x W,
- where H and W denote height and width of padded results of original images.
- Returns:
- cur_canvas: a tensor with shape batch size x 3 x H x W, denoting painting results.
- """
- # param: b, h, w, stroke_per_patch, param_per_stroke
- # decision: b, h, w, stroke_per_patch
- b, h, w, s, p = param.shape
- param = param.view(-1, 8).contiguous()
- decision = decision.view(-1).contiguous().bool()
- H, W = cur_canvas.shape[-2:]
- is_odd_y = h % 2 == 1
- is_odd_x = w % 2 == 1
- patch_size_y = 2 * H // h
- patch_size_x = 2 * W // w
- even_idx_y = torch.arange(0, h, 2, device=cur_canvas.device)
- even_idx_x = torch.arange(0, w, 2, device=cur_canvas.device)
- odd_idx_y = torch.arange(1, h, 2, device=cur_canvas.device)
- odd_idx_x = torch.arange(1, w, 2, device=cur_canvas.device)
- even_y_even_x_coord_y, even_y_even_x_coord_x = torch.meshgrid([even_idx_y, even_idx_x])
- odd_y_odd_x_coord_y, odd_y_odd_x_coord_x = torch.meshgrid([odd_idx_y, odd_idx_x])
- even_y_odd_x_coord_y, even_y_odd_x_coord_x = torch.meshgrid([even_idx_y, odd_idx_x])
- odd_y_even_x_coord_y, odd_y_even_x_coord_x = torch.meshgrid([odd_idx_y, even_idx_x])
- cur_canvas = F.pad(cur_canvas, [patch_size_x // 4, patch_size_x // 4,
- patch_size_y // 4, patch_size_y // 4, 0, 0, 0, 0])
- foregrounds = torch.zeros(param.shape[0], 3, patch_size_y, patch_size_x, device=cur_canvas.device)
- alphas = torch.zeros(param.shape[0], 3, patch_size_y, patch_size_x, device=cur_canvas.device)
- valid_foregrounds, valid_alphas = param2stroke(param[decision, :], patch_size_y, patch_size_x, meta_brushes)
- foregrounds[decision, :, :, :] = valid_foregrounds
- alphas[decision, :, :, :] = valid_alphas
- # foreground, alpha: b * h * w * stroke_per_patch, 3, patch_size_y, patch_size_x
- foregrounds = foregrounds.view(-1, h, w, s, 3, patch_size_y, patch_size_x).contiguous()
- alphas = alphas.view(-1, h, w, s, 3, patch_size_y, patch_size_x).contiguous()
- # foreground, alpha: b, h, w, stroke_per_patch, 3, render_size_y, render_size_x
- decision = decision.view(-1, h, w, s, 1, 1, 1).contiguous()
- # decision: b, h, w, stroke_per_patch, 1, 1, 1
- def partial_render(this_canvas, patch_coord_y, patch_coord_x):
- canvas_patch = F.unfold(this_canvas, (patch_size_y, patch_size_x),
- stride=(patch_size_y // 2, patch_size_x // 2))
- # canvas_patch: b, 3 * py * px, h * w
- canvas_patch = canvas_patch.view(b, 3, patch_size_y, patch_size_x, h, w).contiguous()
- canvas_patch = canvas_patch.permute(0, 4, 5, 1, 2, 3).contiguous()
- # canvas_patch: b, h, w, 3, py, px
- selected_canvas_patch = canvas_patch[:, patch_coord_y, patch_coord_x, :, :, :]
- selected_foregrounds = foregrounds[:, patch_coord_y, patch_coord_x, :, :, :, :]
- selected_alphas = alphas[:, patch_coord_y, patch_coord_x, :, :, :, :]
- selected_decisions = decision[:, patch_coord_y, patch_coord_x, :, :, :, :]
- for i in range(s):
- cur_foreground = selected_foregrounds[:, :, :, i, :, :, :]
- cur_alpha = selected_alphas[:, :, :, i, :, :, :]
- cur_decision = selected_decisions[:, :, :, i, :, :, :]
- selected_canvas_patch = cur_foreground * cur_alpha * cur_decision + selected_canvas_patch * (
- 1 - cur_alpha * cur_decision)
- this_canvas = selected_canvas_patch.permute(0, 3, 1, 4, 2, 5).contiguous()
- # this_canvas: b, 3, h_half, py, w_half, px
- h_half = this_canvas.shape[2]
- w_half = this_canvas.shape[4]
- this_canvas = this_canvas.view(b, 3, h_half * patch_size_y, w_half * patch_size_x).contiguous()
- # this_canvas: b, 3, h_half * py, w_half * px
- return this_canvas
- if even_idx_y.shape[0] > 0 and even_idx_x.shape[0] > 0:
- canvas = partial_render(cur_canvas, even_y_even_x_coord_y, even_y_even_x_coord_x)
- if not is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if not is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- if odd_idx_y.shape[0] > 0 and odd_idx_x.shape[0] > 0:
- canvas = partial_render(cur_canvas, odd_y_odd_x_coord_y, odd_y_odd_x_coord_x)
- canvas = torch.cat([cur_canvas[:, :, :patch_size_y // 2, -canvas.shape[3]:], canvas], dim=2)
- canvas = torch.cat([cur_canvas[:, :, -canvas.shape[2]:, :patch_size_x // 2], canvas], dim=3)
- if is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- if odd_idx_y.shape[0] > 0 and even_idx_x.shape[0] > 0:
- canvas = partial_render(cur_canvas, odd_y_even_x_coord_y, odd_y_even_x_coord_x)
- canvas = torch.cat([cur_canvas[:, :, :patch_size_y // 2, :canvas.shape[3]], canvas], dim=2)
- if is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, :canvas.shape[3]]], dim=2)
- if not is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- if even_idx_y.shape[0] > 0 and odd_idx_x.shape[0] > 0:
- canvas = partial_render(cur_canvas, even_y_odd_x_coord_y, even_y_odd_x_coord_x)
- canvas = torch.cat([cur_canvas[:, :, :canvas.shape[2], :patch_size_x // 2], canvas], dim=3)
- if not is_odd_y:
- canvas = torch.cat([canvas, cur_canvas[:, :, -patch_size_y // 2:, -canvas.shape[3]:]], dim=2)
- if is_odd_x:
- canvas = torch.cat([canvas, cur_canvas[:, :, :canvas.shape[2], -patch_size_x // 2:]], dim=3)
- cur_canvas = canvas
- cur_canvas = cur_canvas[:, :, patch_size_y // 4:-patch_size_y // 4, patch_size_x // 4:-patch_size_x // 4]
- return cur_canvas
-def read_img(img_path, img_type='RGB', h=None, w=None):
- img = Image.open(img_path).convert(img_type)
- if h is not None and w is not None:
- img = img.resize((w, h), resample=Image.NEAREST)
- img = np.array(img)
- if img.ndim == 2:
- img = np.expand_dims(img, axis=-1)
- img = img.transpose((2, 0, 1))
- img = torch.from_numpy(img).unsqueeze(0).float() / 255.
- return img
-def pad(img, H, W):
- b, c, h, w = img.shape
- pad_h = (H - h) // 2
- pad_w = (W - w) // 2
- remainder_h = (H - h) % 2
- remainder_w = (W - w) % 2
- img = torch.cat([torch.zeros((b, c, pad_h, w), device=img.device), img,
- torch.zeros((b, c, pad_h + remainder_h, w), device=img.device)], dim=-2)
- img = torch.cat([torch.zeros((b, c, H, pad_w), device=img.device), img,
- torch.zeros((b, c, H, pad_w + remainder_w), device=img.device)], dim=-1)
- return img
-def crop(img, h, w):
- H, W = img.shape[-2:]
- pad_h = (H - h) // 2
- pad_w = (W - w) // 2
- remainder_h = (H - h) % 2
- remainder_w = (W - w) % 2
- img = img[:, :, pad_h:H - pad_h - remainder_h, pad_w:W - pad_w - remainder_w]
- return img
-def main(input_path, model_path, output_dir, need_animation=False, resize_h=None, resize_w=None, serial=False):
- if not os.path.exists(output_dir):
- os.mkdir(output_dir)
- for entry in os.listdir(output_dir):
- path = os.path.join(output_dir, entry)
- stats = os.stat(path)
- created_time = datetime.fromtimestamp(stats[ST_CTIME])
- if created_time < datetime.now() - timedelta(minutes = 10):
- if os.path.isdir(path):
- shutil.rmtree(path)
- else:
- os.remove(path)
-
-
- input_name = os.path.basename(input_path)
- output_path = os.path.join(output_dir, input_name)
- frame_dir = None
- if need_animation:
- if not serial:
- print('It must be under serial mode if animation results are required, so serial flag is set to True!')
- serial = True
- frame_dir = os.path.join(output_dir, input_name[:input_name.find('.')])
- if not os.path.exists(frame_dir):
- os.mkdir(frame_dir)
- patch_size = 32
- stroke_num = 8
- device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
- net_g = network.Painter(5, stroke_num, 256, 8, 3, 3).to(device)
- net_g.load_state_dict(torch.load(model_path))
- net_g.eval()
- for param in net_g.parameters():
- param.requires_grad = False
- brush_large_vertical = read_img('brush/brush_large_vertical.png', 'L').to(device)
- brush_large_horizontal = read_img('brush/brush_large_horizontal.png', 'L').to(device)
- meta_brushes = torch.cat(
- [brush_large_vertical, brush_large_horizontal], dim=0)
- with torch.no_grad():
- original_img = read_img(input_path, 'RGB', resize_h, resize_w).to(device)
- original_h, original_w = original_img.shape[-2:]
- K = max(math.ceil(math.log2(max(original_h, original_w) / patch_size)), 0)
- original_img_pad_size = patch_size * (2 ** K)
- original_img_pad = pad(original_img, original_img_pad_size, original_img_pad_size)
- final_result = torch.zeros_like(original_img_pad).to(device)
- all_frames = []
- for layer in range(0, K + 1):
- layer_size = patch_size * (2 ** layer)
- img = F.interpolate(original_img_pad, (layer_size, layer_size))
- result = F.interpolate(final_result, (patch_size * (2 ** layer), patch_size * (2 ** layer)))
- img_patch = F.unfold(img, (patch_size, patch_size), stride=(patch_size, patch_size))
- result_patch = F.unfold(result, (patch_size, patch_size),
- stride=(patch_size, patch_size))
- # There are patch_num * patch_num patches in total
- patch_num = (layer_size - patch_size) // patch_size + 1
- # img_patch, result_patch: b, 3 * output_size * output_size, h * w
- img_patch = img_patch.permute(0, 2, 1).contiguous().view(-1, 3, patch_size, patch_size).contiguous()
- result_patch = result_patch.permute(0, 2, 1).contiguous().view(
- -1, 3, patch_size, patch_size).contiguous()
- shape_param, stroke_decision = net_g(img_patch, result_patch)
- stroke_decision = network.SignWithSigmoidGrad.apply(stroke_decision)
- grid = shape_param[:, :, :2].view(img_patch.shape[0] * stroke_num, 1, 1, 2).contiguous()
- img_temp = img_patch.unsqueeze(1).contiguous().repeat(1, stroke_num, 1, 1, 1).view(
- img_patch.shape[0] * stroke_num, 3, patch_size, patch_size).contiguous()
- color = F.grid_sample(img_temp, 2 * grid - 1, align_corners=False).view(
- img_patch.shape[0], stroke_num, 3).contiguous()
- stroke_param = torch.cat([shape_param, color], dim=-1)
- # stroke_param: b * h * w, stroke_per_patch, param_per_stroke
- # stroke_decision: b * h * w, stroke_per_patch, 1
- param = stroke_param.view(1, patch_num, patch_num, stroke_num, 8).contiguous()
- decision = stroke_decision.view(1, patch_num, patch_num, stroke_num).contiguous().bool()
- # param: b, h, w, stroke_per_patch, 8
- # decision: b, h, w, stroke_per_patch
- param[..., :2] = param[..., :2] / 2 + 0.25
- param[..., 2:4] = param[..., 2:4] / 2
- if serial:
- final_result = param2img_serial(param, decision, meta_brushes, final_result,
- frame_dir, False, original_h, original_w, all_frames = all_frames)
- else:
- final_result = param2img_parallel(param, decision, meta_brushes, final_result)
- border_size = original_img_pad_size // (2 * patch_num)
- img = F.interpolate(original_img_pad, (patch_size * (2 ** layer), patch_size * (2 ** layer)))
- result = F.interpolate(final_result, (patch_size * (2 ** layer), patch_size * (2 ** layer)))
- img = F.pad(img, [patch_size // 2, patch_size // 2, patch_size // 2, patch_size // 2,
- 0, 0, 0, 0])
- result = F.pad(result, [patch_size // 2, patch_size // 2, patch_size // 2, patch_size // 2,
- 0, 0, 0, 0])
- img_patch = F.unfold(img, (patch_size, patch_size), stride=(patch_size, patch_size))
- result_patch = F.unfold(result, (patch_size, patch_size), stride=(patch_size, patch_size))
- final_result = F.pad(final_result, [border_size, border_size, border_size, border_size, 0, 0, 0, 0])
- h = (img.shape[2] - patch_size) // patch_size + 1
- w = (img.shape[3] - patch_size) // patch_size + 1
- # img_patch, result_patch: b, 3 * output_size * output_size, h * w
- img_patch = img_patch.permute(0, 2, 1).contiguous().view(-1, 3, patch_size, patch_size).contiguous()
- result_patch = result_patch.permute(0, 2, 1).contiguous().view(-1, 3, patch_size, patch_size).contiguous()
- shape_param, stroke_decision = net_g(img_patch, result_patch)
- grid = shape_param[:, :, :2].view(img_patch.shape[0] * stroke_num, 1, 1, 2).contiguous()
- img_temp = img_patch.unsqueeze(1).contiguous().repeat(1, stroke_num, 1, 1, 1).view(
- img_patch.shape[0] * stroke_num, 3, patch_size, patch_size).contiguous()
- color = F.grid_sample(img_temp, 2 * grid - 1, align_corners=False).view(
- img_patch.shape[0], stroke_num, 3).contiguous()
- stroke_param = torch.cat([shape_param, color], dim=-1)
- # stroke_param: b * h * w, stroke_per_patch, param_per_stroke
- # stroke_decision: b * h * w, stroke_per_patch, 1
- param = stroke_param.view(1, h, w, stroke_num, 8).contiguous()
- decision = stroke_decision.view(1, h, w, stroke_num).contiguous().bool()
- # param: b, h, w, stroke_per_patch, 8
- # decision: b, h, w, stroke_per_patch
- param[..., :2] = param[..., :2] / 2 + 0.25
- param[..., 2:4] = param[..., 2:4] / 2
- if serial:
- final_result = param2img_serial(param, decision, meta_brushes, final_result,
- frame_dir, True, original_h, original_w, all_frames = all_frames)
- else:
- final_result = param2img_parallel(param, decision, meta_brushes, final_result)
- final_result = final_result[:, :, border_size:-border_size, border_size:-border_size]
- final_result = crop(final_result, original_h, original_w)
- save_img(final_result[0], output_path)
- tensor_to_pil = transforms.ToPILImage()(final_result[0].squeeze_(0))
- #return tensor_to_pil
- all_frames[0].save(os.path.join(frame_dir, 'animation.gif'),
- save_all=True, append_images=all_frames[1:], optimize=False, duration=40, loop=0)
- return os.path.join(frame_dir, "animation.gif"), tensor_to_pil
-
-def gradio_inference(image):
- return main(input_path=image.name,
- model_path='model.pth',
- output_dir='output/',
- need_animation=True, # whether need intermediate results for animation.
- resize_h=400, # resize original input to this size. None means do not resize.
- resize_w=400, # resize original input to this size. None means do not resize.
- serial=True) # if need animation, serial must be True.
-
-title = "Paint Transformer"
-description = "Gradio demo for Paint Transformer: Feed Forward Neural Painting with Stroke Prediction. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below."
-article = "Paint Transformer: Feed Forward Neural Painting with Stroke Prediction | Github Repo
"
-gr.Interface(
- gradio_inference,
- gr.inputs.Image(type="file", label="Input"),
- [gr.outputs.Image(type="file", label="Output GIF"),
- gr.outputs.Image(type="pil", label="Output Image")],
- title=title,
- description=description,
- article=article,
- examples=[
- ['city.jpg'],
- ['tower.jpg'],
- ]
- ).launch(enable_queue=True,cache_examples=True)
\ No newline at end of file
diff --git a/spaces/akhaliq/deeplab2/tensorflow_ops/python/kernel_tests/merge_semantic_and_instance_maps_op_test.py b/spaces/akhaliq/deeplab2/tensorflow_ops/python/kernel_tests/merge_semantic_and_instance_maps_op_test.py
deleted file mode 100644
index c38d21c06d7eb113dbce0023edd5d03b532e576d..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/deeplab2/tensorflow_ops/python/kernel_tests/merge_semantic_and_instance_maps_op_test.py
+++ /dev/null
@@ -1,242 +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.
-
-r"""Tests for merge_semantic_and_instance_maps_op."""
-
-import numpy as np
-import tensorflow as tf
-from deeplab2.tensorflow_ops.python.ops import merge_semantic_and_instance_maps_op
-
-
-class MergeSemanticAndInstanceMapsOpTest(tf.test.TestCase):
-
- def testMergeSemanticAndInstanceMaps(self):
- """Test the op with 2 images."""
- batch = 2
- height = 4
- width = 4
-
- # Create the instance labels.
- instance_maps = np.zeros((batch, height, width), dtype=np.int32)
- instance_maps[0, :, :] = np.array([[0, 2, 1, 0], [0, 1, 1, 0], [2, 0, 1, 2],
- [0, 0, 1, 1]])
- instance_maps[1, :, :] = np.array([[1, 2, 3, 1], [0, 2, 1, 3], [0, 2, 2, 0],
- [3, 3, 2, 0]])
-
- # Create the semantic labels.
- # The instances with the instance label equal to 0 and 2 have the same
- # semantic label. The other instances all have different semantic labels.
- semantic_maps = np.zeros((batch, height, width), dtype=np.int32)
- # Instance 0 has 4 pixels predicted as 0 and 3 pixels predicted as 3.
- # Instance 1 has 6 pixels predicted as 1.
- # Instance 2 has 2 pixels predicted as 0 and 1 pixel predicted as 3.
- semantic_maps[0, :, :] = np.array([[0, 0, 1, 0], [0, 1, 1, 0], [3, 3, 1, 0],
- [3, 3, 1, 1]])
- # Instance 0 has 3 pixels predicted as 0 and 1 pixel predicted as 3.
- # Instance 1 has 3 pixels predicted as 1.
- # Instance 2 has 3 pixels predicted as 0 and 2 pixels predicted as 2.
- # Instance 3 has 1 pixel predicted as 0 and 3 pixels predicted as 2.
- semantic_maps[1, :, :] = np.array([[1, 0, 2, 1], [0, 0, 1, 2], [0, 2, 2, 3],
- [0, 2, 0, 0]])
-
- # Create the ID list for things.
- thing_ids = [0, 2]
-
- # Groundtruth semantic segmentation maps after majority voting.
- gt_semantic_maps = np.zeros((batch, height, width), dtype=np.int32)
- gt_semantic_maps[0, :, :] = np.array([[0, 0, 1, 0], [0, 1, 1, 0],
- [3, 3, 1, 0], [3, 3, 1, 1]])
- # Instance 2 takes semantic label 0 after majority voting.
- # Instance 3 takes semantic label 2 after majority voting.
- gt_semantic_maps[1, :, :] = np.array([[1, 0, 2, 1], [0, 0, 1, 2],
- [0, 0, 0, 3], [2, 2, 0, 0]])
- # Groundtruth instance segmentation maps.
- gt_instance_maps = np.zeros((batch, 2, height, width), dtype=np.int32)
-
- # There are two cases for gt_instance_maps in batch 1.
- # Case 1:
- # Instance 0 is re-assigned instance label 1.
- # Instance 2 is re-assigned instance label 2.
- gt_instance_maps[0, 0, :, :] = np.array([[1, 2, 0, 1], [1, 0, 0, 1],
- [0, 0, 0, 2], [0, 0, 0, 0]])
- # Case 2:
- # Instance 0 is re-assigned instance label 2.
- # Instance 2 is re-assigned instance label 1.
- gt_instance_maps[0, 1, :, :] = np.array([[2, 1, 0, 2], [2, 0, 0, 2],
- [0, 0, 0, 1], [0, 0, 0, 0]])
- # There are two cases for gt_instance_maps in batch 2.
- # Case 1:
- # Instance 0 is re-assigned instance label 1.
- # Instance 2 is re-assigned instance label 2.
- # Instance 3 is re-assigned instance label 1.
- gt_instance_maps[1, 0, :, :] = np.array([[0, 2, 1, 0], [1, 2, 0, 1],
- [1, 2, 2, 0], [1, 1, 2, 1]])
- # Case 2:
- # Instance 0 is re-assigned instance label 2.
- # Instance 2 is re-assigned instance label 1.
- # Instance 3 is re-assigned instance label 1.
- gt_instance_maps[1, 1, :, :] = np.array([[0, 1, 1, 0], [2, 1, 0, 1],
- [2, 1, 1, 0], [1, 1, 1, 2]])
- # Groundtruth parsing maps.
- label_divisor = 256
-
- # Run the op.
- parsing_maps = (
- merge_semantic_and_instance_maps_op.merge_semantic_and_instance_maps(
- semantic_maps,
- instance_maps,
- thing_ids,
- label_divisor=label_divisor))
- pass_test = False
- for i in range(2):
- for j in range(2):
- current_gt_instance_maps = np.stack(
- [gt_instance_maps[0, i, :, :], gt_instance_maps[1, j, :, :]],
- axis=0)
- gt_parsing_maps = (
- gt_semantic_maps * label_divisor + current_gt_instance_maps)
- if np.array_equal(parsing_maps, gt_parsing_maps):
- pass_test = True
- self.assertTrue(pass_test)
-
- def testMergeSemanticAndInstanceMapsWithStuffAreaLimit(self):
- batch = 1
- height = 4
- width = 4
-
- # Create the instance labels.
- instance_maps = np.zeros((batch, height, width), dtype=np.int32)
- instance_maps[0, :, :] = np.array([[0, 0, 0, 0],
- [0, 0, 1, 1],
- [0, 0, 0, 0],
- [0, 0, 0, 0]])
-
- # Create the semantic labels.
- semantic_maps = np.zeros((batch, height, width), dtype=np.int32)
- semantic_maps[0, :, :] = np.array([[0, 0, 0, 0],
- [0, 0, 1, 1],
- [0, 0, 2, 2],
- [0, 0, 2, 2]])
- thing_ids = [0, 2]
- stuff_area_limit = 3
- void_label = 3
- # Groundtruth semantic segmentation maps after majority voting.
- # Instance 0 takes semantic label 0.
- # Instance 1 is re-assigned with void label.
- gt_semantic_maps = np.zeros((batch, height, width), dtype=np.int32)
- gt_semantic_maps[0, :, :] = np.array([[0, 0, 0, 0],
- [0, 0, void_label, void_label],
- [0, 0, 0, 0],
- [0, 0, 0, 0]])
- # Groundtruth instance segmentation maps.
- gt_instance_maps = np.zeros((batch, height, width), dtype=np.int32)
- gt_instance_maps[0, :, :] = np.array([[1, 1, 1, 1],
- [1, 1, 0, 0],
- [1, 1, 1, 1],
- [1, 1, 1, 1]])
- label_divisor = 256
- gt_parsing_maps = gt_semantic_maps * label_divisor + gt_instance_maps
-
- # Run the op.
- parsing_maps = (
- merge_semantic_and_instance_maps_op.merge_semantic_and_instance_maps(
- semantic_maps,
- instance_maps,
- thing_ids,
- label_divisor=label_divisor,
- stuff_area_limit=stuff_area_limit,
- void_label=void_label))
- self.assertTrue(np.array_equal(parsing_maps, gt_parsing_maps))
-
-
-class MergeSemanticAndInstanceMapsOpGpuTest(MergeSemanticAndInstanceMapsOpTest):
-
- def session(self, use_gpu=True):
- return super(MergeSemanticAndInstanceMapsOpGpuTest,
- self).session(use_gpu=use_gpu)
-
- def testMergeSemanticAndInstanceMapsWithRandomInputs(self):
- batch = 1
- height = 1441
- width = 1441
- rng = np.random.RandomState(0)
- instance_maps = rng.randint(0, 255, (batch, height, width), dtype=np.int32)
- semantic_maps = rng.randint(0, 3, (batch, height, width), dtype=np.int32)
-
- thing_ids = [0, 2]
- stuff_area_limit = 400
- void_label = 3
- label_divisor = 256
-
- with self.session(use_gpu=False):
- parsing_maps_cpu = (
- merge_semantic_and_instance_maps_op.merge_semantic_and_instance_maps(
- semantic_maps,
- instance_maps,
- thing_ids,
- label_divisor=label_divisor,
- stuff_area_limit=stuff_area_limit,
- void_label=void_label))
- parsing_maps_cpu = parsing_maps_cpu.numpy()
-
- with self.session():
- parsing_maps_gpu = (
- merge_semantic_and_instance_maps_op.merge_semantic_and_instance_maps(
- semantic_maps,
- instance_maps,
- thing_ids,
- label_divisor=label_divisor,
- stuff_area_limit=stuff_area_limit,
- void_label=void_label))
- parsing_maps_gpu = parsing_maps_gpu.numpy()
-
- # Checks semantic maps are the same.
- semantic_maps_cpu = parsing_maps_cpu // label_divisor
- semantic_maps_gpu = parsing_maps_gpu // label_divisor
- np.testing.assert_array_equal(semantic_maps_cpu, semantic_maps_gpu)
-
- # Checks instance maps are the same, despite of label order.
- instance_maps_cpu = parsing_maps_cpu % label_divisor
- instance_maps_gpu = parsing_maps_gpu % label_divisor
-
- thing_labels_cpu = np.unique(semantic_maps_cpu[instance_maps_cpu > 0])
- for semantic_label in thing_labels_cpu:
- semantic_mask = semantic_maps_cpu == semantic_label
- instance_labels_cpu = np.unique(instance_maps_cpu[semantic_mask])
- instance_labels_gpu = np.unique(instance_maps_gpu[semantic_mask])
-
- self.assertEqual(len(instance_labels_cpu), len(instance_labels_gpu))
-
- # For each instance (cpu reference) of this semantic label, we check:
- # 1. Within this instance mask, GPU produces one and only one instance
- # label.
- # 2. GPU results with the current semantic and instance label matches
- # CPU instance mask.
- for instance_label in instance_labels_cpu:
- instance_mask_cpu = np.logical_and(
- instance_maps_cpu == instance_label, semantic_mask)
- instance_labels_gpu = set(instance_maps_gpu[instance_mask_cpu])
- self.assertLen(instance_labels_gpu, 1)
-
- instance_label_gpu = instance_labels_gpu.pop()
- # Here GPU must use the same semantic mask (given we have checked
- # semantic maps are the same).
- instance_mask_gpu = np.logical_and(
- instance_maps_gpu == instance_label_gpu, semantic_mask)
- np.testing.assert_array_equal(instance_mask_cpu, instance_mask_gpu)
-
-
-if __name__ == '__main__':
- tf.test.main()
diff --git a/spaces/akshayvkt/talk-To-SteveJobs/app.py b/spaces/akshayvkt/talk-To-SteveJobs/app.py
deleted file mode 100644
index 6ed19e5c1fc94b225101c286a4d725787989ca76..0000000000000000000000000000000000000000
--- a/spaces/akshayvkt/talk-To-SteveJobs/app.py
+++ /dev/null
@@ -1,91 +0,0 @@
-import gradio as gr
-import openai
-import requests
-import json
-import os
-
-openai.api_key = os.environ.get('OPENAI_API_KEY')
-
-
-messages = [{"role": "system", "content": 'You are Steve Jobs. Respond to all input in 25 words or less.'}]
-
-# Set up the API endpoint URL and headers
-url = f"https://api.elevenlabs.io/v1/text-to-speech/{os.environ.get('voice_id')}/stream"
-headers = {
- "accept": "*/*",
- "xi-api-key": os.environ.get('elevenlabs_api_key'),
- "Content-Type": "application/json",
-}
-
-# Define a function to handle the Gradio input and generate the response
-def transcribe(audio):
- global messages
-
- # Use OpenAI to transcribe the user's audio input
- # API call 1
- audio_file = open(audio, "rb")
- transcript = openai.Audio.transcribe("whisper-1", audio_file)
-
- # Append the user's message to the message history
- messages.append({"role": "user", "content": transcript["text"]})
-
- # Generate a response using OpenAI's chat API
- #API call 2
- response = openai.ChatCompletion.create(model="gpt-3.5-turbo", messages=messages)
-
- # Extract the system message from the API response and append it to the message history
- system_message = response["choices"][0]["message"]
- messages.append(system_message)
-
-
- #API Call 3
- # Use the voice synthesis API to generate an audio response from the system message
- data = {
- "text": system_message["content"],
- "voice_settings": {
- "stability": 0,
- "similarity_boost": 0
- }
- }
- response = requests.post(url, headers=headers, data=json.dumps(data), stream=True)
-
- # Save the audio response to a file
- if response.ok:
- with open("output.wav", "wb") as f:
- for chunk in response.iter_content(chunk_size=1024):
- f.write(chunk)
- else:
- print(f"Error: {response.status_code} - {response.reason}")
-
- # IPython.display.display(IPython.display.Audio('output.wav'))
-
- # Generate a chat transcript for display in the Gradio UI
- chat_transcript = ""
- for message in messages:
- if message['role'] != 'system':
- chat_transcript += message['role'] + ": " + message['content'] + "\n\n"
-
- return chat_transcript,'output.wav'
-
-# css = """
-# #col-container {max-width: 80%; margin-left: auto; margin-right: auto;}
-# #header {text-align: center;}
-# }
-# """
-
-# with gr.Blocks(css=css) as ui:
-
-
-# with gr.Column(elem_id="col-container"):
-# gr.Markdown("""## Talk to AI Steve Jobs: Audio-to-Text+Audio generation
-# Powered by ChatGPT + Whisper + ElevenLabs + HuggingFace
-#
-# """,
-# elem_id="header")
-
-# Define the Gradio UI interface
-# ui = gr.Interface(fn=transcribe, inputs=gr.Audio(source="microphone", type="filepath"), outputs="text")
-ui = gr.Interface(fn=transcribe, inputs=gr.Audio(source="microphone", type="filepath"), outputs=['text','audio'],title='Talk to AI Steve Jobs', description = """Click on Record from microphone and start speaking,
-and when you're done, click on Stop Recording. Then click on Submit. AI Steve will then answer your question. You can continue to ask follow-up questions by clicking on Clear, and then
-using Record from microphone -> Stop Recording -> Submit AI Steve Jobs will also remember the previous questions and answers.""")
-ui.launch(debug=True)
diff --git a/spaces/alexrame/rewardedsoups/streamlit_app/data/locomotion/trajectories/17.html b/spaces/alexrame/rewardedsoups/streamlit_app/data/locomotion/trajectories/17.html
deleted file mode 100644
index 2988216ba8c52c0230b7feb1e52ae07f3d431230..0000000000000000000000000000000000000000
--- a/spaces/alexrame/rewardedsoups/streamlit_app/data/locomotion/trajectories/17.html
+++ /dev/null
@@ -1,48 +0,0 @@
-
-
-
- brax visualizer
-
-
-
-
-
-
-
-
diff --git a/spaces/amarchheda/ChordDuplicate/portaudio/qa/loopback/src/paqa.c b/spaces/amarchheda/ChordDuplicate/portaudio/qa/loopback/src/paqa.c
deleted file mode 100644
index 5eb628336263deb58540cda7f8401f30a720f799..0000000000000000000000000000000000000000
--- a/spaces/amarchheda/ChordDuplicate/portaudio/qa/loopback/src/paqa.c
+++ /dev/null
@@ -1,1601 +0,0 @@
-
-/*
- * PortAudio Portable Real-Time Audio Library
- * Latest Version at: http://www.portaudio.com
- *
- * Copyright (c) 1999-2010 Phil Burk and Ross Bencina
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * 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.
- */
-
-/*
- * The text above constitutes the entire PortAudio license; however,
- * the PortAudio community also makes the following non-binding requests:
- *
- * Any person wishing to distribute modifications to the Software is
- * requested to send the modifications to the original developer so that
- * they can be incorporated into the canonical version. It is also
- * requested that these non-binding requests be included along with the
- * license above.
- */
-
-#include
-#include
-#include
-#include
-#include
-
-#include "portaudio.h"
-
-#include "qa_tools.h"
-
-#include "paqa_tools.h"
-#include "audio_analyzer.h"
-#include "test_audio_analyzer.h"
-
-/** Accumulate counts for how many tests pass or fail. */
-int g_testsPassed = 0;
-int g_testsFailed = 0;
-
-#define MAX_NUM_GENERATORS (8)
-#define MAX_NUM_RECORDINGS (8)
-#define MAX_BACKGROUND_NOISE_RMS (0.0004)
-#define LOOPBACK_DETECTION_DURATION_SECONDS (0.8)
-#define DEFAULT_FRAMES_PER_BUFFER (0)
-#define PAQA_WAIT_STREAM_MSEC (100)
-#define PAQA_TEST_DURATION (1.2)
-
-// Use two separate streams instead of one full duplex stream.
-#define PAQA_FLAG_TWO_STREAMS (1<<0)
-// Use bloching read/write for loopback.
-#define PAQA_FLAG_USE_BLOCKING_IO (1<<1)
-
-const char * s_FlagOnNames[] =
-{
- "Two Streams (Half Duplex)",
- "Blocking Read/Write"
-};
-
-const char * s_FlagOffNames[] =
-{
- "One Stream (Full Duplex)",
- "Callback"
-};
-
-
-/** Parameters that describe a single test run. */
-typedef struct TestParameters_s
-{
- PaStreamParameters inputParameters;
- PaStreamParameters outputParameters;
- double sampleRate;
- int samplesPerFrame;
- int framesPerBuffer;
- int maxFrames;
- double baseFrequency;
- double amplitude;
- PaStreamFlags streamFlags; // paClipOff, etc
- int flags; // PAQA_FLAG_TWO_STREAMS, PAQA_FLAG_USE_BLOCKING_IO
-} TestParameters;
-
-typedef struct LoopbackContext_s
-{
- // Generate a unique signal on each channel.
- PaQaSineGenerator generators[MAX_NUM_GENERATORS];
- // Record each channel individually.
- PaQaRecording recordings[MAX_NUM_RECORDINGS];
-
- // Reported by the stream after it's opened
- PaTime streamInfoInputLatency;
- PaTime streamInfoOutputLatency;
-
- // Measured at runtime.
- volatile int callbackCount; // incremented for each callback
- volatile int inputBufferCount; // incremented if input buffer not NULL
- int inputUnderflowCount;
- int inputOverflowCount;
-
- volatile int outputBufferCount; // incremented if output buffer not NULL
- int outputOverflowCount;
- int outputUnderflowCount;
-
- // Measure whether input or output is lagging behind.
- volatile int minInputOutputDelta;
- volatile int maxInputOutputDelta;
-
- int minFramesPerBuffer;
- int maxFramesPerBuffer;
- int primingCount;
- TestParameters *test;
- volatile int done;
-} LoopbackContext;
-
-typedef struct UserOptions_s
-{
- int sampleRate;
- int framesPerBuffer;
- int inputLatency;
- int outputLatency;
- int saveBadWaves;
- int verbose;
- int waveFileCount;
- const char *waveFilePath;
- PaDeviceIndex inputDevice;
- PaDeviceIndex outputDevice;
-} UserOptions;
-
-#define BIG_BUFFER_SIZE (sizeof(float) * 2 * 2 * 1024)
-static unsigned char g_ReadWriteBuffer[BIG_BUFFER_SIZE];
-
-#define MAX_CONVERSION_SAMPLES (2 * 32 * 1024)
-#define CONVERSION_BUFFER_SIZE (sizeof(float) * 2 * MAX_CONVERSION_SAMPLES)
-static unsigned char g_ConversionBuffer[CONVERSION_BUFFER_SIZE];
-
-/*******************************************************************/
-static int RecordAndPlaySinesCallback( const void *inputBuffer, void *outputBuffer,
- unsigned long framesPerBuffer,
- const PaStreamCallbackTimeInfo* timeInfo,
- PaStreamCallbackFlags statusFlags,
- void *userData )
-{
- int i;
- LoopbackContext *loopbackContext = (LoopbackContext *) userData;
-
-
- loopbackContext->callbackCount += 1;
- if( statusFlags & paInputUnderflow ) loopbackContext->inputUnderflowCount += 1;
- if( statusFlags & paInputOverflow ) loopbackContext->inputOverflowCount += 1;
- if( statusFlags & paOutputUnderflow ) loopbackContext->outputUnderflowCount += 1;
- if( statusFlags & paOutputOverflow ) loopbackContext->outputOverflowCount += 1;
- if( statusFlags & paPrimingOutput ) loopbackContext->primingCount += 1;
- if( framesPerBuffer > loopbackContext->maxFramesPerBuffer )
- {
- loopbackContext->maxFramesPerBuffer = framesPerBuffer;
- }
- if( framesPerBuffer < loopbackContext->minFramesPerBuffer )
- {
- loopbackContext->minFramesPerBuffer = framesPerBuffer;
- }
-
- /* This may get called with NULL inputBuffer during initial setup.
- * We may also use the same callback with output only streams.
- */
- if( inputBuffer != NULL)
- {
- int channelsPerFrame = loopbackContext->test->inputParameters.channelCount;
- float *in = (float *)inputBuffer;
- PaSampleFormat inFormat = loopbackContext->test->inputParameters.sampleFormat;
-
- loopbackContext->inputBufferCount += 1;
-
- if( inFormat != paFloat32 )
- {
- int samplesToConvert = framesPerBuffer * channelsPerFrame;
- in = (float *) g_ConversionBuffer;
- if( samplesToConvert > MAX_CONVERSION_SAMPLES )
- {
- // Hack to prevent buffer overflow.
- // @todo Loop with small buffer instead of failing.
- printf("Format conversion buffer too small!\n");
- return paComplete;
- }
- PaQa_ConvertToFloat( inputBuffer, samplesToConvert, inFormat, (float *) g_ConversionBuffer );
- }
-
- // Read each channel from the buffer.
- for( i=0; idone |= PaQa_WriteRecording( &loopbackContext->recordings[i],
- in + i,
- framesPerBuffer,
- channelsPerFrame );
- }
- }
-
- if( outputBuffer != NULL )
- {
- int channelsPerFrame = loopbackContext->test->outputParameters.channelCount;
- float *out = (float *)outputBuffer;
- PaSampleFormat outFormat = loopbackContext->test->outputParameters.sampleFormat;
-
- loopbackContext->outputBufferCount += 1;
-
- if( outFormat != paFloat32 )
- {
- // If we need to convert then mix to the g_ConversionBuffer and then convert into the PA outputBuffer.
- out = (float *) g_ConversionBuffer;
- }
-
- PaQa_EraseBuffer( out, framesPerBuffer, channelsPerFrame );
- for( i=0; igenerators[i],
- out + i,
- framesPerBuffer,
- channelsPerFrame );
- }
-
- if( outFormat != paFloat32 )
- {
- int samplesToConvert = framesPerBuffer * channelsPerFrame;
- if( samplesToConvert > MAX_CONVERSION_SAMPLES )
- {
- printf("Format conversion buffer too small!\n");
- return paComplete;
- }
- PaQa_ConvertFromFloat( out, framesPerBuffer * channelsPerFrame, outFormat, outputBuffer );
- }
-
- }
-
- // Measure whether the input or output are lagging behind.
- // Don't measure lag at end.
- if( !loopbackContext->done )
- {
- int inputOutputDelta = loopbackContext->inputBufferCount - loopbackContext->outputBufferCount;
- if( loopbackContext->maxInputOutputDelta < inputOutputDelta )
- {
- loopbackContext->maxInputOutputDelta = inputOutputDelta;
- }
- if( loopbackContext->minInputOutputDelta > inputOutputDelta )
- {
- loopbackContext->minInputOutputDelta = inputOutputDelta;
- }
- }
-
- return loopbackContext->done ? paComplete : paContinue;
-}
-
-static void CopyStreamInfoToLoopbackContext( LoopbackContext *loopbackContext, PaStream *inputStream, PaStream *outputStream )
-{
- const PaStreamInfo *inputStreamInfo = Pa_GetStreamInfo( inputStream );
- const PaStreamInfo *outputStreamInfo = Pa_GetStreamInfo( outputStream );
-
- loopbackContext->streamInfoInputLatency = inputStreamInfo ? inputStreamInfo->inputLatency : -1;
- loopbackContext->streamInfoOutputLatency = outputStreamInfo ? outputStreamInfo->outputLatency : -1;
-}
-
-/*******************************************************************/
-/**
- * Open a full duplex audio stream.
- * Generate sine waves on the output channels and record the input channels.
- * Then close the stream.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunLoopbackFullDuplex( LoopbackContext *loopbackContext )
-{
- PaStream *stream = NULL;
- PaError err = 0;
- TestParameters *test = loopbackContext->test;
- loopbackContext->done = 0;
- // Use one full duplex stream.
- err = Pa_OpenStream(
- &stream,
- &test->inputParameters,
- &test->outputParameters,
- test->sampleRate,
- test->framesPerBuffer,
- paClipOff, /* we won't output out of range samples so don't bother clipping them */
- RecordAndPlaySinesCallback,
- loopbackContext );
- if( err != paNoError ) goto error;
-
- CopyStreamInfoToLoopbackContext( loopbackContext, stream, stream );
-
- err = Pa_StartStream( stream );
- if( err != paNoError ) goto error;
-
- // Wait for stream to finish.
- while( loopbackContext->done == 0 )
- {
- Pa_Sleep(PAQA_WAIT_STREAM_MSEC);
- }
-
- err = Pa_StopStream( stream );
- if( err != paNoError ) goto error;
-
- err = Pa_CloseStream( stream );
- if( err != paNoError ) goto error;
-
- return 0;
-
-error:
- return err;
-}
-
-/*******************************************************************/
-/**
- * Open two audio streams, one for input and one for output.
- * Generate sine waves on the output channels and record the input channels.
- * Then close the stream.
- * @return 0 if OK or paTimedOut.
- */
-
-int PaQa_WaitForStream( LoopbackContext *loopbackContext )
-{
- int timeoutMSec = 1000 * PAQA_TEST_DURATION * 2;
-
- // Wait for stream to finish or timeout.
- while( (loopbackContext->done == 0) && (timeoutMSec > 0) )
- {
- Pa_Sleep(PAQA_WAIT_STREAM_MSEC);
- timeoutMSec -= PAQA_WAIT_STREAM_MSEC;
- }
-
- if( loopbackContext->done == 0 )
- {
- printf("ERROR - stream completion timed out!");
- return paTimedOut;
- }
- return 0;
-}
-
-/*******************************************************************/
-/**
- * Open two audio streams, one for input and one for output.
- * Generate sine waves on the output channels and record the input channels.
- * Then close the stream.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunLoopbackHalfDuplex( LoopbackContext *loopbackContext )
-{
- PaStream *inStream = NULL;
- PaStream *outStream = NULL;
- PaError err = 0;
- int timedOut = 0;
- TestParameters *test = loopbackContext->test;
- loopbackContext->done = 0;
-
- // Use two half duplex streams.
- err = Pa_OpenStream(
- &inStream,
- &test->inputParameters,
- NULL,
- test->sampleRate,
- test->framesPerBuffer,
- test->streamFlags,
- RecordAndPlaySinesCallback,
- loopbackContext );
- if( err != paNoError ) goto error;
- err = Pa_OpenStream(
- &outStream,
- NULL,
- &test->outputParameters,
- test->sampleRate,
- test->framesPerBuffer,
- test->streamFlags,
- RecordAndPlaySinesCallback,
- loopbackContext );
- if( err != paNoError ) goto error;
-
- CopyStreamInfoToLoopbackContext( loopbackContext, inStream, outStream );
-
- err = Pa_StartStream( inStream );
- if( err != paNoError ) goto error;
-
- // Start output later so we catch the beginning of the waveform.
- err = Pa_StartStream( outStream );
- if( err != paNoError ) goto error;
-
- timedOut = PaQa_WaitForStream( loopbackContext );
-
- err = Pa_StopStream( inStream );
- if( err != paNoError ) goto error;
-
- err = Pa_StopStream( outStream );
- if( err != paNoError ) goto error;
-
- err = Pa_CloseStream( inStream );
- if( err != paNoError ) goto error;
-
- err = Pa_CloseStream( outStream );
- if( err != paNoError ) goto error;
-
- return timedOut;
-
-error:
- return err;
-}
-
-
-/*******************************************************************/
-/**
- * Open one audio streams, just for input.
- * Record background level.
- * Then close the stream.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunInputOnly( LoopbackContext *loopbackContext )
-{
- PaStream *inStream = NULL;
- PaError err = 0;
- int timedOut = 0;
- TestParameters *test = loopbackContext->test;
- loopbackContext->done = 0;
-
- // Just open an input stream.
- err = Pa_OpenStream(
- &inStream,
- &test->inputParameters,
- NULL,
- test->sampleRate,
- test->framesPerBuffer,
- paClipOff, /* We won't output out of range samples so don't bother clipping them. */
- RecordAndPlaySinesCallback,
- loopbackContext );
- if( err != paNoError ) goto error;
-
- err = Pa_StartStream( inStream );
- if( err != paNoError ) goto error;
-
- timedOut = PaQa_WaitForStream( loopbackContext );
-
- err = Pa_StopStream( inStream );
- if( err != paNoError ) goto error;
-
- err = Pa_CloseStream( inStream );
- if( err != paNoError ) goto error;
-
- return timedOut;
-
-error:
- return err;
-}
-
-/*******************************************************************/
-static int RecordAndPlayBlockingIO( PaStream *inStream,
- PaStream *outStream,
- LoopbackContext *loopbackContext
- )
-{
- int i;
- float *in = (float *)g_ReadWriteBuffer;
- float *out = (float *)g_ReadWriteBuffer;
- PaError err;
- int done = 0;
- long available;
- const long maxPerBuffer = 64;
- TestParameters *test = loopbackContext->test;
- long framesPerBuffer = test->framesPerBuffer;
- if( framesPerBuffer <= 0 )
- {
- framesPerBuffer = maxPerBuffer; // bigger values might run past end of recording
- }
-
- // Read in audio.
- err = Pa_ReadStream( inStream, in, framesPerBuffer );
- // Ignore an overflow on the first read.
- //if( !((loopbackContext->callbackCount == 0) && (err == paInputOverflowed)) )
- if( err != paInputOverflowed )
- {
- QA_ASSERT_EQUALS( "Pa_ReadStream failed", paNoError, err );
- }
- else
- {
- loopbackContext->inputOverflowCount += 1;
- }
-
-
- // Save in a recording.
- for( i=0; itest->inputParameters.channelCount; i++ )
- {
- done |= PaQa_WriteRecording( &loopbackContext->recordings[i],
- in + i,
- framesPerBuffer,
- loopbackContext->test->inputParameters.channelCount );
- }
-
- // Synthesize audio.
- available = Pa_GetStreamWriteAvailable( outStream );
- if( available > (2*framesPerBuffer) ) available = (2*framesPerBuffer);
- PaQa_EraseBuffer( out, available, loopbackContext->test->outputParameters.channelCount );
- for( i=0; itest->outputParameters.channelCount; i++ )
- {
- PaQa_MixSine( &loopbackContext->generators[i],
- out + i,
- available,
- loopbackContext->test->outputParameters.channelCount );
- }
-
- // Write out audio.
- err = Pa_WriteStream( outStream, out, available );
- // Ignore an underflow on the first write.
- //if( !((loopbackContext->callbackCount == 0) && (err == paOutputUnderflowed)) )
- if( err != paOutputUnderflowed )
- {
- QA_ASSERT_EQUALS( "Pa_WriteStream failed", paNoError, err );
- }
- else
- {
- loopbackContext->outputUnderflowCount += 1;
- }
-
-
- loopbackContext->callbackCount += 1;
-
- return done;
-error:
- return err;
-}
-
-
-/*******************************************************************/
-/**
- * Open two audio streams with non-blocking IO.
- * Generate sine waves on the output channels and record the input channels.
- * Then close the stream.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunLoopbackHalfDuplexBlockingIO( LoopbackContext *loopbackContext )
-{
- PaStream *inStream = NULL;
- PaStream *outStream = NULL;
- PaError err = 0;
- TestParameters *test = loopbackContext->test;
-
- // Use two half duplex streams.
- err = Pa_OpenStream(
- &inStream,
- &test->inputParameters,
- NULL,
- test->sampleRate,
- test->framesPerBuffer,
- paClipOff, /* we won't output out of range samples so don't bother clipping them */
- NULL, // causes non-blocking IO
- NULL );
- if( err != paNoError ) goto error1;
- err = Pa_OpenStream(
- &outStream,
- NULL,
- &test->outputParameters,
- test->sampleRate,
- test->framesPerBuffer,
- paClipOff, /* we won't output out of range samples so don't bother clipping them */
- NULL, // causes non-blocking IO
- NULL );
- if( err != paNoError ) goto error2;
-
- CopyStreamInfoToLoopbackContext( loopbackContext, inStream, outStream );
-
- err = Pa_StartStream( outStream );
- if( err != paNoError ) goto error3;
-
- err = Pa_StartStream( inStream );
- if( err != paNoError ) goto error3;
-
- while( err == 0 )
- {
- err = RecordAndPlayBlockingIO( inStream, outStream, loopbackContext );
- if( err < 0 ) goto error3;
- }
-
- err = Pa_StopStream( inStream );
- if( err != paNoError ) goto error3;
-
- err = Pa_StopStream( outStream );
- if( err != paNoError ) goto error3;
-
- err = Pa_CloseStream( outStream );
- if( err != paNoError ) goto error2;
-
- err = Pa_CloseStream( inStream );
- if( err != paNoError ) goto error1;
-
-
- return 0;
-
-error3:
- Pa_CloseStream( outStream );
-error2:
- Pa_CloseStream( inStream );
-error1:
- return err;
-}
-
-
-/*******************************************************************/
-/**
- * Open one audio stream with non-blocking IO.
- * Generate sine waves on the output channels and record the input channels.
- * Then close the stream.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunLoopbackFullDuplexBlockingIO( LoopbackContext *loopbackContext )
-{
- PaStream *stream = NULL;
- PaError err = 0;
- TestParameters *test = loopbackContext->test;
-
- // Use one full duplex stream.
- err = Pa_OpenStream(
- &stream,
- &test->inputParameters,
- &test->outputParameters,
- test->sampleRate,
- test->framesPerBuffer,
- paClipOff, /* we won't output out of range samples so don't bother clipping them */
- NULL, // causes non-blocking IO
- NULL );
- if( err != paNoError ) goto error1;
-
- CopyStreamInfoToLoopbackContext( loopbackContext, stream, stream );
-
- err = Pa_StartStream( stream );
- if( err != paNoError ) goto error2;
-
- while( err == 0 )
- {
- err = RecordAndPlayBlockingIO( stream, stream, loopbackContext );
- if( err < 0 ) goto error2;
- }
-
- err = Pa_StopStream( stream );
- if( err != paNoError ) goto error2;
-
-
- err = Pa_CloseStream( stream );
- if( err != paNoError ) goto error1;
-
-
- return 0;
-
-error2:
- Pa_CloseStream( stream );
-error1:
- return err;
-}
-
-
-/*******************************************************************/
-/**
- * Run some kind of loopback test.
- * @return 0 if OK or negative error.
- */
-int PaQa_RunLoopback( LoopbackContext *loopbackContext )
-{
- PaError err = 0;
- TestParameters *test = loopbackContext->test;
-
-
- if( test->flags & PAQA_FLAG_TWO_STREAMS )
- {
- if( test->flags & PAQA_FLAG_USE_BLOCKING_IO )
- {
- err = PaQa_RunLoopbackHalfDuplexBlockingIO( loopbackContext );
- }
- else
- {
- err = PaQa_RunLoopbackHalfDuplex( loopbackContext );
- }
- }
- else
- {
- if( test->flags & PAQA_FLAG_USE_BLOCKING_IO )
- {
- err = PaQa_RunLoopbackFullDuplexBlockingIO( loopbackContext );
- }
- else
- {
- err = PaQa_RunLoopbackFullDuplex( loopbackContext );
- }
- }
-
- if( err != paNoError )
- {
- printf("PortAudio error = %s\n", Pa_GetErrorText( err ) );
- }
- return err;
-}
-
-/*******************************************************************/
-static int PaQa_SaveTestResultToWaveFile( UserOptions *userOptions, PaQaRecording *recording )
-{
- if( userOptions->saveBadWaves )
- {
- char filename[256];
-#ifdef WIN32
- _snprintf( filename, sizeof(filename), "%s\\paloopback_%d.wav", userOptions->waveFilePath, userOptions->waveFileCount++ );
-#else
- snprintf( filename, sizeof(filename), "%s/paloopback_%d.wav", userOptions->waveFilePath, userOptions->waveFileCount++ );
-#endif
- printf( "\"%s\", ", filename );
- return PaQa_SaveRecordingToWaveFile( recording, filename );
- }
- return 0;
-}
-
-/*******************************************************************/
-static int PaQa_SetupLoopbackContext( LoopbackContext *loopbackContextPtr, TestParameters *testParams )
-{
- int i;
- // Setup loopback context.
- memset( loopbackContextPtr, 0, sizeof(LoopbackContext) );
- loopbackContextPtr->test = testParams;
- for( i=0; isamplesPerFrame; i++ )
- {
- int err = PaQa_InitializeRecording( &loopbackContextPtr->recordings[i], testParams->maxFrames, testParams->sampleRate );
- QA_ASSERT_EQUALS( "PaQa_InitializeRecording failed", paNoError, err );
- }
- for( i=0; isamplesPerFrame; i++ )
- {
- PaQa_SetupSineGenerator( &loopbackContextPtr->generators[i], PaQa_GetNthFrequency( testParams->baseFrequency, i ),
- testParams->amplitude, testParams->sampleRate );
- }
- loopbackContextPtr->minFramesPerBuffer = 0x0FFFFFFF;
- return 0;
-error:
- return -1;
-}
-
-/*******************************************************************/
-static void PaQa_TeardownLoopbackContext( LoopbackContext *loopbackContextPtr )
-{
- int i;
- if( loopbackContextPtr->test != NULL )
- {
- for( i=0; itest->samplesPerFrame; i++ )
- {
- PaQa_TerminateRecording( &loopbackContextPtr->recordings[i] );
- }
- }
-}
-
-/*******************************************************************/
-static void PaQa_PrintShortErrorReport( PaQaAnalysisResult *analysisResultPtr, int channel )
-{
- printf("channel %d ", channel);
- if( analysisResultPtr->popPosition > 0 )
- {
- printf("POP %0.3f at %d, ", (double)analysisResultPtr->popAmplitude, (int)analysisResultPtr->popPosition );
- }
- else
- {
- if( analysisResultPtr->addedFramesPosition > 0 )
- {
- printf("ADD %d at %d ", (int)analysisResultPtr->numAddedFrames, (int)analysisResultPtr->addedFramesPosition );
- }
-
- if( analysisResultPtr->droppedFramesPosition > 0 )
- {
- printf("DROP %d at %d ", (int)analysisResultPtr->numDroppedFrames, (int)analysisResultPtr->droppedFramesPosition );
- }
- }
-}
-
-/*******************************************************************/
-static void PaQa_PrintFullErrorReport( PaQaAnalysisResult *analysisResultPtr, int channel )
-{
- printf("\n=== Loopback Analysis ===================\n");
- printf(" channel: %d\n", channel );
- printf(" latency: %10.3f\n", analysisResultPtr->latency );
- printf(" amplitudeRatio: %10.3f\n", (double)analysisResultPtr->amplitudeRatio );
- printf(" popPosition: %10.3f\n", (double)analysisResultPtr->popPosition );
- printf(" popAmplitude: %10.3f\n", (double)analysisResultPtr->popAmplitude );
- printf(" num added frames: %10.3f\n", analysisResultPtr->numAddedFrames );
- printf(" added frames at: %10.3f\n", analysisResultPtr->addedFramesPosition );
- printf(" num dropped frames: %10.3f\n", analysisResultPtr->numDroppedFrames );
- printf(" dropped frames at: %10.3f\n", analysisResultPtr->droppedFramesPosition );
-}
-
-/*******************************************************************/
-/**
- * Test loopback connection using the given parameters.
- * @return number of channels with glitches, or negative error.
- */
-static int PaQa_SingleLoopBackTest( UserOptions *userOptions, TestParameters *testParams )
-{
- int i;
- LoopbackContext loopbackContext;
- PaError err = paNoError;
- PaQaTestTone testTone;
- PaQaAnalysisResult analysisResult;
- int numBadChannels = 0;
-
- printf("| %5d | %6d | ", ((int)(testParams->sampleRate+0.5)), testParams->framesPerBuffer );
- fflush(stdout);
-
- testTone.samplesPerFrame = testParams->samplesPerFrame;
- testTone.sampleRate = testParams->sampleRate;
- testTone.amplitude = testParams->amplitude;
- testTone.startDelay = 0;
-
- err = PaQa_SetupLoopbackContext( &loopbackContext, testParams );
- if( err ) return err;
-
- err = PaQa_RunLoopback( &loopbackContext );
- QA_ASSERT_TRUE("loopback did not run", (loopbackContext.callbackCount > 1) );
-
- printf( "%7.2f %7.2f %7.2f | ",
- loopbackContext.streamInfoInputLatency * 1000.0,
- loopbackContext.streamInfoOutputLatency * 1000.0,
- (loopbackContext.streamInfoInputLatency + loopbackContext.streamInfoOutputLatency) * 1000.0
- );
-
- printf( "%4d/%4d/%4d, %4d/%4d/%4d | ",
- loopbackContext.inputOverflowCount,
- loopbackContext.inputUnderflowCount,
- loopbackContext.inputBufferCount,
- loopbackContext.outputOverflowCount,
- loopbackContext.outputUnderflowCount,
- loopbackContext.outputBufferCount
- );
-
- // Analyse recording to detect glitches.
- for( i=0; isamplesPerFrame; i++ )
- {
- double freq = PaQa_GetNthFrequency( testParams->baseFrequency, i );
- testTone.frequency = freq;
-
- PaQa_AnalyseRecording( &loopbackContext.recordings[i], &testTone, &analysisResult );
-
- if( i==0 )
- {
- double latencyMSec;
-
- printf( "%4d-%4d | ",
- loopbackContext.minFramesPerBuffer,
- loopbackContext.maxFramesPerBuffer
- );
-
- latencyMSec = 1000.0 * analysisResult.latency / testParams->sampleRate;
- printf("%7.2f | ", latencyMSec );
-
- }
-
- if( analysisResult.valid )
- {
- int badChannel = ( (analysisResult.popPosition > 0)
- || (analysisResult.addedFramesPosition > 0)
- || (analysisResult.droppedFramesPosition > 0) );
-
- if( badChannel )
- {
- if( userOptions->verbose )
- {
- PaQa_PrintFullErrorReport( &analysisResult, i );
- }
- else
- {
- PaQa_PrintShortErrorReport( &analysisResult, i );
- }
- PaQa_SaveTestResultToWaveFile( userOptions, &loopbackContext.recordings[i] );
- }
- numBadChannels += badChannel;
- }
- else
- {
- printf( "[%d] No or low signal, ampRatio = %f", i, analysisResult.amplitudeRatio );
- numBadChannels += 1;
- }
-
- }
- if( numBadChannels == 0 )
- {
- printf( "OK" );
- }
-
- // Print the # errors so far to make it easier to see where the error occurred.
- printf( " - #errs = %d\n", g_testsFailed );
-
- PaQa_TeardownLoopbackContext( &loopbackContext );
- if( numBadChannels > 0 )
- {
- g_testsFailed += 1;
- }
- return numBadChannels;
-
-error:
- PaQa_TeardownLoopbackContext( &loopbackContext );
- printf( "\n" );
- g_testsFailed += 1;
- return err;
-}
-
-/*******************************************************************/
-static void PaQa_SetDefaultTestParameters( TestParameters *testParamsPtr, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
-{
- memset( testParamsPtr, 0, sizeof(TestParameters) );
-
- testParamsPtr->samplesPerFrame = 2;
- testParamsPtr->amplitude = 0.5;
- testParamsPtr->sampleRate = 44100;
- testParamsPtr->maxFrames = (int) (PAQA_TEST_DURATION * testParamsPtr->sampleRate);
- testParamsPtr->framesPerBuffer = DEFAULT_FRAMES_PER_BUFFER;
- testParamsPtr->baseFrequency = 200.0;
- testParamsPtr->flags = PAQA_FLAG_TWO_STREAMS;
- testParamsPtr->streamFlags = paClipOff; /* we won't output out of range samples so don't bother clipping them */
-
- testParamsPtr->inputParameters.device = inputDevice;
- testParamsPtr->inputParameters.sampleFormat = paFloat32;
- testParamsPtr->inputParameters.channelCount = testParamsPtr->samplesPerFrame;
- testParamsPtr->inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputDevice )->defaultLowInputLatency;
- //testParamsPtr->inputParameters.suggestedLatency = Pa_GetDeviceInfo( inputDevice )->defaultHighInputLatency;
-
- testParamsPtr->outputParameters.device = outputDevice;
- testParamsPtr->outputParameters.sampleFormat = paFloat32;
- testParamsPtr->outputParameters.channelCount = testParamsPtr->samplesPerFrame;
- testParamsPtr->outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputDevice )->defaultLowOutputLatency;
- //testParamsPtr->outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputDevice )->defaultHighOutputLatency;
-}
-
-/*******************************************************************/
-static void PaQa_OverrideTestParameters( TestParameters *testParamsPtr, UserOptions *userOptions )
-{
- // Check to see if a specific value was requested.
- if( userOptions->sampleRate >= 0 )
- {
- testParamsPtr->sampleRate = userOptions->sampleRate;
- testParamsPtr->maxFrames = (int) (PAQA_TEST_DURATION * testParamsPtr->sampleRate);
- }
- if( userOptions->framesPerBuffer >= 0 )
- {
- testParamsPtr->framesPerBuffer = userOptions->framesPerBuffer;
- }
- if( userOptions->inputLatency >= 0 )
- {
- testParamsPtr->inputParameters.suggestedLatency = userOptions->inputLatency * 0.001;
- }
- if( userOptions->outputLatency >= 0 )
- {
- testParamsPtr->outputParameters.suggestedLatency = userOptions->outputLatency * 0.001;
- }
- printf( " Running with suggested latency (msec): input = %5.2f, out = %5.2f\n",
- (testParamsPtr->inputParameters.suggestedLatency * 1000.0),
- (testParamsPtr->outputParameters.suggestedLatency * 1000.0) );
-}
-
-/*******************************************************************/
-/**
- * Run a series of tests on this loopback connection.
- * @return number of bad channel results
- */
-static int PaQa_AnalyzeLoopbackConnection( UserOptions *userOptions, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
-{
- int iFlags;
- int iRate;
- int iSize;
- int iFormat;
- int savedValue;
- TestParameters testParams;
- const PaDeviceInfo *inputDeviceInfo = Pa_GetDeviceInfo( inputDevice );
- const PaDeviceInfo *outputDeviceInfo = Pa_GetDeviceInfo( outputDevice );
- int totalBadChannels = 0;
-
- // test half duplex first because it is more likely to work.
- int flagSettings[] = { PAQA_FLAG_TWO_STREAMS, 0 };
- int numFlagSettings = (sizeof(flagSettings)/sizeof(int));
-
- double sampleRates[] = { 8000.0, 11025.0, 16000.0, 22050.0, 32000.0, 44100.0, 48000.0, 96000.0 };
- int numRates = (sizeof(sampleRates)/sizeof(double));
-
- // framesPerBuffer==0 means PA decides on the buffer size.
- int framesPerBuffers[] = { 0, 16, 32, 40, 64, 100, 128, 256, 512, 1024 };
- int numBufferSizes = (sizeof(framesPerBuffers)/sizeof(int));
-
- PaSampleFormat sampleFormats[] = { paFloat32, paUInt8, paInt8, paInt16, paInt32 };
- const char *sampleFormatNames[] = { "paFloat32", "paUInt8", "paInt8", "paInt16", "paInt32" };
- int numSampleFormats = (sizeof(sampleFormats)/sizeof(PaSampleFormat));
-
- printf( "=============== Analysing Loopback %d to %d =====================\n", outputDevice, inputDevice );
- printf( " Devices: %s => %s\n", outputDeviceInfo->name, inputDeviceInfo->name);
-
- PaQa_SetDefaultTestParameters( &testParams, inputDevice, outputDevice );
-
- PaQa_OverrideTestParameters( &testParams, userOptions );
-
- // Loop though combinations of audio parameters.
- for( iFlags=0; iFlagssampleRate < 0 )
- {
- savedValue = testParams.sampleRate;
- for( iRate=0; iRateframesPerBuffer < 0 )
- {
- savedValue = testParams.framesPerBuffer;
- for( iSize=0; iSizetest;
-
- // Start in the middle assuming past latency.
- int startFrame = testParamsPtr->maxFrames/2;
- int numFrames = testParamsPtr->maxFrames/2;
-
- // Check to see if the signal is clipped.
- double amplitudeLeft = PaQa_MeasureSineAmplitudeBySlope( &loopbackContextPtr->recordings[0],
- testParamsPtr->baseFrequency, testParamsPtr->sampleRate,
- startFrame, numFrames );
- double gainLeft = amplitudeLeft / testParamsPtr->amplitude;
- double amplitudeRight = PaQa_MeasureSineAmplitudeBySlope( &loopbackContextPtr->recordings[1],
- testParamsPtr->baseFrequency, testParamsPtr->sampleRate,
- startFrame, numFrames );
- double gainRight = amplitudeLeft / testParamsPtr->amplitude;
- printf(" Loop gain: left = %f, right = %f\n", gainLeft, gainRight );
-
- if( (amplitudeLeft > 1.0 ) || (amplitudeRight > 1.0) )
- {
- printf("ERROR - loop gain is too high. Should be around than 1.0. Please lower output level and/or input gain.\n" );
- clipped = 1;
- }
- return clipped;
-}
-
-/*******************************************************************/
-int PaQa_MeasureBackgroundNoise( LoopbackContext *loopbackContextPtr, double *rmsPtr )
-{
- int result = 0;
- *rmsPtr = 0.0;
- // Rewind so we can record some input.
- loopbackContextPtr->recordings[0].numFrames = 0;
- loopbackContextPtr->recordings[1].numFrames = 0;
- result = PaQa_RunInputOnly( loopbackContextPtr );
- if( result == 0 )
- {
- double leftRMS = PaQa_MeasureRootMeanSquare( loopbackContextPtr->recordings[0].buffer,
- loopbackContextPtr->recordings[0].numFrames );
- double rightRMS = PaQa_MeasureRootMeanSquare( loopbackContextPtr->recordings[1].buffer,
- loopbackContextPtr->recordings[1].numFrames );
- *rmsPtr = (leftRMS + rightRMS) / 2.0;
- }
- return result;
-}
-
-/*******************************************************************/
-/**
- * Output a sine wave then try to detect it on input.
- *
- * @return 1 if loopback connected, 0 if not, or negative error.
- */
-int PaQa_CheckForLoopBack( UserOptions *userOptions, PaDeviceIndex inputDevice, PaDeviceIndex outputDevice )
-{
- TestParameters testParams;
- LoopbackContext loopbackContext;
- const PaDeviceInfo *inputDeviceInfo;
- const PaDeviceInfo *outputDeviceInfo;
- PaError err = paNoError;
- double minAmplitude;
- int loopbackIsConnected;
- int startFrame, numFrames;
- double magLeft, magRight;
-
- inputDeviceInfo = Pa_GetDeviceInfo( inputDevice );
- if( inputDeviceInfo == NULL )
- {
- printf("ERROR - Pa_GetDeviceInfo for input returned NULL.\n");
- return paInvalidDevice;
- }
- if( inputDeviceInfo->maxInputChannels < 2 )
- {
- return 0;
- }
-
- outputDeviceInfo = Pa_GetDeviceInfo( outputDevice );
- if( outputDeviceInfo == NULL )
- {
- printf("ERROR - Pa_GetDeviceInfo for output returned NULL.\n");
- return paInvalidDevice;
- }
- if( outputDeviceInfo->maxOutputChannels < 2 )
- {
- return 0;
- }
-
- printf( "Look for loopback cable between \"%s\" => \"%s\"\n", outputDeviceInfo->name, inputDeviceInfo->name);
-
- printf( " Default suggested input latency (msec): low = %5.2f, high = %5.2f\n",
- (inputDeviceInfo->defaultLowInputLatency * 1000.0),
- (inputDeviceInfo->defaultHighInputLatency * 1000.0) );
- printf( " Default suggested output latency (msec): low = %5.2f, high = %5.2f\n",
- (outputDeviceInfo->defaultLowOutputLatency * 1000.0),
- (outputDeviceInfo->defaultHighOutputLatency * 1000.0) );
-
- PaQa_SetDefaultTestParameters( &testParams, inputDevice, outputDevice );
-
- PaQa_OverrideTestParameters( &testParams, userOptions );
-
- testParams.maxFrames = (int) (LOOPBACK_DETECTION_DURATION_SECONDS * testParams.sampleRate);
- minAmplitude = testParams.amplitude / 4.0;
-
- // Check to see if the selected formats are supported.
- if( Pa_IsFormatSupported( &testParams.inputParameters, NULL, testParams.sampleRate ) != paFormatIsSupported )
- {
- printf( "Input not supported for this format!\n" );
- return 0;
- }
- if( Pa_IsFormatSupported( NULL, &testParams.outputParameters, testParams.sampleRate ) != paFormatIsSupported )
- {
- printf( "Output not supported for this format!\n" );
- return 0;
- }
-
- PaQa_SetupLoopbackContext( &loopbackContext, &testParams );
-
- if( inputDevice == outputDevice )
- {
- // Use full duplex if checking for loopback on one device.
- testParams.flags &= ~PAQA_FLAG_TWO_STREAMS;
- }
- else
- {
- // Use half duplex if checking for loopback on two different device.
- testParams.flags = PAQA_FLAG_TWO_STREAMS;
- }
- err = PaQa_RunLoopback( &loopbackContext );
- QA_ASSERT_TRUE("loopback detection callback did not run", (loopbackContext.callbackCount > 1) );
-
- // Analyse recording to see if we captured the output.
- // Start in the middle assuming past latency.
- startFrame = testParams.maxFrames/2;
- numFrames = testParams.maxFrames/2;
- magLeft = PaQa_CorrelateSine( &loopbackContext.recordings[0],
- loopbackContext.generators[0].frequency,
- testParams.sampleRate,
- startFrame, numFrames, NULL );
- magRight = PaQa_CorrelateSine( &loopbackContext.recordings[1],
- loopbackContext.generators[1].frequency,
- testParams.sampleRate,
- startFrame, numFrames, NULL );
- printf(" Amplitudes: left = %f, right = %f\n", magLeft, magRight );
-
- // Check for backwards cable.
- loopbackIsConnected = ((magLeft > minAmplitude) && (magRight > minAmplitude));
-
- if( !loopbackIsConnected )
- {
- double magLeftReverse = PaQa_CorrelateSine( &loopbackContext.recordings[0],
- loopbackContext.generators[1].frequency,
- testParams.sampleRate,
- startFrame, numFrames, NULL );
-
- double magRightReverse = PaQa_CorrelateSine( &loopbackContext.recordings[1],
- loopbackContext.generators[0].frequency,
- testParams.sampleRate,
- startFrame, numFrames, NULL );
-
- if ((magLeftReverse > minAmplitude) && (magRightReverse>minAmplitude))
- {
- printf("ERROR - You seem to have the left and right channels swapped on the loopback cable!\n");
- }
- }
- else
- {
- double rms = 0.0;
- if( PaQa_CheckForClippedLoopback( &loopbackContext ) )
- {
- // Clipped so don't use this loopback.
- loopbackIsConnected = 0;
- }
-
- err = PaQa_MeasureBackgroundNoise( &loopbackContext, &rms );
- printf(" Background noise = %f\n", rms );
- if( err )
- {
- printf("ERROR - Could not measure background noise on this input!\n");
- loopbackIsConnected = 0;
- }
- else if( rms > MAX_BACKGROUND_NOISE_RMS )
- {
- printf("ERROR - There is too much background noise on this input!\n");
- loopbackIsConnected = 0;
- }
- }
-
- PaQa_TeardownLoopbackContext( &loopbackContext );
- return loopbackIsConnected;
-
-error:
- PaQa_TeardownLoopbackContext( &loopbackContext );
- return err;
-}
-
-/*******************************************************************/
-/**
- * If there is a loopback connection then run the analysis.
- */
-static int CheckLoopbackAndScan( UserOptions *userOptions,
- PaDeviceIndex iIn, PaDeviceIndex iOut )
-{
- int loopbackConnected = PaQa_CheckForLoopBack( userOptions, iIn, iOut );
- if( loopbackConnected > 0 )
- {
- PaQa_AnalyzeLoopbackConnection( userOptions, iIn, iOut );
- return 1;
- }
- return 0;
-}
-
-/*******************************************************************/
-/**
- * Scan every combination of output to input device.
- * If a loopback is found the analyse the combination.
- * The scan can be overridden using the -i and -o command line options.
- */
-static int ScanForLoopback(UserOptions *userOptions)
-{
- PaDeviceIndex iIn,iOut;
- int numLoopbacks = 0;
- int numDevices;
- numDevices = Pa_GetDeviceCount();
-
- // If both devices are specified then just use that combination.
- if ((userOptions->inputDevice >= 0) && (userOptions->outputDevice >= 0))
- {
- numLoopbacks += CheckLoopbackAndScan( userOptions, userOptions->inputDevice, userOptions->outputDevice );
- }
- else if (userOptions->inputDevice >= 0)
- {
- // Just scan for output.
- for( iOut=0; iOutinputDevice, iOut );
- }
- }
- else if (userOptions->outputDevice >= 0)
- {
- // Just scan for input.
- for( iIn=0; iInoutputDevice );
- }
- }
- else
- {
- // Scan both.
- for( iOut=0; iOut 0) );
- return numLoopbacks;
-
-error:
- return -1;
-}
-
-/*==========================================================================================*/
-int TestSampleFormatConversion( void )
-{
- int i;
- const float floatInput[] = { 1.0, 0.5, -0.5, -1.0 };
-
- const char charInput[] = { 127, 64, -64, -128 };
- const unsigned char ucharInput[] = { 255, 128+64, 64, 0 };
- const short shortInput[] = { 32767, 32768/2, -32768/2, -32768 };
- const int intInput[] = { 2147483647, 2147483647/2, -1073741824 /*-2147483648/2 doesn't work in msvc*/, -2147483648 };
-
- float floatOutput[4];
- short shortOutput[4];
- int intOutput[4];
- unsigned char ucharOutput[4];
- char charOutput[4];
-
- QA_ASSERT_EQUALS("int must be 32-bit", 4, (int) sizeof(int) );
- QA_ASSERT_EQUALS("short must be 16-bit", 2, (int) sizeof(short) );
-
- // from Float ======
- PaQa_ConvertFromFloat( floatInput, 4, paUInt8, ucharOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE_INT( "paFloat32 -> paUInt8 -> error", ucharInput[i], ucharOutput[i], 1 );
- }
-
- PaQa_ConvertFromFloat( floatInput, 4, paInt8, charOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt8 -> error", charInput[i], charOutput[i], 1 );
- }
-
- PaQa_ConvertFromFloat( floatInput, 4, paInt16, shortOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt16 error", shortInput[i], shortOutput[i], 1 );
- }
-
- PaQa_ConvertFromFloat( floatInput, 4, paInt32, intOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE_INT( "paFloat32 -> paInt32 error", intInput[i], intOutput[i], 0x00010000 );
- }
-
-
- // to Float ======
- memset( floatOutput, 0, sizeof(floatOutput) );
- PaQa_ConvertToFloat( ucharInput, 4, paUInt8, floatOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE( "paUInt8 -> paFloat32 error", floatInput[i], floatOutput[i], 0.01 );
- }
-
- memset( floatOutput, 0, sizeof(floatOutput) );
- PaQa_ConvertToFloat( charInput, 4, paInt8, floatOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE( "paInt8 -> paFloat32 error", floatInput[i], floatOutput[i], 0.01 );
- }
-
- memset( floatOutput, 0, sizeof(floatOutput) );
- PaQa_ConvertToFloat( shortInput, 4, paInt16, floatOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE( "paInt16 -> paFloat32 error", floatInput[i], floatOutput[i], 0.001 );
- }
-
- memset( floatOutput, 0, sizeof(floatOutput) );
- PaQa_ConvertToFloat( intInput, 4, paInt32, floatOutput );
- for( i=0; i<4; i++ )
- {
- QA_ASSERT_CLOSE( "paInt32 -> paFloat32 error", floatInput[i], floatOutput[i], 0.00001 );
- }
-
- return 0;
-
-error:
- return -1;
-}
-
-
-/*******************************************************************/
-void usage( const char *name )
-{
- printf("%s [-i# -o# -l# -r# -s# -m -w -dDir]\n", name);
- printf(" -i# - Input device ID. Will scan for loopback cable if not specified.\n");
- printf(" -o# - Output device ID. Will scan for loopback if not specified.\n");
- printf(" -l# - Latency for both input and output in milliseconds.\n");
- printf(" --inputLatency # Input latency in milliseconds.\n");
- printf(" --outputLatency # Output latency in milliseconds.\n");
- printf(" -r# - Sample Rate in Hz. Will use multiple common rates if not specified.\n");
- printf(" -s# - Size of callback buffer in frames, framesPerBuffer. Will use common values if not specified.\n");
- printf(" -w - Save bad recordings in a WAV file.\n");
- printf(" -dDir - Path for Directory for WAV files. Default is current directory.\n");
- printf(" -m - Just test the DSP Math code and not the audio devices.\n");
- printf(" -v - Verbose reports.\n");
-}
-
-/*******************************************************************/
-int main( int argc, char **argv )
-{
- int i;
- UserOptions userOptions;
- int result = 0;
- int justMath = 0;
- char *executableName = argv[0];
-
- printf("PortAudio LoopBack Test built " __DATE__ " at " __TIME__ "\n");
-
- if( argc > 1 ){
- printf("running with arguments:");
- for(i=1; i < argc; ++i )
- printf(" %s", argv[i] );
- printf("\n");
- }else{
- printf("running with no arguments\n");
- }
-
- memset(&userOptions, 0, sizeof(userOptions));
- userOptions.inputDevice = paNoDevice;
- userOptions.outputDevice = paNoDevice;
- userOptions.sampleRate = -1;
- userOptions.framesPerBuffer = -1;
- userOptions.inputLatency = -1;
- userOptions.outputLatency = -1;
- userOptions.waveFilePath = ".";
-
- // Process arguments. Skip name of executable.
- i = 1;
- while( i
-//
-// Note that this #include must come after the other ASIO SDK
-// #includes, for example:
-//
-// #include
-// #include
-// #include
-// #include
-// #include
-//
-// Actually the important thing is to #include
-// after . We have
-// incorporated a test to enforce this ordering.
-//
-// The code transparently takes care of the interposition by
-// using macro substitution to intercept calls to ASIOInit()
-// and ASIOExit(). We save the original ASIO global
-// "theAsioDriver" in our "that" variable, and then set
-// "theAsioDriver" to equal our IASIOThiscallResolver instance.
-//
-// Whilst this method of resolving the thiscall problem requires
-// the addition of #include to client
-// code it has the advantage that it does not break the terms
-// of the ASIO licence by publishing it. We are NOT modifying
-// any Steinberg code here, we are merely implementing the IASIO
-// interface in the same way that we would need to do if we
-// wished to provide an open source ASIO driver.
-//
-// For compilation with MinGW -lole32 needs to be added to the
-// linker options. For BORLAND, linking with Import32.lib is
-// sufficient.
-//
-// The dependencies are with: CoInitialize, CoUninitialize,
-// CoCreateInstance, CLSIDFromString - used by asiolist.cpp
-// and are required on Windows whether ThiscallResolver is used
-// or not.
-//
-// Searching for the above strings in the root library path
-// of your compiler should enable the correct libraries to be
-// identified if they aren't immediately obvious.
-//
-// Note that the current implementation of IASIOThiscallResolver
-// is not COM compliant - it does not correctly implement the
-// IUnknown interface. Implementing it is not necessary because
-// it is not called by parts of the ASIO SDK which call through
-// theAsioDriver ptr. The IUnknown methods are implemented as
-// assert(false) to ensure that the code fails if they are
-// ever called.
-// Restrictions: None. Public Domain & Open Source distribute freely
-// You may use IASIOThiscallResolver commercially as well as
-// privately.
-// You the user assume the responsibility for the use of the
-// files, binary or text, and there is no guarantee or warranty,
-// expressed or implied, including but not limited to the
-// implied warranties of merchantability and fitness for a
-// particular purpose. You assume all responsibility and agree
-// to hold no entity, copyright holder or distributors liable
-// for any loss of data or inaccurate representations of data
-// as a result of using IASIOThiscallResolver.
-// Version: 1.4 Added separate macro CALL_THISCALL_1_DOUBLE from
-// Andrew Baldwin, and volatile for whole gcc asm blocks,
-// both for compatibility with newer gcc versions. Cleaned up
-// Borland asm to use one less register.
-// 1.3 Switched to including assert.h for better compatibility.
-// Wrapped entire .h and .cpp contents with a check for
-// _MSC_VER to provide better compatibility with MS compilers.
-// Changed Singleton implementation to use static instance
-// instead of freestore allocated instance. Removed ASIOExit
-// macro as it is no longer needed.
-// 1.2 Removed semicolons from ASIOInit and ASIOExit macros to
-// allow them to be embedded in expressions (if statements).
-// Cleaned up some comments. Removed combase.c dependency (it
-// doesn't compile with BCB anyway) by stubbing IUnknown.
-// 1.1 Incorporated comments from Ross Bencina including things
-// such as changing name from ThiscallResolver to
-// IASIOThiscallResolver, tidying up the constructor, fixing
-// a bug in IASIOThiscallResolver::ASIOExit() and improving
-// portability through the use of conditional compilation
-// 1.0 Initial working version.
-// Created: 6/09/2003
-// Authors: Fraser Adams
-// Ross Bencina
-// Rene G. Ceballos
-// Martin Fay
-// Antti Silvast
-// Andrew Baldwin
-//
-// ****************************************************************************
-
-
-#ifndef included_iasiothiscallresolver_h
-#define included_iasiothiscallresolver_h
-
-// We only need IASIOThiscallResolver at all if we are on Win32. For other
-// platforms we simply bypass the IASIOThiscallResolver definition to allow us
-// to be safely #include'd whatever the platform to keep client code portable
-#if (defined(WIN32) || defined(_WIN32) || defined(__WIN32__)) && !defined(_WIN64)
-
-
-// If microsoft compiler we can call IASIO directly so IASIOThiscallResolver
-// is not used.
-#if !defined(_MSC_VER)
-
-
-// The following is in order to ensure that this header is only included after
-// the other ASIO headers (except for the case of iasiothiscallresolver.cpp).
-// We need to do this because IASIOThiscallResolver works by eclipsing the
-// original definition of ASIOInit() with a macro (see below).
-#if !defined(iasiothiscallresolver_sourcefile)
- #if !defined(__ASIO_H)
- #error iasiothiscallresolver.h must be included AFTER asio.h
- #endif
-#endif
-
-#include
-#include /* From ASIO SDK */
-
-
-class IASIOThiscallResolver : public IASIO {
-private:
- IASIO* that_; // Points to the real IASIO
-
- static IASIOThiscallResolver instance; // Singleton instance
-
- // Constructors - declared private so construction is limited to
- // our Singleton instance
- IASIOThiscallResolver();
- IASIOThiscallResolver(IASIO* that);
-public:
-
- // Methods from the IUnknown interface. We don't fully implement IUnknown
- // because the ASIO SDK never calls these methods through theAsioDriver ptr.
- // These methods are implemented as assert(false).
- virtual HRESULT STDMETHODCALLTYPE QueryInterface(REFIID riid, void **ppv);
- virtual ULONG STDMETHODCALLTYPE AddRef();
- virtual ULONG STDMETHODCALLTYPE Release();
-
- // Methods from the IASIO interface, implemented as forwarning calls to that.
- virtual ASIOBool init(void *sysHandle);
- virtual void getDriverName(char *name);
- virtual long getDriverVersion();
- virtual void getErrorMessage(char *string);
- virtual ASIOError start();
- virtual ASIOError stop();
- virtual ASIOError getChannels(long *numInputChannels, long *numOutputChannels);
- virtual ASIOError getLatencies(long *inputLatency, long *outputLatency);
- virtual ASIOError getBufferSize(long *minSize, long *maxSize, long *preferredSize, long *granularity);
- virtual ASIOError canSampleRate(ASIOSampleRate sampleRate);
- virtual ASIOError getSampleRate(ASIOSampleRate *sampleRate);
- virtual ASIOError setSampleRate(ASIOSampleRate sampleRate);
- virtual ASIOError getClockSources(ASIOClockSource *clocks, long *numSources);
- virtual ASIOError setClockSource(long reference);
- virtual ASIOError getSamplePosition(ASIOSamples *sPos, ASIOTimeStamp *tStamp);
- virtual ASIOError getChannelInfo(ASIOChannelInfo *info);
- virtual ASIOError createBuffers(ASIOBufferInfo *bufferInfos, long numChannels, long bufferSize, ASIOCallbacks *callbacks);
- virtual ASIOError disposeBuffers();
- virtual ASIOError controlPanel();
- virtual ASIOError future(long selector,void *opt);
- virtual ASIOError outputReady();
-
- // Class method, see ASIOInit() macro below.
- static ASIOError ASIOInit(ASIODriverInfo *info); // Delegates to ::ASIOInit
-};
-
-
-// Replace calls to ASIOInit with our interposing version.
-// This macro enables us to perform thiscall resolution simply by #including
-// after the asio #includes (this file _must_ be
-// included _after_ the asio #includes)
-
-#define ASIOInit(name) IASIOThiscallResolver::ASIOInit((name))
-
-
-#endif /* !defined(_MSC_VER) */
-
-#endif /* Win32 */
-
-#endif /* included_iasiothiscallresolver_h */
-
-
diff --git a/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/hpo.py b/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/hpo.py
deleted file mode 100644
index 7dd5c92e8de170222b3cd3eae858f4f3cfddaff6..0000000000000000000000000000000000000000
--- a/spaces/anaclaudia13ct/insect_detection/utils/loggers/comet/hpo.py
+++ /dev/null
@@ -1,118 +0,0 @@
-import argparse
-import json
-import logging
-import os
-import sys
-from pathlib import Path
-
-import comet_ml
-
-logger = logging.getLogger(__name__)
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[3] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-
-from train import train
-from utils.callbacks import Callbacks
-from utils.general import increment_path
-from utils.torch_utils import select_device
-
-# Project Configuration
-config = comet_ml.config.get_config()
-COMET_PROJECT_NAME = config.get_string(os.getenv("COMET_PROJECT_NAME"), "comet.project_name", default="yolov5")
-
-
-def get_args(known=False):
- parser = argparse.ArgumentParser()
- parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='initial weights path')
- parser.add_argument('--cfg', type=str, default='', help='model.yaml path')
- parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
- parser.add_argument('--hyp', type=str, default=ROOT / 'data/hyps/hyp.scratch-low.yaml', help='hyperparameters path')
- parser.add_argument('--epochs', type=int, default=300, help='total training epochs')
- parser.add_argument('--batch-size', type=int, default=16, help='total batch size for all GPUs, -1 for autobatch')
- parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='train, val image size (pixels)')
- parser.add_argument('--rect', action='store_true', help='rectangular training')
- parser.add_argument('--resume', nargs='?', const=True, default=False, help='resume most recent training')
- parser.add_argument('--nosave', action='store_true', help='only save final checkpoint')
- parser.add_argument('--noval', action='store_true', help='only validate final epoch')
- parser.add_argument('--noautoanchor', action='store_true', help='disable AutoAnchor')
- parser.add_argument('--noplots', action='store_true', help='save no plot files')
- parser.add_argument('--evolve', type=int, nargs='?', const=300, help='evolve hyperparameters for x generations')
- parser.add_argument('--bucket', type=str, default='', help='gsutil bucket')
- parser.add_argument('--cache', type=str, nargs='?', const='ram', help='--cache images in "ram" (default) or "disk"')
- parser.add_argument('--image-weights', action='store_true', help='use weighted image selection for training')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--multi-scale', action='store_true', help='vary img-size +/- 50%%')
- parser.add_argument('--single-cls', action='store_true', help='train multi-class data as single-class')
- parser.add_argument('--optimizer', type=str, choices=['SGD', 'Adam', 'AdamW'], default='SGD', help='optimizer')
- parser.add_argument('--sync-bn', action='store_true', help='use SyncBatchNorm, only available in DDP mode')
- parser.add_argument('--workers', type=int, default=8, help='max dataloader workers (per RANK in DDP mode)')
- parser.add_argument('--project', default=ROOT / 'runs/train', help='save to project/name')
- parser.add_argument('--name', default='exp', help='save to project/name')
- parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
- parser.add_argument('--quad', action='store_true', help='quad dataloader')
- parser.add_argument('--cos-lr', action='store_true', help='cosine LR scheduler')
- parser.add_argument('--label-smoothing', type=float, default=0.0, help='Label smoothing epsilon')
- parser.add_argument('--patience', type=int, default=100, help='EarlyStopping patience (epochs without improvement)')
- parser.add_argument('--freeze', nargs='+', type=int, default=[0], help='Freeze layers: backbone=10, first3=0 1 2')
- parser.add_argument('--save-period', type=int, default=-1, help='Save checkpoint every x epochs (disabled if < 1)')
- parser.add_argument('--seed', type=int, default=0, help='Global training seed')
- parser.add_argument('--local_rank', type=int, default=-1, help='Automatic DDP Multi-GPU argument, do not modify')
-
- # Weights & Biases arguments
- parser.add_argument('--entity', default=None, help='W&B: Entity')
- parser.add_argument('--upload_dataset', nargs='?', const=True, default=False, help='W&B: Upload data, "val" option')
- parser.add_argument('--bbox_interval', type=int, default=-1, help='W&B: Set bounding-box image logging interval')
- parser.add_argument('--artifact_alias', type=str, default='latest', help='W&B: Version of dataset artifact to use')
-
- # Comet Arguments
- parser.add_argument("--comet_optimizer_config", type=str, help="Comet: Path to a Comet Optimizer Config File.")
- parser.add_argument("--comet_optimizer_id", type=str, help="Comet: ID of the Comet Optimizer sweep.")
- parser.add_argument("--comet_optimizer_objective", type=str, help="Comet: Set to 'minimize' or 'maximize'.")
- parser.add_argument("--comet_optimizer_metric", type=str, help="Comet: Metric to Optimize.")
- parser.add_argument("--comet_optimizer_workers",
- type=int,
- default=1,
- help="Comet: Number of Parallel Workers to use with the Comet Optimizer.")
-
- return parser.parse_known_args()[0] if known else parser.parse_args()
-
-
-def run(parameters, opt):
- hyp_dict = {k: v for k, v in parameters.items() if k not in ["epochs", "batch_size"]}
-
- opt.save_dir = str(increment_path(Path(opt.project) / opt.name, exist_ok=opt.exist_ok or opt.evolve))
- opt.batch_size = parameters.get("batch_size")
- opt.epochs = parameters.get("epochs")
-
- device = select_device(opt.device, batch_size=opt.batch_size)
- train(hyp_dict, opt, device, callbacks=Callbacks())
-
-
-if __name__ == "__main__":
- opt = get_args(known=True)
-
- opt.weights = str(opt.weights)
- opt.cfg = str(opt.cfg)
- opt.data = str(opt.data)
- opt.project = str(opt.project)
-
- optimizer_id = os.getenv("COMET_OPTIMIZER_ID")
- if optimizer_id is None:
- with open(opt.comet_optimizer_config) as f:
- optimizer_config = json.load(f)
- optimizer = comet_ml.Optimizer(optimizer_config)
- else:
- optimizer = comet_ml.Optimizer(optimizer_id)
-
- opt.comet_optimizer_id = optimizer.id
- status = optimizer.status()
-
- opt.comet_optimizer_objective = status["spec"]["objective"]
- opt.comet_optimizer_metric = status["spec"]["metric"]
-
- logger.info("COMET INFO: Starting Hyperparameter Sweep")
- for parameter in optimizer.get_parameters():
- run(parameter["parameters"], opt)
diff --git a/spaces/anakin87/fact-checking-rocks/README.md b/spaces/anakin87/fact-checking-rocks/README.md
deleted file mode 100644
index d7e547a0002da4731e3901fa03d905bef891adce..0000000000000000000000000000000000000000
--- a/spaces/anakin87/fact-checking-rocks/README.md
+++ /dev/null
@@ -1,102 +0,0 @@
----
-title: Fact Checking rocks!
-emoji: 🎸
-colorFrom: purple
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.19.0
-app_file: Rock_fact_checker.py
-pinned: true
-models: [sentence-transformers/msmarco-distilbert-base-tas-b, microsoft/deberta-v2-xlarge-mnli, google/flan-t5-large]
-tags: [fact-checking, rock, natural language inference, dense retrieval, large language models, haystack, neural search]
-license: apache-2.0
----
-
-# Fact Checking 🎸 Rocks! [](https://huggingface.co/spaces/anakin87/fact-checking-rocks) [](https://github.com/anakin87/fact-checking-rocks)
-
-## *Fact checking baseline combining dense retrieval and textual entailment*
-
-- [Fact Checking 🎸 Rocks! ](#fact-checking--rocks---)
- - [*Fact checking baseline combining dense retrieval and textual entailment*](#fact-checking-baseline-combining-dense-retrieval-and-textual-entailment)
- - [Idea](#idea)
- - [Presentation](#presentation)
- - [System description](#system-description)
- - [Indexing pipeline](#indexing-pipeline)
- - [Search pipeline](#search-pipeline)
- - [Explain using a LLM](#explain-using-a-llm)
- - [Limits and possible improvements](#limits-and-possible-improvements)
- - [Repository structure](#repository-structure)
- - [Installation](#installation)
- - [Entailment Checker node](#entailment-checker-node)
- - [Fact Checking 🎸 Rocks!](#fact-checking--rocks)
-
-### Idea
-💡 This project aims to show that a *naive and simple baseline* for fact checking can be built by combining dense retrieval and a textual entailment task.
-In a nutshell, the flow is as follows:
-* the user enters a factual statement
-* the relevant passages are retrieved from the knowledge base using dense retrieval
-* the system computes the text entailment between each relevant passage and the statement, using a Natural Language Inference model
-* the entailment scores are aggregated to produce a summary score.
-
-### Presentation
-
-- [🍿 Video presentation @ Berlin Buzzwords 2023](https://www.youtube.com/watch?v=4L8Iw9CZNbU)
-- [🧑🏫 Slides](./presentation/fact_checking_rocks.pdf)
-
-### System description
-🪄 This project is strongly based on [🔎 Haystack](https://github.com/deepset-ai/haystack), an open source NLP framework that enables seamless use of Transformer models and LLMs to interact with your data. The main components of our system are an indexing pipeline and a search pipeline.
-
-#### Indexing pipeline
-* [Crawling](https://github.com/anakin87/fact-checking-rocks/blob/321ba7893bbe79582f8c052493acfda497c5b785/notebooks/get_wikipedia_data.ipynb): Crawl data from Wikipedia, starting from the page [List of mainstream rock performers](https://en.wikipedia.org/wiki/List_of_mainstream_rock_performers) and using the [python wrapper](https://github.com/goldsmith/Wikipedia)
-* [Indexing](https://github.com/anakin87/fact-checking-rocks/blob/321ba7893bbe79582f8c052493acfda497c5b785/notebooks/indexing.ipynb)
- * preprocess the downloaded documents into chunks consisting of 2 sentences
- * chunks with less than 10 words are discarded, because not very informative
- * instantiate a [FAISS](https://github.com/facebookresearch/faiss) Document store and store the passages on it
- * create embeddings for the passages, using a Sentence Transformer model and save them in FAISS. The retrieval task will involve [*asymmetric semantic search*](https://www.sbert.net/examples/applications/semantic-search/README.html#symmetric-vs-asymmetric-semantic-search) (statements to be verified are usually shorter than inherent passages), therefore I choose the model `msmarco-distilbert-base-tas-b`
- * save FAISS index.
-
-#### Search pipeline
-
-* the user enters a factual statement
-* compute the embedding of the user statement using the same Sentence Transformer used for indexing (`msmarco-distilbert-base-tas-b`)
-* retrieve the K most relevant text passages stored in FAISS (along with their relevance scores)
-* the following steps are performed using the [`EntailmentChecker`, a custom Haystack node](https://github.com/anakin87/haystack-entailment-checker)
-* **text entailment task**: compute the text entailment between each text passage (premise) and the user statement (hypothesis), using a Natural Language Inference model (`microsoft/deberta-v2-xlarge-mnli`). For every text passage, we have 3 scores (summing to 1): entailment, contradiction and neutral.
-* aggregate the text entailment scores: compute the weighted average of them, where the weight is the relevance score. **Now it is possible to tell if the knowledge base confirms, is neutral or disproves the user statement.**
-* *empirical consideration: if in the first N passages (N 0.5), it is better not to consider (K-N) less relevant documents.*
-
-#### Explain using a LLM
-* if there is entailment or contradiction, prompt `google/flan-t5-large`, asking why the relevant textual passages entail/contradict the user statement.
-
-### Limits and possible improvements
- ✨ As mentioned, the current approach to fact checking is simple and naive. Some **structural limits of this approach**:
- * there is **no statement detection**. In fact, the statement to be verified is chosen by the user. In real-world applications, this step is often necessary.
- * **Wikipedia is taken as a source of truth**. Unfortunately, Wikipedia does not contain universal knowledge and there is no real guarantee that it is a source of truth. There are certainly very interesting approaches that view a snapshot of the entire web as an uncurated source of knowledge (see [Facebook Research SPHERE](https://arxiv.org/abs/2112.09924)).
- * Several papers and even our experiments show a general effectiveness of **dense retrieval** in retrieving textual passages for evaluating the user statement. However, there may be cases in which the most useful textual passages for fact checking do not emerge from the simple semantic similarity with the statement to be verified.
- * **no organic evaluation** was performed, but only manual experiments.
-
-While keeping this simple approach, some **improvements** could be made:
-* For reasons of simplicity and infrastructural limitations, the retrieval uses only a very small portion of the Wikipedia data (artists pages from the [List of mainstream rock performers](https://en.wikipedia.org/wiki/List_of_mainstream_rock_performers)). With these few data available, in many cases the knowledge base remains neutral even with respect to statements about rock albums/songs. Certainly, fact checking **quality could improve by expanding the knowledge base** and possibly extending it to the entire Wikipedia.
-* Both the retriever model and the Natural Language Inference model are general purpose models and have not been fine-tuned for our domain. Undoubtedly they can **show better performance if fine-tuned in the rock music domain**. Particularly, the retriever model might be adapted with low effort, using [Generative Pseudo Labelling](https://haystack.deepset.ai/guides/gpl).
-
-### Repository structure
-* [Rock_fact_checker.py](Rock_fact_checker.py) and [pages folder](./pages/): multi-page Streamlit web app
-* [app_utils folder](./app_utils/): python modules used in the web app
-* [notebooks folder](./notebooks/): Jupyter/Colab notebooks to get Wikipedia data and index the text passages (using Haystack)
-* [data folder](./data/): all necessary data, including original Wikipedia data, FAISS Index and prepared random statements
-
-### Installation
-💻
-#### Entailment Checker node
-If you want to build a similar system using the [`EntailmentChecker`](https://github.com/anakin87/haystack-entailment-checker), I strongly suggest taking a look at [the node repository](https://github.com/anakin87/haystack-entailment-checker). It can be easily installed with
-```bash
-pip install haystack-entailment-checker
-```
-
-#### Fact Checking 🎸 Rocks!
- To install this project locally, follow these steps:
-* `git clone https://github.com/anakin87/fact-checking-rocks`
-* `cd fact-checking-rocks`
-* `pip install -r requirements.txt`
-
-To run the web app, simply type: `streamlit run Rock_fact_checker.py`
diff --git a/spaces/aphenx/bingo/src/components/toaster.tsx b/spaces/aphenx/bingo/src/components/toaster.tsx
deleted file mode 100644
index 4d2693460b61307a1d4c127fd01df9bee16e59ff..0000000000000000000000000000000000000000
--- a/spaces/aphenx/bingo/src/components/toaster.tsx
+++ /dev/null
@@ -1,3 +0,0 @@
-'use client'
-
-export { Toaster } from 'react-hot-toast'
diff --git a/spaces/aphenx/bingo/src/lib/bots/bing/utils.ts b/spaces/aphenx/bingo/src/lib/bots/bing/utils.ts
deleted file mode 100644
index 64b4b96452d125346b0fc4436b5f7c18c962df0b..0000000000000000000000000000000000000000
--- a/spaces/aphenx/bingo/src/lib/bots/bing/utils.ts
+++ /dev/null
@@ -1,87 +0,0 @@
-import { ChatResponseMessage, BingChatResponse } from './types'
-
-export function convertMessageToMarkdown(message: ChatResponseMessage): string {
- if (message.messageType === 'InternalSearchQuery') {
- return message.text
- }
- for (const card of message.adaptiveCards??[]) {
- for (const block of card.body) {
- if (block.type === 'TextBlock') {
- return block.text
- }
- }
- }
- return ''
-}
-
-const RecordSeparator = String.fromCharCode(30)
-
-export const websocketUtils = {
- packMessage(data: any) {
- return `${JSON.stringify(data)}${RecordSeparator}`
- },
- unpackMessage(data: string | ArrayBuffer | Blob) {
- if (!data) return {}
- return data
- .toString()
- .split(RecordSeparator)
- .filter(Boolean)
- .map((s) => {
- try {
- return JSON.parse(s)
- } catch (e) {
- return {}
- }
- })
- },
-}
-
-export async function createImage(prompt: string, id: string, headers: HeadersInit): Promise {
- const { headers: responseHeaders } = await fetch(`https://www.bing.com/images/create?partner=sydney&re=1&showselective=1&sude=1&kseed=7000&SFX=&q=${encodeURIComponent(prompt)}&iframeid=${id}`,
- {
- method: 'HEAD',
- headers,
- redirect: 'manual'
- },
- );
-
- if (!/&id=([^&]+)$/.test(responseHeaders.get('location') || '')) {
- throw new Error('请求异常，请检查 cookie 是否有效')
- }
-
- const resultId = RegExp.$1;
- let count = 0
- const imageThumbUrl = `https://www.bing.com/images/create/async/results/${resultId}?q=${encodeURIComponent(prompt)}&partner=sydney&showselective=1&IID=images.as`;
-
- do {
- await sleep(3000);
- const content = await fetch(imageThumbUrl, { headers, method: 'GET' })
-
- // @ts-ignore
- if (content.headers.get('content-length') > 1) {
- const text = await content.text()
- return (text?.match(/![]()
target?.split('src="').pop()?.replace(/&/g, '&'))
- .map(img => ``).join(' ')
- }
- } while(count ++ < 10);
-}
-
-
-export async function* streamAsyncIterable(stream: ReadableStream) {
- const reader = stream.getReader()
- try {
- while (true) {
- const { done, value } = await reader.read()
- if (done) {
- return
- }
- yield value
- }
- } finally {
- reader.releaseLock()
- }
-}
-
-export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))
-
diff --git a/spaces/arch-123/bingo/src/lib/utils.ts b/spaces/arch-123/bingo/src/lib/utils.ts
deleted file mode 100644
index 8de2eba94bf0bc93579d4f489e8b810dbf6ce92a..0000000000000000000000000000000000000000
--- a/spaces/arch-123/bingo/src/lib/utils.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { clsx, type ClassValue } from 'clsx'
-import { customAlphabet } from 'nanoid'
-import { twMerge } from 'tailwind-merge'
-// @ts-ignore
-import randomip from 'random-ip'
-import cidr from './cidr.json'
-
-export function cn(...inputs: ClassValue[]) {
- return twMerge(clsx(inputs))
-}
-
-export const nanoid = customAlphabet(
- '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
- 7
-) // 7-character random string
-
-export function createChunkDecoder() {
- const decoder = new TextDecoder()
- return function (chunk: Uint8Array | undefined): string {
- if (!chunk) return ''
- return decoder.decode(chunk, { stream: true })
- }
-}
-
-export function random (start: number, end: number) {
- return start + Math.floor(Math.random() * (end - start))
-}
-
-export function randomIP() {
- // return `104.${random(0, 21)}.${random(0, 127)}.${random(1, 255)}`
- const [ip, range] = cidr.at(random(0, cidr.length))?.split('/')!
- return randomip(ip, range)
-}
-
-export const defaultUID = 'xxx'
-
-export function parseHeadersFromCurl(content: string) {
- const re = /-H '([^:]+):\s*([^']+)/mg
- const headers: HeadersInit = {}
- content = content.replaceAll('-H "', '-H \'').replaceAll('" ^', '\'\\').replaceAll('^\\^"', '"') // 将 cmd curl 转成 bash curl
- content.replace(re, (_: string, key: string, value: string) => {
- headers[key] = value
- return ''
- })
- return headers
-}
-
-export const ChunkKeys = ['BING_HEADER', 'BING_HEADER1', 'BING_HEADER2']
-export function encodeHeadersToCookie(content: string) {
- const base64Content = btoa(content)
- const contentChunks = base64Content.match(/.{1,4000}/g) || []
- return ChunkKeys.map((key, index) => `${key}=${contentChunks[index] ?? ''}`)
-}
-
-export function extraCurlFromCookie(cookies: Partial<{ [key: string]: string }>) {
- let base64Content = ''
- ChunkKeys.forEach((key) => {
- base64Content += (cookies[key] || '')
- })
- try {
- return atob(base64Content)
- } catch(e) {
- return ''
- }
-}
-
-export function extraHeadersFromCookie(cookies: Partial<{ [key: string]: string }>) {
- return parseHeadersFromCurl(extraCurlFromCookie(cookies))
-}
-
-export function formatDate(input: string | number | Date): string {
- const date = new Date(input)
- return date.toLocaleDateString('en-US', {
- month: 'long',
- day: 'numeric',
- year: 'numeric'
- })
-}
-
-export function parseCookie(cookie: string, cookieName: string) {
- const targetCookie = new RegExp(`(?:[; ]|^)${cookieName}=([^;]*)`).test(cookie) ? RegExp.$1 : cookie
- return targetCookie ? decodeURIComponent(targetCookie).trim() : cookie.indexOf('=') === -1 ? cookie.trim() : ''
-}
-
-export function setCookie(key: string, value: string) {
- const maxAge = value ? 86400 * 30 : 0
- document.cookie = `${key}=${value || ''}; Path=/; Max-Age=${maxAge}; SameSite=None; Secure`
-}
-
-export function getCookie(cookieName: string) {
- const re = new RegExp(`(?:[; ]|^)${cookieName}=([^;]*)`)
- return re.test(document.cookie) ? RegExp.$1 : ''
-}
-
-export function parseCookies(cookie: string, cookieNames: string[]) {
- const cookies: { [key: string]: string } = {}
- cookieNames.forEach(cookieName => {
- cookies[cookieName] = parseCookie(cookie, cookieName)
- })
- return cookies
-}
-
-export const DEFAULT_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.0.0'
-
-export function parseUA(ua?: string, default_ua = DEFAULT_UA) {
- return / EDGE?/i.test(decodeURIComponent(ua || '')) ? decodeURIComponent(ua!.trim()) : default_ua
-}
-
-export function mockUser(cookies: Partial<{ [key: string]: string }>) {
- const {
- BING_UA = process.env.BING_UA,
- BING_IP,
- _U = defaultUID,
- } = cookies
- const ua = parseUA(BING_UA)
-
- return {
- 'x-forwarded-for': BING_IP!,
- 'Accept-Encoding': 'gzip, deflate, br',
- 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
- 'User-Agent': ua!,
- 'x-ms-useragent': 'azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.3 OS/Win32',
- cookie: `_U=${_U}` || '',
- }
-}
-
-export function createHeaders(cookies: Partial<{ [key: string]: string }>, type?: string) {
- let {
- BING_HEADER = process.env.BING_HEADER,
- BING_IP,
- IMAGE_ONLY = process.env.IMAGE_ONLY ?? '1',
- } = cookies
- const imageOnly = /^(1|true|yes)$/.test(String(IMAGE_ONLY))
- if (BING_HEADER) {
- if (
- (imageOnly && type === 'image')
- || !imageOnly
- ) {
- const headers = extraHeadersFromCookie({
- BING_HEADER,
- ...cookies,
- }) || {}
- headers['x-forward-for'] = BING_IP!
- return headers
- }
- }
- return mockUser(cookies)
-}
-
-export class WatchDog {
- private tid = 0
- watch(fn: Function, timeout = 2000) {
- clearTimeout(this.tid)
- this.tid = setTimeout(fn, timeout + Math.random() * 1000)
- }
- reset() {
- clearTimeout(this.tid)
- }
-}
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/vegalite/v3/tests/test_api.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/vegalite/v3/tests/test_api.py
deleted file mode 100644
index 489d8cf6735f4a0fb444839d9a497e24e9ecf15c..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/vegalite/v3/tests/test_api.py
+++ /dev/null
@@ -1,937 +0,0 @@
-"""Unit tests for altair API"""
-
-import io
-import json
-import operator
-import os
-import tempfile
-
-import jsonschema
-import pytest
-import pandas as pd
-
-import altair.vegalite.v3 as alt
-from altair.utils import AltairDeprecationWarning
-
-try:
- import altair_saver # noqa: F401
-except ImportError:
- altair_saver = None
-
-
-def getargs(*args, **kwargs):
- return args, kwargs
-
-
-OP_DICT = {
- "layer": operator.add,
- "hconcat": operator.or_,
- "vconcat": operator.and_,
-}
-
-
-def _make_chart_type(chart_type):
- data = pd.DataFrame(
- {
- "x": [28, 55, 43, 91, 81, 53, 19, 87],
- "y": [43, 91, 81, 53, 19, 87, 52, 28],
- "color": list("AAAABBBB"),
- }
- )
- base = (
- alt.Chart(data)
- .mark_point()
- .encode(
- x="x",
- y="y",
- color="color",
- )
- )
-
- if chart_type in ["layer", "hconcat", "vconcat", "concat"]:
- func = getattr(alt, chart_type)
- return func(base.mark_square(), base.mark_circle())
- elif chart_type == "facet":
- return base.facet("color")
- elif chart_type == "facet_encoding":
- return base.encode(facet="color")
- elif chart_type == "repeat":
- return base.encode(alt.X(alt.repeat(), type="quantitative")).repeat(["x", "y"])
- elif chart_type == "chart":
- return base
- else:
- raise ValueError("chart_type='{}' is not recognized".format(chart_type))
-
-
-@pytest.fixture
-def basic_chart():
- data = pd.DataFrame(
- {
- "a": ["A", "B", "C", "D", "E", "F", "G", "H", "I"],
- "b": [28, 55, 43, 91, 81, 53, 19, 87, 52],
- }
- )
-
- return alt.Chart(data).mark_bar().encode(x="a", y="b")
-
-
-def test_chart_data_types():
- def Chart(data):
- return alt.Chart(data).mark_point().encode(x="x:Q", y="y:Q")
-
- # Url Data
- data = "/path/to/my/data.csv"
- dct = Chart(data).to_dict()
- assert dct["data"] == {"url": data}
-
- # Dict Data
- data = {"values": [{"x": 1, "y": 2}, {"x": 2, "y": 3}]}
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct = Chart(data).to_dict()
- assert dct["data"] == data
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct = Chart(data).to_dict()
- name = dct["data"]["name"]
- assert dct["datasets"][name] == data["values"]
-
- # DataFrame data
- data = pd.DataFrame({"x": range(5), "y": range(5)})
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct = Chart(data).to_dict()
- assert dct["data"]["values"] == data.to_dict(orient="records")
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct = Chart(data).to_dict()
- name = dct["data"]["name"]
- assert dct["datasets"][name] == data.to_dict(orient="records")
-
- # Named data object
- data = alt.NamedData(name="Foo")
- dct = Chart(data).to_dict()
- assert dct["data"] == {"name": "Foo"}
-
-
-def test_chart_infer_types():
- data = pd.DataFrame(
- {
- "x": pd.date_range("2012", periods=10, freq="Y"),
- "y": range(10),
- "c": list("abcabcabca"),
- }
- )
-
- def _check_encodings(chart):
- dct = chart.to_dict()
- assert dct["encoding"]["x"]["type"] == "temporal"
- assert dct["encoding"]["x"]["field"] == "x"
- assert dct["encoding"]["y"]["type"] == "quantitative"
- assert dct["encoding"]["y"]["field"] == "y"
- assert dct["encoding"]["color"]["type"] == "nominal"
- assert dct["encoding"]["color"]["field"] == "c"
-
- # Pass field names by keyword
- chart = alt.Chart(data).mark_point().encode(x="x", y="y", color="c")
- _check_encodings(chart)
-
- # pass Channel objects by keyword
- chart = (
- alt.Chart(data)
- .mark_point()
- .encode(x=alt.X("x"), y=alt.Y("y"), color=alt.Color("c"))
- )
- _check_encodings(chart)
-
- # pass Channel objects by value
- chart = alt.Chart(data).mark_point().encode(alt.X("x"), alt.Y("y"), alt.Color("c"))
- _check_encodings(chart)
-
- # override default types
- chart = (
- alt.Chart(data)
- .mark_point()
- .encode(alt.X("x", type="nominal"), alt.Y("y", type="ordinal"))
- )
- dct = chart.to_dict()
- assert dct["encoding"]["x"]["type"] == "nominal"
- assert dct["encoding"]["y"]["type"] == "ordinal"
-
-
-@pytest.mark.parametrize(
- "args, kwargs",
- [
- getargs(detail=["value:Q", "name:N"], tooltip=["value:Q", "name:N"]),
- getargs(detail=["value", "name"], tooltip=["value", "name"]),
- getargs(alt.Detail(["value:Q", "name:N"]), alt.Tooltip(["value:Q", "name:N"])),
- getargs(alt.Detail(["value", "name"]), alt.Tooltip(["value", "name"])),
- getargs(
- [alt.Detail("value:Q"), alt.Detail("name:N")],
- [alt.Tooltip("value:Q"), alt.Tooltip("name:N")],
- ),
- getargs(
- [alt.Detail("value"), alt.Detail("name")],
- [alt.Tooltip("value"), alt.Tooltip("name")],
- ),
- ],
-)
-def test_multiple_encodings(args, kwargs):
- df = pd.DataFrame({"value": [1, 2, 3], "name": ["A", "B", "C"]})
- encoding_dct = [
- {"field": "value", "type": "quantitative"},
- {"field": "name", "type": "nominal"},
- ]
- chart = alt.Chart(df).mark_point().encode(*args, **kwargs)
- dct = chart.to_dict()
- assert dct["encoding"]["detail"] == encoding_dct
- assert dct["encoding"]["tooltip"] == encoding_dct
-
-
-def test_chart_operations():
- data = pd.DataFrame(
- {
- "x": pd.date_range("2012", periods=10, freq="Y"),
- "y": range(10),
- "c": list("abcabcabca"),
- }
- )
- chart1 = alt.Chart(data).mark_line().encode(x="x", y="y", color="c")
- chart2 = chart1.mark_point()
- chart3 = chart1.mark_circle()
- chart4 = chart1.mark_square()
-
- chart = chart1 + chart2 + chart3
- assert isinstance(chart, alt.LayerChart)
- assert len(chart.layer) == 3
- chart += chart4
- assert len(chart.layer) == 4
-
- chart = chart1 | chart2 | chart3
- assert isinstance(chart, alt.HConcatChart)
- assert len(chart.hconcat) == 3
- chart |= chart4
- assert len(chart.hconcat) == 4
-
- chart = chart1 & chart2 & chart3
- assert isinstance(chart, alt.VConcatChart)
- assert len(chart.vconcat) == 3
- chart &= chart4
- assert len(chart.vconcat) == 4
-
-
-def test_selection_to_dict():
- brush = alt.selection(type="interval")
-
- # test some value selections
- # Note: X and Y cannot have conditions
- alt.Chart("path/to/data.json").mark_point().encode(
- color=alt.condition(brush, alt.ColorValue("red"), alt.ColorValue("blue")),
- opacity=alt.condition(brush, alt.value(0.5), alt.value(1.0)),
- text=alt.condition(brush, alt.TextValue("foo"), alt.value("bar")),
- ).to_dict()
-
- # test some field selections
- # Note: X and Y cannot have conditions
- # Conditions cannot both be fields
- alt.Chart("path/to/data.json").mark_point().encode(
- color=alt.condition(brush, alt.Color("col1:N"), alt.value("blue")),
- opacity=alt.condition(brush, "col1:N", alt.value(0.5)),
- text=alt.condition(brush, alt.value("abc"), alt.Text("col2:N")),
- size=alt.condition(brush, alt.value(20), "col2:N"),
- ).to_dict()
-
-
-def test_selection_expression():
- selection = alt.selection_single(fields=["value"])
-
- assert isinstance(selection.value, alt.expr.Expression)
- assert selection.value.to_dict() == "{0}.value".format(selection.name)
-
- assert isinstance(selection["value"], alt.expr.Expression)
- assert selection["value"].to_dict() == "{0}['value']".format(selection.name)
-
- with pytest.raises(AttributeError):
- selection.__magic__
-
-
-@pytest.mark.parametrize("format", ["html", "json", "png", "svg", "pdf"])
-def test_save(format, basic_chart):
- if format in ["pdf", "png"]:
- out = io.BytesIO()
- mode = "rb"
- else:
- out = io.StringIO()
- mode = "r"
-
- if format in ["svg", "png", "pdf"]:
- if not altair_saver:
- with pytest.raises(ValueError) as err:
- basic_chart.save(out, format=format)
- assert "github.com/altair-viz/altair_saver" in str(err.value)
- return
- elif format not in altair_saver.available_formats():
- with pytest.raises(ValueError) as err:
- basic_chart.save(out, format=format)
- assert f"No enabled saver found that supports format='{format}'" in str(
- err.value
- )
- return
-
- basic_chart.save(out, format=format)
- out.seek(0)
- content = out.read()
-
- if format == "json":
- assert "$schema" in json.loads(content)
- if format == "html":
- assert content.startswith("")
-
- fid, filename = tempfile.mkstemp(suffix="." + format)
- os.close(fid)
-
- try:
- basic_chart.save(filename)
- with open(filename, mode) as f:
- assert f.read()[:1000] == content[:1000]
- finally:
- os.remove(filename)
-
-
-def test_facet_basic():
- # wrapped facet
- chart1 = (
- alt.Chart("data.csv")
- .mark_point()
- .encode(
- x="x:Q",
- y="y:Q",
- )
- .facet("category:N", columns=2)
- )
-
- dct1 = chart1.to_dict()
-
- assert dct1["facet"] == alt.Facet("category:N").to_dict()
- assert dct1["columns"] == 2
- assert dct1["data"] == alt.UrlData("data.csv").to_dict()
-
- # explicit row/col facet
- chart2 = (
- alt.Chart("data.csv")
- .mark_point()
- .encode(
- x="x:Q",
- y="y:Q",
- )
- .facet(row="category1:Q", column="category2:Q")
- )
-
- dct2 = chart2.to_dict()
-
- assert dct2["facet"]["row"] == alt.Facet("category1:Q").to_dict()
- assert dct2["facet"]["column"] == alt.Facet("category2:Q").to_dict()
- assert "columns" not in dct2
- assert dct2["data"] == alt.UrlData("data.csv").to_dict()
-
-
-def test_facet_parse():
- chart = (
- alt.Chart("data.csv")
- .mark_point()
- .encode(x="x:Q", y="y:Q")
- .facet(row="row:N", column="column:O")
- )
- dct = chart.to_dict()
- assert dct["data"] == {"url": "data.csv"}
- assert "data" not in dct["spec"]
- assert dct["facet"] == {
- "column": {"field": "column", "type": "ordinal"},
- "row": {"field": "row", "type": "nominal"},
- }
-
-
-def test_facet_parse_data():
- data = pd.DataFrame({"x": range(5), "y": range(5), "row": list("abcab")})
- chart = (
- alt.Chart(data)
- .mark_point()
- .encode(x="x", y="y:O")
- .facet(row="row", column="column:O")
- )
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct = chart.to_dict()
- assert "values" in dct["data"]
- assert "data" not in dct["spec"]
- assert dct["facet"] == {
- "column": {"field": "column", "type": "ordinal"},
- "row": {"field": "row", "type": "nominal"},
- }
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct = chart.to_dict()
- assert "datasets" in dct
- assert "name" in dct["data"]
- assert "data" not in dct["spec"]
- assert dct["facet"] == {
- "column": {"field": "column", "type": "ordinal"},
- "row": {"field": "row", "type": "nominal"},
- }
-
-
-def test_selection():
- # test instantiation of selections
- interval = alt.selection_interval(name="selec_1")
- assert interval.selection.type == "interval"
- assert interval.name == "selec_1"
-
- single = alt.selection_single(name="selec_2")
- assert single.selection.type == "single"
- assert single.name == "selec_2"
-
- multi = alt.selection_multi(name="selec_3")
- assert multi.selection.type == "multi"
- assert multi.name == "selec_3"
-
- # test adding to chart
- chart = alt.Chart().add_selection(single)
- chart = chart.add_selection(multi, interval)
- assert set(chart.selection.keys()) == {"selec_1", "selec_2", "selec_3"}
-
- # test logical operations
- assert isinstance(single & multi, alt.Selection)
- assert isinstance(single | multi, alt.Selection)
- assert isinstance(~single, alt.Selection)
- assert isinstance((single & multi)[0].group, alt.SelectionAnd)
- assert isinstance((single | multi)[0].group, alt.SelectionOr)
- assert isinstance((~single)[0].group, alt.SelectionNot)
-
- # test that default names increment (regression for #1454)
- sel1 = alt.selection_single()
- sel2 = alt.selection_multi()
- sel3 = alt.selection_interval()
- names = {s.name for s in (sel1, sel2, sel3)}
- assert len(names) == 3
-
-
-def test_transforms():
- # aggregate transform
- agg1 = alt.AggregatedFieldDef(**{"as": "x1", "op": "mean", "field": "y"})
- agg2 = alt.AggregatedFieldDef(**{"as": "x2", "op": "median", "field": "z"})
- chart = alt.Chart().transform_aggregate([agg1], ["foo"], x2="median(z)")
- kwds = dict(aggregate=[agg1, agg2], groupby=["foo"])
- assert chart.transform == [alt.AggregateTransform(**kwds)]
-
- # bin transform
- chart = alt.Chart().transform_bin("binned", field="field", bin=True)
- kwds = {"as": "binned", "field": "field", "bin": True}
- assert chart.transform == [alt.BinTransform(**kwds)]
-
- # calcualte transform
- chart = alt.Chart().transform_calculate("calc", "datum.a * 4")
- kwds = {"as": "calc", "calculate": "datum.a * 4"}
- assert chart.transform == [alt.CalculateTransform(**kwds)]
-
- # impute transform
- chart = alt.Chart().transform_impute("field", "key", groupby=["x"])
- kwds = {"impute": "field", "key": "key", "groupby": ["x"]}
- assert chart.transform == [alt.ImputeTransform(**kwds)]
-
- # joinaggregate transform
- chart = alt.Chart().transform_joinaggregate(min="min(x)", groupby=["key"])
- kwds = {
- "joinaggregate": [
- alt.JoinAggregateFieldDef(field="x", op="min", **{"as": "min"})
- ],
- "groupby": ["key"],
- }
- assert chart.transform == [alt.JoinAggregateTransform(**kwds)]
-
- # filter transform
- chart = alt.Chart().transform_filter("datum.a < 4")
- assert chart.transform == [alt.FilterTransform(filter="datum.a < 4")]
-
- # flatten transform
- chart = alt.Chart().transform_flatten(["A", "B"], ["X", "Y"])
- kwds = {"as": ["X", "Y"], "flatten": ["A", "B"]}
- assert chart.transform == [alt.FlattenTransform(**kwds)]
-
- # fold transform
- chart = alt.Chart().transform_fold(["A", "B", "C"], as_=["key", "val"])
- kwds = {"as": ["key", "val"], "fold": ["A", "B", "C"]}
- assert chart.transform == [alt.FoldTransform(**kwds)]
-
- # lookup transform
- lookup_data = alt.LookupData(alt.UrlData("foo.csv"), "id", ["rate"])
- chart = alt.Chart().transform_lookup(
- from_=lookup_data, as_="a", lookup="a", default="b"
- )
- kwds = {"from": lookup_data, "as": "a", "lookup": "a", "default": "b"}
- assert chart.transform == [alt.LookupTransform(**kwds)]
-
- # sample transform
- chart = alt.Chart().transform_sample()
- assert chart.transform == [alt.SampleTransform(1000)]
-
- # stack transform
- chart = alt.Chart().transform_stack("stacked", "x", groupby=["y"])
- assert chart.transform == [
- alt.StackTransform(stack="x", groupby=["y"], **{"as": "stacked"})
- ]
-
- # timeUnit transform
- chart = alt.Chart().transform_timeunit("foo", field="x", timeUnit="date")
- kwds = {"as": "foo", "field": "x", "timeUnit": "date"}
- assert chart.transform == [alt.TimeUnitTransform(**kwds)]
-
- # window transform
- chart = alt.Chart().transform_window(xsum="sum(x)", ymin="min(y)", frame=[None, 0])
- window = [
- alt.WindowFieldDef(**{"as": "xsum", "field": "x", "op": "sum"}),
- alt.WindowFieldDef(**{"as": "ymin", "field": "y", "op": "min"}),
- ]
-
- # kwargs don't maintain order in Python < 3.6, so window list can
- # be reversed
- assert chart.transform == [
- alt.WindowTransform(frame=[None, 0], window=window)
- ] or chart.transform == [alt.WindowTransform(frame=[None, 0], window=window[::-1])]
-
-
-def test_filter_transform_selection_predicates():
- selector1 = alt.selection_interval(name="s1")
- selector2 = alt.selection_interval(name="s2")
- base = alt.Chart("data.txt").mark_point()
-
- chart = base.transform_filter(selector1)
- assert chart.to_dict()["transform"] == [{"filter": {"selection": "s1"}}]
-
- chart = base.transform_filter(~selector1)
- assert chart.to_dict()["transform"] == [{"filter": {"selection": {"not": "s1"}}}]
-
- chart = base.transform_filter(selector1 & selector2)
- assert chart.to_dict()["transform"] == [
- {"filter": {"selection": {"and": ["s1", "s2"]}}}
- ]
-
- chart = base.transform_filter(selector1 | selector2)
- assert chart.to_dict()["transform"] == [
- {"filter": {"selection": {"or": ["s1", "s2"]}}}
- ]
-
- chart = base.transform_filter(selector1 | ~selector2)
- assert chart.to_dict()["transform"] == [
- {"filter": {"selection": {"or": ["s1", {"not": "s2"}]}}}
- ]
-
- chart = base.transform_filter(~selector1 | ~selector2)
- assert chart.to_dict()["transform"] == [
- {"filter": {"selection": {"or": [{"not": "s1"}, {"not": "s2"}]}}}
- ]
-
- chart = base.transform_filter(~(selector1 & selector2))
- assert chart.to_dict()["transform"] == [
- {"filter": {"selection": {"not": {"and": ["s1", "s2"]}}}}
- ]
-
-
-def test_resolve_methods():
- chart = alt.LayerChart().resolve_axis(x="shared", y="independent")
- assert chart.resolve == alt.Resolve(
- axis=alt.AxisResolveMap(x="shared", y="independent")
- )
-
- chart = alt.LayerChart().resolve_legend(color="shared", fill="independent")
- assert chart.resolve == alt.Resolve(
- legend=alt.LegendResolveMap(color="shared", fill="independent")
- )
-
- chart = alt.LayerChart().resolve_scale(x="shared", y="independent")
- assert chart.resolve == alt.Resolve(
- scale=alt.ScaleResolveMap(x="shared", y="independent")
- )
-
-
-def test_layer_encodings():
- chart = alt.LayerChart().encode(x="column:Q")
- assert chart.encoding.x == alt.X(shorthand="column:Q")
-
-
-def test_add_selection():
- selections = [
- alt.selection_interval(),
- alt.selection_single(),
- alt.selection_multi(),
- ]
- chart = (
- alt.Chart()
- .mark_point()
- .add_selection(selections[0])
- .add_selection(selections[1], selections[2])
- )
- expected = {s.name: s.selection for s in selections}
- assert chart.selection == expected
-
-
-def test_repeat_add_selections():
- base = alt.Chart("data.csv").mark_point()
- selection = alt.selection_single()
- chart1 = base.add_selection(selection).repeat(list("ABC"))
- chart2 = base.repeat(list("ABC")).add_selection(selection)
- assert chart1.to_dict() == chart2.to_dict()
-
-
-def test_facet_add_selections():
- base = alt.Chart("data.csv").mark_point()
- selection = alt.selection_single()
- chart1 = base.add_selection(selection).facet("val:Q")
- chart2 = base.facet("val:Q").add_selection(selection)
- assert chart1.to_dict() == chart2.to_dict()
-
-
-def test_layer_add_selection():
- base = alt.Chart("data.csv").mark_point()
- selection = alt.selection_single()
- chart1 = alt.layer(base.add_selection(selection), base)
- chart2 = alt.layer(base, base).add_selection(selection)
- assert chart1.to_dict() == chart2.to_dict()
-
-
-@pytest.mark.parametrize("charttype", [alt.concat, alt.hconcat, alt.vconcat])
-def test_compound_add_selections(charttype):
- base = alt.Chart("data.csv").mark_point()
- selection = alt.selection_single()
- chart1 = charttype(base.add_selection(selection), base.add_selection(selection))
- chart2 = charttype(base, base).add_selection(selection)
- assert chart1.to_dict() == chart2.to_dict()
-
-
-def test_selection_property():
- sel = alt.selection_interval()
- chart = alt.Chart("data.csv").mark_point().properties(selection=sel)
-
- assert list(chart["selection"].keys()) == [sel.name]
-
-
-def test_LookupData():
- df = pd.DataFrame({"x": [1, 2, 3], "y": [4, 5, 6]})
- lookup = alt.LookupData(data=df, key="x")
-
- dct = lookup.to_dict()
- assert dct["key"] == "x"
- assert dct["data"] == {
- "values": [{"x": 1, "y": 4}, {"x": 2, "y": 5}, {"x": 3, "y": 6}]
- }
-
-
-def test_themes():
- chart = alt.Chart("foo.txt").mark_point()
- active = alt.themes.active
-
- try:
- alt.themes.enable("default")
- assert chart.to_dict()["config"] == {
- "mark": {"tooltip": None},
- "view": {"width": 400, "height": 300},
- }
-
- alt.themes.enable("opaque")
- assert chart.to_dict()["config"] == {
- "background": "white",
- "mark": {"tooltip": None},
- "view": {"width": 400, "height": 300},
- }
-
- alt.themes.enable("none")
- assert "config" not in chart.to_dict()
-
- finally:
- # re-enable the original active theme
- alt.themes.enable(active)
-
-
-def test_chart_from_dict():
- base = alt.Chart("data.csv").mark_point().encode(x="x:Q", y="y:Q")
-
- charts = [
- base,
- base + base,
- base | base,
- base & base,
- base.facet("c:N"),
- (base + base).facet(row="c:N", data="data.csv"),
- base.repeat(["c", "d"]),
- (base + base).repeat(row=["c", "d"]),
- ]
-
- for chart in charts:
- print(chart)
- chart_out = alt.Chart.from_dict(chart.to_dict())
- assert type(chart_out) is type(chart)
-
- # test that an invalid spec leads to a schema validation error
- with pytest.raises(jsonschema.ValidationError):
- alt.Chart.from_dict({"invalid": "spec"})
-
-
-def test_consolidate_datasets(basic_chart):
- subchart1 = basic_chart
- subchart2 = basic_chart.copy()
- subchart2.data = basic_chart.data.copy()
- chart = subchart1 | subchart2
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct_consolidated = chart.to_dict()
-
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct_standard = chart.to_dict()
-
- assert "datasets" in dct_consolidated
- assert "datasets" not in dct_standard
-
- datasets = dct_consolidated["datasets"]
-
- # two dataset copies should be recognized as duplicates
- assert len(datasets) == 1
-
- # make sure data matches original & names are correct
- name, data = datasets.popitem()
-
- for spec in dct_standard["hconcat"]:
- assert spec["data"]["values"] == data
-
- for spec in dct_consolidated["hconcat"]:
- assert spec["data"] == {"name": name}
-
-
-def test_consolidate_InlineData():
- data = alt.InlineData(
- values=[{"a": 1, "b": 1}, {"a": 2, "b": 2}], format={"type": "csv"}
- )
- chart = alt.Chart(data).mark_point()
-
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct = chart.to_dict()
- assert dct["data"]["format"] == data.format
- assert dct["data"]["values"] == data.values
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct = chart.to_dict()
- assert dct["data"]["format"] == data.format
- assert list(dct["datasets"].values())[0] == data.values
-
- data = alt.InlineData(values=[], name="runtime_data")
- chart = alt.Chart(data).mark_point()
-
- with alt.data_transformers.enable(consolidate_datasets=False):
- dct = chart.to_dict()
- assert dct["data"] == data.to_dict()
-
- with alt.data_transformers.enable(consolidate_datasets=True):
- dct = chart.to_dict()
- assert dct["data"] == data.to_dict()
-
-
-def test_deprecated_encodings():
- base = alt.Chart("data.txt").mark_point()
-
- with pytest.warns(AltairDeprecationWarning) as record:
- chart1 = base.encode(strokeOpacity=alt.Strokeopacity("x:Q")).to_dict()
- assert "alt.StrokeOpacity" in record[0].message.args[0]
- chart2 = base.encode(strokeOpacity=alt.StrokeOpacity("x:Q")).to_dict()
-
- assert chart1 == chart2
-
-
-def test_repeat():
- # wrapped repeat
- chart1 = (
- alt.Chart("data.csv")
- .mark_point()
- .encode(
- x=alt.X(alt.repeat(), type="quantitative"),
- y="y:Q",
- )
- .repeat(["A", "B", "C", "D"], columns=2)
- )
-
- dct1 = chart1.to_dict()
-
- assert dct1["repeat"] == ["A", "B", "C", "D"]
- assert dct1["columns"] == 2
- assert dct1["spec"]["encoding"]["x"]["field"] == {"repeat": "repeat"}
-
- # explicit row/col repeat
- chart2 = (
- alt.Chart("data.csv")
- .mark_point()
- .encode(
- x=alt.X(alt.repeat("row"), type="quantitative"),
- y=alt.Y(alt.repeat("column"), type="quantitative"),
- )
- .repeat(row=["A", "B", "C"], column=["C", "B", "A"])
- )
-
- dct2 = chart2.to_dict()
-
- assert dct2["repeat"] == {"row": ["A", "B", "C"], "column": ["C", "B", "A"]}
- assert "columns" not in dct2
- assert dct2["spec"]["encoding"]["x"]["field"] == {"repeat": "row"}
- assert dct2["spec"]["encoding"]["y"]["field"] == {"repeat": "column"}
-
-
-def test_data_property():
- data = pd.DataFrame({"x": [1, 2, 3], "y": list("ABC")})
- chart1 = alt.Chart(data).mark_point()
- chart2 = alt.Chart().mark_point().properties(data=data)
-
- assert chart1.to_dict() == chart2.to_dict()
-
-
-@pytest.mark.parametrize("method", ["layer", "hconcat", "vconcat", "concat"])
-@pytest.mark.parametrize(
- "data", ["data.json", pd.DataFrame({"x": range(3), "y": list("abc")})]
-)
-def test_subcharts_with_same_data(method, data):
- func = getattr(alt, method)
-
- point = alt.Chart(data).mark_point().encode(x="x:Q", y="y:Q")
- line = point.mark_line()
- text = point.mark_text()
-
- chart1 = func(point, line, text)
- assert chart1.data is not alt.Undefined
- assert all(c.data is alt.Undefined for c in getattr(chart1, method))
-
- if method != "concat":
- op = OP_DICT[method]
- chart2 = op(op(point, line), text)
- assert chart2.data is not alt.Undefined
- assert all(c.data is alt.Undefined for c in getattr(chart2, method))
-
-
-@pytest.mark.parametrize("method", ["layer", "hconcat", "vconcat", "concat"])
-@pytest.mark.parametrize(
- "data", ["data.json", pd.DataFrame({"x": range(3), "y": list("abc")})]
-)
-def test_subcharts_different_data(method, data):
- func = getattr(alt, method)
-
- point = alt.Chart(data).mark_point().encode(x="x:Q", y="y:Q")
- otherdata = alt.Chart("data.csv").mark_point().encode(x="x:Q", y="y:Q")
- nodata = alt.Chart().mark_point().encode(x="x:Q", y="y:Q")
-
- chart1 = func(point, otherdata)
- assert chart1.data is alt.Undefined
- assert getattr(chart1, method)[0].data is data
-
- chart2 = func(point, nodata)
- assert chart2.data is alt.Undefined
- assert getattr(chart2, method)[0].data is data
-
-
-def test_layer_facet(basic_chart):
- chart = (basic_chart + basic_chart).facet(row="row:Q")
- assert chart.data is not alt.Undefined
- assert chart.spec.data is alt.Undefined
- for layer in chart.spec.layer:
- assert layer.data is alt.Undefined
-
- dct = chart.to_dict()
- assert "data" in dct
-
-
-def test_layer_errors():
- toplevel_chart = alt.Chart("data.txt").mark_point().configure_legend(columns=2)
-
- facet_chart1 = alt.Chart("data.txt").mark_point().encode(facet="row:Q")
-
- facet_chart2 = alt.Chart("data.txt").mark_point().facet("row:Q")
-
- repeat_chart = alt.Chart("data.txt").mark_point().repeat(["A", "B", "C"])
-
- simple_chart = alt.Chart("data.txt").mark_point()
-
- with pytest.raises(ValueError) as err:
- toplevel_chart + simple_chart
- assert str(err.value).startswith(
- 'Objects with "config" attribute cannot be used within LayerChart.'
- )
-
- with pytest.raises(ValueError) as err:
- repeat_chart + simple_chart
- assert str(err.value) == "Repeat charts cannot be layered."
-
- with pytest.raises(ValueError) as err:
- facet_chart1 + simple_chart
- assert str(err.value) == "Faceted charts cannot be layered."
-
- with pytest.raises(ValueError) as err:
- alt.layer(simple_chart) + facet_chart2
- assert str(err.value) == "Faceted charts cannot be layered."
-
-
-@pytest.mark.parametrize(
- "chart_type",
- ["layer", "hconcat", "vconcat", "concat", "facet", "facet_encoding", "repeat"],
-)
-def test_resolve(chart_type):
- chart = _make_chart_type(chart_type)
- chart = (
- chart.resolve_scale(
- x="independent",
- )
- .resolve_legend(color="independent")
- .resolve_axis(y="independent")
- )
- dct = chart.to_dict()
- assert dct["resolve"] == {
- "scale": {"x": "independent"},
- "legend": {"color": "independent"},
- "axis": {"y": "independent"},
- }
-
-
-# TODO: test vconcat, hconcat, concat when schema allows them.
-# This is blocked by https://github.com/vega/vega-lite/issues/5261
-@pytest.mark.parametrize("chart_type", ["chart", "layer", "facet_encoding"])
-@pytest.mark.parametrize("facet_arg", [None, "facet", "row", "column"])
-def test_facet(chart_type, facet_arg):
- chart = _make_chart_type(chart_type)
- if facet_arg is None:
- chart = chart.facet("color:N", columns=2)
- else:
- chart = chart.facet(**{facet_arg: "color:N", "columns": 2})
- dct = chart.to_dict()
-
- assert "spec" in dct
- assert dct["columns"] == 2
- expected = {"field": "color", "type": "nominal"}
- if facet_arg is None or facet_arg == "facet":
- assert dct["facet"] == expected
- else:
- assert dct["facet"][facet_arg] == expected
-
-
-def test_sequence():
- data = alt.sequence(100)
- assert data.to_dict() == {"sequence": {"start": 0, "stop": 100}}
-
- data = alt.sequence(5, 10)
- assert data.to_dict() == {"sequence": {"start": 5, "stop": 10}}
-
- data = alt.sequence(0, 1, 0.1, as_="x")
- assert data.to_dict() == {
- "sequence": {"start": 0, "stop": 1, "step": 0.1, "as": "x"}
- }
-
-
-def test_graticule():
- data = alt.graticule()
- assert data.to_dict() == {"graticule": True}
-
- data = alt.graticule(step=[15, 15])
- assert data.to_dict() == {"graticule": {"step": [15, 15]}}
-
-
-def test_sphere():
- data = alt.sphere()
- assert data.to_dict() == {"sphere": True}
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/attr/validators.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/attr/validators.py
deleted file mode 100644
index 0b0c8342f2528678c1ab84b027abb12175f59fc7..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/attr/validators.py
+++ /dev/null
@@ -1,561 +0,0 @@
-# SPDX-License-Identifier: MIT
-
-"""
-Commonly useful validators.
-"""
-
-from __future__ import absolute_import, division, print_function
-
-import operator
-import re
-
-from contextlib import contextmanager
-
-from ._config import get_run_validators, set_run_validators
-from ._make import _AndValidator, and_, attrib, attrs
-from .exceptions import NotCallableError
-
-
-try:
- Pattern = re.Pattern
-except AttributeError: # Python <3.7 lacks a Pattern type.
- Pattern = type(re.compile(""))
-
-
-__all__ = [
- "and_",
- "deep_iterable",
- "deep_mapping",
- "disabled",
- "ge",
- "get_disabled",
- "gt",
- "in_",
- "instance_of",
- "is_callable",
- "le",
- "lt",
- "matches_re",
- "max_len",
- "optional",
- "provides",
- "set_disabled",
-]
-
-
-def set_disabled(disabled):
- """
- Globally disable or enable running validators.
-
- By default, they are run.
-
- :param disabled: If ``True``, disable running all validators.
- :type disabled: bool
-
- .. warning::
-
- This function is not thread-safe!
-
- .. versionadded:: 21.3.0
- """
- set_run_validators(not disabled)
-
-
-def get_disabled():
- """
- Return a bool indicating whether validators are currently disabled or not.
-
- :return: ``True`` if validators are currently disabled.
- :rtype: bool
-
- .. versionadded:: 21.3.0
- """
- return not get_run_validators()
-
-
-@contextmanager
-def disabled():
- """
- Context manager that disables running validators within its context.
-
- .. warning::
-
- This context manager is not thread-safe!
-
- .. versionadded:: 21.3.0
- """
- set_run_validators(False)
- try:
- yield
- finally:
- set_run_validators(True)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _InstanceOfValidator(object):
- type = attrib()
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if not isinstance(value, self.type):
- raise TypeError(
- "'{name}' must be {type!r} (got {value!r} that is a "
- "{actual!r}).".format(
- name=attr.name,
- type=self.type,
- actual=value.__class__,
- value=value,
- ),
- attr,
- self.type,
- value,
- )
-
- def __repr__(self):
- return "".format(
- type=self.type
- )
-
-
-def instance_of(type):
- """
- A validator that raises a `TypeError` if the initializer is called
- with a wrong type for this particular attribute (checks are performed using
- `isinstance` therefore it's also valid to pass a tuple of types).
-
- :param type: The type to check for.
- :type type: type or tuple of types
-
- :raises TypeError: With a human readable error message, the attribute
- (of type `attrs.Attribute`), the expected type, and the value it
- got.
- """
- return _InstanceOfValidator(type)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MatchesReValidator(object):
- pattern = attrib()
- match_func = attrib()
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if not self.match_func(value):
- raise ValueError(
- "'{name}' must match regex {pattern!r}"
- " ({value!r} doesn't)".format(
- name=attr.name, pattern=self.pattern.pattern, value=value
- ),
- attr,
- self.pattern,
- value,
- )
-
- def __repr__(self):
- return "".format(
- pattern=self.pattern
- )
-
-
-def matches_re(regex, flags=0, func=None):
- r"""
- A validator that raises `ValueError` if the initializer is called
- with a string that doesn't match *regex*.
-
- :param regex: a regex string or precompiled pattern to match against
- :param int flags: flags that will be passed to the underlying re function
- (default 0)
- :param callable func: which underlying `re` function to call (options
- are `re.fullmatch`, `re.search`, `re.match`, default
- is ``None`` which means either `re.fullmatch` or an emulation of
- it on Python 2). For performance reasons, they won't be used directly
- but on a pre-`re.compile`\ ed pattern.
-
- .. versionadded:: 19.2.0
- .. versionchanged:: 21.3.0 *regex* can be a pre-compiled pattern.
- """
- fullmatch = getattr(re, "fullmatch", None)
- valid_funcs = (fullmatch, None, re.search, re.match)
- if func not in valid_funcs:
- raise ValueError(
- "'func' must be one of {}.".format(
- ", ".join(
- sorted(
- e and e.__name__ or "None" for e in set(valid_funcs)
- )
- )
- )
- )
-
- if isinstance(regex, Pattern):
- if flags:
- raise TypeError(
- "'flags' can only be used with a string pattern; "
- "pass flags to re.compile() instead"
- )
- pattern = regex
- else:
- pattern = re.compile(regex, flags)
-
- if func is re.match:
- match_func = pattern.match
- elif func is re.search:
- match_func = pattern.search
- elif fullmatch:
- match_func = pattern.fullmatch
- else: # Python 2 fullmatch emulation (https://bugs.python.org/issue16203)
- pattern = re.compile(
- r"(?:{})\Z".format(pattern.pattern), pattern.flags
- )
- match_func = pattern.match
-
- return _MatchesReValidator(pattern, match_func)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _ProvidesValidator(object):
- interface = attrib()
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if not self.interface.providedBy(value):
- raise TypeError(
- "'{name}' must provide {interface!r} which {value!r} "
- "doesn't.".format(
- name=attr.name, interface=self.interface, value=value
- ),
- attr,
- self.interface,
- value,
- )
-
- def __repr__(self):
- return "".format(
- interface=self.interface
- )
-
-
-def provides(interface):
- """
- A validator that raises a `TypeError` if the initializer is called
- with an object that does not provide the requested *interface* (checks are
- performed using ``interface.providedBy(value)`` (see `zope.interface
- ".format(
- what=repr(self.validator)
- )
-
-
-def optional(validator):
- """
- A validator that makes an attribute optional. An optional attribute is one
- which can be set to ``None`` in addition to satisfying the requirements of
- the sub-validator.
-
- :param validator: A validator (or a list of validators) that is used for
- non-``None`` values.
- :type validator: callable or `list` of callables.
-
- .. versionadded:: 15.1.0
- .. versionchanged:: 17.1.0 *validator* can be a list of validators.
- """
- if isinstance(validator, list):
- return _OptionalValidator(_AndValidator(validator))
- return _OptionalValidator(validator)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _InValidator(object):
- options = attrib()
-
- def __call__(self, inst, attr, value):
- try:
- in_options = value in self.options
- except TypeError: # e.g. `1 in "abc"`
- in_options = False
-
- if not in_options:
- raise ValueError(
- "'{name}' must be in {options!r} (got {value!r})".format(
- name=attr.name, options=self.options, value=value
- )
- )
-
- def __repr__(self):
- return "".format(
- options=self.options
- )
-
-
-def in_(options):
- """
- A validator that raises a `ValueError` if the initializer is called
- with a value that does not belong in the options provided. The check is
- performed using ``value in options``.
-
- :param options: Allowed options.
- :type options: list, tuple, `enum.Enum`, ...
-
- :raises ValueError: With a human readable error message, the attribute (of
- type `attrs.Attribute`), the expected options, and the value it
- got.
-
- .. versionadded:: 17.1.0
- """
- return _InValidator(options)
-
-
-@attrs(repr=False, slots=False, hash=True)
-class _IsCallableValidator(object):
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if not callable(value):
- message = (
- "'{name}' must be callable "
- "(got {value!r} that is a {actual!r})."
- )
- raise NotCallableError(
- msg=message.format(
- name=attr.name, value=value, actual=value.__class__
- ),
- value=value,
- )
-
- def __repr__(self):
- return ""
-
-
-def is_callable():
- """
- A validator that raises a `attr.exceptions.NotCallableError` if the
- initializer is called with a value for this particular attribute
- that is not callable.
-
- .. versionadded:: 19.1.0
-
- :raises `attr.exceptions.NotCallableError`: With a human readable error
- message containing the attribute (`attrs.Attribute`) name,
- and the value it got.
- """
- return _IsCallableValidator()
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _DeepIterable(object):
- member_validator = attrib(validator=is_callable())
- iterable_validator = attrib(
- default=None, validator=optional(is_callable())
- )
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if self.iterable_validator is not None:
- self.iterable_validator(inst, attr, value)
-
- for member in value:
- self.member_validator(inst, attr, member)
-
- def __repr__(self):
- iterable_identifier = (
- ""
- if self.iterable_validator is None
- else " {iterable!r}".format(iterable=self.iterable_validator)
- )
- return (
- ""
- ).format(
- iterable_identifier=iterable_identifier,
- member=self.member_validator,
- )
-
-
-def deep_iterable(member_validator, iterable_validator=None):
- """
- A validator that performs deep validation of an iterable.
-
- :param member_validator: Validator to apply to iterable members
- :param iterable_validator: Validator to apply to iterable itself
- (optional)
-
- .. versionadded:: 19.1.0
-
- :raises TypeError: if any sub-validators fail
- """
- return _DeepIterable(member_validator, iterable_validator)
-
-
-@attrs(repr=False, slots=True, hash=True)
-class _DeepMapping(object):
- key_validator = attrib(validator=is_callable())
- value_validator = attrib(validator=is_callable())
- mapping_validator = attrib(default=None, validator=optional(is_callable()))
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if self.mapping_validator is not None:
- self.mapping_validator(inst, attr, value)
-
- for key in value:
- self.key_validator(inst, attr, key)
- self.value_validator(inst, attr, value[key])
-
- def __repr__(self):
- return (
- ""
- ).format(key=self.key_validator, value=self.value_validator)
-
-
-def deep_mapping(key_validator, value_validator, mapping_validator=None):
- """
- A validator that performs deep validation of a dictionary.
-
- :param key_validator: Validator to apply to dictionary keys
- :param value_validator: Validator to apply to dictionary values
- :param mapping_validator: Validator to apply to top-level mapping
- attribute (optional)
-
- .. versionadded:: 19.1.0
-
- :raises TypeError: if any sub-validators fail
- """
- return _DeepMapping(key_validator, value_validator, mapping_validator)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _NumberValidator(object):
- bound = attrib()
- compare_op = attrib()
- compare_func = attrib()
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if not self.compare_func(value, self.bound):
- raise ValueError(
- "'{name}' must be {op} {bound}: {value}".format(
- name=attr.name,
- op=self.compare_op,
- bound=self.bound,
- value=value,
- )
- )
-
- def __repr__(self):
- return "".format(
- op=self.compare_op, bound=self.bound
- )
-
-
-def lt(val):
- """
- A validator that raises `ValueError` if the initializer is called
- with a number larger or equal to *val*.
-
- :param val: Exclusive upper bound for values
-
- .. versionadded:: 21.3.0
- """
- return _NumberValidator(val, "<", operator.lt)
-
-
-def le(val):
- """
- A validator that raises `ValueError` if the initializer is called
- with a number greater than *val*.
-
- :param val: Inclusive upper bound for values
-
- .. versionadded:: 21.3.0
- """
- return _NumberValidator(val, "<=", operator.le)
-
-
-def ge(val):
- """
- A validator that raises `ValueError` if the initializer is called
- with a number smaller than *val*.
-
- :param val: Inclusive lower bound for values
-
- .. versionadded:: 21.3.0
- """
- return _NumberValidator(val, ">=", operator.ge)
-
-
-def gt(val):
- """
- A validator that raises `ValueError` if the initializer is called
- with a number smaller or equal to *val*.
-
- :param val: Exclusive lower bound for values
-
- .. versionadded:: 21.3.0
- """
- return _NumberValidator(val, ">", operator.gt)
-
-
-@attrs(repr=False, frozen=True, slots=True)
-class _MaxLengthValidator(object):
- max_length = attrib()
-
- def __call__(self, inst, attr, value):
- """
- We use a callable class to be able to change the ``__repr__``.
- """
- if len(value) > self.max_length:
- raise ValueError(
- "Length of '{name}' must be <= {max}: {len}".format(
- name=attr.name, max=self.max_length, len=len(value)
- )
- )
-
- def __repr__(self):
- return "".format(max=self.max_length)
-
-
-def max_len(length):
- """
- A validator that raises `ValueError` if the initializer is called
- with a string or iterable that is longer than *length*.
-
- :param int length: Maximum length of the string or iterable
-
- .. versionadded:: 21.3.0
- """
- return _MaxLengthValidator(length)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/criterions/wav2vec_criterion.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/criterions/wav2vec_criterion.py
deleted file mode 100644
index e37274d5a81a10a3b07114325b7cc2abe5cf56d9..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/criterions/wav2vec_criterion.py
+++ /dev/null
@@ -1,230 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import math
-from dataclasses import dataclass, field
-from typing import List, Optional
-
-import torch
-import torch.nn.functional as F
-from fairseq import metrics, utils
-from fairseq.criterions import FairseqCriterion, register_criterion
-from fairseq.dataclass import FairseqDataclass
-from fairseq.logging.meters import safe_round
-from fairseq.utils import is_xla_tensor
-
-
-@dataclass
-class Wav2VecCriterionConfig(FairseqDataclass):
- infonce: bool = field(
- default=False,
- metadata={
- "help": "if set, uses cross entropy instead of binary cross entropy (i.e. InfoNCE loss)"
- },
- )
- loss_weights: Optional[List[float]] = field(
- default=None,
- metadata={"help": "weights for additional loss terms (not first one)"},
- )
- log_keys: List[str] = field(
- default_factory=lambda: [],
- metadata={"help": "output keys to log"},
- )
-
-
-@register_criterion("wav2vec", dataclass=Wav2VecCriterionConfig)
-class Wav2vecCriterion(FairseqCriterion):
- def __init__(self, task, infonce=False, loss_weights=None, log_keys=None):
- super().__init__(task)
- self.infonce = infonce
- self.loss_weights = loss_weights
- self.log_keys = [] if log_keys is None else log_keys
-
- def forward(self, model, sample, reduce=True):
- """Compute the loss for the given sample.
-
- Returns a tuple with three elements:
- 1) the loss
- 2) the sample size, which is used as the denominator for the gradient
- 3) logging outputs to display while training
- """
- net_output = model(**sample["net_input"])
- logits = model.get_logits(net_output).float()
- target = model.get_targets(sample, net_output)
- self.xla = is_xla_tensor(logits)
-
- # XXX: handle weights on xla.
- weights = None
- if hasattr(model, "get_target_weights") and not self.infonce:
- weights = model.get_target_weights(target, net_output)
- if torch.is_tensor(weights):
- weights = weights.float()
-
- losses = []
-
- reduction = "none" if ((not reduce) or self.xla) else "sum"
- if self.infonce:
- loss = F.cross_entropy(logits, target, reduction=reduction)
- else:
- loss = F.binary_cross_entropy_with_logits(
- logits, target.float(), weights, reduction=reduction
- )
-
- if self.xla:
- # tpu-comment: since dynamic shapes lead to recompilations on xla,
- # we don't shrink tensors using mask_indices.
- # Instead, we use mask indices to adjust loss.
- mi = (
- sample["net_input"]["mask_indices"]
- .transpose(0, 1) # logits are transposed in `model.get_logits`
- .reshape(logits.size(0))
- )
- loss = (loss * mi).sum() if reduce else (loss * mi)
-
- if "sample_size" in sample:
- sample_size = sample["sample_size"]
- elif "mask_indices" in sample["net_input"]:
- sample_size = sample["net_input"]["mask_indices"].sum()
- else:
- sample_size = target.numel() if self.infonce else target.long().sum().item()
- losses.append(loss.detach().clone())
-
- if self.loss_weights is not None:
- assert hasattr(model, "get_extra_losses")
- extra_losses = model.get_extra_losses(net_output)
- if torch.is_tensor(extra_losses):
- extra_losses = [extra_losses]
- if len(self.loss_weights) == 1 and len(extra_losses) != 1:
- self.loss_weights = [self.loss_weights[0]] * len(extra_losses)
- assert len(extra_losses) == len(
- self.loss_weights
- ), f"{len(extra_losses)}, {len(self.loss_weights)}"
- for p, coef in zip(extra_losses, self.loss_weights):
- if coef != 0 and p is not None:
- p = coef * p.float() * sample_size
- loss += p
- losses.append(p)
-
- logging_output = {
- "loss": loss.item() if (reduce and not self.xla) else loss.detach(),
- "ntokens": sample_size,
- "nsentences": sample["id"].numel(),
- "sample_size": sample_size,
- }
-
- for lk in self.log_keys:
- # Only store "logits" and "target" for computing MAP and MAUC
- # during validation
- if lk == "logits":
- if not self.training:
- logging_output["logits"] = logits.cpu().numpy()
- elif lk == "target":
- if not self.training:
- # If the targets have been mixed with the predictions of
- # teacher models, find the original targets
- if hasattr(model, "get_original_targets"):
- original_target = model.get_original_targets(sample, net_output)
- else:
- original_target = target
- logging_output["target"] = original_target.cpu().numpy()
- elif lk in net_output:
- value = net_output[lk]
- if not is_xla_tensor(value):
- value = float(value)
- logging_output[lk] = value
-
- if len(losses) > 1:
- for i, l in enumerate(losses):
- logging_output[f"loss_{i}"] = l.item() if not self.xla else l.detach()
-
- if self.infonce:
- with torch.no_grad():
- if logits.numel() == 0:
- corr = 0
- count = 0
- else:
- assert logits.dim() > 1, logits.shape
- max = logits.argmax(-1) == 0
- min = logits.argmin(-1) == 0
- if is_xla_tensor(logits):
- max, min = max * mi, min * mi
- both = max & min
- corr = max.long().sum() - both.long().sum()
- count = mi.sum()
- else:
- both = max & min
- corr = max.long().sum().item() - both.long().sum().item()
- count = float(max.numel())
-
- logging_output["correct"] = corr
- logging_output["count"] = count
-
- return loss, sample_size, logging_output
-
- @staticmethod
- def reduce_metrics(logging_outputs) -> None:
- """Aggregate logging outputs from data parallel training."""
- loss_sum = utils.item(sum(log.get("loss", 0) for log in logging_outputs))
- ntokens = utils.item(sum(log.get("ntokens", 0) for log in logging_outputs))
- nsentences = utils.item(
- sum(log.get("nsentences", 0) for log in logging_outputs)
- )
- sample_size = utils.item(
- sum(log.get("sample_size", 0) for log in logging_outputs)
- )
-
- metrics.log_scalar(
- "loss", loss_sum / (sample_size or 1) / math.log(2), sample_size, round=3
- )
- metrics.log_scalar("ntokens", ntokens)
- metrics.log_scalar("nsentences", nsentences)
-
- correct = sum(log.get("correct", 0) for log in logging_outputs)
- metrics.log_scalar("_correct", correct)
-
- total = sum(log.get("count", 0) for log in logging_outputs)
- metrics.log_scalar("_total", total)
-
- if total > 0:
- metrics.log_derived(
- "accuracy",
- lambda meters: safe_round(
- meters["_correct"].sum / meters["_total"].sum, 5
- )
- if meters["_total"].sum > 0
- else float("nan"),
- )
-
- builtin_keys = {
- "loss",
- "ntokens",
- "nsentences",
- "sample_size",
- "correct",
- "count",
- }
-
- for k in logging_outputs[0]:
- if k not in builtin_keys:
- val = sum(log.get(k, 0) for log in logging_outputs)
- if k.startswith("loss"):
- metrics.log_scalar(
- k, val / (sample_size or 1) / math.log(2), sample_size, round=3
- )
- else:
- metrics.log_scalar(k, val / len(logging_outputs), round=3)
-
- # FIXME: revert when gather based xla reduction is implemented
- # @staticmethod
- # def logging_outputs_can_be_summed() -> bool:
- def logging_outputs_can_be_summed(self) -> bool:
- """
- Whether the logging outputs returned by `forward` can be summed
- across workers prior to calling `reduce_metrics`. Setting this
- to True will improves distributed training speed.
- """
- # XXX: Gather based reduction not implemented for xla yet.
- # So we fall to sum based reduction for xla.
- return self.xla
diff --git a/spaces/atticus/image-text-retrival-huster/misc/utils.py b/spaces/atticus/image-text-retrival-huster/misc/utils.py
deleted file mode 100644
index 4e3915d0feb3331032e910e173081fd3c0b3de62..0000000000000000000000000000000000000000
--- a/spaces/atticus/image-text-retrival-huster/misc/utils.py
+++ /dev/null
@@ -1,195 +0,0 @@
-"""
-****************** COPYRIGHT AND CONFIDENTIALITY INFORMATION ******************
-Copyright (c) 2018 [Thomson Licensing]
-All Rights Reserved
-This program contains proprietary information which is a trade secret/business \
-secret of [Thomson Licensing] and is protected, even if unpublished, under \
-applicable Copyright laws (including French droit d'auteur) and/or may be \
-subject to one or more patent(s).
-Recipient is to retain this program in confidence and is not permitted to use \
-or make copies thereof other than as permitted in a written agreement with \
-[Thomson Licensing] unless otherwise expressly allowed by applicable laws or \
-by [Thomson Licensing] under express agreement.
-Thomson Licensing is a company of the group TECHNICOLOR
-*******************************************************************************
-This scripts permits one to reproduce training and experiments of:
- Engilberge, M., Chevallier, L., Pérez, P., & Cord, M. (2018, April).
- Finding beans in burgers: Deep semantic-visual embedding with localization.
- In Proceedings of CVPR (pp. 3984-3993)
-
-Author: Martin Engilberge
-"""
-
-import os
-
-import nltk
-import pickle
-import torch
-
-from nltk.tokenize import word_tokenize
-from torch.autograd import Variable
-from torch.nn.utils.rnn import pad_sequence
-
-from PIL import Image
-import matplotlib.pyplot as plt
-
-class AverageMeter(object):
-
- def __init__(self):
- 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
-
-
-class Namespace:
- """ Namespace class to manually instantiate joint_embedding model """
- def __init__(self, **kwargs):
- self.__dict__.update(kwargs)
-
-
-def _load_dictionary(dir_st):
- path_dico = os.path.join(dir_st, 'dictionary.txt')
- if not os.path.exists(path_dico):
- print("Invalid path no dictionary found")
- with open(path_dico, 'r') as handle:
- dico_list = handle.readlines()
- dico = {word.strip(): idx for idx, word in enumerate(dico_list)}
- return dico
-
-
-def preprocess(text):
- sent_detector = nltk.data.load('tokenizers/punkt/english.pickle')
- sents = sent_detector.tokenize(text)
- result = list()
- for s in sents:
- tokens = word_tokenize(s)
- result.append(tokens)
-
- return result
-
-
-def flatten(l):
- return [item for sublist in l for item in sublist]
-
-
-def encode_sentences(sents, embed, dico):
- sents_list = list()
- for sent in sents:
- sent_tok = preprocess(sent)[0]
- sent_in = Variable(torch.FloatTensor(1, len(sent_tok), 620))
- for i, w in enumerate(sent_tok):
- try:
- sent_in.data[0, i] = torch.from_numpy(embed[dico[w]])
- except KeyError:
- sent_in.data[0, i] = torch.from_numpy(embed[dico["UNK"]])
-
- sents_list.append(sent_in)
- return sents_list
-
-
-def encode_sentence(sent, embed, dico, tokenize=True):
- if tokenize:
- sent_tok = preprocess(sent)[0]
- else:
- sent_tok = sent
-
- sent_in = torch.FloatTensor(len(sent_tok), 620)
-
- for i, w in enumerate(sent_tok):
- try:
- sent_in[i, :620] = torch.from_numpy(embed[dico[w]])
- except KeyError:
- sent_in[i, :620] = torch.from_numpy(embed[dico["UNK"]])
-
- return sent_in
-
-
-def save_checkpoint(state, is_best, model_name, epoch):
- if is_best:
- torch.save(state, './weights/best_' + model_name + ".pth.tar")
-
-
-def log_epoch(logger, epoch, train_loss, val_loss, lr, batch_train, batch_val, data_train, data_val, recall):
- logger.add_scalar('Loss/Train', train_loss, epoch)
- logger.add_scalar('Loss/Val', val_loss, epoch)
- logger.add_scalar('Learning/Rate', lr, epoch)
- logger.add_scalar('Learning/Overfitting', val_loss / train_loss, epoch)
- logger.add_scalar('Time/Train/Batch Processing', batch_train, epoch)
- logger.add_scalar('Time/Val/Batch Processing', batch_val, epoch)
- logger.add_scalar('Time/Train/Data loading', data_train, epoch)
- logger.add_scalar('Time/Val/Data loading', data_val, epoch)
- logger.add_scalar('Recall/Val/CapRet/R@1', recall[0][0], epoch)
- logger.add_scalar('Recall/Val/CapRet/R@5', recall[0][1], epoch)
- logger.add_scalar('Recall/Val/CapRet/R@10', recall[0][2], epoch)
- logger.add_scalar('Recall/Val/CapRet/MedR', recall[2], epoch)
- logger.add_scalar('Recall/Val/ImgRet/R@1', recall[1][0], epoch)
- logger.add_scalar('Recall/Val/ImgRet/R@5', recall[1][1], epoch)
- logger.add_scalar('Recall/Val/ImgRet/R@10', recall[1][2], epoch)
- logger.add_scalar('Recall/Val/ImgRet/MedR', recall[3], epoch)
-
-
-def collate_fn_padded(data):
- images, captions = zip(*data)
-
- images = torch.stack(images, 0)
-
- lengths = [len(cap) for cap in captions]
- targets = pad_sequence(captions, batch_first=True)
-
- return images, targets, lengths
-
-
-def collate_fn_cap_padded(data):
- captions = data
-
- lengths = [len(cap) for cap in captions]
- targets = pad_sequence(captions, batch_first=True)
-
- return targets, lengths
-
-
-def collate_fn_semseg(data):
- images, size, targets = zip(*data)
- images = torch.stack(images, 0)
-
- return images, size, targets
-
-
-def collate_fn_img_padded(data):
- images = data
- images = torch.stack(images, 0)
-
- return images
-
-
-def load_obj(path):
- with open(os.path.normpath(path + '.pkl'), 'rb') as f:
- return pickle.load(f)
-
-
-def save_obj(obj, path):
- with open(os.path.normpath(path + '.pkl'), 'wb') as f:
- pickle.dump(obj, f, pickle.HIGHEST_PROTOCOL)
-
-def show_imgs(imgs_path):
- plt.ion()
- for i, img_path in enumerate(imgs_path):
- img = Image.open(img_path)
- plt.figure("Image") # 图像窗口名称
- plt.imshow(img)
- plt.axis('on') # 关掉坐标轴为 off
- plt.title('image_{}'.format(i)) # 图像题目
- plt.ioff()
- plt.show()
- plt.close()
-
diff --git a/spaces/awacke1/ChatGPT-Memory-Chat-Story-Generator/README.md b/spaces/awacke1/ChatGPT-Memory-Chat-Story-Generator/README.md
deleted file mode 100644
index 97a87f595e00fed444b46756680b7870cc4ae0a5..0000000000000000000000000000000000000000
--- a/spaces/awacke1/ChatGPT-Memory-Chat-Story-Generator/README.md
+++ /dev/null
@@ -1,34 +0,0 @@
----
-title: 🔍ChatGPT Episodic and Semantic Memory Generator🏊
-emoji: 🌟GPT🔍
-colorFrom: green
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.21.0
-app_file: app.py
-pinned: true
-license: mit
----
-
-## ChatGPT Datasets 📚
-- WebText
-- Common Crawl
-- BooksCorpus
-- English Wikipedia
-- Toronto Books Corpus
-- OpenWebText
-
-## ChatGPT Datasets - Details 📚
-- **WebText:** A dataset of web pages crawled from domains on the Alexa top 5,000 list. This dataset was used to pretrain GPT-2.
- - [WebText: A Large-Scale Unsupervised Text Corpus by Radford et al.](https://paperswithcode.com/dataset/webtext)
-- **Common Crawl:** A dataset of web pages from a variety of domains, which is updated regularly. This dataset was used to pretrain GPT-3.
- - [Language Models are Few-Shot Learners](https://paperswithcode.com/dataset/common-crawl) by Brown et al.
-- **BooksCorpus:** A dataset of over 11,000 books from a variety of genres.
- - [Scalable Methods for 8 Billion Token Language Modeling](https://paperswithcode.com/dataset/bookcorpus) by Zhu et al.
-- **English Wikipedia:** A dump of the English-language Wikipedia as of 2018, with articles from 2001-2017.
- - [Improving Language Understanding by Generative Pre-Training](https://huggingface.co/spaces/awacke1/WikipediaUltimateAISearch?logs=build) Space for Wikipedia Search
-- **Toronto Books Corpus:** A dataset of over 7,000 books from a variety of genres, collected by the University of Toronto.
- - [Massively Multilingual Sentence Embeddings for Zero-Shot Cross-Lingual Transfer and Beyond](https://paperswithcode.com/dataset/bookcorpus) by Schwenk and Douze.
-- **OpenWebText:** A dataset of web pages that were filtered to remove content that was likely to be low-quality or spammy. This dataset was used to pretrain GPT-3.
- - [Language Models are Few-Shot Learners](https://paperswithcode.com/dataset/openwebtext) by Brown et al.
-
\ No newline at end of file
diff --git a/spaces/awacke1/File-Memory-Operations-Human-Feedback-Gradio/README.md b/spaces/awacke1/File-Memory-Operations-Human-Feedback-Gradio/README.md
deleted file mode 100644
index 4c21f36860600cfada577cc25d36c0fa22c72da0..0000000000000000000000000000000000000000
--- a/spaces/awacke1/File-Memory-Operations-Human-Feedback-Gradio/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: 🔥File-Memory-Human-Feedback-Gradio🔥
-emoji: 🔥🔥🔥
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.18.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-https://huggingface.co/spaces/bigscience-data/roots-search
diff --git a/spaces/awacke1/PhysicsRacingDemoWith3DARVR/style.css b/spaces/awacke1/PhysicsRacingDemoWith3DARVR/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/awacke1/PhysicsRacingDemoWith3DARVR/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/awacke1/PrompTart/app.py b/spaces/awacke1/PrompTart/app.py
deleted file mode 100644
index dd94797e9b5bc16756c9b63135678b8375bbae56..0000000000000000000000000000000000000000
--- a/spaces/awacke1/PrompTart/app.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import pandas as pd
-import gradio as gr
-
-df = pd.read_csv("images.csv")
-df['url'] = df['url'].apply(lambda x: '  + ')
')
-df = df[[ 'url', 'prompt']]
-
-def display_df():
- df_images = df.head(1000)
- return df_images
-
-def display_df_search(search):
- df_images = df.loc[df['prompt'].str.contains(search, case=False, na=False)]
- #df_images = df.head(1000)
- return df_images
-
-def display_next1000(dataframe, end):
- dataframe = dataframe.sample(frac=1)
- start = (end or dataframe.index[-1]) + 1
- end = start + 999
- df_images = df.loc[start:end]
- return df_images, end
-
-def Match(name):
- pd.set_option("display.max_rows", None)
- data = df
- swith=data.loc[data['prompt'].str.contains(name, case=False, na=False)]
- return swith
-
-
-with gr.Blocks() as demo:
- gr.Markdown("🍰PrompTart🎨
")
- gr.Markdown("""Art Prompts from Playground. Git. Create Art Here. Papers,Code,Datasets for SOTA in Art""")
-
-
-
- with gr.Row():
- num_end = gr.Number(visible=False)
- b1 = gr.Button("Images and Prompts 0-1000")
- b2 = gr.Button("Next 1000 Images and Prompts")
-
- with gr.Row(): # inputs and buttons
- inp = gr.Textbox(lines=1, default="", label="Search")
- b3 = gr.Button("Search")
-
- with gr.Row():
- out_dataframe = gr.Dataframe(wrap=True, max_rows=1000, overflow_row_behaviour= "paginate", datatype = ["markdown", "markdown"], headers=['url', 'prompt'])
-
- b1.click(fn=display_df, outputs=out_dataframe)
- b2.click(fn=display_next1000, inputs= [out_dataframe, num_end ], outputs=[out_dataframe, num_end])
- b3.click(fn=display_df_search, inputs=inp, outputs=out_dataframe)
-
-demo.launch(debug=True, show_error=True)
\ No newline at end of file
diff --git a/spaces/awacke1/google-pegasus-pubmed/app.py b/spaces/awacke1/google-pegasus-pubmed/app.py
deleted file mode 100644
index a777b7ef4a34a82e370cf4f92c51a32b775c9cd7..0000000000000000000000000000000000000000
--- a/spaces/awacke1/google-pegasus-pubmed/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/google/pegasus-pubmed").launch()
\ No newline at end of file
diff --git a/spaces/awacke1/sileod-deberta-v3-base-tasksource-nli-2/app.py b/spaces/awacke1/sileod-deberta-v3-base-tasksource-nli-2/app.py
deleted file mode 100644
index a4f41814613957f3cf8485c64f6e8d303eccf62f..0000000000000000000000000000000000000000
--- a/spaces/awacke1/sileod-deberta-v3-base-tasksource-nli-2/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/sileod/deberta-v3-base-tasksource-nli").launch()
\ No newline at end of file
diff --git a/spaces/azusarang/so-vits-svc-models-ba_P/vdecoder/hifigan/models.py b/spaces/azusarang/so-vits-svc-models-ba_P/vdecoder/hifigan/models.py
deleted file mode 100644
index 9747301f350bb269e62601017fe4633ce271b27e..0000000000000000000000000000000000000000
--- a/spaces/azusarang/so-vits-svc-models-ba_P/vdecoder/hifigan/models.py
+++ /dev/null
@@ -1,503 +0,0 @@
-import os
-import json
-from .env import AttrDict
-import numpy as np
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from .utils import init_weights, get_padding
-
-LRELU_SLOPE = 0.1
-
-
-def load_model(model_path, device='cuda'):
- config_file = os.path.join(os.path.split(model_path)[0], 'config.json')
- with open(config_file) as f:
- data = f.read()
-
- global h
- json_config = json.loads(data)
- h = AttrDict(json_config)
-
- generator = Generator(h).to(device)
-
- cp_dict = torch.load(model_path)
- generator.load_state_dict(cp_dict['generator'])
- generator.eval()
- generator.remove_weight_norm()
- del cp_dict
- return generator, h
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.h = h
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- xt = c2(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.h = h
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-def padDiff(x):
- return F.pad(F.pad(x, (0,0,-1,1), 'constant', 0) - x, (0,0,0,-1), 'constant', 0)
-
-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
- self.flag_for_pulse = flag_for_pulse
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = (f0 > self.voiced_threshold).type(torch.float32)
- return uv
-
- def _f02sine(self, f0_values):
- """ f0_values: (batchsize, length, dim)
- where dim indicates fundamental tone and overtones
- """
- # convert to F0 in rad. The interger part n can be ignored
- # because 2 * np.pi * n doesn't affect phase
- rad_values = (f0_values / self.sampling_rate) % 1
-
- # initial phase noise (no noise for fundamental component)
- rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], \
- device=f0_values.device)
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-
- # instantanouse phase sine[t] = sin(2*pi \sum_i=1 ^{t} rad)
- if not self.flag_for_pulse:
- # for normal case
-
- # To prevent torch.cumsum numerical overflow,
- # it is necessary to add -1 whenever \sum_k=1^n rad_value_k > 1.
- # Buffer tmp_over_one_idx indicates the time step to add -1.
- # This will not change F0 of sine because (x-1) * 2*pi = x * 2*pi
- tmp_over_one = torch.cumsum(rad_values, 1) % 1
- tmp_over_one_idx = (padDiff(tmp_over_one)) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-
- sines = torch.sin(torch.cumsum(rad_values + cumsum_shift, dim=1)
- * 2 * np.pi)
- else:
- # If necessary, make sure that the first time step of every
- # voiced segments is sin(pi) or cos(0)
- # This is used for pulse-train generation
-
- # identify the last time step in unvoiced segments
- uv = self._f02uv(f0_values)
- uv_1 = torch.roll(uv, shifts=-1, dims=1)
- uv_1[:, -1, :] = 1
- u_loc = (uv < 1) * (uv_1 > 0)
-
- # get the instantanouse phase
- tmp_cumsum = torch.cumsum(rad_values, dim=1)
- # different batch needs to be processed differently
- for idx in range(f0_values.shape[0]):
- temp_sum = tmp_cumsum[idx, u_loc[idx, :, 0], :]
- temp_sum[1:, :] = temp_sum[1:, :] - temp_sum[0:-1, :]
- # stores the accumulation of i.phase within
- # each voiced segments
- tmp_cumsum[idx, :, :] = 0
- tmp_cumsum[idx, u_loc[idx, :, 0], :] = temp_sum
-
- # rad_values - tmp_cumsum: remove the accumulation of i.phase
- # within the previous voiced segment.
- i_phase = torch.cumsum(rad_values - tmp_cumsum, dim=1)
-
- # get the sines
- sines = torch.cos(i_phase * 2 * np.pi)
- return sines
-
- def forward(self, f0):
- """ 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_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim,
- device=f0.device)
- # fundamental component
- fn = torch.multiply(f0, torch.FloatTensor([[range(1, self.harmonic_num + 2)]]).to(f0.device))
-
- # generate sine waveforms
- sine_waves = self._f02sine(fn) * self.sine_amp
-
- # generate uv signal
- # uv = torch.ones(f0.shape)
- # uv = uv * (f0 > self.voiced_threshold)
- uv = self._f02uv(f0)
-
- # noise: for unvoiced should be similar to sine_amp
- # std = self.sine_amp/3 -> max value ~ self.sine_amp
- # . for voiced regions is self.noise_std
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
-
- # first: set the unvoiced part to 0 by uv
- # then: additive noise
- 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):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
-
- # 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):
- """
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- """
- # source for harmonic branch
- sine_wavs, uv, _ = self.l_sin_gen(x)
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-
- # source for noise branch, in the same shape as uv
- noise = torch.randn_like(uv) * self.sine_amp / 3
- return sine_merge, noise, uv
-
-
-class Generator(torch.nn.Module):
- def __init__(self, h):
- super(Generator, self).__init__()
- self.h = h
-
- self.num_kernels = len(h["resblock_kernel_sizes"])
- self.num_upsamples = len(h["upsample_rates"])
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(h["upsample_rates"]))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=h["sampling_rate"],
- harmonic_num=8)
- self.noise_convs = nn.ModuleList()
- self.conv_pre = weight_norm(Conv1d(h["inter_channels"], h["upsample_initial_channel"], 7, 1, padding=3))
- resblock = ResBlock1 if h["resblock"] == '1' else ResBlock2
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(h["upsample_rates"], h["upsample_kernel_sizes"])):
- c_cur = h["upsample_initial_channel"] // (2 ** (i + 1))
- self.ups.append(weight_norm(
- ConvTranspose1d(h["upsample_initial_channel"] // (2 ** i), h["upsample_initial_channel"] // (2 ** (i + 1)),
- k, u, padding=(k - u) // 2)))
- if i + 1 < len(h["upsample_rates"]): #
- stride_f0 = np.prod(h["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 = h["upsample_initial_channel"] // (2 ** (i + 1))
- for j, (k, d) in enumerate(zip(h["resblock_kernel_sizes"], h["resblock_dilation_sizes"])):
- self.resblocks.append(resblock(h, ch, k, d))
-
- self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3))
- self.ups.apply(init_weights)
- self.conv_post.apply(init_weights)
- self.cond = nn.Conv1d(h['gin_channels'], h['upsample_initial_channel'], 1)
-
- def forward(self, x, f0, g=None):
- # print(1,x.shape,f0.shape,f0[:, None].shape)
- f0 = self.f0_upsamp(f0[:, None]).transpose(1, 2) # bs,n,t
- # print(2,f0.shape)
- har_source, noi_source, uv = self.m_source(f0)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- x = x + self.cond(g)
- # print(124,x.shape,har_source.shape)
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, LRELU_SLOPE)
- # print(3,x.shape)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- # print(4,x_source.shape,har_source.shape,x.shape)
- 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):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
- remove_weight_norm(self.conv_pre)
- remove_weight_norm(self.conv_post)
-
-
-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
- 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(5, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(2, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, periods=None):
- super(MultiPeriodDiscriminator, self).__init__()
- self.periods = periods if periods is not None else [2, 3, 5, 7, 11]
- self.discriminators = nn.ModuleList()
- for period in self.periods:
- self.discriminators.append(DiscriminatorP(period))
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- 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, 128, 15, 1, padding=7)),
- norm_f(Conv1d(128, 128, 41, 2, groups=4, padding=20)),
- norm_f(Conv1d(128, 256, 41, 2, groups=16, padding=20)),
- norm_f(Conv1d(256, 512, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(512, 1024, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 1, groups=16, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiScaleDiscriminator(torch.nn.Module):
- def __init__(self):
- super(MultiScaleDiscriminator, self).__init__()
- self.discriminators = nn.ModuleList([
- DiscriminatorS(use_spectral_norm=True),
- DiscriminatorS(),
- DiscriminatorS(),
- ])
- self.meanpools = nn.ModuleList([
- AvgPool1d(4, 2, padding=2),
- AvgPool1d(4, 2, padding=2)
- ])
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- if i != 0:
- y = self.meanpools[i - 1](y)
- y_hat = self.meanpools[i - 1](y_hat)
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- r_loss = torch.mean((1 - dr) ** 2)
- g_loss = torch.mean(dg ** 2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- l = torch.mean((1 - dg) ** 2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
diff --git a/spaces/banana-projects/web3d/node_modules/three/examples/jsm/utils/GeometryUtils.d.ts b/spaces/banana-projects/web3d/node_modules/three/examples/jsm/utils/GeometryUtils.d.ts
deleted file mode 100644
index e9e1deb278428b36f6efa45e1924841e88b7a20e..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/examples/jsm/utils/GeometryUtils.d.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-/**
- * @deprecated
- */
-export namespace GeometryUtils {
- /**
- * @deprecated Use {@link Geometry#merge geometry.merge( geometry2, matrix, materialIndexOffset )} instead.
- */
- export function merge(geometry1: any, geometry2: any, materialIndexOffset?: any): any;
- /**
- * @deprecated Use {@link Geometry#center geometry.center()} instead.
- */
- export function center(geometry: any): any;
-}
diff --git a/spaces/binker/interpreter5/bot_backend.py b/spaces/binker/interpreter5/bot_backend.py
deleted file mode 100644
index 4620a738d9dc2c0a4222c9b56e17f17a6b986272..0000000000000000000000000000000000000000
--- a/spaces/binker/interpreter5/bot_backend.py
+++ /dev/null
@@ -1,232 +0,0 @@
-import json
-import openai
-import os
-import copy
-import shutil
-from jupyter_backend import *
-from typing import *
-
-functions = [
- {
- "name": "execute_code",
- "description": "This function allows you to execute Python code and retrieve the terminal output. If the code "
- "generates image output, the function will return the text '[image]'. The code is sent to a "
- "Jupyter kernel for execution. The kernel will remain active after execution, retaining all "
- "variables in memory.",
- "parameters": {
- "type": "object",
- "properties": {
- "code": {
- "type": "string",
- "description": "The code text"
- }
- },
- "required": ["code"],
- }
- }
-]
-
-system_msg = '''You are an AI code interpreter.
-Your goal is to help users do a variety of jobs by executing Python code.
-
-You should:
-1. Comprehend the user's requirements carefully & to the letter.
-2. Give a brief description for what you plan to do & call the provided function to run code.
-3. Provide results analysis based on the execution output.
-4. If error occurred, try to fix it.
-
-Note: If the user uploads a file, you will receive a system message "User uploaded a file: filename". Use the filename as the path in the code. '''
-
-with open('config.json') as f:
- config = json.load(f)
-
-if not config['API_KEY']:
- config['API_KEY'] = os.getenv('OPENAI_API_KEY')
- os.unsetenv('OPENAI_API_KEY')
-
-
-def get_config():
- return config
-
-
-def config_openai_api(api_type, api_base, api_version, api_key):
- openai.api_type = api_type
- openai.api_base = api_base
- openai.api_version = api_version
- openai.api_key = api_key
-
-
-class GPTResponseLog:
- def __init__(self):
- self.assistant_role_name = ''
- self.content = ''
- self.function_name = None
- self.function_args_str = ''
- self.display_code_block = ''
- self.finish_reason = 'stop'
- self.bot_history = None
-
- def reset_gpt_response_log_values(self, exclude=None):
- if exclude is None:
- exclude = []
-
- attributes = {'assistant_role_name': '',
- 'content': '',
- 'function_name': None,
- 'function_args_str': '',
- 'display_code_block': '',
- 'finish_reason': 'stop',
- 'bot_history': None}
-
- for attr_name in exclude:
- del attributes[attr_name]
- for attr_name, value in attributes.items():
- setattr(self, attr_name, value)
-
- def set_assistant_role_name(self, assistant_role_name: str):
- self.assistant_role_name = assistant_role_name
-
- def add_content(self, content: str):
- self.content += content
-
- def set_function_name(self, function_name: str):
- self.function_name = function_name
-
- def copy_current_bot_history(self, bot_history: List):
- self.bot_history = copy.deepcopy(bot_history)
-
- def add_function_args_str(self, function_args_str: str):
- self.function_args_str += function_args_str
-
- def update_display_code_block(self, display_code_block):
- self.display_code_block = display_code_block
-
- def update_finish_reason(self, finish_reason: str):
- self.finish_reason = finish_reason
-
-
-class BotBackend(GPTResponseLog):
- def __init__(self):
- super().__init__()
- self.unique_id = hash(id(self))
- self.jupyter_work_dir = f'cache/work_dir_{self.unique_id}'
- self.jupyter_kernel = JupyterKernel(work_dir=self.jupyter_work_dir)
- self.gpt_model_choice = "GPT-3.5"
- self.revocable_files = []
- self._init_conversation()
- self._init_api_config()
- self._init_kwargs_for_chat_completion()
-
- def _init_conversation(self):
- first_system_msg = {'role': 'system', 'content': system_msg}
- if hasattr(self, 'conversation'):
- self.conversation.clear()
- self.conversation.append(first_system_msg)
- else:
- self.conversation: List[Dict] = [first_system_msg]
-
- def _init_api_config(self):
- self.config = get_config()
- api_type = self.config['API_TYPE']
- api_base = self.config['API_base']
- api_version = self.config['API_VERSION']
- api_key = config['API_KEY']
- config_openai_api(api_type, api_base, api_version, api_key)
-
- def _init_kwargs_for_chat_completion(self):
- self.kwargs_for_chat_completion = {
- 'stream': True,
- 'messages': self.conversation,
- 'functions': functions,
- 'function_call': 'auto'
- }
-
- model_name = self.config['model'][self.gpt_model_choice]['model_name']
-
- if self.config['API_TYPE'] == 'azure':
- self.kwargs_for_chat_completion['engine'] = model_name
- else:
- self.kwargs_for_chat_completion['model'] = model_name
-
- def _clear_all_files_in_work_dir(self):
- for filename in os.listdir(self.jupyter_work_dir):
- os.remove(
- os.path.join(self.jupyter_work_dir, filename)
- )
-
- def add_gpt_response_content_message(self):
- self.conversation.append(
- {'role': self.assistant_role_name, 'content': self.content}
- )
-
- def add_text_message(self, user_text):
- self.conversation.append(
- {'role': 'user', 'content': user_text}
- )
- self.revocable_files.clear()
- self.update_finish_reason(finish_reason='new_input')
-
- def add_file_message(self, path, bot_msg):
- filename = os.path.basename(path)
- work_dir = self.jupyter_work_dir
-
- shutil.copy(path, work_dir)
-
- gpt_msg = {'role': 'system', 'content': f'User uploaded a file: {filename}'}
- self.conversation.append(gpt_msg)
- self.revocable_files.append(
- {
- 'bot_msg': bot_msg,
- 'gpt_msg': gpt_msg,
- 'path': os.path.join(work_dir, filename)
- }
- )
-
- def add_function_call_response_message(self, function_response: str, save_tokens=True):
- self.conversation.append(
- {
- "role": self.assistant_role_name,
- "name": self.function_name,
- "content": self.function_args_str
- }
- )
-
- if save_tokens and len(function_response) > 500:
- function_response = f'{function_response[:200]}\n[Output too much, the middle part output is omitted]\n ' \
- f'End part of output:\n{function_response[-200:]}'
- self.conversation.append(
- {
- "role": "function",
- "name": self.function_name,
- "content": function_response,
- }
- )
-
- def revoke_file(self):
- if self.revocable_files:
- file = self.revocable_files[-1]
- bot_msg = file['bot_msg']
- gpt_msg = file['gpt_msg']
- path = file['path']
-
- assert self.conversation[-1] is gpt_msg
- del self.conversation[-1]
-
- os.remove(path)
-
- del self.revocable_files[-1]
-
- return bot_msg
- else:
- return None
-
- def update_gpt_model_choice(self, model_choice):
- self.gpt_model_choice = model_choice
- self._init_kwargs_for_chat_completion()
-
- def restart(self):
- self._clear_all_files_in_work_dir()
- self.revocable_files.clear()
- self._init_conversation()
- self.reset_gpt_response_log_values()
- self.jupyter_kernel.restart_jupyter_kernel()
diff --git a/spaces/bioriAsaeru/text-to-voice/Ben 10Race Against Time 2007 DVDRip Dual AudioEng HindiAMDTMRG [BETTER].md b/spaces/bioriAsaeru/text-to-voice/Ben 10Race Against Time 2007 DVDRip Dual AudioEng HindiAMDTMRG [BETTER].md
deleted file mode 100644
index f55454e57a25323b7a93d3cfad9431940283207b..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Ben 10Race Against Time 2007 DVDRip Dual AudioEng HindiAMDTMRG [BETTER].md
+++ /dev/null
@@ -1,43 +0,0 @@
-
-How to Fix AVG PC TuneUp Trial Expired Error
-AVG PC TuneUp is a popular software that helps you optimize your PC's performance and speed. It offers various features such as cleaning up junk files, fixing registry errors, updating drivers, and more. However, some users may encounter a problem when their AVG PC TuneUp trial expires and they are unable to use the software anymore.
-Ben 10Race Against Time 2007 DVDRip Dual AudioEng HindiAMDTMRG
Download File ===> https://urloso.com/2uyP2u
-In this article, we will show you how to fix the AVG PC TuneUp trial expired error and continue using the software without any issues.
-Why does AVG PC TuneUp trial expire?
-AVG PC TuneUp trial expires after a certain period of time, usually 30 days, depending on the offer you have chosen. This is because AVG PC TuneUp is a paid software that requires a license key to activate and use all its features. The trial version is meant to give you a preview of what the software can do for your PC and help you decide whether you want to buy it or not.
-When your AVG PC TuneUp trial expires, you will see a message on your screen that says "Your Internet Security trial has expired" or "Your AVG PC TuneUp trial has expired". You will also see a "Buy Now" button that will take you to the AVG website where you can purchase a license key for the software.
-How to fix AVG PC TuneUp trial expired error?
-There are two ways to fix the AVG PC TuneUp trial expired error:
-
-
-
-Buy a license key for AVG PC TuneUp
-The easiest and most recommended way to fix the AVG PC TuneUp trial expired error is to buy a license key for the software. This will allow you to use all the features of AVG PC TuneUp without any limitations or interruptions. You can choose from different plans and prices depending on your needs and preferences.
-To buy a license key for AVG PC TuneUp, follow these steps:
-
-
-Uninstall and reinstall AVG PC TuneUp free version
-If you do not want to buy a license key for AVG PC TuneUp, you can try uninstalling and reinstalling the free version of the software. This will allow you to use some basic features of AVG PC TuneUp such as disk cleaner, browser cleaner, startup manager, etc. However, you will not be able to use some advanced features such as registry cleaner, driver updater, sleep mode, etc.
-To uninstall and reinstall AVG PC TuneUp free version, follow these steps:
-
-
-
-Conclusion
-
-We hope this article has helped you fix the AVG PC TuneUp trial expired error and continue using the software without any problems. If you have any questions or suggestions, please feel free to leave a comment below. Thank you for reading!
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Edgar Baqueiro Rojas Derecho Civil Introduccion Personas Pdf Download.md b/spaces/bioriAsaeru/text-to-voice/Edgar Baqueiro Rojas Derecho Civil Introduccion Personas Pdf Download.md
deleted file mode 100644
index 64f580fc778c2bdbb7349e8102f8ff2c83b24a62..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Edgar Baqueiro Rojas Derecho Civil Introduccion Personas Pdf Download.md
+++ /dev/null
@@ -1,10 +0,0 @@
-Edgar Baqueiro Rojas Derecho Civil Introduccion Personas Pdf Download
Download File ↔ https://urloso.com/2uyS7z
-
-10 Dec 2012 - phyorry f4bc01c98b Dec 2020 - fitjayd d868ddde6e ... 35-edgar-baqueiro-rojas-derecho-civil-introduccion-personas-pdf-download-link -pdf-download-link-doc-link-doc-link.html#comment-post-comment.html.
-3 Dec 2019 - 10 Jul 2019 - fitjayd d868ddde6e ...
-40-edgar-baqueiro-rojas-derecho-civil-introduccion-personas-pdf-download-link-pdf-download-link-doc-link-doc-link.html#comment-post-comment.html.
-17 Dec 2019 - 7 Apr 2019 - fitjayd d868ddde6e ...
-40-edgar-baqueiro-rojas-derecho-civil-introduccion-personas-pdf-download-link-pdf-download-link-doc-link-doc-link.html#comment-post-comment.html 8a78ff9644
-
-
-
diff --git a/spaces/bioriAsaeru/text-to-voice/Instarepost Full Version Apk Downloads Everything You Need to Know About This Amazing App.md b/spaces/bioriAsaeru/text-to-voice/Instarepost Full Version Apk Downloads Everything You Need to Know About This Amazing App.md
deleted file mode 100644
index 9a6a4eadea2c7f20c8409ac75b941cb521f72f74..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Instarepost Full Version Apk Downloads Everything You Need to Know About This Amazing App.md
+++ /dev/null
@@ -1,9 +0,0 @@
-
-fruit slice game for pc free download
code blocks c++ download for windows 10 64 bit
alienware theme windows 8.1 download free
adobe premiere download free full version windows 7 free
download driver hp p1006 windows 10 64 bit
-Instarepost Full Version Apk Downloads
Download ➡ https://urloso.com/2uyPvq
-air war games for pc free download
download reloader activator windows 10
sim city 3000 free download full version windows 7 free
all pc games free download list
hp laserjet 1100 driver windows 7 64 bit download free
windows 7 home premium oa download 64 bit iso free
autocad 3d free download for windows 10
adventure time card wars game download pc free
windows 7 virtual pc free download
pro tools m powered 8 download windows free
-aura sync download windows 10 64 bitwindows 7 base system device driver download freetalking tom 2 free download for pc windows 10jdownloader 2 free download for windows 10 freewindows 10 download bittorrent freepc windows 7 vlc player downloadc++ runtime library download windows 10download kundli software full version for free for windows 7 freefree game sites for pc free downloadbluestacks 5 download for pc windows 7
download game war of the monsters pc
microsoft defender windows 10 free download 64 bit
feature update via windows 10 version 1909 enablement package download
download microsoft defender for windows xp free
bully game download for pc free
windows 8.1 cracked free download free
argouml download for windows 10 64 bit
bionicle the game pc download
gopro driver windows 10 download
microsoft office for windows xp professional 2002 free download free
windows server 2008 r2 service pack 2 x64 download free
free full pc games download for windows 10
eos utility for windows 10 download
kcast download for windows xp free
norton commander windows xp free download free
-windows 8 pro iso free download freedownload recycle bin icon for windows 10bruce lee games free download pccreative sb0570 driver windows 7 free download freedownload m player for windows freedetroit become human pc download full game for freeralink rt3290 driver windows 10 download freehp laserjet p1102w driver download for windows 10dopdf free download for windows 10 64 bitintel management engine windows 10 download
windows 10 the missing manual pdf free download free
microsoft word 2013 download free full version for windows 8 free
skype download xp windows free free
big time cash make money free download for pc
bunny shooter game download for pc
car driving simulator games free download for pc
icloud for windows 10 download photos
4 pics 1 word free download for pc windows xp free
counter terrorism game free download for pc
download windows installer windows 7 64 bit free
download pc games without torrent
download pokemon x and y for pc full version free
detroit become human pc download full game for free
kmspico windows 10 download free
download free full version pc games for windows 8
- aaccfb2cb3
-
-
\ No newline at end of file
diff --git a/spaces/bla/tranny/App/Chat/utils/RAG.py b/spaces/bla/tranny/App/Chat/utils/RAG.py
deleted file mode 100644
index 753676f22213a7e07766eb1dba4adafdbf5b4ede..0000000000000000000000000000000000000000
--- a/spaces/bla/tranny/App/Chat/utils/RAG.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import aiohttp
-import asyncio,pprint
-import google.generativeai as palm
-from langchain.chains.question_answering import load_qa_chain
-from langchain.llms import GooglePalm
-from langchain.text_splitter import RecursiveCharacterTextSplitter
-from langchain import PromptTemplate
-import os
-PALM_API = ''
-API_KEY=os.environ.get("PALM_API",PALM_API)
-palm.configure(api_key=API_KEY)
-
-
-def count_tokens(text):
- return palm.count_message_tokens(prompt=text)['token_count']
-llm = GooglePalm(
- google_api_key=API_KEY, **{ "safety_settings": [
- {"category": "HARM_CATEGORY_DEROGATORY", "threshold": 4},
- {"category": "HARM_CATEGORY_TOXICITY", "threshold": 4},
- {"category": "HARM_CATEGORY_VIOLENCE", "threshold": 4},
- {"category": "HARM_CATEGORY_SEXUAL", "threshold": 4},
- {"category": "HARM_CATEGORY_MEDICAL", "threshold": 4},
- {"category": "HARM_CATEGORY_DANGEROUS", "threshold": 4},
- ]})
-text_splitter = RecursiveCharacterTextSplitter(separators=["\n\n", "\n","."], chunk_size=40_000, chunk_overlap=500)
-with open('./sample.txt', 'r') as file:
- essay = file.read()
-
-docs = text_splitter.create_documents([essay])
-for doc in docs:
- print(count_tokens(doc.page_content))
-
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/tests/modeling/test_anchor_generator.py b/spaces/brjathu/HMR2.0/vendor/detectron2/tests/modeling/test_anchor_generator.py
deleted file mode 100644
index 13a808e587382216da6fe7ee957603f448172657..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/tests/modeling/test_anchor_generator.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import unittest
-import torch
-
-from detectron2.config import get_cfg
-from detectron2.layers import ShapeSpec
-from detectron2.modeling.anchor_generator import DefaultAnchorGenerator, RotatedAnchorGenerator
-
-logger = logging.getLogger(__name__)
-
-
-class TestAnchorGenerator(unittest.TestCase):
- def test_default_anchor_generator(self):
- cfg = get_cfg()
- cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[32, 64]]
- cfg.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS = [[0.25, 1, 4]]
-
- anchor_generator = DefaultAnchorGenerator(cfg, [ShapeSpec(stride=4)])
-
- # only the last two dimensions of features matter here
- num_images = 2
- features = {"stage3": torch.rand(num_images, 96, 1, 2)}
- anchors = anchor_generator([features["stage3"]])
- expected_anchor_tensor = torch.tensor(
- [
- [-32.0, -8.0, 32.0, 8.0],
- [-16.0, -16.0, 16.0, 16.0],
- [-8.0, -32.0, 8.0, 32.0],
- [-64.0, -16.0, 64.0, 16.0],
- [-32.0, -32.0, 32.0, 32.0],
- [-16.0, -64.0, 16.0, 64.0],
- [-28.0, -8.0, 36.0, 8.0], # -28.0 == -32.0 + STRIDE (4)
- [-12.0, -16.0, 20.0, 16.0],
- [-4.0, -32.0, 12.0, 32.0],
- [-60.0, -16.0, 68.0, 16.0],
- [-28.0, -32.0, 36.0, 32.0],
- [-12.0, -64.0, 20.0, 64.0],
- ]
- )
-
- self.assertTrue(torch.allclose(anchors[0].tensor, expected_anchor_tensor))
-
- def test_default_anchor_generator_centered(self):
- # test explicit args
- anchor_generator = DefaultAnchorGenerator(
- sizes=[32, 64], aspect_ratios=[0.25, 1, 4], strides=[4]
- )
-
- # only the last two dimensions of features matter here
- num_images = 2
- features = {"stage3": torch.rand(num_images, 96, 1, 2)}
- expected_anchor_tensor = torch.tensor(
- [
- [-30.0, -6.0, 34.0, 10.0],
- [-14.0, -14.0, 18.0, 18.0],
- [-6.0, -30.0, 10.0, 34.0],
- [-62.0, -14.0, 66.0, 18.0],
- [-30.0, -30.0, 34.0, 34.0],
- [-14.0, -62.0, 18.0, 66.0],
- [-26.0, -6.0, 38.0, 10.0],
- [-10.0, -14.0, 22.0, 18.0],
- [-2.0, -30.0, 14.0, 34.0],
- [-58.0, -14.0, 70.0, 18.0],
- [-26.0, -30.0, 38.0, 34.0],
- [-10.0, -62.0, 22.0, 66.0],
- ]
- )
-
- anchors = anchor_generator([features["stage3"]])
- self.assertTrue(torch.allclose(anchors[0].tensor, expected_anchor_tensor))
-
- anchors = torch.jit.script(anchor_generator)([features["stage3"]])
- self.assertTrue(torch.allclose(anchors[0].tensor, expected_anchor_tensor))
-
- def test_rrpn_anchor_generator(self):
- cfg = get_cfg()
- cfg.MODEL.ANCHOR_GENERATOR.SIZES = [[32, 64]]
- cfg.MODEL.ANCHOR_GENERATOR.ASPECT_RATIOS = [[0.25, 1, 4]]
- cfg.MODEL.ANCHOR_GENERATOR.ANGLES = [0, 45] # test single list[float]
- anchor_generator = RotatedAnchorGenerator(cfg, [ShapeSpec(stride=4)])
-
- # only the last two dimensions of features matter here
- num_images = 2
- features = {"stage3": torch.rand(num_images, 96, 1, 2)}
- anchors = anchor_generator([features["stage3"]])
- expected_anchor_tensor = torch.tensor(
- [
- [0.0, 0.0, 64.0, 16.0, 0.0],
- [0.0, 0.0, 64.0, 16.0, 45.0],
- [0.0, 0.0, 32.0, 32.0, 0.0],
- [0.0, 0.0, 32.0, 32.0, 45.0],
- [0.0, 0.0, 16.0, 64.0, 0.0],
- [0.0, 0.0, 16.0, 64.0, 45.0],
- [0.0, 0.0, 128.0, 32.0, 0.0],
- [0.0, 0.0, 128.0, 32.0, 45.0],
- [0.0, 0.0, 64.0, 64.0, 0.0],
- [0.0, 0.0, 64.0, 64.0, 45.0],
- [0.0, 0.0, 32.0, 128.0, 0.0],
- [0.0, 0.0, 32.0, 128.0, 45.0],
- [4.0, 0.0, 64.0, 16.0, 0.0], # 4.0 == 0.0 + STRIDE (4)
- [4.0, 0.0, 64.0, 16.0, 45.0],
- [4.0, 0.0, 32.0, 32.0, 0.0],
- [4.0, 0.0, 32.0, 32.0, 45.0],
- [4.0, 0.0, 16.0, 64.0, 0.0],
- [4.0, 0.0, 16.0, 64.0, 45.0],
- [4.0, 0.0, 128.0, 32.0, 0.0],
- [4.0, 0.0, 128.0, 32.0, 45.0],
- [4.0, 0.0, 64.0, 64.0, 0.0],
- [4.0, 0.0, 64.0, 64.0, 45.0],
- [4.0, 0.0, 32.0, 128.0, 0.0],
- [4.0, 0.0, 32.0, 128.0, 45.0],
- ]
- )
-
- self.assertTrue(torch.allclose(anchors[0].tensor, expected_anchor_tensor))
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/btlee215/openchat-openchat/README.md b/spaces/btlee215/openchat-openchat/README.md
deleted file mode 100644
index 0af5a009aeafac733f4a4df22f12a4ed736223a3..0000000000000000000000000000000000000000
--- a/spaces/btlee215/openchat-openchat/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Openchat Openchat
-emoji: 👀
-colorFrom: red
-colorTo: purple
-sdk: gradio
-sdk_version: 3.35.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/caltex1/streamlit_pdf_gpt/README.md b/spaces/caltex1/streamlit_pdf_gpt/README.md
deleted file mode 100644
index 6d178bfef0f9b524ec241d6a626b9ef35ce0fff9..0000000000000000000000000000000000000000
--- a/spaces/caltex1/streamlit_pdf_gpt/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Streamlit Pdf Gpt
-emoji: 📚
-colorFrom: red
-colorTo: indigo
-sdk: streamlit
-sdk_version: 1.19.0
-app_file: app.py
-pinned: false
-duplicated_from: amrithhun/streamlit_pdf_gpt
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/visualizer.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/visualizer.py
deleted file mode 100644
index 8e145181871d1981e41db3c8cbc7e8f4cc7b5833..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/visualizer.py
+++ /dev/null
@@ -1,1267 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import colorsys
-import logging
-import math
-import numpy as np
-from enum import Enum, unique
-import cv2
-import matplotlib as mpl
-import matplotlib.colors as mplc
-import matplotlib.figure as mplfigure
-import pycocotools.mask as mask_util
-import torch
-from matplotlib.backends.backend_agg import FigureCanvasAgg
-from PIL import Image
-
-from detectron2.data import MetadataCatalog
-from detectron2.structures import BitMasks, Boxes, BoxMode, Keypoints, PolygonMasks, RotatedBoxes
-from detectron2.utils.file_io import PathManager
-
-from .colormap import random_color
-
-logger = logging.getLogger(__name__)
-
-__all__ = ["ColorMode", "VisImage", "Visualizer"]
-
-
-_SMALL_OBJECT_AREA_THRESH = 1000
-_LARGE_MASK_AREA_THRESH = 120000
-_OFF_WHITE = (1.0, 1.0, 240.0 / 255)
-_BLACK = (0, 0, 0)
-_RED = (1.0, 0, 0)
-
-_KEYPOINT_THRESHOLD = 0.05
-
-
-@unique
-class ColorMode(Enum):
- """
- Enum of different color modes to use for instance visualizations.
- """
-
- IMAGE = 0
- """
- Picks a random color for every instance and overlay segmentations with low opacity.
- """
- SEGMENTATION = 1
- """
- Let instances of the same category have similar colors
- (from metadata.thing_colors), and overlay them with
- high opacity. This provides more attention on the quality of segmentation.
- """
- IMAGE_BW = 2
- """
- Same as IMAGE, but convert all areas without masks to gray-scale.
- Only available for drawing per-instance mask predictions.
- """
-
-
-class GenericMask:
- """
- Attribute:
- polygons (list[ndarray]): list[ndarray]: polygons for this mask.
- Each ndarray has format [x, y, x, y, ...]
- mask (ndarray): a binary mask
- """
-
- def __init__(self, mask_or_polygons, height, width):
- self._mask = self._polygons = self._has_holes = None
- self.height = height
- self.width = width
-
- m = mask_or_polygons
- if isinstance(m, dict):
- # RLEs
- assert "counts" in m and "size" in m
- if isinstance(m["counts"], list): # uncompressed RLEs
- h, w = m["size"]
- assert h == height and w == width
- m = mask_util.frPyObjects(m, h, w)
- self._mask = mask_util.decode(m)[:, :]
- return
-
- if isinstance(m, list): # list[ndarray]
- self._polygons = [np.asarray(x).reshape(-1) for x in m]
- return
-
- if isinstance(m, np.ndarray): # assumed to be a binary mask
- assert m.shape[1] != 2, m.shape
- assert m.shape == (
- height,
- width,
- ), f"mask shape: {m.shape}, target dims: {height}, {width}"
- self._mask = m.astype("uint8")
- return
-
- raise ValueError("GenericMask cannot handle object {} of type '{}'".format(m, type(m)))
-
- @property
- def mask(self):
- if self._mask is None:
- self._mask = self.polygons_to_mask(self._polygons)
- return self._mask
-
- @property
- def polygons(self):
- if self._polygons is None:
- self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
- return self._polygons
-
- @property
- def has_holes(self):
- if self._has_holes is None:
- if self._mask is not None:
- self._polygons, self._has_holes = self.mask_to_polygons(self._mask)
- else:
- self._has_holes = False # if original format is polygon, does not have holes
- return self._has_holes
-
- def mask_to_polygons(self, mask):
- # cv2.RETR_CCOMP flag retrieves all the contours and arranges them to a 2-level
- # hierarchy. External contours (boundary) of the object are placed in hierarchy-1.
- # Internal contours (holes) are placed in hierarchy-2.
- # cv2.CHAIN_APPROX_NONE flag gets vertices of polygons from contours.
- mask = np.ascontiguousarray(mask) # some versions of cv2 does not support incontiguous arr
- res = cv2.findContours(mask.astype("uint8"), cv2.RETR_CCOMP, cv2.CHAIN_APPROX_NONE)
- hierarchy = res[-1]
- if hierarchy is None: # empty mask
- return [], False
- has_holes = (hierarchy.reshape(-1, 4)[:, 3] >= 0).sum() > 0
- res = res[-2]
- res = [x.flatten() for x in res]
- # These coordinates from OpenCV are integers in range [0, W-1 or H-1].
- # We add 0.5 to turn them into real-value coordinate space. A better solution
- # would be to first +0.5 and then dilate the returned polygon by 0.5.
- res = [x + 0.5 for x in res if len(x) >= 6]
- return res, has_holes
-
- def polygons_to_mask(self, polygons):
- rle = mask_util.frPyObjects(polygons, self.height, self.width)
- rle = mask_util.merge(rle)
- return mask_util.decode(rle)[:, :]
-
- def area(self):
- return self.mask.sum()
-
- def bbox(self):
- p = mask_util.frPyObjects(self.polygons, self.height, self.width)
- p = mask_util.merge(p)
- bbox = mask_util.toBbox(p)
- bbox[2] += bbox[0]
- bbox[3] += bbox[1]
- return bbox
-
-
-class _PanopticPrediction:
- """
- Unify different panoptic annotation/prediction formats
- """
-
- def __init__(self, panoptic_seg, segments_info, metadata=None):
- if segments_info is None:
- assert metadata is not None
- # If "segments_info" is None, we assume "panoptic_img" is a
- # H*W int32 image storing the panoptic_id in the format of
- # category_id * label_divisor + instance_id. We reserve -1 for
- # VOID label.
- label_divisor = metadata.label_divisor
- segments_info = []
- for panoptic_label in np.unique(panoptic_seg.numpy()):
- if panoptic_label == -1:
- # VOID region.
- continue
- pred_class = panoptic_label // label_divisor
- isthing = pred_class in metadata.thing_dataset_id_to_contiguous_id.values()
- segments_info.append(
- {
- "id": int(panoptic_label),
- "category_id": int(pred_class),
- "isthing": bool(isthing),
- }
- )
- del metadata
-
- self._seg = panoptic_seg
-
- self._sinfo = {s["id"]: s for s in segments_info} # seg id -> seg info
- segment_ids, areas = torch.unique(panoptic_seg, sorted=True, return_counts=True)
- areas = areas.numpy()
- sorted_idxs = np.argsort(-areas)
- self._seg_ids, self._seg_areas = segment_ids[sorted_idxs], areas[sorted_idxs]
- self._seg_ids = self._seg_ids.tolist()
- for sid, area in zip(self._seg_ids, self._seg_areas):
- if sid in self._sinfo:
- self._sinfo[sid]["area"] = float(area)
-
- def non_empty_mask(self):
- """
- Returns:
- (H, W) array, a mask for all pixels that have a prediction
- """
- empty_ids = []
- for id in self._seg_ids:
- if id not in self._sinfo:
- empty_ids.append(id)
- if len(empty_ids) == 0:
- return np.zeros(self._seg.shape, dtype=np.uint8)
- assert (
- len(empty_ids) == 1
- ), ">1 ids corresponds to no labels. This is currently not supported"
- return (self._seg != empty_ids[0]).numpy().astype(np.bool)
-
- def semantic_masks(self):
- for sid in self._seg_ids:
- sinfo = self._sinfo.get(sid)
- if sinfo is None or sinfo["isthing"]:
- # Some pixels (e.g. id 0 in PanopticFPN) have no instance or semantic predictions.
- continue
- yield (self._seg == sid).numpy().astype(np.bool), sinfo
-
- def instance_masks(self):
- for sid in self._seg_ids:
- sinfo = self._sinfo.get(sid)
- if sinfo is None or not sinfo["isthing"]:
- continue
- mask = (self._seg == sid).numpy().astype(np.bool)
- if mask.sum() > 0:
- yield mask, sinfo
-
-
-def _create_text_labels(classes, scores, class_names, is_crowd=None):
- """
- Args:
- classes (list[int] or None):
- scores (list[float] or None):
- class_names (list[str] or None):
- is_crowd (list[bool] or None):
-
- Returns:
- list[str] or None
- """
- labels = None
- if classes is not None:
- if class_names is not None and len(class_names) > 0:
- labels = [class_names[i] for i in classes]
- else:
- labels = [str(i) for i in classes]
- if scores is not None:
- if labels is None:
- labels = ["{:.0f}%".format(s * 100) for s in scores]
- else:
- labels = ["{} {:.0f}%".format(l, s * 100) for l, s in zip(labels, scores)]
- if labels is not None and is_crowd is not None:
- labels = [l + ("|crowd" if crowd else "") for l, crowd in zip(labels, is_crowd)]
- return labels
-
-
-class VisImage:
- def __init__(self, img, scale=1.0):
- """
- Args:
- img (ndarray): an RGB image of shape (H, W, 3) in range [0, 255].
- scale (float): scale the input image
- """
- self.img = img
- self.scale = scale
- self.width, self.height = img.shape[1], img.shape[0]
- self._setup_figure(img)
-
- def _setup_figure(self, img):
- """
- Args:
- Same as in :meth:`__init__()`.
-
- Returns:
- fig (matplotlib.pyplot.figure): top level container for all the image plot elements.
- ax (matplotlib.pyplot.Axes): contains figure elements and sets the coordinate system.
- """
- fig = mplfigure.Figure(frameon=False)
- self.dpi = fig.get_dpi()
- # add a small 1e-2 to avoid precision lost due to matplotlib's truncation
- # (https://github.com/matplotlib/matplotlib/issues/15363)
- fig.set_size_inches(
- (self.width * self.scale + 1e-2) / self.dpi,
- (self.height * self.scale + 1e-2) / self.dpi,
- )
- self.canvas = FigureCanvasAgg(fig)
- # self.canvas = mpl.backends.backend_cairo.FigureCanvasCairo(fig)
- ax = fig.add_axes([0.0, 0.0, 1.0, 1.0])
- ax.axis("off")
- self.fig = fig
- self.ax = ax
- self.reset_image(img)
-
- def reset_image(self, img):
- """
- Args:
- img: same as in __init__
- """
- img = img.astype("uint8")
- self.ax.imshow(img, extent=(0, self.width, self.height, 0), interpolation="nearest")
-
- def save(self, filepath):
- """
- Args:
- filepath (str): a string that contains the absolute path, including the file name, where
- the visualized image will be saved.
- """
- self.fig.savefig(filepath)
-
- def get_image(self):
- """
- Returns:
- ndarray:
- the visualized image of shape (H, W, 3) (RGB) in uint8 type.
- The shape is scaled w.r.t the input image using the given `scale` argument.
- """
- canvas = self.canvas
- s, (width, height) = canvas.print_to_buffer()
- # buf = io.BytesIO() # works for cairo backend
- # canvas.print_rgba(buf)
- # width, height = self.width, self.height
- # s = buf.getvalue()
-
- buffer = np.frombuffer(s, dtype="uint8")
-
- img_rgba = buffer.reshape(height, width, 4)
- rgb, alpha = np.split(img_rgba, [3], axis=2)
- return rgb.astype("uint8")
-
-
-class Visualizer:
- """
- Visualizer that draws data about detection/segmentation on images.
-
- It contains methods like `draw_{text,box,circle,line,binary_mask,polygon}`
- that draw primitive objects to images, as well as high-level wrappers like
- `draw_{instance_predictions,sem_seg,panoptic_seg_predictions,dataset_dict}`
- that draw composite data in some pre-defined style.
-
- Note that the exact visualization style for the high-level wrappers are subject to change.
- Style such as color, opacity, label contents, visibility of labels, or even the visibility
- of objects themselves (e.g. when the object is too small) may change according
- to different heuristics, as long as the results still look visually reasonable.
-
- To obtain a consistent style, you can implement custom drawing functions with the
- abovementioned primitive methods instead. If you need more customized visualization
- styles, you can process the data yourself following their format documented in
- tutorials (:doc:`/tutorials/models`, :doc:`/tutorials/datasets`). This class does not
- intend to satisfy everyone's preference on drawing styles.
-
- This visualizer focuses on high rendering quality rather than performance. It is not
- designed to be used for real-time applications.
- """
-
- # TODO implement a fast, rasterized version using OpenCV
-
- def __init__(self, img_rgb, metadata=None, scale=1.0, instance_mode=ColorMode.IMAGE):
- """
- Args:
- img_rgb: a numpy array of shape (H, W, C), where H and W correspond to
- the height and width of the image respectively. C is the number of
- color channels. The image is required to be in RGB format since that
- is a requirement of the Matplotlib library. The image is also expected
- to be in the range [0, 255].
- metadata (Metadata): dataset metadata (e.g. class names and colors)
- instance_mode (ColorMode): defines one of the pre-defined style for drawing
- instances on an image.
- """
- self.img = np.asarray(img_rgb).clip(0, 255).astype(np.uint8)
- if metadata is None:
- metadata = MetadataCatalog.get("__nonexist__")
- self.metadata = metadata
- self.output = VisImage(self.img, scale=scale)
- self.cpu_device = torch.device("cpu")
-
- # too small texts are useless, therefore clamp to 9
- self._default_font_size = max(
- np.sqrt(self.output.height * self.output.width) // 90, 10 // scale
- )
- self._instance_mode = instance_mode
- self.keypoint_threshold = _KEYPOINT_THRESHOLD
-
- def draw_instance_predictions(self, predictions):
- """
- Draw instance-level prediction results on an image.
-
- Args:
- predictions (Instances): the output of an instance detection/segmentation
- model. Following fields will be used to draw:
- "pred_boxes", "pred_classes", "scores", "pred_masks" (or "pred_masks_rle").
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- boxes = predictions.pred_boxes if predictions.has("pred_boxes") else None
- scores = predictions.scores if predictions.has("scores") else None
- classes = predictions.pred_classes.tolist() if predictions.has("pred_classes") else None
- labels = _create_text_labels(classes, scores, self.metadata.get("thing_classes", None))
- keypoints = predictions.pred_keypoints if predictions.has("pred_keypoints") else None
-
- if predictions.has("pred_masks"):
- masks = np.asarray(predictions.pred_masks)
- masks = [GenericMask(x, self.output.height, self.output.width) for x in masks]
- else:
- masks = None
-
- if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("thing_colors"):
- colors = [
- self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in classes
- ]
- alpha = 0.8
- else:
- colors = None
- alpha = 0.5
-
- if self._instance_mode == ColorMode.IMAGE_BW:
- self.output.reset_image(
- self._create_grayscale_image(
- (predictions.pred_masks.any(dim=0) > 0).numpy()
- if predictions.has("pred_masks")
- else None
- )
- )
- alpha = 0.3
-
- self.overlay_instances(
- masks=masks,
- boxes=boxes,
- labels=labels,
- keypoints=keypoints,
- assigned_colors=colors,
- alpha=alpha,
- )
- return self.output
-
- def draw_sem_seg(self, sem_seg, area_threshold=None, alpha=0.8):
- """
- Draw semantic segmentation predictions/labels.
-
- Args:
- sem_seg (Tensor or ndarray): the segmentation of shape (H, W).
- Each value is the integer label of the pixel.
- area_threshold (int): segments with less than `area_threshold` are not drawn.
- alpha (float): the larger it is, the more opaque the segmentations are.
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- if isinstance(sem_seg, torch.Tensor):
- sem_seg = sem_seg.numpy()
- labels, areas = np.unique(sem_seg, return_counts=True)
- sorted_idxs = np.argsort(-areas).tolist()
- labels = labels[sorted_idxs]
- for label in filter(lambda l: l < len(self.metadata.stuff_classes), labels):
- try:
- mask_color = [x / 255 for x in self.metadata.stuff_colors[label]]
- except (AttributeError, IndexError):
- mask_color = None
-
- binary_mask = (sem_seg == label).astype(np.uint8)
- text = self.metadata.stuff_classes[label]
- self.draw_binary_mask(
- binary_mask,
- color=mask_color,
- edge_color=_OFF_WHITE,
- text=text,
- alpha=alpha,
- area_threshold=area_threshold,
- )
- return self.output
-
- def draw_panoptic_seg(self, panoptic_seg, segments_info, area_threshold=None, alpha=0.7):
- """
- Draw panoptic prediction annotations or results.
-
- Args:
- panoptic_seg (Tensor): of shape (height, width) where the values are ids for each
- segment.
- segments_info (list[dict] or None): Describe each segment in `panoptic_seg`.
- If it is a ``list[dict]``, each dict contains keys "id", "category_id".
- If None, category id of each pixel is computed by
- ``pixel // metadata.label_divisor``.
- area_threshold (int): stuff segments with less than `area_threshold` are not drawn.
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- pred = _PanopticPrediction(panoptic_seg, segments_info, self.metadata)
-
- if self._instance_mode == ColorMode.IMAGE_BW:
- self.output.reset_image(self._create_grayscale_image(pred.non_empty_mask()))
-
- # draw mask for all semantic segments first i.e. "stuff"
- for mask, sinfo in pred.semantic_masks():
- category_idx = sinfo["category_id"]
- try:
- mask_color = [x / 255 for x in self.metadata.stuff_colors[category_idx]]
- except AttributeError:
- mask_color = None
-
- text = self.metadata.stuff_classes[category_idx]
- self.draw_binary_mask(
- mask,
- color=mask_color,
- edge_color=_OFF_WHITE,
- text=text,
- alpha=alpha,
- area_threshold=area_threshold,
- )
-
- # draw mask for all instances second
- all_instances = list(pred.instance_masks())
- if len(all_instances) == 0:
- return self.output
- masks, sinfo = list(zip(*all_instances))
- category_ids = [x["category_id"] for x in sinfo]
-
- try:
- scores = [x["score"] for x in sinfo]
- except KeyError:
- scores = None
- labels = _create_text_labels(
- category_ids, scores, self.metadata.thing_classes, [x.get("iscrowd", 0) for x in sinfo]
- )
-
- try:
- colors = [
- self._jitter([x / 255 for x in self.metadata.thing_colors[c]]) for c in category_ids
- ]
- except AttributeError:
- colors = None
- self.overlay_instances(masks=masks, labels=labels, assigned_colors=colors, alpha=alpha)
-
- return self.output
-
- draw_panoptic_seg_predictions = draw_panoptic_seg # backward compatibility
-
- def draw_dataset_dict(self, dic):
- """
- Draw annotations/segmentaions in Detectron2 Dataset format.
-
- Args:
- dic (dict): annotation/segmentation data of one image, in Detectron2 Dataset format.
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- annos = dic.get("annotations", None)
- if annos:
- if "segmentation" in annos[0]:
- masks = [x["segmentation"] for x in annos]
- else:
- masks = None
- if "keypoints" in annos[0]:
- keypts = [x["keypoints"] for x in annos]
- keypts = np.array(keypts).reshape(len(annos), -1, 3)
- else:
- keypts = None
-
- boxes = [
- BoxMode.convert(x["bbox"], x["bbox_mode"], BoxMode.XYXY_ABS)
- if len(x["bbox"]) == 4
- else x["bbox"]
- for x in annos
- ]
-
- colors = None
- category_ids = [x["category_id"] for x in annos]
- if self._instance_mode == ColorMode.SEGMENTATION and self.metadata.get("thing_colors"):
- colors = [
- self._jitter([x / 255 for x in self.metadata.thing_colors[c]])
- for c in category_ids
- ]
- names = self.metadata.get("thing_classes", None)
- labels = _create_text_labels(
- category_ids,
- scores=None,
- class_names=names,
- is_crowd=[x.get("iscrowd", 0) for x in annos],
- )
- self.overlay_instances(
- labels=labels, boxes=boxes, masks=masks, keypoints=keypts, assigned_colors=colors
- )
-
- sem_seg = dic.get("sem_seg", None)
- if sem_seg is None and "sem_seg_file_name" in dic:
- with PathManager.open(dic["sem_seg_file_name"], "rb") as f:
- sem_seg = Image.open(f)
- sem_seg = np.asarray(sem_seg, dtype="uint8")
- if sem_seg is not None:
- self.draw_sem_seg(sem_seg, area_threshold=0, alpha=0.5)
-
- pan_seg = dic.get("pan_seg", None)
- if pan_seg is None and "pan_seg_file_name" in dic:
- with PathManager.open(dic["pan_seg_file_name"], "rb") as f:
- pan_seg = Image.open(f)
- pan_seg = np.asarray(pan_seg)
- from panopticapi.utils import rgb2id
-
- pan_seg = rgb2id(pan_seg)
- if pan_seg is not None:
- segments_info = dic["segments_info"]
- pan_seg = torch.tensor(pan_seg)
- self.draw_panoptic_seg(pan_seg, segments_info, area_threshold=0, alpha=0.5)
- return self.output
-
- def overlay_instances(
- self,
- *,
- boxes=None,
- labels=None,
- masks=None,
- keypoints=None,
- assigned_colors=None,
- alpha=0.5,
- ):
- """
- Args:
- boxes (Boxes, RotatedBoxes or ndarray): either a :class:`Boxes`,
- or an Nx4 numpy array of XYXY_ABS format for the N objects in a single image,
- or a :class:`RotatedBoxes`,
- or an Nx5 numpy array of (x_center, y_center, width, height, angle_degrees) format
- for the N objects in a single image,
- labels (list[str]): the text to be displayed for each instance.
- masks (masks-like object): Supported types are:
-
- * :class:`detectron2.structures.PolygonMasks`,
- :class:`detectron2.structures.BitMasks`.
- * list[list[ndarray]]: contains the segmentation masks for all objects in one image.
- The first level of the list corresponds to individual instances. The second
- level to all the polygon that compose the instance, and the third level
- to the polygon coordinates. The third level should have the format of
- [x0, y0, x1, y1, ..., xn, yn] (n >= 3).
- * list[ndarray]: each ndarray is a binary mask of shape (H, W).
- * list[dict]: each dict is a COCO-style RLE.
- keypoints (Keypoint or array like): an array-like object of shape (N, K, 3),
- where the N is the number of instances and K is the number of keypoints.
- The last dimension corresponds to (x, y, visibility or score).
- assigned_colors (list[matplotlib.colors]): a list of colors, where each color
- corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
- for full list of formats that the colors are accepted in.
- Returns:
- output (VisImage): image object with visualizations.
- """
- num_instances = 0
- if boxes is not None:
- boxes = self._convert_boxes(boxes)
- num_instances = len(boxes)
- if masks is not None:
- masks = self._convert_masks(masks)
- if num_instances:
- assert len(masks) == num_instances
- else:
- num_instances = len(masks)
- if keypoints is not None:
- if num_instances:
- assert len(keypoints) == num_instances
- else:
- num_instances = len(keypoints)
- keypoints = self._convert_keypoints(keypoints)
- if labels is not None:
- assert len(labels) == num_instances
- if assigned_colors is None:
- assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
- if num_instances == 0:
- return self.output
- if boxes is not None and boxes.shape[1] == 5:
- return self.overlay_rotated_instances(
- boxes=boxes, labels=labels, assigned_colors=assigned_colors
- )
-
- # Display in largest to smallest order to reduce occlusion.
- areas = None
- if boxes is not None:
- areas = np.prod(boxes[:, 2:] - boxes[:, :2], axis=1)
- elif masks is not None:
- areas = np.asarray([x.area() for x in masks])
-
- if areas is not None:
- sorted_idxs = np.argsort(-areas).tolist()
- # Re-order overlapped instances in descending order.
- boxes = boxes[sorted_idxs] if boxes is not None else None
- labels = [labels[k] for k in sorted_idxs] if labels is not None else None
- masks = [masks[idx] for idx in sorted_idxs] if masks is not None else None
- assigned_colors = [assigned_colors[idx] for idx in sorted_idxs]
- keypoints = keypoints[sorted_idxs] if keypoints is not None else None
-
- for i in range(num_instances):
- color = assigned_colors[i]
- if boxes is not None:
- self.draw_box(boxes[i], edge_color=color)
-
- if masks is not None:
- for segment in masks[i].polygons:
- self.draw_polygon(segment.reshape(-1, 2), color, alpha=alpha)
-
- if labels is not None:
- # first get a box
- if boxes is not None:
- x0, y0, x1, y1 = boxes[i]
- text_pos = (x0, y0) # if drawing boxes, put text on the box corner.
- horiz_align = "left"
- elif masks is not None:
- # skip small mask without polygon
- if len(masks[i].polygons) == 0:
- continue
-
- x0, y0, x1, y1 = masks[i].bbox()
-
- # draw text in the center (defined by median) when box is not drawn
- # median is less sensitive to outliers.
- text_pos = np.median(masks[i].mask.nonzero(), axis=1)[::-1]
- horiz_align = "center"
- else:
- continue # drawing the box confidence for keypoints isn't very useful.
- # for small objects, draw text at the side to avoid occlusion
- instance_area = (y1 - y0) * (x1 - x0)
- if (
- instance_area < _SMALL_OBJECT_AREA_THRESH * self.output.scale
- or y1 - y0 < 40 * self.output.scale
- ):
- if y1 >= self.output.height - 5:
- text_pos = (x1, y0)
- else:
- text_pos = (x0, y1)
-
- height_ratio = (y1 - y0) / np.sqrt(self.output.height * self.output.width)
- lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
- font_size = (
- np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2)
- * 0.5
- * self._default_font_size
- )
- self.draw_text(
- labels[i],
- text_pos,
- color=lighter_color,
- horizontal_alignment=horiz_align,
- font_size=font_size,
- )
-
- # draw keypoints
- if keypoints is not None:
- for keypoints_per_instance in keypoints:
- self.draw_and_connect_keypoints(keypoints_per_instance)
-
- return self.output
-
- def overlay_rotated_instances(self, boxes=None, labels=None, assigned_colors=None):
- """
- Args:
- boxes (ndarray): an Nx5 numpy array of
- (x_center, y_center, width, height, angle_degrees) format
- for the N objects in a single image.
- labels (list[str]): the text to be displayed for each instance.
- assigned_colors (list[matplotlib.colors]): a list of colors, where each color
- corresponds to each mask or box in the image. Refer to 'matplotlib.colors'
- for full list of formats that the colors are accepted in.
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- num_instances = len(boxes)
-
- if assigned_colors is None:
- assigned_colors = [random_color(rgb=True, maximum=1) for _ in range(num_instances)]
- if num_instances == 0:
- return self.output
-
- # Display in largest to smallest order to reduce occlusion.
- if boxes is not None:
- areas = boxes[:, 2] * boxes[:, 3]
-
- sorted_idxs = np.argsort(-areas).tolist()
- # Re-order overlapped instances in descending order.
- boxes = boxes[sorted_idxs]
- labels = [labels[k] for k in sorted_idxs] if labels is not None else None
- colors = [assigned_colors[idx] for idx in sorted_idxs]
-
- for i in range(num_instances):
- self.draw_rotated_box_with_label(
- boxes[i], edge_color=colors[i], label=labels[i] if labels is not None else None
- )
-
- return self.output
-
- def draw_and_connect_keypoints(self, keypoints):
- """
- Draws keypoints of an instance and follows the rules for keypoint connections
- to draw lines between appropriate keypoints. This follows color heuristics for
- line color.
-
- Args:
- keypoints (Tensor): a tensor of shape (K, 3), where K is the number of keypoints
- and the last dimension corresponds to (x, y, probability).
-
- Returns:
- output (VisImage): image object with visualizations.
- """
- visible = {}
- keypoint_names = self.metadata.get("keypoint_names")
- for idx, keypoint in enumerate(keypoints):
-
- # draw keypoint
- x, y, prob = keypoint
- if prob > self.keypoint_threshold:
- self.draw_circle((x, y), color=_RED)
- if keypoint_names:
- keypoint_name = keypoint_names[idx]
- visible[keypoint_name] = (x, y)
-
- if self.metadata.get("keypoint_connection_rules"):
- for kp0, kp1, color in self.metadata.keypoint_connection_rules:
- if kp0 in visible and kp1 in visible:
- x0, y0 = visible[kp0]
- x1, y1 = visible[kp1]
- color = tuple(x / 255.0 for x in color)
- self.draw_line([x0, x1], [y0, y1], color=color)
-
- # draw lines from nose to mid-shoulder and mid-shoulder to mid-hip
- # Note that this strategy is specific to person keypoints.
- # For other keypoints, it should just do nothing
- try:
- ls_x, ls_y = visible["left_shoulder"]
- rs_x, rs_y = visible["right_shoulder"]
- mid_shoulder_x, mid_shoulder_y = (ls_x + rs_x) / 2, (ls_y + rs_y) / 2
- except KeyError:
- pass
- else:
- # draw line from nose to mid-shoulder
- nose_x, nose_y = visible.get("nose", (None, None))
- if nose_x is not None:
- self.draw_line([nose_x, mid_shoulder_x], [nose_y, mid_shoulder_y], color=_RED)
-
- try:
- # draw line from mid-shoulder to mid-hip
- lh_x, lh_y = visible["left_hip"]
- rh_x, rh_y = visible["right_hip"]
- except KeyError:
- pass
- else:
- mid_hip_x, mid_hip_y = (lh_x + rh_x) / 2, (lh_y + rh_y) / 2
- self.draw_line([mid_hip_x, mid_shoulder_x], [mid_hip_y, mid_shoulder_y], color=_RED)
- return self.output
-
- """
- Primitive drawing functions:
- """
-
- def draw_text(
- self,
- text,
- position,
- *,
- font_size=None,
- color="g",
- horizontal_alignment="center",
- rotation=0,
- ):
- """
- Args:
- text (str): class label
- position (tuple): a tuple of the x and y coordinates to place text on image.
- font_size (int, optional): font of the text. If not provided, a font size
- proportional to the image width is calculated and used.
- color: color of the text. Refer to `matplotlib.colors` for full list
- of formats that are accepted.
- horizontal_alignment (str): see `matplotlib.text.Text`
- rotation: rotation angle in degrees CCW
-
- Returns:
- output (VisImage): image object with text drawn.
- """
- if not font_size:
- font_size = self._default_font_size
-
- # since the text background is dark, we don't want the text to be dark
- color = np.maximum(list(mplc.to_rgb(color)), 0.2)
- color[np.argmax(color)] = max(0.8, np.max(color))
-
- x, y = position
- self.output.ax.text(
- x,
- y,
- text,
- size=font_size * self.output.scale,
- family="sans-serif",
- bbox={"facecolor": "black", "alpha": 0.8, "pad": 0.7, "edgecolor": "none"},
- verticalalignment="top",
- horizontalalignment=horizontal_alignment,
- color=color,
- zorder=10,
- rotation=rotation,
- )
- return self.output
-
- def draw_box(self, box_coord, alpha=0.5, edge_color="g", line_style="-"):
- """
- Args:
- box_coord (tuple): a tuple containing x0, y0, x1, y1 coordinates, where x0 and y0
- are the coordinates of the image's top left corner. x1 and y1 are the
- coordinates of the image's bottom right corner.
- alpha (float): blending efficient. Smaller values lead to more transparent masks.
- edge_color: color of the outline of the box. Refer to `matplotlib.colors`
- for full list of formats that are accepted.
- line_style (string): the string to use to create the outline of the boxes.
-
- Returns:
- output (VisImage): image object with box drawn.
- """
- x0, y0, x1, y1 = box_coord
- width = x1 - x0
- height = y1 - y0
-
- linewidth = max(self._default_font_size / 4, 1)
-
- self.output.ax.add_patch(
- mpl.patches.Rectangle(
- (x0, y0),
- width,
- height,
- fill=False,
- edgecolor=edge_color,
- linewidth=linewidth * self.output.scale,
- alpha=alpha,
- linestyle=line_style,
- )
- )
- return self.output
-
- def draw_rotated_box_with_label(
- self, rotated_box, alpha=0.5, edge_color="g", line_style="-", label=None
- ):
- """
- Draw a rotated box with label on its top-left corner.
-
- Args:
- rotated_box (tuple): a tuple containing (cnt_x, cnt_y, w, h, angle),
- where cnt_x and cnt_y are the center coordinates of the box.
- w and h are the width and height of the box. angle represents how
- many degrees the box is rotated CCW with regard to the 0-degree box.
- alpha (float): blending efficient. Smaller values lead to more transparent masks.
- edge_color: color of the outline of the box. Refer to `matplotlib.colors`
- for full list of formats that are accepted.
- line_style (string): the string to use to create the outline of the boxes.
- label (string): label for rotated box. It will not be rendered when set to None.
-
- Returns:
- output (VisImage): image object with box drawn.
- """
- cnt_x, cnt_y, w, h, angle = rotated_box
- area = w * h
- # use thinner lines when the box is small
- linewidth = self._default_font_size / (
- 6 if area < _SMALL_OBJECT_AREA_THRESH * self.output.scale else 3
- )
-
- theta = angle * math.pi / 180.0
- c = math.cos(theta)
- s = math.sin(theta)
- rect = [(-w / 2, h / 2), (-w / 2, -h / 2), (w / 2, -h / 2), (w / 2, h / 2)]
- # x: left->right ; y: top->down
- rotated_rect = [(s * yy + c * xx + cnt_x, c * yy - s * xx + cnt_y) for (xx, yy) in rect]
- for k in range(4):
- j = (k + 1) % 4
- self.draw_line(
- [rotated_rect[k][0], rotated_rect[j][0]],
- [rotated_rect[k][1], rotated_rect[j][1]],
- color=edge_color,
- linestyle="--" if k == 1 else line_style,
- linewidth=linewidth,
- )
-
- if label is not None:
- text_pos = rotated_rect[1] # topleft corner
-
- height_ratio = h / np.sqrt(self.output.height * self.output.width)
- label_color = self._change_color_brightness(edge_color, brightness_factor=0.7)
- font_size = (
- np.clip((height_ratio - 0.02) / 0.08 + 1, 1.2, 2) * 0.5 * self._default_font_size
- )
- self.draw_text(label, text_pos, color=label_color, font_size=font_size, rotation=angle)
-
- return self.output
-
- def draw_circle(self, circle_coord, color, radius=3):
- """
- Args:
- circle_coord (list(int) or tuple(int)): contains the x and y coordinates
- of the center of the circle.
- color: color of the polygon. Refer to `matplotlib.colors` for a full list of
- formats that are accepted.
- radius (int): radius of the circle.
-
- Returns:
- output (VisImage): image object with box drawn.
- """
- x, y = circle_coord
- self.output.ax.add_patch(
- mpl.patches.Circle(circle_coord, radius=radius, fill=True, color=color)
- )
- return self.output
-
- def draw_line(self, x_data, y_data, color, linestyle="-", linewidth=None):
- """
- Args:
- x_data (list[int]): a list containing x values of all the points being drawn.
- Length of list should match the length of y_data.
- y_data (list[int]): a list containing y values of all the points being drawn.
- Length of list should match the length of x_data.
- color: color of the line. Refer to `matplotlib.colors` for a full list of
- formats that are accepted.
- linestyle: style of the line. Refer to `matplotlib.lines.Line2D`
- for a full list of formats that are accepted.
- linewidth (float or None): width of the line. When it's None,
- a default value will be computed and used.
-
- Returns:
- output (VisImage): image object with line drawn.
- """
- if linewidth is None:
- linewidth = self._default_font_size / 3
- linewidth = max(linewidth, 1)
- self.output.ax.add_line(
- mpl.lines.Line2D(
- x_data,
- y_data,
- linewidth=linewidth * self.output.scale,
- color=color,
- linestyle=linestyle,
- )
- )
- return self.output
-
- def draw_binary_mask(
- self, binary_mask, color=None, *, edge_color=None, text=None, alpha=0.5, area_threshold=10
- ):
- """
- Args:
- binary_mask (ndarray): numpy array of shape (H, W), where H is the image height and
- W is the image width. Each value in the array is either a 0 or 1 value of uint8
- type.
- color: color of the mask. Refer to `matplotlib.colors` for a full list of
- formats that are accepted. If None, will pick a random color.
- edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
- full list of formats that are accepted.
- text (str): if None, will be drawn on the object
- alpha (float): blending efficient. Smaller values lead to more transparent masks.
- area_threshold (float): a connected component smaller than this area will not be shown.
-
- Returns:
- output (VisImage): image object with mask drawn.
- """
- if color is None:
- color = random_color(rgb=True, maximum=1)
- color = mplc.to_rgb(color)
-
- has_valid_segment = False
- binary_mask = binary_mask.astype("uint8") # opencv needs uint8
- mask = GenericMask(binary_mask, self.output.height, self.output.width)
- shape2d = (binary_mask.shape[0], binary_mask.shape[1])
-
- if not mask.has_holes:
- # draw polygons for regular masks
- for segment in mask.polygons:
- area = mask_util.area(mask_util.frPyObjects([segment], shape2d[0], shape2d[1]))
- if area < (area_threshold or 0):
- continue
- has_valid_segment = True
- segment = segment.reshape(-1, 2)
- self.draw_polygon(segment, color=color, edge_color=edge_color, alpha=alpha)
- else:
- # TODO: Use Path/PathPatch to draw vector graphics:
- # https://stackoverflow.com/questions/8919719/how-to-plot-a-complex-polygon
- rgba = np.zeros(shape2d + (4,), dtype="float32")
- rgba[:, :, :3] = color
- rgba[:, :, 3] = (mask.mask == 1).astype("float32") * alpha
- has_valid_segment = True
- self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
-
- if text is not None and has_valid_segment:
- lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
- self._draw_text_in_mask(binary_mask, text, lighter_color)
- return self.output
-
- def draw_soft_mask(self, soft_mask, color=None, *, text=None, alpha=0.5):
- """
- Args:
- soft_mask (ndarray): float array of shape (H, W), each value in [0, 1].
- color: color of the mask. Refer to `matplotlib.colors` for a full list of
- formats that are accepted. If None, will pick a random color.
- text (str): if None, will be drawn on the object
- alpha (float): blending efficient. Smaller values lead to more transparent masks.
-
- Returns:
- output (VisImage): image object with mask drawn.
- """
- if color is None:
- color = random_color(rgb=True, maximum=1)
- color = mplc.to_rgb(color)
-
- shape2d = (soft_mask.shape[0], soft_mask.shape[1])
- rgba = np.zeros(shape2d + (4,), dtype="float32")
- rgba[:, :, :3] = color
- rgba[:, :, 3] = soft_mask * alpha
- self.output.ax.imshow(rgba, extent=(0, self.output.width, self.output.height, 0))
-
- if text is not None:
- lighter_color = self._change_color_brightness(color, brightness_factor=0.7)
- binary_mask = (soft_mask > 0.5).astype("uint8")
- self._draw_text_in_mask(binary_mask, text, lighter_color)
- return self.output
-
- def draw_polygon(self, segment, color, edge_color=None, alpha=0.5):
- """
- Args:
- segment: numpy array of shape Nx2, containing all the points in the polygon.
- color: color of the polygon. Refer to `matplotlib.colors` for a full list of
- formats that are accepted.
- edge_color: color of the polygon edges. Refer to `matplotlib.colors` for a
- full list of formats that are accepted. If not provided, a darker shade
- of the polygon color will be used instead.
- alpha (float): blending efficient. Smaller values lead to more transparent masks.
-
- Returns:
- output (VisImage): image object with polygon drawn.
- """
- if edge_color is None:
- # make edge color darker than the polygon color
- if alpha > 0.8:
- edge_color = self._change_color_brightness(color, brightness_factor=-0.7)
- else:
- edge_color = color
- edge_color = mplc.to_rgb(edge_color) + (1,)
-
- polygon = mpl.patches.Polygon(
- segment,
- fill=True,
- facecolor=mplc.to_rgb(color) + (alpha,),
- edgecolor=edge_color,
- linewidth=max(self._default_font_size // 15 * self.output.scale, 1),
- )
- self.output.ax.add_patch(polygon)
- return self.output
-
- """
- Internal methods:
- """
-
- def _jitter(self, color):
- """
- Randomly modifies given color to produce a slightly different color than the color given.
-
- Args:
- color (tuple[double]): a tuple of 3 elements, containing the RGB values of the color
- picked. The values in the list are in the [0.0, 1.0] range.
-
- Returns:
- jittered_color (tuple[double]): a tuple of 3 elements, containing the RGB values of the
- color after being jittered. The values in the list are in the [0.0, 1.0] range.
- """
- color = mplc.to_rgb(color)
- vec = np.random.rand(3)
- # better to do it in another color space
- vec = vec / np.linalg.norm(vec) * 0.5
- res = np.clip(vec + color, 0, 1)
- return tuple(res)
-
- def _create_grayscale_image(self, mask=None):
- """
- Create a grayscale version of the original image.
- The colors in masked area, if given, will be kept.
- """
- img_bw = self.img.astype("f4").mean(axis=2)
- img_bw = np.stack([img_bw] * 3, axis=2)
- if mask is not None:
- img_bw[mask] = self.img[mask]
- return img_bw
-
- def _change_color_brightness(self, color, brightness_factor):
- """
- Depending on the brightness_factor, gives a lighter or darker color i.e. a color with
- less or more saturation than the original color.
-
- Args:
- color: color of the polygon. Refer to `matplotlib.colors` for a full list of
- formats that are accepted.
- brightness_factor (float): a value in [-1.0, 1.0] range. A lightness factor of
- 0 will correspond to no change, a factor in [-1.0, 0) range will result in
- a darker color and a factor in (0, 1.0] range will result in a lighter color.
-
- Returns:
- modified_color (tuple[double]): a tuple containing the RGB values of the
- modified color. Each value in the tuple is in the [0.0, 1.0] range.
- """
- assert brightness_factor >= -1.0 and brightness_factor <= 1.0
- color = mplc.to_rgb(color)
- polygon_color = colorsys.rgb_to_hls(*mplc.to_rgb(color))
- modified_lightness = polygon_color[1] + (brightness_factor * polygon_color[1])
- modified_lightness = 0.0 if modified_lightness < 0.0 else modified_lightness
- modified_lightness = 1.0 if modified_lightness > 1.0 else modified_lightness
- modified_color = colorsys.hls_to_rgb(polygon_color[0], modified_lightness, polygon_color[2])
- return modified_color
-
- def _convert_boxes(self, boxes):
- """
- Convert different format of boxes to an NxB array, where B = 4 or 5 is the box dimension.
- """
- if isinstance(boxes, Boxes) or isinstance(boxes, RotatedBoxes):
- return boxes.tensor.detach().numpy()
- else:
- return np.asarray(boxes)
-
- def _convert_masks(self, masks_or_polygons):
- """
- Convert different format of masks or polygons to a tuple of masks and polygons.
-
- Returns:
- list[GenericMask]:
- """
-
- m = masks_or_polygons
- if isinstance(m, PolygonMasks):
- m = m.polygons
- if isinstance(m, BitMasks):
- m = m.tensor.numpy()
- if isinstance(m, torch.Tensor):
- m = m.numpy()
- ret = []
- for x in m:
- if isinstance(x, GenericMask):
- ret.append(x)
- else:
- ret.append(GenericMask(x, self.output.height, self.output.width))
- return ret
-
- def _draw_text_in_mask(self, binary_mask, text, color):
- """
- Find proper places to draw text given a binary mask.
- """
- # TODO sometimes drawn on wrong objects. the heuristics here can improve.
- _num_cc, cc_labels, stats, centroids = cv2.connectedComponentsWithStats(binary_mask, 8)
- if stats[1:, -1].size == 0:
- return
- largest_component_id = np.argmax(stats[1:, -1]) + 1
-
- # draw text on the largest component, as well as other very large components.
- for cid in range(1, _num_cc):
- if cid == largest_component_id or stats[cid, -1] > _LARGE_MASK_AREA_THRESH:
- # median is more stable than centroid
- # center = centroids[largest_component_id]
- center = np.median((cc_labels == cid).nonzero(), axis=1)[::-1]
- self.draw_text(text, center, color=color)
-
- def _convert_keypoints(self, keypoints):
- if isinstance(keypoints, Keypoints):
- keypoints = keypoints.tensor
- keypoints = np.asarray(keypoints)
- return keypoints
-
- def get_output(self):
- """
- Returns:
- output (VisImage): the image output containing the visualizations added
- to the image.
- """
- return self.output
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/docs/tutorials/training.md b/spaces/carlosalonso/Detection-video/carpeta_deteccion/docs/tutorials/training.md
deleted file mode 100644
index 83a6cb0a8e38ca06bbf96201ac2595d2116523c3..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/docs/tutorials/training.md
+++ /dev/null
@@ -1,67 +0,0 @@
-# Training
-
-From the previous tutorials, you may now have a custom model and a data loader.
-To run training, users typically have a preference in one of the following two styles:
-
-### Custom Training Loop
-
-With a model and a data loader ready, everything else needed to write a training loop can
-be found in PyTorch, and you are free to write the training loop yourself.
-This style allows researchers to manage the entire training logic more clearly and have full control.
-One such example is provided in [tools/plain_train_net.py](../../tools/plain_train_net.py).
-
-Any customization on the training logic is then easily controlled by the user.
-
-### Trainer Abstraction
-
-We also provide a standardized "trainer" abstraction with a
-hook system that helps simplify the standard training behavior.
-It includes the following two instantiations:
-
-* [SimpleTrainer](../modules/engine.html#detectron2.engine.SimpleTrainer)
- provides a minimal training loop for single-cost single-optimizer single-data-source training, with nothing else.
- Other tasks (checkpointing, logging, etc) can be implemented using
- [the hook system](../modules/engine.html#detectron2.engine.HookBase).
-* [DefaultTrainer](../modules/engine.html#detectron2.engine.defaults.DefaultTrainer) is a `SimpleTrainer` initialized from a
- yacs config, used by
- [tools/train_net.py](../../tools/train_net.py) and many scripts.
- It includes more standard default behaviors that one might want to opt in,
- including default configurations for optimizer, learning rate schedule,
- logging, evaluation, checkpointing etc.
-
-To customize a `DefaultTrainer`:
-
-1. For simple customizations (e.g. change optimizer, evaluator, LR scheduler, data loader, etc.), overwrite [its methods](../modules/engine.html#detectron2.engine.defaults.DefaultTrainer) in a subclass, just like [tools/train_net.py](../../tools/train_net.py).
-2. For extra tasks during training, check the
- [hook system](../modules/engine.html#detectron2.engine.HookBase) to see if it's supported.
-
- As an example, to print hello during training:
- ```python
- class HelloHook(HookBase):
- def after_step(self):
- if self.trainer.iter % 100 == 0:
- print(f"Hello at iteration {self.trainer.iter}!")
- ```
-3. Using a trainer+hook system means there will always be some non-standard behaviors that cannot be supported, especially in research.
- For this reason, we intentionally keep the trainer & hook system minimal, rather than powerful.
- If anything cannot be achieved by such a system, it's easier to start from [tools/plain_train_net.py](../../tools/plain_train_net.py) to implement custom training logic manually.
-
-### Logging of Metrics
-
-During training, detectron2 models and trainer put metrics to a centralized [EventStorage](../modules/utils.html#detectron2.utils.events.EventStorage).
-You can use the following code to access it and log metrics to it:
-```python
-from detectron2.utils.events import get_event_storage
-
-# inside the model:
-if self.training:
- value = # compute the value from inputs
- storage = get_event_storage()
- storage.put_scalar("some_accuracy", value)
-```
-
-Refer to its documentation for more details.
-
-Metrics are then written to various destinations with [EventWriter](../modules/utils.html#module-detectron2.utils.events).
-DefaultTrainer enables a few `EventWriter` with default configurations.
-See above for how to customize them.
diff --git a/spaces/chendl/compositional_test/transformers/examples/flax/text-classification/README.md b/spaces/chendl/compositional_test/transformers/examples/flax/text-classification/README.md
deleted file mode 100644
index 8d43ab7725a24174576d1a9cdd35f540605bb339..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/flax/text-classification/README.md
+++ /dev/null
@@ -1,108 +0,0 @@
-
-
-# Text classification examples
-
-## GLUE tasks
-
-Based on the script [`run_flax_glue.py`](https://github.com/huggingface/transformers/blob/main/examples/flax/text-classification/run_flax_glue.py).
-
-Fine-tuning the library models for sequence classification on the GLUE benchmark: [General Language Understanding
-Evaluation](https://gluebenchmark.com/). This script can fine-tune any of the models on the [hub](https://huggingface.co/models) and can also be used for a
-dataset hosted on our [hub](https://huggingface.co/datasets) or your own data in a csv or a JSON file (the script might need some tweaks in that case,
-refer to the comments inside for help).
-
-GLUE is made up of a total of 9 different tasks. Here is how to run the script on one of them:
-
-```bash
-export TASK_NAME=mrpc
-
-python run_flax_glue.py \
- --model_name_or_path bert-base-cased \
- --task_name ${TASK_NAME} \
- --max_seq_length 128 \
- --learning_rate 2e-5 \
- --num_train_epochs 3 \
- --per_device_train_batch_size 4 \
- --eval_steps 100 \
- --output_dir ./$TASK_NAME/ \
- --push_to_hub
-```
-
-where task name can be one of cola, mnli, mnli_mismatched, mnli_matched, mrpc, qnli, qqp, rte, sst2, stsb, wnli.
-
-Using the command above, the script will train for 3 epochs and run eval after each epoch.
-Metrics and hyperparameters are stored in Tensorflow event files in `--output_dir`.
-You can see the results by running `tensorboard` in that directory:
-
-```bash
-$ tensorboard --logdir .
-```
-
-or directly on the hub under *Training metrics*.
-
-### Accuracy Evaluation
-
-We train five replicas and report mean accuracy and stdev on the dev set below.
-We use the settings as in the command above (with an exception for MRPC and
-WNLI which are tiny and where we used 5 epochs instead of 3), and we use a total
-train batch size of 32 (we train on 8 Cloud v3 TPUs, so a per-device batch size of 4),
-
-On the task other than MRPC and WNLI we train for 3 these epochs because this is the standard,
-but looking at the training curves of some of them (e.g., SST-2, STS-b), it appears the models
-are undertrained and we could get better results when training longer.
-
-In the Tensorboard results linked below, the random seed of each model is equal to the ID of the run. So in order to reproduce run 1, run the command above with `--seed=1`. The best run used random seed 3, which is the default in the script. The results of all runs are in [this Google Sheet](https://docs.google.com/spreadsheets/d/1p3XzReMO75m_XdEJvPue-PIq_PN-96J2IJpJW1yS-10/edit?usp=sharing).
-
-| Task | Metric | Acc (best run) | Acc (avg/5runs) | Stdev | Metrics |
-|-------|------------------------------|----------------|-----------------|-----------|--------------------------------------------------------------------------|
-| CoLA | Matthews corr | 60.57 | 59.04 | 1.06 | [tfhub.dev](https://tensorboard.dev/experiment/lfr2adVpRtmLDALKrElkzg/) |
-| SST-2 | Accuracy | 92.66 | 92.23 | 0.57 | [tfhub.dev](https://tensorboard.dev/experiment/jYvfv2trRHKMjoWnXVwrZA/) |
-| MRPC | F1/Accuracy | 89.90/85.78 | 88.97/84.36 | 0.72/1.09 | [tfhub.dev](https://tensorboard.dev/experiment/bo3W3DEoRw2Q7YXjWrJkfg/) |
-| STS-B | Pearson/Spearman corr. | 89.04/88.70 | 88.94/88.63 | 0.07/0.07 | [tfhub.dev](https://tensorboard.dev/experiment/fxVwbLD7QpKhbot0r9rn2w/) |
-| QQP | Accuracy/F1 | 90.81/87.58 | 90.76/87.51 | 0.05/0.06 | [tfhub.dev](https://tensorboard.dev/experiment/di089Rc9TZmsnKRMrYNLsA/) |
-| MNLI | Matched acc. | 84.10 | 83.80 | 0.16 | [tfhub.dev](https://tensorboard.dev/experiment/JgNCGHDJSRaW6HBx6YQFYQ/) |
-| QNLI | Accuracy | 91.01 | 90.82 | 0.17 | [tfhub.dev](https://tensorboard.dev/experiment/Bq7cMGJnQMSggYgL8qNGeQ/) |
-| RTE | Accuracy | 66.06 | 64.76 | 1.04 | [tfhub.dev](https://tensorboard.dev/experiment/66Eq24bhRjqN6CEhgDSGqQ/) |
-| WNLI | Accuracy | 46.48 | 37.01 | 6.83 | [tfhub.dev](https://tensorboard.dev/experiment/TAqcnddqTkWvVEeGaWwIdQ/) |
-
-Some of these results are significantly different from the ones reported on the test set of GLUE benchmark on the
-website. For QQP and WNLI, please refer to [FAQ #12](https://gluebenchmark.com/faq) on the website.
-
-### Runtime evaluation
-
-We also ran each task once on a single V100 GPU, 8 V100 GPUs, and 8 Cloud v3 TPUs and report the
-overall training time below. For comparison we ran Pytorch's [run_glue.py](https://github.com/huggingface/transformers/blob/main/examples/pytorch/text-classification/run_glue.py) on a single GPU (last column).
-
-
-| Task | TPU v3-8 | 8 GPU | [1 GPU](https://tensorboard.dev/experiment/mkPS4Zh8TnGe1HB6Yzwj4Q) | 1 GPU (Pytorch) |
-|-------|-----------|------------|------------|-----------------|
-| CoLA | 1m 42s | 1m 26s | 3m 9s | 4m 6s |
-| SST-2 | 5m 12s | 6m 28s | 22m 33s | 34m 37s |
-| MRPC | 1m 29s | 1m 14s | 2m 20s | 2m 56s |
-| STS-B | 1m 30s | 1m 12s | 2m 16s | 2m 48s |
-| QQP | 22m 50s | 31m 48s | 1h 59m 41s | 2h 54m |
-| MNLI | 25m 03s | 33m 55s | 2h 9m 37s | 3h 7m 6s |
-| QNLI | 7m30s | 9m 40s | 34m 40s | 49m 8s |
-| RTE | 1m 20s | 55s | 1m 10s | 1m 16s |
-| WNLI | 1m 11s | 48s | 39s | 36s |
-|-------|
-| **TOTAL** | 1h 03m | 1h 28m | 5h 16m | 6h 37m |
-
-*All experiments are ran on Google Cloud Platform.
-GPU experiments are ran without further optimizations besides JAX
-transformations. GPU experiments are ran with full precision (fp32). "TPU v3-8"
-are 8 TPU cores on 4 chips (each chips has 2 cores), while "8 GPU" are 8 GPU chips.
diff --git a/spaces/chendl/compositional_test/transformers/examples/run_on_remote.py b/spaces/chendl/compositional_test/transformers/examples/run_on_remote.py
deleted file mode 100644
index 9d42ed845c9e8f3815dba5c05a1c55a2d05315f0..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/run_on_remote.py
+++ /dev/null
@@ -1,71 +0,0 @@
-#!/usr/bin/env python
-# coding=utf-8
-# Copyright 2021 The HuggingFace Inc. 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 argparse
-import shlex
-
-import runhouse as rh
-
-
-if __name__ == "__main__":
- # Refer to https://runhouse-docs.readthedocs-hosted.com/en/main/rh_primitives/cluster.html#hardware-setup for cloud access
- # setup instructions, if using on-demand hardware
-
- # If user passes --user --host --key_path , fill them in as BYO cluster
- # If user passes --instance --provider , fill them in as on-demand cluster
- # Throw an error if user passes both BYO and on-demand cluster args
- # Otherwise, use default values
- parser = argparse.ArgumentParser()
- parser.add_argument("--user", type=str, default="ubuntu")
- parser.add_argument("--host", type=str, default="localhost")
- parser.add_argument("--key_path", type=str, default=None)
- parser.add_argument("--instance", type=str, default="V100:1")
- parser.add_argument("--provider", type=str, default="cheapest")
- parser.add_argument("--use_spot", type=bool, default=False)
- parser.add_argument("--example", type=str, default="pytorch/text-generation/run_generation.py")
- args, unknown = parser.parse_known_args()
- if args.host != "localhost":
- if args.instance != "V100:1" or args.provider != "cheapest":
- raise ValueError("Cannot specify both BYO and on-demand cluster args")
- cluster = rh.cluster(
- name="rh-cluster", ips=[args.host], ssh_creds={"ssh_user": args.user, "ssh_private_key": args.key_path}
- )
- else:
- cluster = rh.cluster(
- name="rh-cluster", instance_type=args.instance, provider=args.provider, use_spot=args.use_spot
- )
- example_dir = args.example.rsplit("/", 1)[0]
-
- # Set up remote environment
- cluster.install_packages(["pip:./"]) # Installs transformers from local source
- # Note transformers is copied into the home directory on the remote machine, so we can install from there
- cluster.run([f"pip install -r transformers/examples/{example_dir}/requirements.txt"])
- cluster.run(["pip install torch --upgrade --extra-index-url https://download.pytorch.org/whl/cu117"])
-
- # Run example. You can bypass the CLI wrapper and paste your own code here.
- cluster.run([f'python transformers/examples/{args.example} {" ".join(shlex.quote(arg) for arg in unknown)}'])
-
- # Alternatively, we can just import and run a training function (especially if there's no wrapper CLI):
- # from my_script... import train
- # reqs = ['pip:./', 'torch', 'datasets', 'accelerate', 'evaluate', 'tqdm', 'scipy', 'scikit-learn', 'tensorboard']
- # launch_train_gpu = rh.function(fn=train,
- # system=gpu,
- # reqs=reqs,
- # name='train_bert_glue')
- #
- # We can pass in arguments just like we would to a function:
- # launch_train_gpu(num_epochs = 3, lr = 2e-5, seed = 42, batch_size = 16
- # stream_logs=True)
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/aiohttp/web_routedef.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/aiohttp/web_routedef.py
deleted file mode 100644
index a1eb0a76549fbde5aa0c81f02b041b77bd91e0ad..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/aiohttp/web_routedef.py
+++ /dev/null
@@ -1,216 +0,0 @@
-import abc
-import os # noqa
-from typing import (
- TYPE_CHECKING,
- Any,
- Callable,
- Dict,
- Iterator,
- List,
- Optional,
- Sequence,
- Type,
- Union,
- overload,
-)
-
-import attr
-
-from . import hdrs
-from .abc import AbstractView
-from .typedefs import Handler, PathLike
-
-if TYPE_CHECKING: # pragma: no cover
- from .web_request import Request
- from .web_response import StreamResponse
- from .web_urldispatcher import AbstractRoute, UrlDispatcher
-else:
- Request = StreamResponse = UrlDispatcher = AbstractRoute = None
-
-
-__all__ = (
- "AbstractRouteDef",
- "RouteDef",
- "StaticDef",
- "RouteTableDef",
- "head",
- "options",
- "get",
- "post",
- "patch",
- "put",
- "delete",
- "route",
- "view",
- "static",
-)
-
-
-class AbstractRouteDef(abc.ABC):
- @abc.abstractmethod
- def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
- pass # pragma: no cover
-
-
-_HandlerType = Union[Type[AbstractView], Handler]
-
-
-@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
-class RouteDef(AbstractRouteDef):
- method: str
- path: str
- handler: _HandlerType
- kwargs: Dict[str, Any]
-
- def __repr__(self) -> str:
- info = []
- for name, value in sorted(self.kwargs.items()):
- info.append(f", {name}={value!r}")
- return " {handler.__name__!r}" "{info}>".format(
- method=self.method, path=self.path, handler=self.handler, info="".join(info)
- )
-
- def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
- if self.method in hdrs.METH_ALL:
- reg = getattr(router, "add_" + self.method.lower())
- return [reg(self.path, self.handler, **self.kwargs)]
- else:
- return [
- router.add_route(self.method, self.path, self.handler, **self.kwargs)
- ]
-
-
-@attr.s(auto_attribs=True, frozen=True, repr=False, slots=True)
-class StaticDef(AbstractRouteDef):
- prefix: str
- path: PathLike
- kwargs: Dict[str, Any]
-
- def __repr__(self) -> str:
- info = []
- for name, value in sorted(self.kwargs.items()):
- info.append(f", {name}={value!r}")
- return " {path}" "{info}>".format(
- prefix=self.prefix, path=self.path, info="".join(info)
- )
-
- def register(self, router: UrlDispatcher) -> List[AbstractRoute]:
- resource = router.add_static(self.prefix, self.path, **self.kwargs)
- routes = resource.get_info().get("routes", {})
- return list(routes.values())
-
-
-def route(method: str, path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return RouteDef(method, path, handler, kwargs)
-
-
-def head(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_HEAD, path, handler, **kwargs)
-
-
-def options(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_OPTIONS, path, handler, **kwargs)
-
-
-def get(
- path: str,
- handler: _HandlerType,
- *,
- name: Optional[str] = None,
- allow_head: bool = True,
- **kwargs: Any,
-) -> RouteDef:
- return route(
- hdrs.METH_GET, path, handler, name=name, allow_head=allow_head, **kwargs
- )
-
-
-def post(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_POST, path, handler, **kwargs)
-
-
-def put(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_PUT, path, handler, **kwargs)
-
-
-def patch(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_PATCH, path, handler, **kwargs)
-
-
-def delete(path: str, handler: _HandlerType, **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_DELETE, path, handler, **kwargs)
-
-
-def view(path: str, handler: Type[AbstractView], **kwargs: Any) -> RouteDef:
- return route(hdrs.METH_ANY, path, handler, **kwargs)
-
-
-def static(prefix: str, path: PathLike, **kwargs: Any) -> StaticDef:
- return StaticDef(prefix, path, kwargs)
-
-
-_Deco = Callable[[_HandlerType], _HandlerType]
-
-
-class RouteTableDef(Sequence[AbstractRouteDef]):
- """Route definition table"""
-
- def __init__(self) -> None:
- self._items: List[AbstractRouteDef] = []
-
- def __repr__(self) -> str:
- return f""
-
- @overload
- def __getitem__(self, index: int) -> AbstractRouteDef:
- ...
-
- @overload
- def __getitem__(self, index: slice) -> List[AbstractRouteDef]:
- ...
-
- def __getitem__(self, index): # type: ignore[no-untyped-def]
- return self._items[index]
-
- def __iter__(self) -> Iterator[AbstractRouteDef]:
- return iter(self._items)
-
- def __len__(self) -> int:
- return len(self._items)
-
- def __contains__(self, item: object) -> bool:
- return item in self._items
-
- def route(self, method: str, path: str, **kwargs: Any) -> _Deco:
- def inner(handler: _HandlerType) -> _HandlerType:
- self._items.append(RouteDef(method, path, handler, kwargs))
- return handler
-
- return inner
-
- def head(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_HEAD, path, **kwargs)
-
- def get(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_GET, path, **kwargs)
-
- def post(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_POST, path, **kwargs)
-
- def put(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_PUT, path, **kwargs)
-
- def patch(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_PATCH, path, **kwargs)
-
- def delete(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_DELETE, path, **kwargs)
-
- def options(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_OPTIONS, path, **kwargs)
-
- def view(self, path: str, **kwargs: Any) -> _Deco:
- return self.route(hdrs.METH_ANY, path, **kwargs)
-
- def static(self, prefix: str, path: PathLike, **kwargs: Any) -> None:
- self._items.append(StaticDef(prefix, path, kwargs))
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/chromadb/server/__init__.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/chromadb/server/__init__.py
deleted file mode 100644
index eccd02cb0681d6e0031874754a1bbe110b6b12a2..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/chromadb/server/__init__.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from abc import ABC, abstractmethod
-
-from chromadb.config import Settings
-
-
-class Server(ABC):
- @abstractmethod
- def __init__(self, settings: Settings):
- pass
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dataclasses_json/api.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dataclasses_json/api.py
deleted file mode 100644
index ffb973578db72ed61595996c1d6e5f6fc54c92b1..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/dataclasses_json/api.py
+++ /dev/null
@@ -1,142 +0,0 @@
-import abc
-import json
-from typing import (Any, Callable, Dict, List, Optional, Tuple, Type, TypeVar,
- Union)
-
-from dataclasses_json.cfg import config, LetterCase # noqa: F401
-from dataclasses_json.core import (Json, _ExtendedEncoder, _asdict,
- _decode_dataclass)
-from dataclasses_json.mm import (JsonData, SchemaType, build_schema)
-from dataclasses_json.undefined import Undefined
-from dataclasses_json.utils import (_handle_undefined_parameters_safe,
- _undefined_parameter_action_safe)
-
-A = TypeVar('A', bound="DataClassJsonMixin")
-Fields = List[Tuple[str, Any]]
-
-
-class DataClassJsonMixin(abc.ABC):
- """
- DataClassJsonMixin is an ABC that functions as a Mixin.
-
- As with other ABCs, it should not be instantiated directly.
- """
- dataclass_json_config = None
-
- def to_json(self,
- *,
- skipkeys: bool = False,
- ensure_ascii: bool = True,
- check_circular: bool = True,
- allow_nan: bool = True,
- indent: Optional[Union[int, str]] = None,
- separators: Tuple[str, str] = None,
- default: Callable = None,
- sort_keys: bool = False,
- **kw) -> str:
- return json.dumps(self.to_dict(encode_json=False),
- cls=_ExtendedEncoder,
- skipkeys=skipkeys,
- ensure_ascii=ensure_ascii,
- check_circular=check_circular,
- allow_nan=allow_nan,
- indent=indent,
- separators=separators,
- default=default,
- sort_keys=sort_keys,
- **kw)
-
- @classmethod
- def from_json(cls: Type[A],
- s: JsonData,
- *,
- parse_float=None,
- parse_int=None,
- parse_constant=None,
- infer_missing=False,
- **kw) -> A:
- kvs = json.loads(s,
- parse_float=parse_float,
- parse_int=parse_int,
- parse_constant=parse_constant,
- **kw)
- return cls.from_dict(kvs, infer_missing=infer_missing)
-
- @classmethod
- def from_dict(cls: Type[A],
- kvs: Json,
- *,
- infer_missing=False) -> A:
- return _decode_dataclass(cls, kvs, infer_missing)
-
- def to_dict(self, encode_json=False) -> Dict[str, Json]:
- return _asdict(self, encode_json=encode_json)
-
- @classmethod
- def schema(cls: Type[A],
- *,
- infer_missing: bool = False,
- only=None,
- exclude=(),
- many: bool = False,
- context=None,
- load_only=(),
- dump_only=(),
- partial: bool = False,
- unknown=None) -> "SchemaType[A]":
- Schema = build_schema(cls, DataClassJsonMixin, infer_missing, partial)
-
- if unknown is None:
- undefined_parameter_action = _undefined_parameter_action_safe(cls)
- if undefined_parameter_action is not None:
- # We can just make use of the same-named mm keywords
- unknown = undefined_parameter_action.name.lower()
-
- return Schema(only=only,
- exclude=exclude,
- many=many,
- context=context,
- load_only=load_only,
- dump_only=dump_only,
- partial=partial,
- unknown=unknown)
-
-
-def dataclass_json(_cls=None, *, letter_case=None,
- undefined: Optional[Union[str, Undefined]] = None):
- """
- Based on the code in the `dataclasses` module to handle optional-parens
- decorators. See example below:
-
- @dataclass_json
- @dataclass_json(letter_case=LetterCase.CAMEL)
- class Example:
- ...
- """
-
- def wrap(cls):
- return _process_class(cls, letter_case, undefined)
-
- if _cls is None:
- return wrap
- return wrap(_cls)
-
-
-def _process_class(cls, letter_case, undefined) -> Type[DataClassJsonMixin]:
- if letter_case is not None or undefined is not None:
- cls.dataclass_json_config = config(letter_case=letter_case,
- undefined=undefined)[
- 'dataclasses_json']
-
- cls.to_json = DataClassJsonMixin.to_json
- # unwrap and rewrap classmethod to tag it to cls rather than the literal
- # DataClassJsonMixin ABC
- cls.from_json = classmethod(DataClassJsonMixin.from_json.__func__)
- cls.to_dict = DataClassJsonMixin.to_dict
- cls.from_dict = classmethod(DataClassJsonMixin.from_dict.__func__)
- cls.schema = classmethod(DataClassJsonMixin.schema.__func__)
-
- cls.__init__ = _handle_undefined_parameters_safe(cls, kvs=(), usage="init")
- # register cls as a virtual subclass of DataClassJsonMixin
- DataClassJsonMixin.register(cls)
- return cls
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/google/protobuf/internal/wire_format.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/google/protobuf/internal/wire_format.py
deleted file mode 100644
index 1f54414b1aa6fe6024abae883767d1a3ae6bb12f..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/google/protobuf/internal/wire_format.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# Protocol Buffers - Google's data interchange format
-# Copyright 2008 Google Inc. All rights reserved.
-# https://developers.google.com/protocol-buffers/
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-# * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-# * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-"""Constants and static functions to support protocol buffer wire format."""
-
-__author__ = 'robinson@google.com (Will Robinson)'
-
-import struct
-from google.protobuf import descriptor
-from google.protobuf import message
-
-
-TAG_TYPE_BITS = 3 # Number of bits used to hold type info in a proto tag.
-TAG_TYPE_MASK = (1 << TAG_TYPE_BITS) - 1 # 0x7
-
-# These numbers identify the wire type of a protocol buffer value.
-# We use the least-significant TAG_TYPE_BITS bits of the varint-encoded
-# tag-and-type to store one of these WIRETYPE_* constants.
-# These values must match WireType enum in //google/protobuf/wire_format.h.
-WIRETYPE_VARINT = 0
-WIRETYPE_FIXED64 = 1
-WIRETYPE_LENGTH_DELIMITED = 2
-WIRETYPE_START_GROUP = 3
-WIRETYPE_END_GROUP = 4
-WIRETYPE_FIXED32 = 5
-_WIRETYPE_MAX = 5
-
-
-# Bounds for various integer types.
-INT32_MAX = int((1 << 31) - 1)
-INT32_MIN = int(-(1 << 31))
-UINT32_MAX = (1 << 32) - 1
-
-INT64_MAX = (1 << 63) - 1
-INT64_MIN = -(1 << 63)
-UINT64_MAX = (1 << 64) - 1
-
-# "struct" format strings that will encode/decode the specified formats.
-FORMAT_UINT32_LITTLE_ENDIAN = '> TAG_TYPE_BITS), (tag & TAG_TYPE_MASK)
-
-
-def ZigZagEncode(value):
- """ZigZag Transform: Encodes signed integers so that they can be
- effectively used with varint encoding. See wire_format.h for
- more details.
- """
- if value >= 0:
- return value << 1
- return (value << 1) ^ (~0)
-
-
-def ZigZagDecode(value):
- """Inverse of ZigZagEncode()."""
- if not value & 0x1:
- return value >> 1
- return (value >> 1) ^ (~0)
-
-
-
-# The *ByteSize() functions below return the number of bytes required to
-# serialize "field number + type" information and then serialize the value.
-
-
-def Int32ByteSize(field_number, int32):
- return Int64ByteSize(field_number, int32)
-
-
-def Int32ByteSizeNoTag(int32):
- return _VarUInt64ByteSizeNoTag(0xffffffffffffffff & int32)
-
-
-def Int64ByteSize(field_number, int64):
- # Have to convert to uint before calling UInt64ByteSize().
- return UInt64ByteSize(field_number, 0xffffffffffffffff & int64)
-
-
-def UInt32ByteSize(field_number, uint32):
- return UInt64ByteSize(field_number, uint32)
-
-
-def UInt64ByteSize(field_number, uint64):
- return TagByteSize(field_number) + _VarUInt64ByteSizeNoTag(uint64)
-
-
-def SInt32ByteSize(field_number, int32):
- return UInt32ByteSize(field_number, ZigZagEncode(int32))
-
-
-def SInt64ByteSize(field_number, int64):
- return UInt64ByteSize(field_number, ZigZagEncode(int64))
-
-
-def Fixed32ByteSize(field_number, fixed32):
- return TagByteSize(field_number) + 4
-
-
-def Fixed64ByteSize(field_number, fixed64):
- return TagByteSize(field_number) + 8
-
-
-def SFixed32ByteSize(field_number, sfixed32):
- return TagByteSize(field_number) + 4
-
-
-def SFixed64ByteSize(field_number, sfixed64):
- return TagByteSize(field_number) + 8
-
-
-def FloatByteSize(field_number, flt):
- return TagByteSize(field_number) + 4
-
-
-def DoubleByteSize(field_number, double):
- return TagByteSize(field_number) + 8
-
-
-def BoolByteSize(field_number, b):
- return TagByteSize(field_number) + 1
-
-
-def EnumByteSize(field_number, enum):
- return UInt32ByteSize(field_number, enum)
-
-
-def StringByteSize(field_number, string):
- return BytesByteSize(field_number, string.encode('utf-8'))
-
-
-def BytesByteSize(field_number, b):
- return (TagByteSize(field_number)
- + _VarUInt64ByteSizeNoTag(len(b))
- + len(b))
-
-
-def GroupByteSize(field_number, message):
- return (2 * TagByteSize(field_number) # START and END group.
- + message.ByteSize())
-
-
-def MessageByteSize(field_number, message):
- return (TagByteSize(field_number)
- + _VarUInt64ByteSizeNoTag(message.ByteSize())
- + message.ByteSize())
-
-
-def MessageSetItemByteSize(field_number, msg):
- # First compute the sizes of the tags.
- # There are 2 tags for the beginning and ending of the repeated group, that
- # is field number 1, one with field number 2 (type_id) and one with field
- # number 3 (message).
- total_size = (2 * TagByteSize(1) + TagByteSize(2) + TagByteSize(3))
-
- # Add the number of bytes for type_id.
- total_size += _VarUInt64ByteSizeNoTag(field_number)
-
- message_size = msg.ByteSize()
-
- # The number of bytes for encoding the length of the message.
- total_size += _VarUInt64ByteSizeNoTag(message_size)
-
- # The size of the message.
- total_size += message_size
- return total_size
-
-
-def TagByteSize(field_number):
- """Returns the bytes required to serialize a tag with this field number."""
- # Just pass in type 0, since the type won't affect the tag+type size.
- return _VarUInt64ByteSizeNoTag(PackTag(field_number, 0))
-
-
-# Private helper function for the *ByteSize() functions above.
-
-def _VarUInt64ByteSizeNoTag(uint64):
- """Returns the number of bytes required to serialize a single varint
- using boundary value comparisons. (unrolled loop optimization -WPierce)
- uint64 must be unsigned.
- """
- if uint64 <= 0x7f: return 1
- if uint64 <= 0x3fff: return 2
- if uint64 <= 0x1fffff: return 3
- if uint64 <= 0xfffffff: return 4
- if uint64 <= 0x7ffffffff: return 5
- if uint64 <= 0x3ffffffffff: return 6
- if uint64 <= 0x1ffffffffffff: return 7
- if uint64 <= 0xffffffffffffff: return 8
- if uint64 <= 0x7fffffffffffffff: return 9
- if uint64 > UINT64_MAX:
- raise message.EncodeError('Value out of range: %d' % uint64)
- return 10
-
-
-NON_PACKABLE_TYPES = (
- descriptor.FieldDescriptor.TYPE_STRING,
- descriptor.FieldDescriptor.TYPE_GROUP,
- descriptor.FieldDescriptor.TYPE_MESSAGE,
- descriptor.FieldDescriptor.TYPE_BYTES
-)
-
-
-def IsTypePackable(field_type):
- """Return true iff packable = true is valid for fields of this type.
-
- Args:
- field_type: a FieldDescriptor::Type value.
-
- Returns:
- True iff fields of this type are packable.
- """
- return field_type not in NON_PACKABLE_TYPES
diff --git a/spaces/cihyFjudo/fairness-paper-search/Sony All Products Incl Multi Keygen And Patch v2.6 Update 24 11 2014 Download Now.md b/spaces/cihyFjudo/fairness-paper-search/Sony All Products Incl Multi Keygen And Patch v2.6 Update 24 11 2014 Download Now.md
deleted file mode 100644
index 2cc5741a3a9e7e4f7789561f89f1f2f11e7f761c..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Sony All Products Incl Multi Keygen And Patch v2.6 Update 24 11 2014 Download Now.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Sony All Products Incl Multi Keygen And Patch v2.6 Update 24 11 2014
Download File » https://tinurli.com/2uwiQO
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/charset_normalizer/utils.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/charset_normalizer/utils.py
deleted file mode 100644
index bf2767a0e6022c52690cdabf684b0b676ed0eadc..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/charset_normalizer/utils.py
+++ /dev/null
@@ -1,414 +0,0 @@
-import importlib
-import logging
-import unicodedata
-from codecs import IncrementalDecoder
-from encodings.aliases import aliases
-from functools import lru_cache
-from re import findall
-from typing import Generator, List, Optional, Set, Tuple, Union
-
-from _multibytecodec import MultibyteIncrementalDecoder
-
-from .constant import (
- ENCODING_MARKS,
- IANA_SUPPORTED_SIMILAR,
- RE_POSSIBLE_ENCODING_INDICATION,
- UNICODE_RANGES_COMBINED,
- UNICODE_SECONDARY_RANGE_KEYWORD,
- UTF8_MAXIMAL_ALLOCATION,
-)
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_accentuated(character: str) -> bool:
- try:
- description: str = unicodedata.name(character)
- except ValueError:
- return False
- return (
- "WITH GRAVE" in description
- or "WITH ACUTE" in description
- or "WITH CEDILLA" in description
- or "WITH DIAERESIS" in description
- or "WITH CIRCUMFLEX" in description
- or "WITH TILDE" in description
- )
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def remove_accent(character: str) -> str:
- decomposed: str = unicodedata.decomposition(character)
- if not decomposed:
- return character
-
- codes: List[str] = decomposed.split(" ")
-
- return chr(int(codes[0], 16))
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def unicode_range(character: str) -> Optional[str]:
- """
- Retrieve the Unicode range official name from a single character.
- """
- character_ord: int = ord(character)
-
- for range_name, ord_range in UNICODE_RANGES_COMBINED.items():
- if character_ord in ord_range:
- return range_name
-
- return None
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_latin(character: str) -> bool:
- try:
- description: str = unicodedata.name(character)
- except ValueError:
- return False
- return "LATIN" in description
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_ascii(character: str) -> bool:
- try:
- character.encode("ascii")
- except UnicodeEncodeError:
- return False
- return True
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_punctuation(character: str) -> bool:
- character_category: str = unicodedata.category(character)
-
- if "P" in character_category:
- return True
-
- character_range: Optional[str] = unicode_range(character)
-
- if character_range is None:
- return False
-
- return "Punctuation" in character_range
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_symbol(character: str) -> bool:
- character_category: str = unicodedata.category(character)
-
- if "S" in character_category or "N" in character_category:
- return True
-
- character_range: Optional[str] = unicode_range(character)
-
- if character_range is None:
- return False
-
- return "Forms" in character_range
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_emoticon(character: str) -> bool:
- character_range: Optional[str] = unicode_range(character)
-
- if character_range is None:
- return False
-
- return "Emoticons" in character_range
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_separator(character: str) -> bool:
- if character.isspace() or character in {"｜", "+", "<", ">"}:
- return True
-
- character_category: str = unicodedata.category(character)
-
- return "Z" in character_category or character_category in {"Po", "Pd", "Pc"}
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_case_variable(character: str) -> bool:
- return character.islower() != character.isupper()
-
-
-def is_private_use_only(character: str) -> bool:
- character_category: str = unicodedata.category(character)
-
- return character_category == "Co"
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_cjk(character: str) -> bool:
- try:
- character_name = unicodedata.name(character)
- except ValueError:
- return False
-
- return "CJK" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_hiragana(character: str) -> bool:
- try:
- character_name = unicodedata.name(character)
- except ValueError:
- return False
-
- return "HIRAGANA" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_katakana(character: str) -> bool:
- try:
- character_name = unicodedata.name(character)
- except ValueError:
- return False
-
- return "KATAKANA" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_hangul(character: str) -> bool:
- try:
- character_name = unicodedata.name(character)
- except ValueError:
- return False
-
- return "HANGUL" in character_name
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_thai(character: str) -> bool:
- try:
- character_name = unicodedata.name(character)
- except ValueError:
- return False
-
- return "THAI" in character_name
-
-
-@lru_cache(maxsize=len(UNICODE_RANGES_COMBINED))
-def is_unicode_range_secondary(range_name: str) -> bool:
- return any(keyword in range_name for keyword in UNICODE_SECONDARY_RANGE_KEYWORD)
-
-
-@lru_cache(maxsize=UTF8_MAXIMAL_ALLOCATION)
-def is_unprintable(character: str) -> bool:
- return (
- character.isspace() is False # includes \n \t \r \v
- and character.isprintable() is False
- and character != "\x1A" # Why? Its the ASCII substitute character.
- and character != "\ufeff" # bug discovered in Python,
- # Zero Width No-Break Space located in Arabic Presentation Forms-B, Unicode 1.1 not acknowledged as space.
- )
-
-
-def any_specified_encoding(sequence: bytes, search_zone: int = 4096) -> Optional[str]:
- """
- Extract using ASCII-only decoder any specified encoding in the first n-bytes.
- """
- if not isinstance(sequence, bytes):
- raise TypeError
-
- seq_len: int = len(sequence)
-
- results: List[str] = findall(
- RE_POSSIBLE_ENCODING_INDICATION,
- sequence[: min(seq_len, search_zone)].decode("ascii", errors="ignore"),
- )
-
- if len(results) == 0:
- return None
-
- for specified_encoding in results:
- specified_encoding = specified_encoding.lower().replace("-", "_")
-
- encoding_alias: str
- encoding_iana: str
-
- for encoding_alias, encoding_iana in aliases.items():
- if encoding_alias == specified_encoding:
- return encoding_iana
- if encoding_iana == specified_encoding:
- return encoding_iana
-
- return None
-
-
-@lru_cache(maxsize=128)
-def is_multi_byte_encoding(name: str) -> bool:
- """
- Verify is a specific encoding is a multi byte one based on it IANA name
- """
- return name in {
- "utf_8",
- "utf_8_sig",
- "utf_16",
- "utf_16_be",
- "utf_16_le",
- "utf_32",
- "utf_32_le",
- "utf_32_be",
- "utf_7",
- } or issubclass(
- importlib.import_module("encodings.{}".format(name)).IncrementalDecoder,
- MultibyteIncrementalDecoder,
- )
-
-
-def identify_sig_or_bom(sequence: bytes) -> Tuple[Optional[str], bytes]:
- """
- Identify and extract SIG/BOM in given sequence.
- """
-
- for iana_encoding in ENCODING_MARKS:
- marks: Union[bytes, List[bytes]] = ENCODING_MARKS[iana_encoding]
-
- if isinstance(marks, bytes):
- marks = [marks]
-
- for mark in marks:
- if sequence.startswith(mark):
- return iana_encoding, mark
-
- return None, b""
-
-
-def should_strip_sig_or_bom(iana_encoding: str) -> bool:
- return iana_encoding not in {"utf_16", "utf_32"}
-
-
-def iana_name(cp_name: str, strict: bool = True) -> str:
- cp_name = cp_name.lower().replace("-", "_")
-
- encoding_alias: str
- encoding_iana: str
-
- for encoding_alias, encoding_iana in aliases.items():
- if cp_name in [encoding_alias, encoding_iana]:
- return encoding_iana
-
- if strict:
- raise ValueError("Unable to retrieve IANA for '{}'".format(cp_name))
-
- return cp_name
-
-
-def range_scan(decoded_sequence: str) -> List[str]:
- ranges: Set[str] = set()
-
- for character in decoded_sequence:
- character_range: Optional[str] = unicode_range(character)
-
- if character_range is None:
- continue
-
- ranges.add(character_range)
-
- return list(ranges)
-
-
-def cp_similarity(iana_name_a: str, iana_name_b: str) -> float:
- if is_multi_byte_encoding(iana_name_a) or is_multi_byte_encoding(iana_name_b):
- return 0.0
-
- decoder_a = importlib.import_module(
- "encodings.{}".format(iana_name_a)
- ).IncrementalDecoder
- decoder_b = importlib.import_module(
- "encodings.{}".format(iana_name_b)
- ).IncrementalDecoder
-
- id_a: IncrementalDecoder = decoder_a(errors="ignore")
- id_b: IncrementalDecoder = decoder_b(errors="ignore")
-
- character_match_count: int = 0
-
- for i in range(255):
- to_be_decoded: bytes = bytes([i])
- if id_a.decode(to_be_decoded) == id_b.decode(to_be_decoded):
- character_match_count += 1
-
- return character_match_count / 254
-
-
-def is_cp_similar(iana_name_a: str, iana_name_b: str) -> bool:
- """
- Determine if two code page are at least 80% similar. IANA_SUPPORTED_SIMILAR dict was generated using
- the function cp_similarity.
- """
- return (
- iana_name_a in IANA_SUPPORTED_SIMILAR
- and iana_name_b in IANA_SUPPORTED_SIMILAR[iana_name_a]
- )
-
-
-def set_logging_handler(
- name: str = "charset_normalizer",
- level: int = logging.INFO,
- format_string: str = "%(asctime)s | %(levelname)s | %(message)s",
-) -> None:
- logger = logging.getLogger(name)
- logger.setLevel(level)
-
- handler = logging.StreamHandler()
- handler.setFormatter(logging.Formatter(format_string))
- logger.addHandler(handler)
-
-
-def cut_sequence_chunks(
- sequences: bytes,
- encoding_iana: str,
- offsets: range,
- chunk_size: int,
- bom_or_sig_available: bool,
- strip_sig_or_bom: bool,
- sig_payload: bytes,
- is_multi_byte_decoder: bool,
- decoded_payload: Optional[str] = None,
-) -> Generator[str, None, None]:
- if decoded_payload and is_multi_byte_decoder is False:
- for i in offsets:
- chunk = decoded_payload[i : i + chunk_size]
- if not chunk:
- break
- yield chunk
- else:
- for i in offsets:
- chunk_end = i + chunk_size
- if chunk_end > len(sequences) + 8:
- continue
-
- cut_sequence = sequences[i : i + chunk_size]
-
- if bom_or_sig_available and strip_sig_or_bom is False:
- cut_sequence = sig_payload + cut_sequence
-
- chunk = cut_sequence.decode(
- encoding_iana,
- errors="ignore" if is_multi_byte_decoder else "strict",
- )
-
- # multi-byte bad cutting detector and adjustment
- # not the cleanest way to perform that fix but clever enough for now.
- if is_multi_byte_decoder and i > 0:
- chunk_partial_size_chk: int = min(chunk_size, 16)
-
- if (
- decoded_payload
- and chunk[:chunk_partial_size_chk] not in decoded_payload
- ):
- for j in range(i, i - 4, -1):
- cut_sequence = sequences[j:chunk_end]
-
- if bom_or_sig_available and strip_sig_or_bom is False:
- cut_sequence = sig_payload + cut_sequence
-
- chunk = cut_sequence.decode(encoding_iana, errors="ignore")
-
- if chunk[:chunk_partial_size_chk] in decoded_payload:
- break
-
- yield chunk
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/otlLib/__init__.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/otlLib/__init__.py
deleted file mode 100644
index 12e414fc3bf00e6152f953b989914f034edfe9e1..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/otlLib/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""OpenType Layout-related functionality."""
diff --git a/spaces/codejin/diffsingerkr/Arg_Parser.py b/spaces/codejin/diffsingerkr/Arg_Parser.py
deleted file mode 100644
index 2ac9bd2133a61a6299b16e20fe94655da7bbcb01..0000000000000000000000000000000000000000
--- a/spaces/codejin/diffsingerkr/Arg_Parser.py
+++ /dev/null
@@ -1,30 +0,0 @@
-from argparse import Namespace
-
-def Recursive_Parse(args_dict):
- parsed_dict = {}
- for key, value in args_dict.items():
- if isinstance(value, dict):
- value = Recursive_Parse(value)
- parsed_dict[key]= value
-
- args = Namespace()
- args.__dict__ = parsed_dict
- return args
-
-def To_Non_Recursive_Dict(
- args: Namespace
- ):
- parsed_dict = {}
- for key, value in args.__dict__.items():
- if isinstance(value, Namespace):
- value_dict = To_Non_Recursive_Dict(value)
- for sub_key, sub_value in value_dict.items():
- parsed_dict[f'{key}.{sub_key}'] = sub_value
- else:
- parsed_dict[key] = value
-
- return parsed_dict
-
-
-
-
\ No newline at end of file
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c
deleted file mode 100644
index 00fc7b20f17d3d40dbe83b41dbc6699afabf298b..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aarch64/h264chroma_init_aarch64.c
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * ARM NEON optimised H.264 chroma functions
- * Copyright (c) 2008 Mans Rullgard
- *
- * 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/attributes.h"
-#include "libavutil/cpu.h"
-#include "libavutil/aarch64/cpu.h"
-#include "libavcodec/h264chroma.h"
-
-#include "config.h"
-
-void ff_put_h264_chroma_mc8_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-void ff_put_h264_chroma_mc4_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-void ff_put_h264_chroma_mc2_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-
-void ff_avg_h264_chroma_mc8_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-void ff_avg_h264_chroma_mc4_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-void ff_avg_h264_chroma_mc2_neon(uint8_t *dst, const uint8_t *src, ptrdiff_t stride,
- int h, int x, int y);
-
-av_cold void ff_h264chroma_init_aarch64(H264ChromaContext *c, int bit_depth)
-{
- const int high_bit_depth = bit_depth > 8;
- int cpu_flags = av_get_cpu_flags();
-
- if (have_neon(cpu_flags) && !high_bit_depth) {
- c->put_h264_chroma_pixels_tab[0] = ff_put_h264_chroma_mc8_neon;
- c->put_h264_chroma_pixels_tab[1] = ff_put_h264_chroma_mc4_neon;
- c->put_h264_chroma_pixels_tab[2] = ff_put_h264_chroma_mc2_neon;
-
- c->avg_h264_chroma_pixels_tab[0] = ff_avg_h264_chroma_mc8_neon;
- c->avg_h264_chroma_pixels_tab[1] = ff_avg_h264_chroma_mc4_neon;
- c->avg_h264_chroma_pixels_tab[2] = ff_avg_h264_chroma_mc2_neon;
- }
-}
diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3defs.h b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3defs.h
deleted file mode 100644
index ff92f0ac4ab9970748239d9a908c1843ca0d4661..0000000000000000000000000000000000000000
--- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/ac3defs.h
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- * Common AC-3 definitions
- * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
- *
- * 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
- */
-
-#ifndef AVCODEC_AC3DEFS_H
-#define AVCODEC_AC3DEFS_H
-
-#define EAC3_MAX_CHANNELS 16 /**< maximum number of channels in EAC3 */
-#define AC3_MAX_CHANNELS 7 /**< maximum number of channels, including coupling channel */
-#define CPL_CH 0 /**< coupling channel index */
-
-#define AC3_MAX_COEFS 256
-#define AC3_BLOCK_SIZE 256
-#define AC3_MAX_BLOCKS 6
-#define AC3_FRAME_SIZE (AC3_MAX_BLOCKS * 256)
-#define AC3_WINDOW_SIZE (AC3_BLOCK_SIZE * 2)
-#define AC3_CRITICAL_BANDS 50
-#define AC3_MAX_CPL_BANDS 18
-
-/* exponent encoding strategy */
-#define EXP_REUSE 0
-#define EXP_NEW 1
-
-#define EXP_D15 1
-#define EXP_D25 2
-#define EXP_D45 3
-
-/** Delta bit allocation strategy */
-typedef enum {
- DBA_REUSE = 0,
- DBA_NEW,
- DBA_NONE,
- DBA_RESERVED
-} AC3DeltaStrategy;
-
-/** Channel mode (audio coding mode) */
-typedef enum {
- AC3_CHMODE_DUALMONO = 0,
- AC3_CHMODE_MONO,
- AC3_CHMODE_STEREO,
- AC3_CHMODE_3F,
- AC3_CHMODE_2F1R,
- AC3_CHMODE_3F1R,
- AC3_CHMODE_2F2R,
- AC3_CHMODE_3F2R
-} AC3ChannelMode;
-
-/** Dolby Surround mode */
-typedef enum AC3DolbySurroundMode {
- AC3_DSURMOD_NOTINDICATED = 0,
- AC3_DSURMOD_OFF,
- AC3_DSURMOD_ON,
- AC3_DSURMOD_RESERVED
-} AC3DolbySurroundMode;
-
-/** Dolby Surround EX mode */
-typedef enum AC3DolbySurroundEXMode {
- AC3_DSUREXMOD_NOTINDICATED = 0,
- AC3_DSUREXMOD_OFF,
- AC3_DSUREXMOD_ON,
- AC3_DSUREXMOD_PLIIZ
-} AC3DolbySurroundEXMode;
-
-/** Dolby Headphone mode */
-typedef enum AC3DolbyHeadphoneMode {
- AC3_DHEADPHONMOD_NOTINDICATED = 0,
- AC3_DHEADPHONMOD_OFF,
- AC3_DHEADPHONMOD_ON,
- AC3_DHEADPHONMOD_RESERVED
-} AC3DolbyHeadphoneMode;
-
-/** Preferred Stereo Downmix mode */
-typedef enum AC3PreferredStereoDownmixMode {
- AC3_DMIXMOD_NOTINDICATED = 0,
- AC3_DMIXMOD_LTRT,
- AC3_DMIXMOD_LORO,
- AC3_DMIXMOD_DPLII // reserved value in A/52, but used by encoders to indicate DPL2
-} AC3PreferredStereoDownmixMode;
-
-typedef enum {
- EAC3_FRAME_TYPE_INDEPENDENT = 0,
- EAC3_FRAME_TYPE_DEPENDENT,
- EAC3_FRAME_TYPE_AC3_CONVERT,
- EAC3_FRAME_TYPE_RESERVED
-} EAC3FrameType;
-
-#endif /* AVCODEC_AC3DEFS_H */
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Cmo descargar e instalar Getting Over It APK en tu dispositivo Android.md b/spaces/congsaPfin/Manga-OCR/logs/Cmo descargar e instalar Getting Over It APK en tu dispositivo Android.md
deleted file mode 100644
index 741e1a0ea6b931fde5ac3c478c72e4dde8e79f4f..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Cmo descargar e instalar Getting Over It APK en tu dispositivo Android.md
+++ /dev/null
@@ -1,104 +0,0 @@
-
-Getting Over It APK: A Challenging and Rewarding Climbing Game
-If you are looking for a game that will test your skills, patience, and perseverance, you might want to try Getting Over It APK. This is a climbing game that will make you feel a range of emotions, from frustration to satisfaction, from anger to laughter. In this article, we will tell you everything you need to know about this game, including what it is, why you should play it, and how to download and install it on your Android device.
-getting over it apk para android
DOWNLOAD ››› https://urlca.com/2uO83F
- What is Getting Over It APK?
-Getting Over It APK is a climbing game that was created by Bennett Foddy as a homage to Jazzuo's 2002 B-Game classic 'Sexy Hiking'. The game was released in 2017 for Windows and iOS, and later ported to Android by Noodlecake Studios. The game has received critical acclaim and popularity for its unique gameplay, difficulty, and commentary.
- The origin and inspiration of the game
-The game was inspired by Jazzuo's 'Sexy Hiking', which was a B-Game that featured a man with a hammer trying to climb a mountain made of random objects. B-Games are games that are intentionally bad or weird, often made as jokes or experiments. Bennett Foddy, who is a game designer and a professor of philosophy, decided to make his own version of 'Sexy Hiking' as a tribute to Jazzuo and the B-Game genre. He also wanted to explore the themes of frustration, failure, and perseverance in games.
- The gameplay and mechanics of the game
-The game is very simple in terms of gameplay and mechanics. You control a man who is stuck in a pot with only a hammer. You use the mouse or touch screen to move the hammer around, which allows you to push, pull, swing, or hook yourself onto various objects on the mountain. Your goal is to reach the top of the mountain without falling down. However, this is easier said than done, as the game has no checkpoints, save points, or undo buttons. If you make a mistake or lose your grip, you can fall all the way back to the bottom or even further. The game also has no end or reward, except for a secret ending that only a few players have seen.
- The difficulty and frustration of the game
-The game is notoriously difficult and frustrating, as it requires precise timing, coordination, and patience to master. The game also has a steep learning curve, as it takes time to get used to the physics and controls of the hammer. The game is designed to make you feel angry, annoyed, or hopeless at times, as you can lose hours of progress in seconds. The game also has random elements that can affect your performance, such as wind, gravity, or glitches. The game is not for everyone, as some people might find it too hard or unfair.
- Why should you play Getting Over It APK?
-Despite its difficulty and frustration, Getting Over It APK is also a very rewarding and enjoyable game for many reasons. Here are some of them:
- The satisfaction and achievement of the game
-The game is not impossible to beat, as many players have proven by reaching the top of the mountain or even speedrunning it in minutes. The game gives you a sense of satisfaction and achievement when you overcome a difficult obstacle or make progress on your climb. The game also challenges you to improve your skills and learn from your mistakes. The game can be very addictive and fun
The philosophy and humor of the game
-The game is not just a game, but also a philosophical and humorous commentary on life, games, and art. The game features a voice-over narration by Bennett Foddy himself, who talks to you throughout your climb. He gives you insights, anecdotes, quotes, jokes, and references to various topics, such as history, literature, music, movies, or other games. He also reacts to your actions, whether you succeed or fail, and sometimes breaks the fourth wall. The narration is witty, sarcastic, and sometimes motivational, depending on your perspective. The game also has many Easter eggs and secrets that add to the humor and mystery of the game.
- The graphics and sound of the game
-The game has a minimalist and retro style of graphics, which contrast with the realistic physics and sounds of the game. The game uses hand-drawn 2D graphics that resemble old-school games or cartoons. The game also has a simple but effective color scheme that changes according to the time of day or the location on the mountain. The game has a soothing and atmospheric soundtrack that consists of classical music and ambient sounds. The game also has realistic sound effects that match the movements and impacts of the hammer and the pot. The game creates a unique and immersive experience that appeals to both the eyes and the ears.
- How to download and install Getting Over It APK?
-If you want to play Getting Over It APK on your Android device, you will need to download and install it from a reliable source. Here are some things you need to know before you do that:
-getting over it with bennett foddy apk android
-descargar getting over it gratis para android
-getting over it apk download for android
-getting over it apk mod android
-getting over it apk full android
-getting over it apk obb android
-getting over it android apk free
-getting over it apk no verification android
-getting over it apk latest version android
-getting over it apk offline android
-getting over it apk hack android
-getting over it apk cracked android
-getting over it apk mega android
-getting over it apk mediafıre android
-getting over it apk sin verificacion android
-getting over it apk uptodown android
-getting over it apk revdl android
-getting over it apk rexdl android
-getting over it apk highly compressed android
-getting over it apk unlimited money android
-getting over it apk data android
-getting over it apk google play android
-getting over it apk original android
-getting over it apk premium android
-getting over it apk pro android
-getting over it apk paid android
-getting over it apk unlocked android
-getting over it apk unlimited coins android
-getting over it apk no root android
-getting over it apk no ads android
-getting over it apk gameplay android
-getting over it apk review android
-getting over it apk tips and tricks android
-getting over it apk cheats and hacks android
-getting over it apk walkthrough and guide android
-getting over it apk best settings android
-getting over it apk requirements and compatibility android
-getting over it apk features and benefits android
-getting over it apk size and performance android
-getting over it apk graphics and sound quality android
-getting over it apk update and patch notes android
-getting over it apk bugs and issues android
-getting over it apk support and feedback android
-getting over it apk alternatives and similar apps android
-getting over it apk ranking and rating android
-getting over it apk awards and achievements android
-getting over it apk news and events android
-getting over it apk community and forums android
- The requirements and compatibility of the game
-The game requires Android 5.0 or higher to run smoothly. The game also requires at least 100 MB of free storage space on your device. The game is compatible with most Android devices, but some older or low-end devices might experience lag or crashes. The game also supports external controllers for better control.
- The steps and precautions of the installation process
-The game is not available on the Google Play Store, so you will need to download it from a third-party website or app store. However, you should be careful when doing so, as some sources might contain malware or viruses that can harm your device or steal your data. You should only download the game from trusted and verified sources that have positive reviews and ratings from other users. You should also scan the APK file with an antivirus app before installing it.
-Once you have downloaded the APK file, you will need to enable the installation of apps from unknown sources on your device settings. This will allow you to install apps that are not from the Google Play Store. To do this, go to Settings > Security > Unknown Sources and toggle it on. You might see a warning message that tells you about the risks of installing apps from unknown sources, but you can ignore it if you trust the source of the APK file.
-After enabling unknown sources, you can locate the APK file on your device using a file manager app or your browser's downloads folder. Tap on the APK file and follow the instructions on the screen to install it. You might see another warning message that tells you about the permissions that the app requires, but you can accept them if you trust the app.
-Once the installation is complete, you can launch the game from your app drawer or home screen and enjoy it.
- The alternatives and sources of the game
-If you are unable to download or install Getting Over It APK on your device for some reason, or if you want to try other similar games, you have some alternatives and sources to choose from. Here are some of them:
-
-Alternative Description Source Pogostuck: Rage With Your Friends A multiplayer climbing game that features different characters, maps, modes, and customization options. Google Play Store Just Getting Over It with Bennett Foddy A parody of Getting Over It that features Bennett Foddy himself as the character in the pot. Google Play Store Climb With Wheelbarrow A climbing game that features a man in a wheelbarrow instead of a pot. Google Play Store Getting Over It with Bennett Foddy Mod APK A modified version of Getting Over It that offers unlimited money, unlocked items, no ads, and more. APKPure.com Getting Over It with Bennett Foddy PC Version The original version of Getting Over It that runs on Windows and Mac computers. Steam or Humble Bundle
- Conclusion
-Getting Over It APK is a climbing game that will challenge you, frustrate you, and reward you. It is a game that is inspired by a B-Game classic, and features a unique gameplay, difficulty, and commentary. It is a game that will make you feel a range of emotions, from anger to laughter, from despair to satisfaction. It is a game that you can download and install on your Android device, or try other alternatives and sources. It is a game that you should play if you are looking for a different and memorable gaming experience.
- FAQs
-Here are some frequently asked questions about Getting Over It APK:
-
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Craftsman 6 APK Create Explore and Survive in a Sandbox World.md b/spaces/congsaPfin/Manga-OCR/logs/Craftsman 6 APK Create Explore and Survive in a Sandbox World.md
deleted file mode 100644
index 37eed93c351085837db7da0159ca81d8ee29b2a5..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Craftsman 6 APK Create Explore and Survive in a Sandbox World.md
+++ /dev/null
@@ -1,110 +0,0 @@
-
-Download Craftsman 6 APK: A Free and Fun Sandbox Game for Android
-If you are looking for a game that lets you unleash your creativity and imagination, then you might want to try Craftsman 6 APK. This is a free sandbox game that allows you to design and build your own world with blocks. You can explore, craft, and survive in this pixelated adventure. In this article, we will tell you everything you need to know about Craftsman 6 APK, including its features, how to download and install it, why you should play it, and some tips and tricks to help you enjoy it more. We will also give you some alternatives to Craftsman 6 APK in case you want to try something different.
-download craftsman 6 apk
DOWNLOAD » https://urlca.com/2uObbA
- What is Craftsman 6 APK?
-Craftsman 6 APK is a game that is inspired by Minecraft, a popular sandbox game that has millions of fans around the world. However, unlike Minecraft, which is a paid game, Craftsman 6 APK is completely free to play. You can download it from various websites or app stores without spending any money.
-Craftsman 6 APK is similar to Minecraft in many ways. You can create your own world with blocks of different materials, such as dirt, stone, wood, and more. You can also explore the infinite map and discover different biomes, such as forests, deserts, mountains, and oceans. You can also craft tools, weapons, armor, and other items to help you survive and fight against enemies. You can also play with your friends online or offline in multiplayer mode.
- Features of Craftsman 6 APK
-Some of the features that make Craftsman 6 APK a fun and enjoyable game are:
-
-
- How to download and install Craftsman 6 APK
-If you want to download and install Craftsman 6 APK on your Android device, here are the steps you need to follow:
-How to download craftsman 6 apk for free
-Download craftsman 6 apk latest version
-Craftsman 6 apk mod unlimited money
-Craftsman 6 apk online multiplayer
-Craftsman 6 apk gameplay and features
-Download craftsman 6 apk for android devices
-Craftsman 6 apk review and rating
-Craftsman 6 apk download link and installation guide
-Craftsman 6 apk tips and tricks
-Craftsman 6 apk best builds and designs
-Download craftsman 6 apk for PC windows
-Craftsman 6 apk offline mode and cheats
-Craftsman 6 apk vs minecraft comparison
-Craftsman 6 apk update and patch notes
-Craftsman 6 apk alternatives and similar games
-Download craftsman 6 apk for iOS devices
-Craftsman 6 apk custom skins and textures
-Craftsman 6 apk servers and communities
-Craftsman 6 apk challenges and achievements
-Craftsman 6 apk bugs and fixes
-Download craftsman 6 apk for mac os
-Craftsman 6 apk creative mode and sandbox
-Craftsman 6 apk maps and worlds
-Craftsman 6 apk videos and screenshots
-Craftsman 6 apk system requirements and compatibility
-Download craftsman 6 apk for linux os
-Craftsman 6 apk survival mode and adventure
-Craftsman 6 apk weapons and tools
-Craftsman 6 apk animals and mobs
-Craftsman 6 apk secrets and easter eggs
-Download craftsman 6 apk for chrome os
-Craftsman 6 apk blocks and materials
-Craftsman 6 apk vehicles and machines
-Craftsman 6 apk plants and biomes
-Craftsman 6 apk weather and time
-Download craftsman 6 apk for fire os
-Craftsman 6 apk furniture and decorations
-Craftsman 6 apk redstone and circuits
-Craftsman 6 apk commands and codes
-Craftsman 6 apk skins and mods
-
-
- Why play Craftsman 6 APK?
-Craftsman 6 APK is a game that has many benefits and advantages for its players. Here are some of the reasons why you should play Craftsman 6 APK:
- Pros and cons of Craftsman 6 APK
-Like any other game, Craftsman 6 APK has its pros and cons. Here are some of them:
-
-
-Pros
-Cons
-
-
-
-
- Tips and tricks for Craftsman 6 APK
-If you want to improve your skills and experience in Craftsman 6 APK, here are some tips and tricks that you can use:
-
-
- Alternatives to Craftsman 6 APK
-If you want to try something different from Craftsman 6 APK, here are some alternatives that you can play:
-
-
- Conclusion
-Craftsman 6 APK is a free and fun sandbox game that lets you create your own world with blocks. You can explore, craft, survive, and play with your friends in this pixelated adventure. You can download it from various websites or app stores without any hassle. However, you should also be aware of its pros and cons, and some tips and tricks to help you enjoy it more. You can also try some alternatives to Craftsman 6 APK if you want to experience something different.
- FAQs
-Here are some frequently asked questions about Craftsman 6 APK:
-
-
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Download and Play GT Club Drag Racing Car Game MOD APK - The Free Racing Game with Drag Style and No Brakes.md b/spaces/congsaPfin/Manga-OCR/logs/Download and Play GT Club Drag Racing Car Game MOD APK - The Free Racing Game with Drag Style and No Brakes.md
deleted file mode 100644
index aec9a47c1988180d088d0727aa047f44725b23e5..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Download and Play GT Club Drag Racing Car Game MOD APK - The Free Racing Game with Drag Style and No Brakes.md
+++ /dev/null
@@ -1,73 +0,0 @@
-
-Download GT Club Drag Racing Car Game Mod APK
-If you are a fan of drag racing games, you might want to check out GT Club Drag Racing Car Game. This is a thrilling and realistic racing game that lets you compete with other players online and offline. You can choose from a variety of supercars, customize them, and upgrade them to suit your preferences. You can also join clubs, participate in tournaments, and win rewards.
-However, if you want to enjoy the game to the fullest, you might need to spend some real money to unlock all the cars and features. That's why we recommend you to download the mod APK version of GT Club Drag Racing Car Game. This is a modified version that gives you unlimited money, gold, and other benefits for free. In this article, we will tell you more about this mod APK and how to download and install it on your device.
-download gt club drag racing car game mod apk
Download File → https://urlca.com/2uO7i1
-Introduction
-What is GT Club Drag Racing Car Game?
-GT Club Drag Racing Car Game is a racing game developed by TSQ Publishing Corp. The game has tens of millions of official installs from Google Play. The game features realistic physics, stunning graphics, and immersive sound effects. You can race against other players in real-time or offline mode. You can also join clubs, chat with other racers, and challenge them to duels.
-Why download the mod APK version?
-The mod APK version of GT Club Drag Racing Car Game is a hacked version that gives you unlimited money, gold, and other benefits for free. You can use these resources to unlock all the cars, customize them, and upgrade them to the max level. You can also enjoy the game without any ads or root requirement. The mod APK version is safe and easy to install on your device.
-Features of GT Club Drag Racing Car Game Mod APK
-Unlimited money and gold
-Money and gold are the main currencies in GT Club Drag Racing Car Game. You need them to buy new cars, upgrade them, and access premium features. However, earning money and gold in the game can be time-consuming and tedious. That's why the mod APK version gives you unlimited money and gold for free. You can spend them as much as you want without worrying about running out.
-All cars unlocked and upgraded
-The game offers a wide range of supercars from famous brands like Ferrari, Lamborghini, Bugatti, Porsche, and more. However, not all of them are available at the beginning. You need to unlock them by completing missions, winning races, or spending money and gold. With the mod APK version, you can unlock all the cars for free. You can also upgrade them to the max level without any cost.
-No ads and no root required
-Another benefit of downloading the mod APK version of GT Club Drag Racing Car Game is that you can enjoy the game without any ads or root requirement. Ads can be annoying and distracting when you are racing. Rooting your device can be risky and complicated. That's why the mod APK version removes all the ads and does not require root access to work. You can play the game smoothly and safely.
-High-quality graphics and sound effects
-The game boasts high-quality graphics and sound effects that make you feel like you are in a real drag race. You can see the details of the cars, the tracks, and the environment. You can also hear the roar of the engines, the screech of the tires, and the cheers of the crowd. You can also adjust the graphics and sound settings to suit your device and preference.
-How to download and install GT Club Drag Racing Car Game Mod APK
-If you are interested in downloading and installing the mod APK version of GT Club Drag Racing Car Game, you can follow these simple steps:
-How to download gt club drag racing car game mod apk for free
-GT club drag racing car game mod apk unlimited money and gems
-Best drag racing car games for android with gt club mod apk
-GT club drag racing car game mod apk latest version download
-Download gt club drag racing car game mod apk offline
-GT club drag racing car game mod apk features and gameplay
-GT club drag racing car game mod apk review and rating
-Download gt club drag racing car game mod apk for PC
-GT club drag racing car game mod apk cheats and hacks
-GT club drag racing car game mod apk download link and installation guide
-GT club drag racing car game mod apk vs real racing 3
-GT club drag racing car game mod apk tips and tricks
-GT club drag racing car game mod apk online multiplayer mode
-Download gt club drag racing car game mod apk without root
-GT club drag racing car game mod apk no ads and in-app purchases
-GT club drag racing car game mod apk system requirements and compatibility
-Download gt club drag racing car game mod apk from APKCombo[^1^]
-GT club drag racing car game mod apk update and patch notes
-GT club drag racing car game mod apk screenshots and videos
-Download gt club drag racing car game mod apk with obb data file
-GT club drag racing car game mod apk new cars and tracks
-GT club drag racing car game mod apk customizations and upgrades
-Download gt club drag racing car game mod apk with manual gears
-GT club drag racing car game mod apk speed test and performance
-GT club drag racing car game mod apk feedback and support
-Step 1: Enable unknown sources on your device
-Before you can install any mod APK file on your device, you need to enable unknown sources. This is a security feature that prevents the installation of apps from sources other than Google Play. To enable unknown sources, go to your device settings, then security, then toggle on the unknown sources option.
-Step 2: Download the mod APK file from a trusted source
-Next, you need to download the mod APK file of GT Club Drag Racing Car Game from a trusted source. You can use the link below to download the latest version of the mod APK file. Make sure you have enough storage space on your device before downloading the file.
-Download GT Club Drag Racing Car Game Mod APK
-Step 3: Locate and install the mod APK file on your device
-After downloading the mod APK file, you need to locate and install it on your device. You can use any file manager app to find the downloaded file in your downloads folder. Tap on the file and follow the instructions to install it on your device.
-Step 4: Launch the game and enjoy the mod features
-Finally, you can launch the game and enjoy the mod features. You will see that you have unlimited money, gold, and other benefits. You can also access all the cars, customize them, and upgrade them. You can also play the game without any ads or root requirement.
-Conclusion
-GT Club Drag Racing Car Game is a fun and exciting racing game that lets you compete with other players online and offline. You can choose from a variety of supercars, customize them, and upgrade them to suit your preferences. You can also join clubs, participate in tournaments, and win rewards.
-However, if you want to enjoy the game to the fullest, you might want to download the mod APK version of GT Club Drag Racing Car Game. This is a modified version that gives you unlimited money, gold, and other benefits for free. You can use these resources to unlock all the cars and features. You can also enjoy the game without any ads or root requirement.
-To download and install the mod APK version of GT Club Drag Racing Car Game, you can follow the steps we have provided in this article. We hope this article was helpful and informative for you. If you have any questions or feedback, feel free to leave a comment below.
-FAQs
-Here are some frequently asked questions about GT Club Drag Racing Car Game Mod APK:
-Is GT Club Drag Racing Car Game Mod APK safe to use?
-Yes, GT Club Drag Racing Car Game Mod APK is safe to use as long as you download it from a trusted source. We have tested the mod APK file and found no viruses or malware in it. However, we advise you to use it at your own risk and discretion.
-Will I get banned for using GT Club Drag Racing Car Game Mod APK?
-No, you will not get banned for using GT Club Drag Racing Car Game Mod APK as long as you use it wisely and moderately. The mod APK version has an anti-ban feature that prevents detection by the game servers. However, we advise you not to abuse the mod features or cheat in online mode.
-Can I update GT Club Drag Racing Car Game Mod APK?
-No, you cannot update GT Club Drag Racing Car Game Mod APK from Google Play or any other source. If you do so, you will lose all the mod features and benefits. To update the mod APK version, you need to download and install the latest version of the mod APK file from a trusted source.
-Can I play GT Club Drag Racing Car Game Mod APK offline?
-Yes, you can play GT Club Drag Racing Car Game Mod APK offline without any internet connection. However, some features and modes may not be available in offline mode. To enjoy all the features and modes of the game, you need to have an active internet connection.
-Can I play GT Club Drag Racing Car Game Mod APK with my friends?
-Yes, you can play GT Club Drag Racing Car Game Mod APK with your friends online or offline. You can join clubs, chat with other racers, and challenge them to duels. You can also race against other players in real-time or offline mode. However, you need to make sure that your friends also have the mod APK version of the game installed on their devices. Otherwise, you may not be able to play with them.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/How to Get Brain Find Can you find it? Mod APK - Enjoy the Best of Brain Find with Unlimited Features.md b/spaces/congsaPfin/Manga-OCR/logs/How to Get Brain Find Can you find it? Mod APK - Enjoy the Best of Brain Find with Unlimited Features.md
deleted file mode 100644
index 95dab0233826228d56c3c92c41b09bd9008c8745..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/How to Get Brain Find Can you find it? Mod APK - Enjoy the Best of Brain Find with Unlimited Features.md
+++ /dev/null
@@ -1,90 +0,0 @@
-
-Brain Find: Can You Find It? Mod APK - A Fun and Challenging Brain Game
-Do you love brain games that make you think hard and challenge your mind? If so, you might want to try Brain Find: Can You Find It? Mod APK, a popular puzzle game that tests your logic, creativity, and problem-solving skills. In this article, we will tell you what this game is, how to download and install it on your Android device, and what benefits you can get from playing it.
-What is Brain Find: Can You Find It?
-Brain Find: Can You Find It? is a game that makes you think outside the box. It is not a typical puzzle game where you have to match colors, shapes, or numbers. Instead, it is a game where you have to use your brain to find hidden clues, solve riddles, crack codes, and discover secrets. The game has hundreds of levels and puzzles, each with a different theme and difficulty. Some puzzles are easy and straightforward, while others are tricky and require you to think in unconventional ways. The game is designed to stimulate your brain and make you laugh at the same time.
-brain find can you find it mod apk
DOWNLOAD » https://urlca.com/2uO7Ob
-A game that tests your logic, creativity, and problem-solving skills
-One of the main features of Brain Find: Can You Find It? is that it tests your logic, creativity, and problem-solving skills. The game does not give you any hints or instructions on how to solve the puzzles. You have to figure out the solution by yourself, using your common sense, intuition, imagination, and lateral thinking. The game challenges you to think differently and look for clues in unexpected places. For example, you might have to shake your phone, tilt your screen, tap on hidden objects, or even use your voice to solve some puzzles. The game also rewards you for being creative and finding alternative solutions.
-A game that makes you think outside the box
-Another feature of Brain Find: Can You Find It? is that it makes you think outside the box. The game does not follow any rules or logic. Sometimes, the answer to a puzzle might be absurd, illogical, or hilarious. The game encourages you to be playful and curious, and to explore different possibilities. The game also surprises you with unexpected twists and turns, making you question everything you see and hear. For example, you might have to find a hidden cat in a picture of dogs, or figure out why a man is crying in a happy scene.
-A game that has hundreds of levels and puzzles
-The last feature of Brain Find: Can You Find It? is that it has hundreds of levels and puzzles for you to enjoy. The game has a variety of themes and scenarios, such as animals, food, sports, movies, music, art, history, science, and more. Each theme has its own style and humor, making the game more fun and diverse. The game also has different types of puzzles, such as word puzzles, math puzzles, logic puzzles, visual puzzles, trivia puzzles, and more. Each puzzle has a different level of difficulty and challenge, making the game more interesting and addictive. The game also updates regularly with new levels and puzzles, keeping you entertained and engaged.
-What is a mod APK file?
-If you are wondering what a mod APK file is, you are not alone. Many people are curious about this term and what it means. A mod APK file is a modified version of an original APK file, which is the file format used by Android devices to install and run applications. A mod APK file can be downloaded and installed from third-party sources, rather than from the official Google Play Store. A mod APK file may offer additional features or benefits that are not available in the original version of the application.
-A modified version of an original APK file
-A mod APK file is a modified version of an original APK file, which means that it has been altered or changed by someone other than the original developer of the application. A mod APK file may have different graphics, sounds, functions, or gameplay than the original version. For example, a mod APK file of a game may have unlimited coins, gems, lives, or other resources that are normally limited or require in-app purchases. A mod APK file may also have unlocked levels, characters, items, or modes that are otherwise restricted or inaccessible in the original version.
-A file that can be downloaded and installed from third-party sources
-A mod APK file can be downloaded and installed from third-party sources, which are websites or platforms that are not affiliated with or authorized by the original developer of the application. A mod APK file can be found online by searching for the name of the application followed by "mod APK" or "modded APK". For example, if you want to download a mod APK file of Brain Find: Can You Find It?, you can search for "Brain Find: Can You Find It? mod APK" or "Brain Find: Can You Find It? modded APK". However, you should be careful when downloading and installing a mod APK file from third-party sources, as some of them may contain viruses, malware, or spyware that can harm your device or compromise your privacy.
-A file that may offer additional features or benefits
-A mod APK file may offer additional features or benefits that are not available in the original version of the application. These features or benefits may vary depending on the type and purpose of the mod APK file. Some common features or benefits that a mod APK file may offer are:
-brain find can you find it mod apk download
-brain find can you find it mod apk unlimited hints
-brain find can you find it mod apk latest version
-brain find can you find it mod apk android 1
-brain find can you find it mod apk free
-brain find can you find it mod apk hack
-brain find can you find it mod apk offline
-brain find can you find it mod apk no ads
-brain find can you find it mod apk 2023
-brain find can you find it mod apk revdl
-brain find can you solve puzzles mod apk
-brain find tricky riddles mod apk
-brain find hidden objects mod apk
-brain find mind quiz games mod apk
-brain find discovery gameplay mod apk
-brain find fun puzzle game mod apk
-brain find level 1000 mod apk
-brain find all levels unlocked mod apk
-brain find unlimited money mod apk
-brain find premium mod apk
-download brain find can you find it for android
-install brain find can you find it on pc
-play brain find can you find it online
-update brain find can you find it to latest version
-review brain find can you find it game
-how to play brain find can you find it game
-how to download brain find can you find it game
-how to install brain find can you find it game
-how to update brain find can you find it game
-how to hack brain find can you find it game
-tips and tricks for brain find can you find it game
-cheats and codes for brain find can you find it game
-walkthrough and guide for brain find can you find it game
-solutions and answers for brain find can you find it game
-best features of brain find can you find it game
-pros and cons of brain find can you find it game
-alternatives to brain find can you find it game
-similar games to brain find can you find it game
-is brain find can you find it game safe?
-is brain find can you find it game fun?
-
-Feature/Benefit Description Unlimited resources A mod APK file may provide unlimited coins, gems, lives, energy, or other resources that are normally limited or require in-app purchases in the original version of the application. Unlocked content A mod APK file may unlock levels, characters, items, modes, or other content that are otherwise restricted or inaccessible in the original version of the application. Removed ads A mod APK file may remove ads or pop-ups that interrupt or annoy the user in the original version of the application. Enhanced performance A mod APK file may enhance the performance, speed, graphics, or sound quality of the application. Customized features A mod APK file may add new features or modify existing features of the application according to the user's preference or taste.
enhance your neural connections and pathways. Playing brain games can also challenge your working memory, which is the ability to hold and manipulate information in your mind. Playing brain games can help you improve your memory recall, concentration, and alertness.
-Reduce the risk of dementia or Alzheimer's
-Another benefit of playing brain games is that they can reduce the risk of dementia or Alzheimer's, which are degenerative brain diseases that affect millions of people around the world. Dementia or Alzheimer's can cause memory loss, confusion, mood changes, and cognitive impairment. Playing brain games can help prevent or delay the onset of these diseases by keeping your brain active and healthy. Playing brain games can also stimulate the growth of new brain cells and protect them from damage or deterioration. Playing brain games can help you maintain your mental clarity and function as you age.
-Enhance your creativity and problem-solving skills
-A third benefit of playing brain games is that they can enhance your creativity and problem-solving skills. These are skills that help you generate new ideas, find solutions, and overcome challenges. Playing brain games can stimulate your right brain hemisphere, which is responsible for creativity, intuition, and imagination. Playing brain games can also activate your left brain hemisphere, which is responsible for logic, analysis, and reasoning. Playing brain games can help you balance both sides of your brain and use them effectively. Playing brain games can help you develop your critical thinking, innovation, and decision-making skills.
-Have fun and relieve stress
-The last benefit of playing brain games is that they can have fun and relieve stress. Stress is a common problem that affects many people in their daily lives. Stress can cause physical, emotional, and mental problems, such as headaches, anxiety, depression, or insomnia. Playing brain games can help you cope with stress by providing you with a positive and enjoyable distraction. Playing brain games can also release endorphins, which are natural chemicals that make you feel happy and relaxed. Playing brain games can help you improve your mood and well-being.
-Conclusion
-In conclusion, Brain Find: Can You Find It? Mod APK is a fun and challenging brain game that tests your logic, creativity, and problem-solving skills. It is a game that makes you think outside the box and surprises you with unexpected puzzles. It is also a game that has hundreds of levels and puzzles for you to enjoy. To play this game, you need to download and install a mod APK file from a reliable and safe APK download site. A mod APK file is a modified version of an original APK file that may offer additional features or benefits that are not available in the original version of the application. Playing brain games like Brain Find: Can You Find It? can also benefit your mental health and well-being by improving your memory, attention, and reaction time, reducing the risk of dementia or Alzheimer's, enhancing your creativity and problem-solving skills, and having fun and relieving stress. If you are looking for a game that will challenge your mind and make you laugh at the same time, you should try Brain Find: Can You Find It? Mod APK.
-FAQs
-Here are some frequently asked questions about Brain Find: Can You Find It? Mod APK:
-Q: Is Brain Find: Can You Find It? Mod APK safe to download and install?
-A: Yes, as long as you download and install it from a reliable and safe APK download site that does not contain any viruses, malware, or spyware. However, you should always be careful when downloading and installing any mod APK file from third-party sources, as some of them may be harmful or malicious.
-Q: What are the requirements to play Brain Find: Can You Find It? Mod APK?
-A: To play Brain Find: Can You Find It? Mod APK, you need to have an Android device that runs on Android 4.4 or higher version. You also need to have enough storage space on your device to download and install the mod APK file.
-Q: How do I update Brain Find: Can You Find It? Mod APK?
-A: To update Brain Find: Can You Find It? Mod APK, you need to check if there is a new version available on the APK download site where you got the mod APK file. If there is a new version available, you need to download and install it on your device following the same steps as before.
-Q: How do I uninstall Brain Find: Can You Find It? Mod APK?
-A: To uninstall Brain Find: Can You Find It? Mod APK, you need to go to your device's settings and look for the applications or apps option. Then, you need to find the game on the list of installed applications and tap on it. Then, you need to tap on the uninstall button and confirm your choice. This will remove the game and the mod APK file from your device.
-Q: Where can I get more information or support for Brain Find: Can You Find It? Mod APK?
-A: If you have any questions, issues, or feedback about Brain Find: Can You Find It? Mod APK, you can contact the developer of the game or the mod APK file through their official website, social media, or email. You can also visit the APK download site where you got the mod APK file and check the comments or reviews section for more information or support from other users.
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Internet Cafe Simulator How to Manage Your Own Internet Cafe for Free on PC.md b/spaces/congsaPfin/Manga-OCR/logs/Internet Cafe Simulator How to Manage Your Own Internet Cafe for Free on PC.md
deleted file mode 100644
index c2b695dce9d6e72e949961f3704c7b57170fa877..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Internet Cafe Simulator How to Manage Your Own Internet Cafe for Free on PC.md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-How to Download Internet Cafe Simulator for Free
-Have you ever dreamed of running your own internet cafe business? Do you want to experience the challenges and rewards of managing a comprehensive workplace, interacting with customers and city dwellers, and expanding your capacity and earnings? If so, you might be interested in playing Internet Cafe Simulator, a realistic and immersive simulation game developed by Cheesecake Dev. But what if you don't want to pay for the game, or you want to try it before you buy it? Don't worry, there are ways to download internet cafe simulator for free, and in this article, we will show you how.
-how to download internet cafe simulator for free
DOWNLOAD ––– https://urlca.com/2uOd3d
-What is Internet Cafe Simulator?
-Internet Cafe Simulator is an internet cafe business simulation game that was released in 2019. In this game, you can set up and manage your own internet cafe, from choosing the location, furnishing and decorating the environment, buying and installing computers and gaming equipment, hiring staff, paying bills, and dealing with customers. You can also explore the city and interact with various people and activities, such as shopping, gambling, dating, fighting, or doing illegal work. You can also buy crypto money, invest in popular games, or hire hackers to boost your reputation. The game offers a lot of freedom and customization options, as well as realistic graphics and physics. You can play the game in single-player or multiplayer mode.
-Why Play Internet Cafe Simulator for Free?
-There are many reasons why you might want to play internet cafe simulator for free. Maybe you are on a tight budget and you can't afford to spend money on games. Maybe you are not sure if you will like the game or not, and you want to test it before you commit to buying it. Maybe you are a fan of indie games and you want to support the developers by giving them feedback or spreading the word about their game. Whatever your reason is, playing internet cafe simulator for free is possible and easy, as long as you know where to look.
-How to Download Internet Cafe Simulator for Free
-Option 1: Steam
-One of the easiest ways to download internet cafe simulator for free is to use Steam, the popular online gaming platform. Steam offers two options for getting the game for free: the free demo and the free starter pack. The free demo lets you play the first hour of the game, while the free starter pack gives you access to the full game with some limitations. Here's how to get them:
-
-
-Option 2: Websites
-Another Another way to download internet cafe simulator for free is to use websites that offer free or discounted downloads of the game. There are many websites that do this, but you have to be careful and check their credibility and security before downloading anything. Some of the websites that we recommend are: - Epic Store: Epic Store is a digital distribution platform that offers free games every week. You can check their website regularly and see if internet cafe simulator is available for free or at a lower price. - My Abandonware: My Abandonware is a website that hosts old and classic games that are no longer supported by their developers or publishers. You can find internet cafe simulator on their website and download it for free, as long as you have a compatible system and emulator. - IGN Beta Giveaway: IGN Beta Giveaway is a program that gives away free beta keys for upcoming games. You can sign up for their newsletter and get notified when they have a giveaway for internet cafe simulator. You can then redeem your beta key on Steam and play the game for free before it is officially released.
Option 3: Torrents
-The last option to download internet cafe simulator for free is to use torrents, which are peer-to-peer file sharing networks that allow users to download and upload files from each other. However, this option is not recommended, as it comes with many risks and legal issues. Some of the problems that you might face when using torrents are:
-
-
-If you still want to use torrents to download internet cafe simulator for free, you should take some precautions to protect yourself and your computer. Some of the tips that you should follow are:
-
-
-Conclusion
-In conclusion, internet cafe simulator is a fun and realistic simulation game that lets you run your own internet cafe business and explore the city life. If you want to play the game for free, you have three options: Steam, websites, or torrents. Each option has its own advantages and disadvantages, so you should choose the one that suits your needs and preferences. We hope this article helped you learn how to download internet cafe simulator for free, and we encourage you to try the game and share your feedback with us.
-how to get internet cafe simulator for free on pc
-internet cafe simulator free download full version
-how to install internet cafe simulator for free
-internet cafe simulator pc game free download
-how to play internet cafe simulator for free
-internet cafe simulator free download windows 10
-how to download internet cafe simulator on bluestacks
-internet cafe simulator free download android
-how to run internet cafe simulator for free
-internet cafe simulator free download mac
-how to download internet cafe simulator from youtube
-internet cafe simulator free download apk
-how to update internet cafe simulator for free
-internet cafe simulator free download steam
-how to download internet cafe simulator with crack
-internet cafe simulator free download ios
-how to download internet cafe simulator without virus
-internet cafe simulator free download no survey
-how to download internet cafe simulator on laptop
-internet cafe simulator free download for windows 7
-how to download internet cafe simulator from google drive
-internet cafe simulator free download mega
-how to download internet cafe simulator on macbook
-internet cafe simulator free download utorrent
-how to download internet cafe simulator mod apk
-internet cafe simulator free download ocean of games
-how to download internet cafe simulator on chromebook
-internet cafe simulator free download softonic
-how to download internet cafe simulator with multiplayer
-internet cafe simulator free download rar
-how to download internet cafe simulator on phone
-internet cafe simulator free download highly compressed
-how to download internet cafe simulator on windows 8
-internet cafe simulator free download skidrow
-how to download internet cafe simulator on linux
-internet cafe simulator free download igg games
-how to download internet cafe simulator on ipad
-internet cafe simulator free download fitgirl repack
-how to download internet cafe simulator on xbox one
-internet cafe simulator free download gog
-how to download internet cafe simulator on ps4
-internet cafe simulator free download codex
-how to download internet casino simulation for free
-FAQs
-Q: How much does internet cafe simulator cost?
-A: Internet cafe simulator costs $9.99 on Steam, but it may vary depending on your region and currency.
-Q: Is internet cafe simulator multiplayer?
-A: Yes, internet cafe simulator has a multiplayer mode that allows you to play with other players online.
-Q: What are the system requirements for internet cafe simulator?
-A: The minimum system requirements for internet cafe simulator are:
-
-
-Q: Can I customize my internet cafe in internet cafe simulator?
-A: Yes, you can customize your internet cafe in many ways, such as choosing the location, furniture, decoration, computers, gaming equipment, staff, menu, prices, and more A: Yes, you can customize your internet cafe in many ways, such as choosing the location, furniture, decoration, computers, gaming equipment, staff, menu, prices, and more. You can also upgrade your internet cafe as you earn more money and reputation.
-Q: What are some of the challenges and risks in internet cafe simulator?
-A: Some of the challenges and risks in internet cafe simulator are:
-
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Resso Mod Apk The Ultimate Music Streaming App with Premium Features [Mediafre Download].md b/spaces/congsaPfin/Manga-OCR/logs/Resso Mod Apk The Ultimate Music Streaming App with Premium Features [Mediafre Download].md
deleted file mode 100644
index c201a240b1fbac384076787182cd5bc994ec1e6e..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Resso Mod Apk The Ultimate Music Streaming App with Premium Features [Mediafre Download].md
+++ /dev/null
@@ -1,68 +0,0 @@
-
-Download Resso Mod Apk Premium 2023 Mediafire: Enjoy Unlimited Music Streaming
-Are you a music lover who wants to enjoy unlimited music streaming on your Android device? If yes, then you should try Resso, a new and innovative music app that lets you listen to your favorite songs, create your own playlists, and interact with other music fans. And if you want to unlock all the premium features of Resso for free, then you should download Resso Mod Apk Premium 2023 Mediafire, a modified version of the app that gives you access to everything without paying a dime. In this article, we will tell you what Resso is, what features it offers, what benefits you can get from Resso Mod Apk, and how to download and install it on your device. So, let's get started!
-What is Resso?
-Resso is a music streaming app that was launched in 2019 by Moon Video Inc., a subsidiary of ByteDance, the company behind TikTok. Resso aims to provide a more social and interactive music experience for users, by allowing them to express themselves through lyrics, comments, and emojis. Resso also helps users discover new music and trends, by offering personalized recommendations and curated charts. Resso is currently available in India, Indonesia, Brazil, Philippines, and some other countries.
-download resso mod apk premium 2023 mediafıre
Download File 🔗 https://urlca.com/2uO83X
-Features of Resso
-Resso has many features that make it stand out from other music apps. Here are some of them:
-Listen to thousands of songs from various genres and artists
-Resso has a huge library of songs that you can listen to online or offline. You can browse by genres, artists, albums, playlists, or moods. You can also search for any song or artist that you like. Whether you are into pop, rock, hip-hop, EDM, or Bollywood, you will find something that suits your taste.
-Create your own playlists and share them with others
-Resso lets you create your own playlists with the songs that you love. You can add as many songs as you want, rearrange them, rename them, and edit them anytime. You can also share your playlists with other users or on social media platforms. You can also follow other users' playlists and see what they are listening to.
-Customize your music experience with lyrics, comments, and emojis
-Resso is not just a music app, but also a social platform where you can express yourself and connect with other music fans. You can view the lyrics of any song that you are listening to, and sync them with the music. You can also comment on the lyrics or on any part of the song that you like. You can also use emojis to show your emotions or reactions. You can see what other users are saying about the song or join the conversation.
-Discover new music and trends with recommendations and charts
-Resso helps you discover new music that matches your preferences and mood. You can get personalized recommendations based on your listening history and behavior. You can also explore the top charts that show the most popular songs in different categories. You can also see what songs are trending on Resso or other platforms. You can also find new songs by genres, moods, or activities.
-What is Resso Mod Apk?
-Resso Mod Apk is a modified version of the original Resso app that gives you access to all the premium features of Resso without paying any subscription fee. Resso Mod Apk is not available on the Google Play Store or the official website of Resso, but you can download it from a third-party source like Mediafire. Resso Mod Apk is safe and easy to use, as long as you download it from a trusted link and follow the instructions carefully.
-Benefits of Resso Mod Apk
-Resso Mod Apk has many benefits that make it worth downloading. Here are some of them:
-Unlock premium features for free
-Resso Mod Apk allows you to enjoy all the premium features of Resso without spending any money. You can access the full library of songs, create unlimited playlists, download songs offline, and more. You can also use the advanced settings to customize your music experience, such as adjusting the equalizer, changing the playback speed, and choosing the audio quality.
-How to download resso mod apk premium 2023 mediafıre for free
-Resso mod apk premium 2023 mediafıre latest version download
-Download resso mod apk premium 2023 mediafıre with unlimited songs
-Resso mod apk premium 2023 mediafıre no ads download link
-Download resso mod apk premium 2023 mediafıre and enjoy music offline
-Resso mod apk premium 2023 mediafıre features and benefits
-Download resso mod apk premium 2023 mediafıre and connect with music lovers
-Resso mod apk premium 2023 mediafıre review and rating
-Download resso mod apk premium 2023 mediafıre and discover new songs
-Resso mod apk premium 2023 mediafıre installation guide and tips
-Download resso mod apk premium 2023 mediafıre and follow your favorite artists
-Resso mod apk premium 2023 mediafıre comparison with other music apps
-Download resso mod apk premium 2023 mediafıre and create your own playlists
-Resso mod apk premium 2023 mediafıre hack and cheat codes
-Download resso mod apk premium 2023 mediafıre and share your feedback
-Resso mod apk premium 2023 mediafıre troubleshooting and support
-Download resso mod apk premium 2023 mediafıre and join the community
-Resso mod apk premium 2023 mediafıre update and news
-Download resso mod apk premium 2023 mediafıre and access exclusive content
-Resso mod apk premium 2023 mediafıre pros and cons
-Download resso mod apk premium 2023 mediafıre and customize your settings
-Resso mod apk premium 2023 mediafıre FAQs and answers
-Download resso mod apk premium 2023 mediafıre and earn rewards
-Resso mod apk premium 2023 mediafıre testimonials and success stories
-Download resso mod apk premium 2023 mediafıre and learn more about the app
-Remove ads and interruptions
-Resso Mod Apk removes all the annoying ads and interruptions that may disturb your music listening. You can listen to your favorite songs without any breaks or pop-ups. You can also skip any song that you don't like without any limit.
-Download songs offline and listen anytime
-Resso Mod Apk lets you download any song that you want and listen to it offline. You can save your data and battery by downloading songs when you have a Wi-Fi connection and listening to them later when you are offline. You can also create offline playlists and sync them with your device.
-Enjoy high-quality audio and video
-Resso Mod Apk offers you high-quality audio and video streaming for your music enjoyment. You can choose from different audio formats, such as MP3, AAC, or FLAC, depending on your preference and device compatibility. You can also watch music videos in HD quality and enjoy the visuals along with the sound.
-How to download Resso Mod Apk Premium 2023 Mediafire?
-If you are interested in downloading Resso Mod Apk Premium 2023 Mediafire, then you need to follow these simple steps:
-Steps to download and install Resso Mod Apk
-Visit the Mediafire link provided below
-The first step is to visit the Mediafire link that we have provided below this article. This link will take you to the download page of Resso Mod Apk Premium 2023 Mediafire. You will see a green button that says "Download". Click on it and wait for a few seconds until the download starts.
-Download the Resso Mod Apk file to your device
-The next step is to download the Resso Mod Apk file to your device. The file size is about 60 MB, so make sure you have enough space on your device and a stable internet connection. The download may take a few minutes depending on your speed. Once the download is complete, you will see a notification on your device.
-Enable unknown sources in your settings
-The third step is to enable unknown sources in your settings. This is necessary because Resso Mod Apk is not from an official source and your device may block its installation. To enable unknown sources, go to your settings, then security, then unknown sources, and turn it on. You may see a warning message that says "Your phone and personal data are more vulnerable to attack by apps from unknown sources. You agree that you are solely responsible for any damage to your phone or loss of data that may result from using these apps." Tap on OK to proceed.
-Install the Resso Mod Apk and launch the app
-The final step is to install the Resso Mod Apk and launch the app. To install the Resso Mod Apk, go to your file manager, then downloads, then find the Resso Mod Apk file that you downloaded earlier. Tap on it and follow the instructions on the screen. The installation may take a few seconds or minutes depending on your device. Once the installation is done, you will see an icon of Resso on your home screen or app drawer. Tap on it and launch the app.
-Conclusion
-Resso is a great music app that lets you enjoy unlimited music streaming with social and interactive features. However, if you want to unlock all the premium features of Resso for free, then you should download Resso Mod Apk Mod Apk. Therefore, we cannot help you with any technical issues or queries that you may have regarding Resso Mod Apk. Please use Resso Mod Apk at your own risk and discretion.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/contluForse/HuggingGPT/assets/Borland C Builder Xe3 Crack UPDATED Bildre Lohnsteuererk.md b/spaces/contluForse/HuggingGPT/assets/Borland C Builder Xe3 Crack UPDATED Bildre Lohnsteuererk.md
deleted file mode 100644
index be3887134eda8675ae0e6ada3f25c0a682c1a43f..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Borland C Builder Xe3 Crack UPDATED Bildre Lohnsteuererk.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Borland C Builder Xe3 Crack bildre lohnsteuererk
Download Zip ⇒⇒⇒ https://ssurll.com/2uzxQc
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/points_sampler.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/points_sampler.py
deleted file mode 100644
index ae1a24f939dd0e2934765326363ea51c2f2b4cca..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/points_sampler.py
+++ /dev/null
@@ -1,177 +0,0 @@
-from typing import List
-
-import torch
-from torch import nn as nn
-
-from annotator.mmpkg.mmcv.runner import force_fp32
-from .furthest_point_sample import (furthest_point_sample,
- furthest_point_sample_with_dist)
-
-
-def calc_square_dist(point_feat_a, point_feat_b, norm=True):
- """Calculating square distance between a and b.
-
- Args:
- point_feat_a (Tensor): (B, N, C) Feature vector of each point.
- point_feat_b (Tensor): (B, M, C) Feature vector of each point.
- norm (Bool, optional): Whether to normalize the distance.
- Default: True.
-
- Returns:
- Tensor: (B, N, M) Distance between each pair points.
- """
- num_channel = point_feat_a.shape[-1]
- # [bs, n, 1]
- a_square = torch.sum(point_feat_a.unsqueeze(dim=2).pow(2), dim=-1)
- # [bs, 1, m]
- b_square = torch.sum(point_feat_b.unsqueeze(dim=1).pow(2), dim=-1)
-
- corr_matrix = torch.matmul(point_feat_a, point_feat_b.transpose(1, 2))
-
- dist = a_square + b_square - 2 * corr_matrix
- if norm:
- dist = torch.sqrt(dist) / num_channel
- return dist
-
-
-def get_sampler_cls(sampler_type):
- """Get the type and mode of points sampler.
-
- Args:
- sampler_type (str): The type of points sampler.
- The valid value are "D-FPS", "F-FPS", or "FS".
-
- Returns:
- class: Points sampler type.
- """
- sampler_mappings = {
- 'D-FPS': DFPSSampler,
- 'F-FPS': FFPSSampler,
- 'FS': FSSampler,
- }
- try:
- return sampler_mappings[sampler_type]
- except KeyError:
- raise KeyError(
- f'Supported `sampler_type` are {sampler_mappings.keys()}, but got \
- {sampler_type}')
-
-
-class PointsSampler(nn.Module):
- """Points sampling.
-
- Args:
- num_point (list[int]): Number of sample points.
- fps_mod_list (list[str], optional): Type of FPS method, valid mod
- ['F-FPS', 'D-FPS', 'FS'], Default: ['D-FPS'].
- F-FPS: using feature distances for FPS.
- D-FPS: using Euclidean distances of points for FPS.
- FS: using F-FPS and D-FPS simultaneously.
- fps_sample_range_list (list[int], optional):
- Range of points to apply FPS. Default: [-1].
- """
-
- def __init__(self,
- num_point: List[int],
- fps_mod_list: List[str] = ['D-FPS'],
- fps_sample_range_list: List[int] = [-1]):
- super().__init__()
- # FPS would be applied to different fps_mod in the list,
- # so the length of the num_point should be equal to
- # fps_mod_list and fps_sample_range_list.
- assert len(num_point) == len(fps_mod_list) == len(
- fps_sample_range_list)
- self.num_point = num_point
- self.fps_sample_range_list = fps_sample_range_list
- self.samplers = nn.ModuleList()
- for fps_mod in fps_mod_list:
- self.samplers.append(get_sampler_cls(fps_mod)())
- self.fp16_enabled = False
-
- @force_fp32()
- def forward(self, points_xyz, features):
- """
- Args:
- points_xyz (Tensor): (B, N, 3) xyz coordinates of the features.
- features (Tensor): (B, C, N) Descriptors of the features.
-
- Returns:
- Tensor: (B, npoint, sample_num) Indices of sampled points.
- """
- indices = []
- last_fps_end_index = 0
-
- for fps_sample_range, sampler, npoint in zip(
- self.fps_sample_range_list, self.samplers, self.num_point):
- assert fps_sample_range < points_xyz.shape[1]
-
- if fps_sample_range == -1:
- sample_points_xyz = points_xyz[:, last_fps_end_index:]
- if features is not None:
- sample_features = features[:, :, last_fps_end_index:]
- else:
- sample_features = None
- else:
- sample_points_xyz = \
- points_xyz[:, last_fps_end_index:fps_sample_range]
- if features is not None:
- sample_features = features[:, :, last_fps_end_index:
- fps_sample_range]
- else:
- sample_features = None
-
- fps_idx = sampler(sample_points_xyz.contiguous(), sample_features,
- npoint)
-
- indices.append(fps_idx + last_fps_end_index)
- last_fps_end_index += fps_sample_range
- indices = torch.cat(indices, dim=1)
-
- return indices
-
-
-class DFPSSampler(nn.Module):
- """Using Euclidean distances of points for FPS."""
-
- def __init__(self):
- super().__init__()
-
- def forward(self, points, features, npoint):
- """Sampling points with D-FPS."""
- fps_idx = furthest_point_sample(points.contiguous(), npoint)
- return fps_idx
-
-
-class FFPSSampler(nn.Module):
- """Using feature distances for FPS."""
-
- def __init__(self):
- super().__init__()
-
- def forward(self, points, features, npoint):
- """Sampling points with F-FPS."""
- assert features is not None, \
- 'feature input to FFPS_Sampler should not be None'
- features_for_fps = torch.cat([points, features.transpose(1, 2)], dim=2)
- features_dist = calc_square_dist(
- features_for_fps, features_for_fps, norm=False)
- fps_idx = furthest_point_sample_with_dist(features_dist, npoint)
- return fps_idx
-
-
-class FSSampler(nn.Module):
- """Using F-FPS and D-FPS simultaneously."""
-
- def __init__(self):
- super().__init__()
-
- def forward(self, points, features, npoint):
- """Sampling points with FS_Sampling."""
- assert features is not None, \
- 'feature input to FS_Sampler should not be None'
- ffps_sampler = FFPSSampler()
- dfps_sampler = DFPSSampler()
- fps_idx_ffps = ffps_sampler(points, features, npoint)
- fps_idx_dfps = dfps_sampler(points, features, npoint)
- fps_idx = torch.cat([fps_idx_ffps, fps_idx_dfps], dim=1)
- return fps_idx
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/tin_shift.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/tin_shift.py
deleted file mode 100644
index 472c9fcfe45a124e819b7ed5653e585f94a8811e..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmcv/ops/tin_shift.py
+++ /dev/null
@@ -1,68 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# Code reference from "Temporal Interlacing Network"
-# https://github.com/deepcs233/TIN/blob/master/cuda_shift/rtc_wrap.py
-# Hao Shao, Shengju Qian, Yu Liu
-# shaoh19@mails.tsinghua.edu.cn, sjqian@cse.cuhk.edu.hk, yuliu@ee.cuhk.edu.hk
-
-import torch
-import torch.nn as nn
-from torch.autograd import Function
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext',
- ['tin_shift_forward', 'tin_shift_backward'])
-
-
-class TINShiftFunction(Function):
-
- @staticmethod
- def forward(ctx, input, shift):
- C = input.size(2)
- num_segments = shift.size(1)
- if C // num_segments <= 0 or C % num_segments != 0:
- raise ValueError('C should be a multiple of num_segments, '
- f'but got C={C} and num_segments={num_segments}.')
-
- ctx.save_for_backward(shift)
-
- out = torch.zeros_like(input)
- ext_module.tin_shift_forward(input, shift, out)
-
- return out
-
- @staticmethod
- def backward(ctx, grad_output):
-
- shift = ctx.saved_tensors[0]
- data_grad_input = grad_output.new(*grad_output.size()).zero_()
- shift_grad_input = shift.new(*shift.size()).zero_()
- ext_module.tin_shift_backward(grad_output, shift, data_grad_input)
-
- return data_grad_input, shift_grad_input
-
-
-tin_shift = TINShiftFunction.apply
-
-
-class TINShift(nn.Module):
- """Temporal Interlace Shift.
-
- Temporal Interlace shift is a differentiable temporal-wise frame shifting
- which is proposed in "Temporal Interlacing Network"
-
- Please refer to https://arxiv.org/abs/2001.06499 for more details.
- Code is modified from https://github.com/mit-han-lab/temporal-shift-module
- """
-
- def forward(self, input, shift):
- """Perform temporal interlace shift.
-
- Args:
- input (Tensor): Feature map with shape [N, num_segments, C, H * W].
- shift (Tensor): Shift tensor with shape [N, num_segments].
-
- Returns:
- Feature map after temporal interlace shift.
- """
- return tin_shift(input, shift)
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/cnn/bricks/__init__.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/cnn/bricks/__init__.py
deleted file mode 100644
index 0f33124ed23fc6f27119a37bcb5ab004d3572be0..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/mmcv/cnn/bricks/__init__.py
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .activation import build_activation_layer
-from .context_block import ContextBlock
-from .conv import build_conv_layer
-from .conv2d_adaptive_padding import Conv2dAdaptivePadding
-from .conv_module import ConvModule
-from .conv_ws import ConvAWS2d, ConvWS2d, conv_ws_2d
-from .depthwise_separable_conv_module import DepthwiseSeparableConvModule
-from .drop import Dropout, DropPath
-from .generalized_attention import GeneralizedAttention
-from .hsigmoid import HSigmoid
-from .hswish import HSwish
-from .non_local import NonLocal1d, NonLocal2d, NonLocal3d
-from .norm import build_norm_layer, is_norm
-from .padding import build_padding_layer
-from .plugin import build_plugin_layer
-from .registry import (ACTIVATION_LAYERS, CONV_LAYERS, NORM_LAYERS,
- PADDING_LAYERS, PLUGIN_LAYERS, UPSAMPLE_LAYERS)
-from .scale import Scale
-from .swish import Swish
-from .upsample import build_upsample_layer
-from .wrappers import (Conv2d, Conv3d, ConvTranspose2d, ConvTranspose3d,
- Linear, MaxPool2d, MaxPool3d)
-
-__all__ = [
- 'ConvModule', 'build_activation_layer', 'build_conv_layer',
- 'build_norm_layer', 'build_padding_layer', 'build_upsample_layer',
- 'build_plugin_layer', 'is_norm', 'HSigmoid', 'HSwish', 'NonLocal1d',
- 'NonLocal2d', 'NonLocal3d', 'ContextBlock', 'GeneralizedAttention',
- 'ACTIVATION_LAYERS', 'CONV_LAYERS', 'NORM_LAYERS', 'PADDING_LAYERS',
- 'UPSAMPLE_LAYERS', 'PLUGIN_LAYERS', 'Scale', 'ConvAWS2d', 'ConvWS2d',
- 'conv_ws_2d', 'DepthwiseSeparableConvModule', 'Swish', 'Linear',
- 'Conv2dAdaptivePadding', 'Conv2d', 'ConvTranspose2d', 'MaxPool2d',
- 'ConvTranspose3d', 'MaxPool3d', 'Conv3d', 'Dropout', 'DropPath'
-]
diff --git a/spaces/cybercorejapan/human-detection-docker/models/detectors/yolov7.py b/spaces/cybercorejapan/human-detection-docker/models/detectors/yolov7.py
deleted file mode 100644
index a3804ef1ba40544636f290e5a2fa2c3850ab2b59..0000000000000000000000000000000000000000
--- a/spaces/cybercorejapan/human-detection-docker/models/detectors/yolov7.py
+++ /dev/null
@@ -1,251 +0,0 @@
-from typing import List, Dict, Tuple, Union
-import torch, cv2
-import numpy as np
-
-from models.base.trt_base import TRT_Base
-from models.base.onnx_base import ONNX_Base
-from mmcv.ops.nms import batched_nms, nms
-
-class YOLOBase():
- def __init__(self,
- preprocess_cfg: Dict=dict(
- border_color=(114, 114, 114),
- auto=False,
- scaleFill=True,
- scaleup=True,
- stride=32),
- nms_agnostic_cfg: Dict=dict(
- type='nms',
- iou_threshold=0.9,
- class_agnostic=True),
- score_thr=0.1,
- use_torch: bool=False,
- ):
- """ This base-class has preprocess and postprocess function for YOLO model.
-
- Args:
- preprocess_cfg (Dict):
- - border_color (Tuple[int, int, int]): padding value.
- - auto (bool): resize input to minimum rectangle.
- - scaleFill (bool): stretching the input image.
- - scaleUp (bool): allow scale up the input image.
- - stride (int): stride of the model.
- nms_agnostic_cfg (Dict):
- - type (str): nms type (nms, softnms).
- - iou_threshold (float): IoU threshold of NMS.
- - class_agnostic (bool): enable class-agnostic NMS instead of NMS for each class.
- use_torch (bool): use torch tensor or numpy array in preprocess and postprocess function.
- """
- self.preprocess_cfg=preprocess_cfg
- self.nms_agnostic_cfg=nms_agnostic_cfg
- self.use_torch= use_torch
- self.score_thr = score_thr
-
- def letterbox(self,
- img: np.ndarray,
- new_shape: Tuple[int, int]=(640, 640),
- border_color: Tuple[int, int, int]=(114, 114, 114),
- auto: bool=True,
- scaleFill: bool=False,
- scaleup: bool=True,
- stride: int=32):
- """ Resize input image.
-
- Args:
- img (np.ndarray): input image.
- new_shape (Tuple[int, int]): the shape of output image.
- border_color: Tuple[int, int, int]: padding value.
- auto (bool): resize input to minimum rectangle.
- scaleFill (bool): stretching the input image.
- scaleUp (bool): allow scale up the input image.
- stride (int): stride of the model.
- """
-
- # Resize and pad image while meeting stride-multiple constraints
- shape = img.shape[:2] # current shape [height, width]
- if isinstance(new_shape, int):
- new_shape = (new_shape, new_shape)
-
- # Scale ratio (new / old)
- r = min(new_shape[0] / shape[0], new_shape[1] / shape[1])
- if not scaleup: # only scale down, do not scale up (for better test mAP)
- r = min(r, 1.0)
-
- # Compute padding
- ratio = r, r # width, height ratios
- new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r))
- dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding
- if auto: # minimum rectangle
- dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding
- elif scaleFill: # stretch
- dw, dh = 0.0, 0.0
- new_unpad = (new_shape[1], new_shape[0])
- ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios
-
- dw /= 2 # divide padding into 2 sides
- dh /= 2
-
- top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1))
- left, right = int(round(dw - 0.1)), int(round(dw + 0.1))
-
- if shape[::-1] != new_unpad: # resize
- new_img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR)
- else:
- new_img = img
- new_img = cv2.copyMakeBorder(new_img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=border_color) # add border
- return new_img, ratio, (dw, dh)
-
- def preprocess(self, input_data: np.ndarray):
- """ Preprocess function for input data.
-
- Args:
- input_data (np.ndarray): batch input image.
- """
- tensor_data = []
- if ((isinstance(input_data, np.ndarray)) and (len(input_data.shape) == 3)):
- input_data = [input_data]
- for i in range(len(input_data)):
- img = input_data[i]
- img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
- preprocessed_img, ratio, dwdh = self.letterbox(img, new_shape=self.input_shape[2:], **self.preprocess_cfg)
- height, width = preprocessed_img.shape[0], preprocessed_img.shape[1]
- if self.use_torch:
- tensor_data.append(torch.from_numpy(preprocessed_img).to(self.device))
- else:
- tensor_data.append(preprocessed_img)
- if self.use_torch:
- tensor_data = torch.stack(tensor_data, dim=0).permute(0, 3, 1, 2).float().contiguous()/255.0
- else:
- tensor_data = np.stack(tensor_data, axis=0).transpose(0, 3, 1, 2)/255.0
-
- return tensor_data, height, width, ratio[0], dwdh
-
- def scale_boxes(self,
- boxes: Union[torch.Tensor,np.ndarray],
- r: float,
- dwdh: Tuple[float, float]) -> torch.Tensor:
- """ Scale predicted boxes to the original image shape.
-
- Args:
- boxes (torch.tensor or np.ndarray): output boxes.
- r (float): ratio between model shape and input shape.
- dwdh (Tuple[float, float]): top-left padding position.
- """
- dwdh = dwdh * 2
- if isinstance(boxes, torch.Tensor):
- dwdh = torch.tensor(dwdh)
- boxes -= dwdh
- boxes /= r
- return boxes
-
- def post_process(self,
- boxes: torch.Tensor,
- scores: torch.Tensor,
- classes: torch.Tensor,
- ratio: float,
- dwdh: Tuple[int,int]) -> List[Dict]:
- """ Postprocess function for input data.
-
- Args:
- boxes (torch.Tensor): output boxes of shape [N_box, 4].
- scores (torch.Tensor): confidence scores of shape [N_box,].
- classes (torch.Tensor): class ids of shape [N_box,].
- ratio (float): ratio between original image shape and model's input shape.
- dwdh (Tuple[int,int]): padding margin output from letterbox function.
-
- Returns:
- List[Dict]: _description_
- """
- boxes = self.scale_boxes(boxes, ratio, dwdh)
- det_outputs = []
- batch_size = len(boxes)
- for idx in range(batch_size):
- frame_boxes = boxes[idx]
- frame_scores = scores[idx]
- frame_labels = classes[idx]
- # Filter out confidence scores below threshold
- index = frame_scores > self.score_thr
- frame_boxes = frame_boxes[index]
- frame_scores = frame_scores[index]
- frame_labels = frame_labels[index]
- # Use NMS to suppress class-agnostic boxes
- result_boxes, keep = batched_nms(frame_boxes.float(), frame_scores.float(), frame_labels, nms_cfg=self.nms_agnostic_cfg)
- det_outputs.append({"boxes": result_boxes,"labels": frame_labels[keep]})
- return det_outputs
-
-class YOLOv7TRT(TRT_Base, YOLOBase):
- def __init__(self,
- preprocess_cfg: Dict,
- nms_agnostic_cfg: Dict,
- score_thr=0.1,
- img_shape: Tuple[int, int]=(640, 640),
- batch_size: int=32,
- model_path: str="",
- device: str='0',):
- """ YOLOv7 TRT class for inference, which is based on TRT_Base and YOLOBase.
- """
- self.img_shape = img_shape
- self.batch_size = batch_size
- input_shape = (self.batch_size, *self.img_shape)
- super().__init__(input_shape, model_path, device)
- YOLOBase.__init__(self, preprocess_cfg=preprocess_cfg,
- nms_agnostic_cfg=nms_agnostic_cfg,
- score_thr=score_thr,
- use_torch=True)
-
- def infer_batch(self, image_batch: np.ndarray) -> List[Dict]:
- """ Batch inference function for batch input image.
-
- Args:
- image_batch (np.ndarray): batch of input image.
- """
-
- tensor_data, height, width, ratio, dwdh = self.preprocess(image_batch)
- self.change_runtime_dimension(input_shape=(len(tensor_data), 3, height, width))
- self.model['binding_addrs']['images'] = int(tensor_data.data_ptr())
- self.model['context'].execute_v2(list(self.model['binding_addrs'].values()))
- nums = self.model['bindings']['num_dets'].data.cpu()
- boxes = self.model['bindings']['det_boxes'].data.cpu()
- scores = self.model['bindings']['det_scores'].data.cpu()
- classes = self.model['bindings']['det_classes'].data.cpu()
-
- return self.post_process(boxes, scores, classes, ratio, dwdh)
-
-class YOLOv7ONNX(ONNX_Base, YOLOBase):
- def __init__(self,
- preprocess_cfg,
- nms_agnostic_cfg,
- score_thr=0.1,
- img_shape: Tuple[int, int]=(640, 640),
- batch_size: int=32,
- model_path: str="",
- device: str='0',):
- """ YOLOv7 ONNX class for inference, which is based on ONNX_Base and YOLOBase.
- """
- self.img_shape = img_shape
- self.batch_size = batch_size
- input_shape = (self.batch_size, *self.img_shape)
- super().__init__(input_shape, model_path, device)
- YOLOBase.__init__(self,
- preprocess_cfg=preprocess_cfg,
- nms_agnostic_cfg=nms_agnostic_cfg,
- score_thr=score_thr,
- use_torch=False)
-
- def infer_batch(self, image_batch: np.ndarray) -> List[Dict]:
-
- numpy_array_data, height, width, ratio, dwdh = self.preprocess(image_batch)
- numpy_array_data = numpy_array_data.astype(np.float32)
- results = super().infer_batch(numpy_array_data)
- num_dets, boxes, scores, classes = results
- boxes = torch.from_numpy(boxes)
- scores = torch.from_numpy(scores)
- classes = torch.from_numpy(classes)
- return self.post_process(boxes, scores, classes, ratio, dwdh)
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/dachenchen/HiWantJoin/modules/llama_func.py b/spaces/dachenchen/HiWantJoin/modules/llama_func.py
deleted file mode 100644
index e1c513af1bf6d1569b071eb5fc0ce441d0692f83..0000000000000000000000000000000000000000
--- a/spaces/dachenchen/HiWantJoin/modules/llama_func.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import os
-import logging
-
-from llama_index import download_loader
-from llama_index import (
- Document,
- LLMPredictor,
- PromptHelper,
- QuestionAnswerPrompt,
- RefinePrompt,
-)
-import colorama
-import PyPDF2
-from tqdm import tqdm
-
-from modules.presets import *
-from modules.utils import *
-from modules.config import local_embedding
-
-
-def get_index_name(file_src):
- file_paths = [x.name for x in file_src]
- file_paths.sort(key=lambda x: os.path.basename(x))
-
- md5_hash = hashlib.md5()
- for file_path in file_paths:
- with open(file_path, "rb") as f:
- while chunk := f.read(8192):
- md5_hash.update(chunk)
-
- return md5_hash.hexdigest()
-
-
-def block_split(text):
- blocks = []
- while len(text) > 0:
- blocks.append(Document(text[:1000]))
- text = text[1000:]
- return blocks
-
-
-def get_documents(file_src):
- documents = []
- logging.debug("Loading documents...")
- logging.debug(f"file_src: {file_src}")
- for file in file_src:
- filepath = file.name
- filename = os.path.basename(filepath)
- file_type = os.path.splitext(filepath)[1]
- logging.info(f"loading file: {filename}")
- try:
- if file_type == ".pdf":
- logging.debug("Loading PDF...")
- try:
- from modules.pdf_func import parse_pdf
- from modules.config import advance_docs
-
- two_column = advance_docs["pdf"].get("two_column", False)
- pdftext = parse_pdf(filepath, two_column).text
- except:
- pdftext = ""
- with open(filepath, "rb") as pdfFileObj:
- pdfReader = PyPDF2.PdfReader(pdfFileObj)
- for page in tqdm(pdfReader.pages):
- pdftext += page.extract_text()
- text_raw = pdftext
- elif file_type == ".docx":
- logging.debug("Loading Word...")
- DocxReader = download_loader("DocxReader")
- loader = DocxReader()
- text_raw = loader.load_data(file=filepath)[0].text
- elif file_type == ".epub":
- logging.debug("Loading EPUB...")
- EpubReader = download_loader("EpubReader")
- loader = EpubReader()
- text_raw = loader.load_data(file=filepath)[0].text
- elif file_type == ".xlsx":
- logging.debug("Loading Excel...")
- text_list = excel_to_string(filepath)
- for elem in text_list:
- documents.append(Document(elem))
- continue
- else:
- logging.debug("Loading text file...")
- with open(filepath, "r", encoding="utf-8") as f:
- text_raw = f.read()
- except Exception as e:
- logging.error(f"Error loading file: {filename}")
- pass
- text = add_space(text_raw)
- # text = block_split(text)
- # documents += text
- documents += [Document(text)]
- logging.debug("Documents loaded.")
- return documents
-
-
-def construct_index(
- api_key,
- file_src,
- max_input_size=4096,
- num_outputs=5,
- max_chunk_overlap=20,
- chunk_size_limit=600,
- embedding_limit=None,
- separator=" ",
-):
- from langchain.chat_models import ChatOpenAI
- from langchain.embeddings.huggingface import HuggingFaceEmbeddings
- from llama_index import GPTSimpleVectorIndex, ServiceContext, LangchainEmbedding, OpenAIEmbedding
-
- if api_key:
- os.environ["OPENAI_API_KEY"] = api_key
- else:
- # 由于一个依赖的愚蠢的设计，这里必须要有一个API KEY
- os.environ["OPENAI_API_KEY"] = "sk-xxxxxxx"
- chunk_size_limit = None if chunk_size_limit == 0 else chunk_size_limit
- embedding_limit = None if embedding_limit == 0 else embedding_limit
- separator = " " if separator == "" else separator
-
- prompt_helper = PromptHelper(
- max_input_size=max_input_size,
- num_output=num_outputs,
- max_chunk_overlap=max_chunk_overlap,
- embedding_limit=embedding_limit,
- chunk_size_limit=600,
- separator=separator,
- )
- index_name = get_index_name(file_src)
- if os.path.exists(f"./index/{index_name}.json"):
- logging.info("找到了缓存的索引文件，加载中……")
- return GPTSimpleVectorIndex.load_from_disk(f"./index/{index_name}.json")
- else:
- try:
- documents = get_documents(file_src)
- if local_embedding:
- embed_model = LangchainEmbedding(HuggingFaceEmbeddings(model_name = "sentence-transformers/distiluse-base-multilingual-cased-v2"))
- else:
- embed_model = OpenAIEmbedding()
- logging.info("构建索引中……")
- with retrieve_proxy():
- service_context = ServiceContext.from_defaults(
- prompt_helper=prompt_helper,
- chunk_size_limit=chunk_size_limit,
- embed_model=embed_model,
- )
- index = GPTSimpleVectorIndex.from_documents(
- documents, service_context=service_context
- )
- logging.debug("索引构建完成！")
- os.makedirs("./index", exist_ok=True)
- index.save_to_disk(f"./index/{index_name}.json")
- logging.debug("索引已保存至本地!")
- return index
-
- except Exception as e:
- logging.error("索引构建失败！", e)
- print(e)
- return None
-
-
-def add_space(text):
- punctuations = {"，": "， ", "。": "。 ", "？": "？ ", "！": "！ ", "：": "： ", "；": "； "}
- for cn_punc, en_punc in punctuations.items():
- text = text.replace(cn_punc, en_punc)
- return text
diff --git a/spaces/daddyjin/TalkingFaceGeneration/FONT/modules/model.py b/spaces/daddyjin/TalkingFaceGeneration/FONT/modules/model.py
deleted file mode 100644
index 4d3bfcdcf9dd3db4ebcad575a971547a41560696..0000000000000000000000000000000000000000
--- a/spaces/daddyjin/TalkingFaceGeneration/FONT/modules/model.py
+++ /dev/null
@@ -1,597 +0,0 @@
-from torch import nn
-import torch
-import torch.nn.functional as F
-from modules.util import AntiAliasInterpolation2d, make_coordinate_grid
-from torchvision import models
-import numpy as np
-from torch.autograd import grad
-
-
-class Vgg19(torch.nn.Module):
- """
- Vgg19 network for perceptual loss. See Sec 3.3.
- """
- def __init__(self, requires_grad=False):
- super(Vgg19, self).__init__()
- vgg_pretrained_features = models.vgg19(pretrained=True).features
- self.slice1 = torch.nn.Sequential()
- self.slice2 = torch.nn.Sequential()
- self.slice3 = torch.nn.Sequential()
- self.slice4 = torch.nn.Sequential()
- self.slice5 = torch.nn.Sequential()
- for x in range(2):
- self.slice1.add_module(str(x), vgg_pretrained_features[x])
- for x in range(2, 7):
- self.slice2.add_module(str(x), vgg_pretrained_features[x])
- for x in range(7, 12):
- self.slice3.add_module(str(x), vgg_pretrained_features[x])
- for x in range(12, 21):
- self.slice4.add_module(str(x), vgg_pretrained_features[x])
- for x in range(21, 30):
- self.slice5.add_module(str(x), vgg_pretrained_features[x])
-
- self.mean = torch.nn.Parameter(data=torch.Tensor(np.array([0.485, 0.456, 0.406]).reshape((1, 3, 1, 1))),
- requires_grad=False)
- self.std = torch.nn.Parameter(data=torch.Tensor(np.array([0.229, 0.224, 0.225]).reshape((1, 3, 1, 1))),
- requires_grad=False)
-
- if not requires_grad:
- for param in self.parameters():
- param.requires_grad = False
-
- def forward(self, X):
- X = (X - self.mean) / self.std
- h_relu1 = self.slice1(X)
- h_relu2 = self.slice2(h_relu1)
- h_relu3 = self.slice3(h_relu2)
- h_relu4 = self.slice4(h_relu3)
- h_relu5 = self.slice5(h_relu4)
- out = [h_relu1, h_relu2, h_relu3, h_relu4, h_relu5]
- return out
-
-
-class ImagePyramide(torch.nn.Module):
- """
- Create image pyramide for computing pyramide perceptual loss. See Sec 3.3
- """
- def __init__(self, scales, num_channels):
- super(ImagePyramide, self).__init__()
- downs = {}
- for scale in scales:
- downs[str(scale).replace('.', '-')] = AntiAliasInterpolation2d(num_channels, scale)
- self.downs = nn.ModuleDict(downs)
-
- def forward(self, x):
- out_dict = {}
- for scale, down_module in self.downs.items():
- out_dict['prediction_' + str(scale).replace('-', '.')] = down_module(x)
- return out_dict
-
-
-class Transform:
- """
- Random tps transformation for equivariance constraints. See Sec 3.3
- """
- def __init__(self, bs, **kwargs):
- noise = torch.normal(mean=0, std=kwargs['sigma_affine'] * torch.ones([bs, 2, 3]))
- self.theta = noise + torch.eye(2, 3).view(1, 2, 3)
- self.bs = bs
-
- if ('sigma_tps' in kwargs) and ('points_tps' in kwargs):
- self.tps = True
- self.control_points = make_coordinate_grid((kwargs['points_tps'], kwargs['points_tps']), type=noise.type())
- self.control_points = self.control_points.unsqueeze(0)
- self.control_params = torch.normal(mean=0,
- std=kwargs['sigma_tps'] * torch.ones([bs, 1, kwargs['points_tps'] ** 2]))
- else:
- self.tps = False
-
- def transform_frame(self, frame):
- grid = make_coordinate_grid(frame.shape[2:], type=frame.type()).unsqueeze(0) #[1,256,256,2]
- grid = grid.view(1, frame.shape[2] * frame.shape[3], 2)
- grid = self.warp_coordinates(grid).view(self.bs, frame.shape[2], frame.shape[3], 2)
- return F.grid_sample(frame, grid, padding_mode="reflection")
-
- def inverse_transform_frame(self, frame):
- grid = make_coordinate_grid(frame.shape[2:], type=frame.type()).unsqueeze(0) #[1,256,256,2]
- grid = grid.view(1, frame.shape[2] * frame.shape[3], 2)
- grid = self.inverse_warp_coordinates(grid).view(self.bs, frame.shape[2], frame.shape[3], 2)
- return F.grid_sample(frame, grid, padding_mode="reflection")
-
- def warp_coordinates(self, coordinates):
- theta = self.theta.type(coordinates.type())
- theta = theta.unsqueeze(1)
- transformed = torch.matmul(theta[:, :, :, :2], coordinates.unsqueeze(-1)) + theta[:, :, :, 2:]
- transformed = transformed.squeeze(-1)
-
- if self.tps:
- control_points = self.control_points.type(coordinates.type())
- control_params = self.control_params.type(coordinates.type())
- distances = coordinates.view(coordinates.shape[0], -1, 1, 2) - control_points.view(1, 1, -1, 2)
- distances = torch.abs(distances).sum(-1)
-
- result = distances ** 2
- result = result * torch.log(distances + 1e-6)
- result = result * control_params
- result = result.sum(dim=2).view(self.bs, coordinates.shape[1], 1)
- transformed = transformed + result
-
- return transformed
-
- def inverse_warp_coordinates(self, coordinates):
- theta = self.theta.type(coordinates.type())
- theta = theta.unsqueeze(1)
- a = torch.FloatTensor([[[[0,0,1]]]]).repeat([self.bs,1,1,1]).cuda()
- c = torch.cat((theta,a),2)
- d = c.inverse()[:,:,:2,:]
- d = d.type(coordinates.type())
- transformed = torch.matmul(d[:, :, :, :2], coordinates.unsqueeze(-1)) + d[:, :, :, 2:]
- transformed = transformed.squeeze(-1)
-
- if self.tps:
- control_points = self.control_points.type(coordinates.type())
- control_params = self.control_params.type(coordinates.type())
- distances = coordinates.view(coordinates.shape[0], -1, 1, 2) - control_points.view(1, 1, -1, 2)
- distances = torch.abs(distances).sum(-1)
-
- result = distances ** 2
- result = result * torch.log(distances + 1e-6)
- result = result * control_params
- result = result.sum(dim=2).view(self.bs, coordinates.shape[1], 1)
- transformed = transformed + result
-
-
- return transformed
-
- def jacobian(self, coordinates):
- coordinates.requires_grad=True
- new_coordinates = self.warp_coordinates(coordinates)#[4,10,2]
- grad_x = grad(new_coordinates[..., 0].sum(), coordinates, create_graph=True)
- grad_y = grad(new_coordinates[..., 1].sum(), coordinates, create_graph=True)
- jacobian = torch.cat([grad_x[0].unsqueeze(-2), grad_y[0].unsqueeze(-2)], dim=-2)
- return jacobian
-
-
-def detach_kp(kp):
- return {key: value.detach() for key, value in kp.items()}
-
-class TrainPart1Model(torch.nn.Module):
- """
- Merge all generator related updates into single model for better multi-gpu usage
- """
-
- def __init__(self, kp_extractor, kp_extractor_a, audio_feature, generator, discriminator, train_params, device_ids):
- super(TrainPart1Model, self).__init__()
- self.kp_extractor = kp_extractor
- self.kp_extractor_a = kp_extractor_a
-
- self.audio_feature = audio_feature
- self.generator = generator
- self.discriminator = discriminator
- self.train_params = train_params
- self.scales = train_params['scales']
- self.disc_scales = self.discriminator.scales
- self.pyramid = ImagePyramide(self.scales, generator.num_channels)
- if torch.cuda.is_available():
- self.pyramid = self.pyramid.cuda()
-
- self.loss_weights = train_params['loss_weights']
-
- if sum(self.loss_weights['perceptual']) != 0:
- self.vgg = Vgg19()
- if torch.cuda.is_available():
- self.vgg = self.vgg.cuda()
-
-
- self.mse_loss_fn = nn.MSELoss().cuda()
- def forward(self, x):
-
- kp_source = self.kp_extractor(x['example_image'])
-
-
- kp_driving = []
- for i in range(16):
- kp_driving.append(self.kp_extractor(x['driving'][:,i]))
-
-
-
- kp_driving_a = [] #x['example_image'],
-
-
- # print(x['example_image'].shape, x['driving_audio'].shape, x['driving_pose'].shape)
- deco_out = self.audio_feature(x['example_image'], x['driving_audio'], x['driving_pose'], self.train_params['jaco_net'])
- loss_values = {}
-
- if self.loss_weights['audio'] != 0:
-
- kp_driving_a = []
- for i in range(16):
- kp_driving_a.append(self.kp_extractor_a(deco_out[:,i]))#
-
-
- loss_value = 0
- loss_heatmap = 0
- loss_jacobian = 0
- loss_perceptual = 0
- for i in range(len(kp_driving)):
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'] - kp_driving_a[i]['jacobian']).mean())*self.loss_weights['audio']
-
- # loss_jacobian = loss_jacobian*self.loss_weights['audio']
- loss_heatmap += (torch.abs(kp_driving[i]['heatmap'] - kp_driving_a[i]['heatmap']).mean())*self.loss_weights['audio']*100
-
-
- loss_value += (torch.abs(kp_driving[i]['value'].detach() - kp_driving_a[i]['value']).mean())*self.loss_weights['audio']
-
- loss_values['loss_value'] = loss_value/len(kp_driving)
- loss_values['loss_heatmap'] = loss_heatmap/len(kp_driving)
- loss_values['loss_jacobian'] = loss_jacobian/len(kp_driving)
-
-
- if self.train_params['generator'] == 'not':
- # loss_values['perceptual'] = self.mse_loss_fn(deco_out,deco_out)
- for i in range(1): #0,len(kp_driving),4
-
- generated = self.generator(x['example_image'], kp_source=kp_source, kp_driving=kp_driving_a[i])
- generated.update({'kp_source': kp_source, 'kp_driving': kp_driving_a})
-
-
- elif self.train_params['generator'] == 'visual':
- for i in range(0,len(kp_driving),4): #0,len(kp_driving),4
-
- generated = self.generator(x['example_image'], kp_source=kp_source, kp_driving=kp_driving[i])
- generated.update({'kp_source': kp_source, 'kp_driving': kp_driving})
-
- pyramide_real = self.pyramid(x['driving'][:,i])
- pyramide_generated = self.pyramid(generated['prediction'])
-
- if sum(self.loss_weights['perceptual']) != 0:
- value_total = 0
- for scale in self.scales:
- x_vgg = self.vgg(pyramide_generated['prediction_' + str(scale)])
- y_vgg = self.vgg(pyramide_real['prediction_' + str(scale)])
-
- for i, weight in enumerate(self.loss_weights['perceptual']):
- value = torch.abs(x_vgg[i] - y_vgg[i].detach()).mean()
- value_total += self.loss_weights['perceptual'][i] * value
- loss_perceptual += value_total
-
- length = int((len(kp_driving)-1)/4)+1
- loss_values['perceptual'] = loss_perceptual/length
- elif self.train_params['generator'] == 'audio':
- for i in range(0,len(kp_driving),4): #0,len(kp_driving),4
-
- generated = self.generator(x['example_image'], kp_source=kp_source, kp_driving=kp_driving_a[i])
- generated.update({'kp_source': kp_source, 'kp_driving': kp_driving_a})
-
- pyramide_real = self.pyramid(x['driving'][:,i])
- pyramide_generated = self.pyramid(generated['prediction'])
-
- if sum(self.loss_weights['perceptual']) != 0:
- value_total = 0
- for scale in self.scales:
- x_vgg = self.vgg(pyramide_generated['prediction_' + str(scale)])
- y_vgg = self.vgg(pyramide_real['prediction_' + str(scale)])
-
- for i, weight in enumerate(self.loss_weights['perceptual']):
- value = torch.abs(x_vgg[i] - y_vgg[i].detach()).mean()
- value_total += self.loss_weights['perceptual'][i] * value
- loss_perceptual += value_total
-
- length = int((len(kp_driving)-1)/4)+1
- loss_values['perceptual'] = loss_perceptual/length
- else:
- print('wrong train_params: ', self.train_params['generator'])
-
- return loss_values,generated
-
-
-class TrainPart2Model(torch.nn.Module):
- """
- Merge all generator related updates into single model for better multi-gpu usage
- """
-
- def __init__(self, kp_extractor, emo_feature, kp_extractor_a, audio_feature, generator, discriminator, train_params, device_ids):
- super(TrainPart2Model, self).__init__()
- self.kp_extractor = kp_extractor
- self.kp_extractor_a = kp_extractor_a
-
- self.audio_feature = audio_feature
- self.emo_feature = emo_feature
- self.generator = generator
- self.discriminator = discriminator
- self.train_params = train_params
- self.scales = train_params['scales']
- self.disc_scales = self.discriminator.scales
- self.pyramid = ImagePyramide(self.scales, generator.num_channels)
- if torch.cuda.is_available():
- self.pyramid = self.pyramid.cuda()
-
- self.loss_weights = train_params['loss_weights']
-
- if sum(self.loss_weights['perceptual']) != 0:
- self.vgg = Vgg19()
- if torch.cuda.is_available():
- self.vgg = self.vgg.cuda()
-
- self.mse_loss_fn = nn.MSELoss().cuda()
- self.CroEn_loss = nn.CrossEntropyLoss().cuda()
- def forward(self, x):
-
- kp_source = self.kp_extractor(x['example_image'])
-
- kp_driving = []
- kp_emo = []
- for i in range(16):
- kp_driving.append(self.kp_extractor(x['driving'][:,i]))
- # kp_emo.append(self.emo_detector(x['driving'][:,i]))
-
- kp_driving_a = [] #x['example_image'],
- deco_out = self.audio_feature(x['example_image'], x['driving_audio'], x['driving_pose'], self.train_params['jaco_net'])
- # emo_out = self.emo_feature(x['example_image'], x['driving_audio'], x['driving_pose'], self.train_params['jaco_net'])
- loss_values = {}
-
- if self.loss_weights['emo'] != 0:
-
- kp_driving_a = []
- fakes = []
- for i in range(16):
- kp_driving_a.append(self.kp_extractor_a(deco_out[:,i]))#
- value = self.kp_extractor_a(deco_out[:,i])['value']
- jacobian = self.kp_extractor_a(deco_out[:,i])['jacobian']
- if self.train_params['type'] == 'linear_4' :
- out, fake = self.emo_feature(x['transformed_driving'][:,i],value,jacobian)
- kp_emo.append(out)
- fakes.append(fake)
- # kp_emo.append(self.emo_feature(x['transformed_driving'][:,i],value,jacobian))
- elif self.train_params['type'] == 'linear_10':
- # kp_emo.append(self.emo_feature.linear_10(x['transformed_driving'][:,i],value,jacobian))
-
- out, fake = self.emo_feature.linear_10(x['transformed_driving'][:,i],value,jacobian)
- kp_emo.append(out)
- fakes.append(fake)
- elif self.train_params['type'] == 'linear_4_new':
- # kp_emo.append(self.emo_feature.linear_10(x['transformed_driving'][:,i],value,jacobian))
-
- out, fake = self.emo_feature.linear_4(x['transformed_driving'][:,i],value,jacobian)
- kp_emo.append(out)
- fakes.append(fake)
- elif self.train_params['type'] == 'linear_np_4':
- # kp_emo.append(self.emo_feature.linear_10(x['transformed_driving'][:,i],value,jacobian))
-
- out, fake = self.emo_feature.linear_np_4(x['transformed_driving'][:,i],value,jacobian)
- kp_emo.append(out)
- fakes.append(fake)
- elif self.train_params['type'] == 'linear_np_10':
- # kp_emo.append(self.emo_feature.linear_10(x['transformed_driving'][:,i],value,jacobian))
-
- out, fake = self.emo_feature.linear_np_10(x['transformed_driving'][:,i],value,jacobian)
- kp_emo.append(out)
- fakes.append(fake)
-
- loss_value = 0
-
- loss_jacobian = 0
-
- loss_classify = 0
- kp_all = kp_driving_a
-
- for i in range(len(kp_driving)):
-
- if self.train_params['type'] == 'linear_4' or self.train_params['type'] == 'linear_4_new' or self.train_params['type'] == 'linear_np_4':
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'][:,1] - kp_driving_a[i]['jacobian'][:,1] -kp_emo[i]['jacobian'][:,0]).mean())*self.loss_weights['emo']
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'][:,4] - kp_driving_a[i]['jacobian'][:,4] -kp_emo[i]['jacobian'][:,1]).mean())*self.loss_weights['emo']
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'][:,6] - kp_driving_a[i]['jacobian'][:,6] -kp_emo[i]['jacobian'][:,2]).mean())*self.loss_weights['emo']
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'][:,8] - kp_driving_a[i]['jacobian'][:,8] -kp_emo[i]['jacobian'][:,3]).mean())*self.loss_weights['emo']
-
- loss_classify += self.CroEn_loss(fakes[i],x['emotion'])
- loss_value += (torch.abs(kp_driving[i]['value'][:,1] .detach() - kp_driving_a[i]['value'][:,1] - kp_emo[i]['value'][:,0] ).mean())*self.loss_weights['emo']
- loss_value += (torch.abs(kp_driving[i]['value'][:,4] .detach() - kp_driving_a[i]['value'][:,4] - kp_emo[i]['value'][:,1] ).mean())*self.loss_weights['emo']
- loss_value += (torch.abs(kp_driving[i]['value'][:,6] .detach() - kp_driving_a[i]['value'][:,6] - kp_emo[i]['value'][:,2] ).mean())*self.loss_weights['emo']
- loss_value += (torch.abs(kp_driving[i]['value'][:,8] .detach() - kp_driving_a[i]['value'][:,8] - kp_emo[i]['value'][:,3] ).mean())*self.loss_weights['emo']
- kp_all[i]['jacobian'][:,1] = kp_emo[i]['jacobian'][:,0] + kp_driving_a[i]['jacobian'][:,1]
- kp_all[i]['jacobian'][:,4] = kp_emo[i]['jacobian'][:,1] + kp_driving_a[i]['jacobian'][:,4]
- kp_all[i]['jacobian'][:,6] = kp_emo[i]['jacobian'][:,2] + kp_driving_a[i]['jacobian'][:,6]
- kp_all[i]['jacobian'][:,8] = kp_emo[i]['jacobian'][:,3] + kp_driving_a[i]['jacobian'][:,8]
- kp_all[i]['value'][:,1] = kp_emo[i]['value'][:,0] + kp_driving_a[i]['value'][:,1]
- kp_all[i]['value'][:,4] = kp_emo[i]['value'][:,1] + kp_driving_a[i]['value'][:,4]
- kp_all[i]['value'][:,6] = kp_emo[i]['value'][:,2] + kp_driving_a[i]['value'][:,6]
- kp_all[i]['value'][:,8] = kp_emo[i]['value'][:,3] + kp_driving_a[i]['value'][:,8]
- elif self.train_params['type'] == 'linear_10' or self.train_params['type'] == 'linear_np_10':
- loss_jacobian += (torch.abs(kp_driving[i]['jacobian'] - kp_driving_a[i]['jacobian'] -kp_emo[i]['jacobian']).mean())*self.loss_weights['emo']
-
- loss_classify += self.CroEn_loss(fakes[i],x['emotion'])
- loss_value += (torch.abs(kp_driving[i]['value'].detach() - kp_driving_a[i]['value'] - kp_emo[i]['value'] ).mean())*self.loss_weights['emo']
-
- # kp_all[i]['value'] = kp_emo[i]['value'] + kp_driving_a[i]['value']
-
- loss_values['loss_value'] = loss_value/len(kp_driving)
- # loss_values['loss_heatmap'] = loss_heatmap/len(kp_driving)
- loss_values['loss_jacobian'] = loss_jacobian/len(kp_driving)
- if self.train_params['classify'] == True:
- loss_values['loss_classify'] = loss_classify/len(kp_driving)
- else:
- loss_values['loss_classify'] = torch.tensor(0, device = loss_values['loss_value'].device)
-
-
-
-
-
- return loss_values,generated
-
-
-class GeneratorFullModel(torch.nn.Module):
- """
- Merge all generator related updates into single model for better multi-gpu usage
- """
-
- def __init__(self, kp_extractor, kp_extractor_a, audio_feature, generator, discriminator, train_params):
- super(GeneratorFullModel, self).__init__()
- self.kp_extractor = kp_extractor
- self.kp_extractor_a = kp_extractor_a
- # self.content_encoder = content_encoder
- # self.emotion_encoder = emotion_encoder
- self.audio_feature = audio_feature
- self.generator = generator
- self.discriminator = discriminator
- self.train_params = train_params
- self.scales = train_params['scales']
- self.disc_scales = self.discriminator.scales
- self.pyramid = ImagePyramide(self.scales, generator.num_channels)
- if torch.cuda.is_available():
- self.pyramid = self.pyramid.cuda()
-
- self.loss_weights = train_params['loss_weights']
-
- if sum(self.loss_weights['perceptual']) != 0:
- self.vgg = Vgg19()
- if torch.cuda.is_available():
- self.vgg = self.vgg.cuda()
-
- self.pca = torch.FloatTensor(np.load('.../LRW/list/U_106.npy'))[:, :16].cuda()
- self.mean = torch.FloatTensor(np.load('.../LRW/list/mean_106.npy')).cuda()
-
- def forward(self, x):
- # source_a_f = self.audio_feature(x['source_audio'],x['source_lm'],x[])
- # source_a_f = self.audio_feature(self.content_encoder(x['source_audio'].unsqueeze(1)), self.emotion_encoder(x['source_audio'].unsqueeze(1)))
- # kp_source = self.kp_extractor(x['source'])
- # kp_source_a = self.kp_extractor_a(x['source'], x['source_cube'], source_a_f)
- # driving_a_f = self.audio_feature(self.content_encoder(x['driving_audio'].unsqueeze(1)), self.emotion_encoder(x['driving_audio'].unsqueeze(1)))
- # driving_a_f = self.audio_feature(x['driving_audio'])
- # kp_driving = self.kp_extractor(x['driving'])
- # kp_driving_a = self.kp_extractor_a(x['driving'], x['driving_cube'], driving_a_f)
-
- kp_driving = []
- for i in range(16):
- kp_driving.append(self.kp_extractor(x['driving'][:,i],x['driving_landmark'][:,i],self.loss_weights['equivariance_value']))
-
- kp_driving_a = []
- fc_out, deco_out = self.audio_feature(x['example_landmark'], x['driving_audio'], x['driving_pose'])
- fake_lmark=fc_out + x['example_landmark'].expand_as(fc_out)
-
-
- fake_lmark = torch.mm( fake_lmark, self.pca.t() )
- fake_lmark = fake_lmark + self.mean.expand_as(fake_lmark)
-
-
- fake_lmark = fake_lmark.unsqueeze(0)
-
- # for i in range(16):
- # kp_driving_a.append()
-
- # generated = self.generator(x['source'], kp_source=kp_source, kp_driving=kp_driving)
- # generated.update({'kp_source': kp_source, 'kp_driving': kp_driving})
-
- loss_values = {}
-
- pyramide_real = self.pyramid(x['driving'])
- pyramide_generated = self.pyramid(generated['prediction'])
-
- if self.loss_weights['audio'] != 0:
- value = torch.abs(kp_source['jacobian'].detach() - kp_source_a['jacobian'].detach()).mean() + torch.abs(kp_driving['jacobian'].detach() - kp_driving_a['jacobian']).mean()
- value = value/2
- loss_values['jacobian'] = value*self.loss_weights['audio']
- value = torch.abs(kp_source['heatmap'].detach() - kp_source_a['heatmap'].detach()).mean() + torch.abs(kp_driving['heatmap'].detach() - kp_driving_a['heatmap']).mean()
- value = value/2
- loss_values['heatmap'] = value*self.loss_weights['audio']
- value = torch.abs(kp_source['value'].detach() - kp_source_a['value'].detach()).mean() + torch.abs(kp_driving['value'].detach() - kp_driving_a['value']).mean()
- value = value/2
- loss_values['value'] = value*self.loss_weights['audio']
-
- if sum(self.loss_weights['perceptual']) != 0:
- value_total = 0
- for scale in self.scales:
- x_vgg = self.vgg(pyramide_generated['prediction_' + str(scale)])
- y_vgg = self.vgg(pyramide_real['prediction_' + str(scale)])
-
- for i, weight in enumerate(self.loss_weights['perceptual']):
- value = torch.abs(x_vgg[i] - y_vgg[i].detach()).mean()
- value_total += self.loss_weights['perceptual'][i] * value
- loss_values['perceptual'] = value_total
-
- if self.loss_weights['generator_gan'] != 0:
- discriminator_maps_generated = self.discriminator(pyramide_generated, kp=detach_kp(kp_driving))
- discriminator_maps_real = self.discriminator(pyramide_real, kp=detach_kp(kp_driving))
- value_total = 0
- for scale in self.disc_scales:
- key = 'prediction_map_%s' % scale
- value = ((1 - discriminator_maps_generated[key]) ** 2).mean()
- value_total += self.loss_weights['generator_gan'] * value
- loss_values['gen_gan'] = value_total
-
- if sum(self.loss_weights['feature_matching']) != 0:
- value_total = 0
- for scale in self.disc_scales:
- key = 'feature_maps_%s' % scale
- for i, (a, b) in enumerate(zip(discriminator_maps_real[key], discriminator_maps_generated[key])):
- if self.loss_weights['feature_matching'][i] == 0:
- continue
- value = torch.abs(a - b).mean()
- value_total += self.loss_weights['feature_matching'][i] * value
- loss_values['feature_matching'] = value_total
-
- if (self.loss_weights['equivariance_value'] + self.loss_weights['equivariance_jacobian']) != 0:
- transform = Transform(x['driving'].shape[0], **self.train_params['transform_params'])
- transformed_frame = transform.transform_frame(x['driving'])
- transformed_landmark = transform.inverse_warp_coordinates(x['driving_landmark'])
- transformed_kp = self.kp_extractor(transformed_frame)
-
- generated['transformed_frame'] = transformed_frame
- generated['transformed_kp'] = transformed_kp
-
- ## Value loss part
- if self.loss_weights['equivariance_value'] != 0:
- value = torch.abs(kp_driving['value'] - transform.warp_coordinates(transformed_kp['value'])).mean()
- loss_values['equivariance_value'] = self.loss_weights['equivariance_value'] * value
-
- ## jacobian loss part
- if self.loss_weights['equivariance_jacobian'] != 0:
- jacobian_transformed = torch.matmul(transform.jacobian(transformed_kp['value']),
- transformed_kp['jacobian'])
-
- normed_driving = torch.inverse(kp_driving['jacobian'])
- normed_transformed = jacobian_transformed
- value = torch.matmul(normed_driving, normed_transformed)
-
- eye = torch.eye(2).view(1, 1, 2, 2).type(value.type())
-
- value = torch.abs(eye - value).mean()
- loss_values['equivariance_jacobian'] = self.loss_weights['equivariance_jacobian'] * value
-
- return loss_values, generated
-
-
-class DiscriminatorFullModel(torch.nn.Module):
- """
- Merge all discriminator related updates into single model for better multi-gpu usage
- """
-
- def __init__(self, kp_extractor, generator, discriminator, train_params):
- super(DiscriminatorFullModel, self).__init__()
- self.kp_extractor = kp_extractor
- self.generator = generator
- self.discriminator = discriminator
- self.train_params = train_params
- self.scales = self.discriminator.scales
- self.pyramid = ImagePyramide(self.scales, generator.num_channels)
- if torch.cuda.is_available():
- self.pyramid = self.pyramid.cuda()
-
- self.loss_weights = train_params['loss_weights']
-
- def forward(self, x, generated):
- pyramide_real = self.pyramid(x['driving'])
- pyramide_generated = self.pyramid(generated['prediction'].detach())
-
- kp_driving = generated['kp_driving']
- discriminator_maps_generated = self.discriminator(pyramide_generated, kp=detach_kp(kp_driving))
- discriminator_maps_real = self.discriminator(pyramide_real, kp=detach_kp(kp_driving))
-
- loss_values = {}
- value_total = 0
- for scale in self.scales:
- key = 'prediction_map_%s' % scale
- value = (1 - discriminator_maps_real[key]) ** 2 + discriminator_maps_generated[key] ** 2
- value_total += self.loss_weights['discriminator_gan'] * value.mean()
- loss_values['disc_gan'] = value_total
-
- return loss_values
diff --git a/spaces/darroncole928/hi/Dockerfile b/spaces/darroncole928/hi/Dockerfile
deleted file mode 100644
index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000
--- a/spaces/darroncole928/hi/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/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/TarIO.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/TarIO.py
deleted file mode 100644
index 32928f6af30b38f30915b76fcd52864f47b41d79..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/PIL/TarIO.py
+++ /dev/null
@@ -1,66 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# read files from within a tar file
-#
-# History:
-# 95-06-18 fl Created
-# 96-05-28 fl Open files in binary mode
-#
-# Copyright (c) Secret Labs AB 1997.
-# Copyright (c) Fredrik Lundh 1995-96.
-#
-# See the README file for information on usage and redistribution.
-#
-
-import io
-
-from . import ContainerIO
-
-
-class TarIO(ContainerIO.ContainerIO):
- """A file object that provides read access to a given member of a TAR file."""
-
- def __init__(self, tarfile, file):
- """
- Create file object.
-
- :param tarfile: Name of TAR file.
- :param file: Name of member file.
- """
- self.fh = open(tarfile, "rb")
-
- while True:
- s = self.fh.read(512)
- if len(s) != 512:
- msg = "unexpected end of tar file"
- raise OSError(msg)
-
- name = s[:100].decode("utf-8")
- i = name.find("\0")
- if i == 0:
- msg = "cannot find subfile"
- raise OSError(msg)
- if i > 0:
- name = name[:i]
-
- size = int(s[124:135], 8)
-
- if file == name:
- break
-
- self.fh.seek((size + 511) & (~511), io.SEEK_CUR)
-
- # Open region
- super().__init__(self.fh, self.fh.tell(), size)
-
- # Context manager support
- def __enter__(self):
- return self
-
- def __exit__(self, *args):
- self.close()
-
- def close(self):
- self.fh.close()
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/http_writer.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/http_writer.py
deleted file mode 100644
index 73f0f96f0ae3f152c22931054c7c4193cc45d8ef..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/aiohttp/http_writer.py
+++ /dev/null
@@ -1,198 +0,0 @@
-"""Http related parsers and protocol."""
-
-import asyncio
-import zlib
-from typing import Any, Awaitable, Callable, NamedTuple, Optional, Union # noqa
-
-from multidict import CIMultiDict
-
-from .abc import AbstractStreamWriter
-from .base_protocol import BaseProtocol
-from .helpers import NO_EXTENSIONS
-
-__all__ = ("StreamWriter", "HttpVersion", "HttpVersion10", "HttpVersion11")
-
-
-class HttpVersion(NamedTuple):
- major: int
- minor: int
-
-
-HttpVersion10 = HttpVersion(1, 0)
-HttpVersion11 = HttpVersion(1, 1)
-
-
-_T_OnChunkSent = Optional[Callable[[bytes], Awaitable[None]]]
-_T_OnHeadersSent = Optional[Callable[["CIMultiDict[str]"], Awaitable[None]]]
-
-
-class StreamWriter(AbstractStreamWriter):
- def __init__(
- self,
- protocol: BaseProtocol,
- loop: asyncio.AbstractEventLoop,
- on_chunk_sent: _T_OnChunkSent = None,
- on_headers_sent: _T_OnHeadersSent = None,
- ) -> None:
- self._protocol = protocol
-
- self.loop = loop
- self.length = None
- self.chunked = False
- self.buffer_size = 0
- self.output_size = 0
-
- self._eof = False
- self._compress: Any = None
- self._drain_waiter = None
-
- self._on_chunk_sent: _T_OnChunkSent = on_chunk_sent
- self._on_headers_sent: _T_OnHeadersSent = on_headers_sent
-
- @property
- def transport(self) -> Optional[asyncio.Transport]:
- return self._protocol.transport
-
- @property
- def protocol(self) -> BaseProtocol:
- return self._protocol
-
- def enable_chunking(self) -> None:
- self.chunked = True
-
- def enable_compression(
- self, encoding: str = "deflate", strategy: int = zlib.Z_DEFAULT_STRATEGY
- ) -> None:
- zlib_mode = 16 + zlib.MAX_WBITS if encoding == "gzip" else zlib.MAX_WBITS
- self._compress = zlib.compressobj(wbits=zlib_mode, strategy=strategy)
-
- def _write(self, chunk: bytes) -> None:
- size = len(chunk)
- self.buffer_size += size
- self.output_size += size
- transport = self.transport
- if not self._protocol.connected or transport is None or transport.is_closing():
- raise ConnectionResetError("Cannot write to closing transport")
- transport.write(chunk)
-
- async def write(
- self, chunk: bytes, *, drain: bool = True, LIMIT: int = 0x10000
- ) -> None:
- """Writes chunk of data to a stream.
-
- write_eof() indicates end of stream.
- writer can't be used after write_eof() method being called.
- write() return drain future.
- """
- if self._on_chunk_sent is not None:
- await self._on_chunk_sent(chunk)
-
- if isinstance(chunk, memoryview):
- if chunk.nbytes != len(chunk):
- # just reshape it
- chunk = chunk.cast("c")
-
- if self._compress is not None:
- chunk = self._compress.compress(chunk)
- if not chunk:
- return
-
- if self.length is not None:
- chunk_len = len(chunk)
- if self.length >= chunk_len:
- self.length = self.length - chunk_len
- else:
- chunk = chunk[: self.length]
- self.length = 0
- if not chunk:
- return
-
- if chunk:
- if self.chunked:
- chunk_len_pre = ("%x\r\n" % len(chunk)).encode("ascii")
- chunk = chunk_len_pre + chunk + b"\r\n"
-
- self._write(chunk)
-
- if self.buffer_size > LIMIT and drain:
- self.buffer_size = 0
- await self.drain()
-
- async def write_headers(
- self, status_line: str, headers: "CIMultiDict[str]"
- ) -> None:
- """Write request/response status and headers."""
- if self._on_headers_sent is not None:
- await self._on_headers_sent(headers)
-
- # status + headers
- buf = _serialize_headers(status_line, headers)
- self._write(buf)
-
- async def write_eof(self, chunk: bytes = b"") -> None:
- if self._eof:
- return
-
- if chunk and self._on_chunk_sent is not None:
- await self._on_chunk_sent(chunk)
-
- if self._compress:
- if chunk:
- chunk = self._compress.compress(chunk)
-
- chunk = chunk + self._compress.flush()
- if chunk and self.chunked:
- chunk_len = ("%x\r\n" % len(chunk)).encode("ascii")
- chunk = chunk_len + chunk + b"\r\n0\r\n\r\n"
- else:
- if self.chunked:
- if chunk:
- chunk_len = ("%x\r\n" % len(chunk)).encode("ascii")
- chunk = chunk_len + chunk + b"\r\n0\r\n\r\n"
- else:
- chunk = b"0\r\n\r\n"
-
- if chunk:
- self._write(chunk)
-
- await self.drain()
-
- self._eof = True
-
- async def drain(self) -> None:
- """Flush the write buffer.
-
- The intended use is to write
-
- await w.write(data)
- await w.drain()
- """
- if self._protocol.transport is not None:
- await self._protocol._drain_helper()
-
-
-def _safe_header(string: str) -> str:
- if "\r" in string or "\n" in string:
- raise ValueError(
- "Newline or carriage return detected in headers. "
- "Potential header injection attack."
- )
- return string
-
-
-def _py_serialize_headers(status_line: str, headers: "CIMultiDict[str]") -> bytes:
- headers_gen = (_safe_header(k) + ": " + _safe_header(v) for k, v in headers.items())
- line = status_line + "\r\n" + "\r\n".join(headers_gen) + "\r\n\r\n"
- return line.encode("utf-8")
-
-
-_serialize_headers = _py_serialize_headers
-
-try:
- import aiohttp._http_writer as _http_writer # type: ignore[import]
-
- _c_serialize_headers = _http_writer._serialize_headers
- if not NO_EXTENSIONS:
- _serialize_headers = _c_serialize_headers
-except ImportError:
- pass
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/designspaceLib/split.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/designspaceLib/split.py
deleted file mode 100644
index 0b7cdf4be05dea1e810b4fddf4bf026bc1a50a85..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/designspaceLib/split.py
+++ /dev/null
@@ -1,475 +0,0 @@
-"""Allows building all the variable fonts of a DesignSpace version 5 by
-splitting the document into interpolable sub-space, then into each VF.
-"""
-
-from __future__ import annotations
-
-import itertools
-import logging
-import math
-from typing import Any, Callable, Dict, Iterator, List, Tuple, cast
-
-from fontTools.designspaceLib import (
- AxisDescriptor,
- AxisMappingDescriptor,
- DesignSpaceDocument,
- DiscreteAxisDescriptor,
- InstanceDescriptor,
- RuleDescriptor,
- SimpleLocationDict,
- SourceDescriptor,
- VariableFontDescriptor,
-)
-from fontTools.designspaceLib.statNames import StatNames, getStatNames
-from fontTools.designspaceLib.types import (
- ConditionSet,
- Range,
- Region,
- getVFUserRegion,
- locationInRegion,
- regionInRegion,
- userRegionToDesignRegion,
-)
-
-LOGGER = logging.getLogger(__name__)
-
-MakeInstanceFilenameCallable = Callable[
- [DesignSpaceDocument, InstanceDescriptor, StatNames], str
-]
-
-
-def defaultMakeInstanceFilename(
- doc: DesignSpaceDocument, instance: InstanceDescriptor, statNames: StatNames
-) -> str:
- """Default callable to synthesize an instance filename
- when makeNames=True, for instances that don't specify an instance name
- in the designspace. This part of the name generation can be overriden
- because it's not specified by the STAT table.
- """
- familyName = instance.familyName or statNames.familyNames.get("en")
- styleName = instance.styleName or statNames.styleNames.get("en")
- return f"{familyName}-{styleName}.ttf"
-
-
-def splitInterpolable(
- doc: DesignSpaceDocument,
- makeNames: bool = True,
- expandLocations: bool = True,
- makeInstanceFilename: MakeInstanceFilenameCallable = defaultMakeInstanceFilename,
-) -> Iterator[Tuple[SimpleLocationDict, DesignSpaceDocument]]:
- """Split the given DS5 into several interpolable sub-designspaces.
- There are as many interpolable sub-spaces as there are combinations of
- discrete axis values.
-
- E.g. with axes:
- - italic (discrete) Upright or Italic
- - style (discrete) Sans or Serif
- - weight (continuous) 100 to 900
-
- There are 4 sub-spaces in which the Weight axis should interpolate:
- (Upright, Sans), (Upright, Serif), (Italic, Sans) and (Italic, Serif).
-
- The sub-designspaces still include the full axis definitions and STAT data,
- but the rules, sources, variable fonts, instances are trimmed down to only
- keep what falls within the interpolable sub-space.
-
- Args:
- - ``makeNames``: Whether to compute the instance family and style
- names using the STAT data.
- - ``expandLocations``: Whether to turn all locations into "full"
- locations, including implicit default axis values where missing.
- - ``makeInstanceFilename``: Callable to synthesize an instance filename
- when makeNames=True, for instances that don't specify an instance name
- in the designspace. This part of the name generation can be overridden
- because it's not specified by the STAT table.
-
- .. versionadded:: 5.0
- """
- discreteAxes = []
- interpolableUserRegion: Region = {}
- for axis in doc.axes:
- if hasattr(axis, "values"):
- # Mypy doesn't support narrowing union types via hasattr()
- # TODO(Python 3.10): use TypeGuard
- # https://mypy.readthedocs.io/en/stable/type_narrowing.html
- axis = cast(DiscreteAxisDescriptor, axis)
- discreteAxes.append(axis)
- else:
- axis = cast(AxisDescriptor, axis)
- interpolableUserRegion[axis.name] = Range(
- axis.minimum,
- axis.maximum,
- axis.default,
- )
- valueCombinations = itertools.product(*[axis.values for axis in discreteAxes])
- for values in valueCombinations:
- discreteUserLocation = {
- discreteAxis.name: value
- for discreteAxis, value in zip(discreteAxes, values)
- }
- subDoc = _extractSubSpace(
- doc,
- {**interpolableUserRegion, **discreteUserLocation},
- keepVFs=True,
- makeNames=makeNames,
- expandLocations=expandLocations,
- makeInstanceFilename=makeInstanceFilename,
- )
- yield discreteUserLocation, subDoc
-
-
-def splitVariableFonts(
- doc: DesignSpaceDocument,
- makeNames: bool = False,
- expandLocations: bool = False,
- makeInstanceFilename: MakeInstanceFilenameCallable = defaultMakeInstanceFilename,
-) -> Iterator[Tuple[str, DesignSpaceDocument]]:
- """Convert each variable font listed in this document into a standalone
- designspace. This can be used to compile all the variable fonts from a
- format 5 designspace using tools that can only deal with 1 VF at a time.
-
- Args:
- - ``makeNames``: Whether to compute the instance family and style
- names using the STAT data.
- - ``expandLocations``: Whether to turn all locations into "full"
- locations, including implicit default axis values where missing.
- - ``makeInstanceFilename``: Callable to synthesize an instance filename
- when makeNames=True, for instances that don't specify an instance name
- in the designspace. This part of the name generation can be overridden
- because it's not specified by the STAT table.
-
- .. versionadded:: 5.0
- """
- # Make one DesignspaceDoc v5 for each variable font
- for vf in doc.getVariableFonts():
- vfUserRegion = getVFUserRegion(doc, vf)
- vfDoc = _extractSubSpace(
- doc,
- vfUserRegion,
- keepVFs=False,
- makeNames=makeNames,
- expandLocations=expandLocations,
- makeInstanceFilename=makeInstanceFilename,
- )
- vfDoc.lib = {**vfDoc.lib, **vf.lib}
- yield vf.name, vfDoc
-
-
-def convert5to4(
- doc: DesignSpaceDocument,
-) -> Dict[str, DesignSpaceDocument]:
- """Convert each variable font listed in this document into a standalone
- format 4 designspace. This can be used to compile all the variable fonts
- from a format 5 designspace using tools that only know about format 4.
-
- .. versionadded:: 5.0
- """
- vfs = {}
- for _location, subDoc in splitInterpolable(doc):
- for vfName, vfDoc in splitVariableFonts(subDoc):
- vfDoc.formatVersion = "4.1"
- vfs[vfName] = vfDoc
- return vfs
-
-
-def _extractSubSpace(
- doc: DesignSpaceDocument,
- userRegion: Region,
- *,
- keepVFs: bool,
- makeNames: bool,
- expandLocations: bool,
- makeInstanceFilename: MakeInstanceFilenameCallable,
-) -> DesignSpaceDocument:
- subDoc = DesignSpaceDocument()
- # Don't include STAT info
- # FIXME: (Jany) let's think about it. Not include = OK because the point of
- # the splitting is to build VFs and we'll use the STAT data of the full
- # document to generate the STAT of the VFs, so "no need" to have STAT data
- # in sub-docs. Counterpoint: what if someone wants to split this DS for
- # other purposes? Maybe for that it would be useful to also subset the STAT
- # data?
- # subDoc.elidedFallbackName = doc.elidedFallbackName
-
- def maybeExpandDesignLocation(object):
- if expandLocations:
- return object.getFullDesignLocation(doc)
- else:
- return object.designLocation
-
- for axis in doc.axes:
- range = userRegion[axis.name]
- if isinstance(range, Range) and hasattr(axis, "minimum"):
- # Mypy doesn't support narrowing union types via hasattr()
- # TODO(Python 3.10): use TypeGuard
- # https://mypy.readthedocs.io/en/stable/type_narrowing.html
- axis = cast(AxisDescriptor, axis)
- subDoc.addAxis(
- AxisDescriptor(
- # Same info
- tag=axis.tag,
- name=axis.name,
- labelNames=axis.labelNames,
- hidden=axis.hidden,
- # Subset range
- minimum=max(range.minimum, axis.minimum),
- default=range.default or axis.default,
- maximum=min(range.maximum, axis.maximum),
- map=[
- (user, design)
- for user, design in axis.map
- if range.minimum <= user <= range.maximum
- ],
- # Don't include STAT info
- axisOrdering=None,
- axisLabels=None,
- )
- )
-
- subDoc.axisMappings = mappings = []
- subDocAxes = {axis.name for axis in subDoc.axes}
- for mapping in doc.axisMappings:
- if not all(axis in subDocAxes for axis in mapping.inputLocation.keys()):
- continue
- if not all(axis in subDocAxes for axis in mapping.outputLocation.keys()):
- LOGGER.error(
- "In axis mapping from input %s, some output axes are not in the variable-font: %s",
- mapping.inputLocation,
- mapping.outputLocation,
- )
- continue
-
- mappingAxes = set()
- mappingAxes.update(mapping.inputLocation.keys())
- mappingAxes.update(mapping.outputLocation.keys())
- for axis in doc.axes:
- if axis.name not in mappingAxes:
- continue
- range = userRegion[axis.name]
- if (
- range.minimum != axis.minimum
- or (range.default is not None and range.default != axis.default)
- or range.maximum != axis.maximum
- ):
- LOGGER.error(
- "Limiting axis ranges used in elements not supported: %s",
- axis.name,
- )
- continue
-
- mappings.append(
- AxisMappingDescriptor(
- inputLocation=mapping.inputLocation,
- outputLocation=mapping.outputLocation,
- )
- )
-
- # Don't include STAT info
- # subDoc.locationLabels = doc.locationLabels
-
- # Rules: subset them based on conditions
- designRegion = userRegionToDesignRegion(doc, userRegion)
- subDoc.rules = _subsetRulesBasedOnConditions(doc.rules, designRegion)
- subDoc.rulesProcessingLast = doc.rulesProcessingLast
-
- # Sources: keep only the ones that fall within the kept axis ranges
- for source in doc.sources:
- if not locationInRegion(doc.map_backward(source.designLocation), userRegion):
- continue
-
- subDoc.addSource(
- SourceDescriptor(
- filename=source.filename,
- path=source.path,
- font=source.font,
- name=source.name,
- designLocation=_filterLocation(
- userRegion, maybeExpandDesignLocation(source)
- ),
- layerName=source.layerName,
- familyName=source.familyName,
- styleName=source.styleName,
- muteKerning=source.muteKerning,
- muteInfo=source.muteInfo,
- mutedGlyphNames=source.mutedGlyphNames,
- )
- )
-
- # Copy family name translations from the old default source to the new default
- vfDefault = subDoc.findDefault()
- oldDefault = doc.findDefault()
- if vfDefault is not None and oldDefault is not None:
- vfDefault.localisedFamilyName = oldDefault.localisedFamilyName
-
- # Variable fonts: keep only the ones that fall within the kept axis ranges
- if keepVFs:
- # Note: call getVariableFont() to make the implicit VFs explicit
- for vf in doc.getVariableFonts():
- vfUserRegion = getVFUserRegion(doc, vf)
- if regionInRegion(vfUserRegion, userRegion):
- subDoc.addVariableFont(
- VariableFontDescriptor(
- name=vf.name,
- filename=vf.filename,
- axisSubsets=[
- axisSubset
- for axisSubset in vf.axisSubsets
- if isinstance(userRegion[axisSubset.name], Range)
- ],
- lib=vf.lib,
- )
- )
-
- # Instances: same as Sources + compute missing names
- for instance in doc.instances:
- if not locationInRegion(instance.getFullUserLocation(doc), userRegion):
- continue
-
- if makeNames:
- statNames = getStatNames(doc, instance.getFullUserLocation(doc))
- familyName = instance.familyName or statNames.familyNames.get("en")
- styleName = instance.styleName or statNames.styleNames.get("en")
- subDoc.addInstance(
- InstanceDescriptor(
- filename=instance.filename
- or makeInstanceFilename(doc, instance, statNames),
- path=instance.path,
- font=instance.font,
- name=instance.name or f"{familyName} {styleName}",
- userLocation={} if expandLocations else instance.userLocation,
- designLocation=_filterLocation(
- userRegion, maybeExpandDesignLocation(instance)
- ),
- familyName=familyName,
- styleName=styleName,
- postScriptFontName=instance.postScriptFontName
- or statNames.postScriptFontName,
- styleMapFamilyName=instance.styleMapFamilyName
- or statNames.styleMapFamilyNames.get("en"),
- styleMapStyleName=instance.styleMapStyleName
- or statNames.styleMapStyleName,
- localisedFamilyName=instance.localisedFamilyName
- or statNames.familyNames,
- localisedStyleName=instance.localisedStyleName
- or statNames.styleNames,
- localisedStyleMapFamilyName=instance.localisedStyleMapFamilyName
- or statNames.styleMapFamilyNames,
- localisedStyleMapStyleName=instance.localisedStyleMapStyleName
- or {},
- lib=instance.lib,
- )
- )
- else:
- subDoc.addInstance(
- InstanceDescriptor(
- filename=instance.filename,
- path=instance.path,
- font=instance.font,
- name=instance.name,
- userLocation={} if expandLocations else instance.userLocation,
- designLocation=_filterLocation(
- userRegion, maybeExpandDesignLocation(instance)
- ),
- familyName=instance.familyName,
- styleName=instance.styleName,
- postScriptFontName=instance.postScriptFontName,
- styleMapFamilyName=instance.styleMapFamilyName,
- styleMapStyleName=instance.styleMapStyleName,
- localisedFamilyName=instance.localisedFamilyName,
- localisedStyleName=instance.localisedStyleName,
- localisedStyleMapFamilyName=instance.localisedStyleMapFamilyName,
- localisedStyleMapStyleName=instance.localisedStyleMapStyleName,
- lib=instance.lib,
- )
- )
-
- subDoc.lib = doc.lib
-
- return subDoc
-
-
-def _conditionSetFrom(conditionSet: List[Dict[str, Any]]) -> ConditionSet:
- c: Dict[str, Range] = {}
- for condition in conditionSet:
- minimum, maximum = condition.get("minimum"), condition.get("maximum")
- c[condition["name"]] = Range(
- minimum if minimum is not None else -math.inf,
- maximum if maximum is not None else math.inf,
- )
- return c
-
-
-def _subsetRulesBasedOnConditions(
- rules: List[RuleDescriptor], designRegion: Region
-) -> List[RuleDescriptor]:
- # What rules to keep:
- # - Keep the rule if any conditionset is relevant.
- # - A conditionset is relevant if all conditions are relevant or it is empty.
- # - A condition is relevant if
- # - axis is point (C-AP),
- # - and point in condition's range (C-AP-in)
- # (in this case remove the condition because it's always true)
- # - else (C-AP-out) whole conditionset can be discarded (condition false
- # => conditionset false)
- # - axis is range (C-AR),
- # - (C-AR-all) and axis range fully contained in condition range: we can
- # scrap the condition because it's always true
- # - (C-AR-inter) and intersection(axis range, condition range) not empty:
- # keep the condition with the smaller range (= intersection)
- # - (C-AR-none) else, whole conditionset can be discarded
- newRules: List[RuleDescriptor] = []
- for rule in rules:
- newRule: RuleDescriptor = RuleDescriptor(
- name=rule.name, conditionSets=[], subs=rule.subs
- )
- for conditionset in rule.conditionSets:
- cs = _conditionSetFrom(conditionset)
- newConditionset: List[Dict[str, Any]] = []
- discardConditionset = False
- for selectionName, selectionValue in designRegion.items():
- # TODO: Ensure that all(key in conditionset for key in region.keys())?
- if selectionName not in cs:
- # raise Exception("Selection has different axes than the rules")
- continue
- if isinstance(selectionValue, (float, int)): # is point
- # Case C-AP-in
- if selectionValue in cs[selectionName]:
- pass # always matches, conditionset can stay empty for this one.
- # Case C-AP-out
- else:
- discardConditionset = True
- else: # is range
- # Case C-AR-all
- if selectionValue in cs[selectionName]:
- pass # always matches, conditionset can stay empty for this one.
- else:
- intersection = cs[selectionName].intersection(selectionValue)
- # Case C-AR-inter
- if intersection is not None:
- newConditionset.append(
- {
- "name": selectionName,
- "minimum": intersection.minimum,
- "maximum": intersection.maximum,
- }
- )
- # Case C-AR-none
- else:
- discardConditionset = True
- if not discardConditionset:
- newRule.conditionSets.append(newConditionset)
- if newRule.conditionSets:
- newRules.append(newRule)
-
- return newRules
-
-
-def _filterLocation(
- userRegion: Region,
- location: Dict[str, float],
-) -> Dict[str, float]:
- return {
- name: value
- for name, value in location.items()
- if name in userRegion and isinstance(userRegion[name], Range)
- }
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/markdown_it/helpers/parse_link_label.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/markdown_it/helpers/parse_link_label.py
deleted file mode 100644
index 01c653c56be8a10a6018e8b18ad64af2542ed1ac..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/markdown_it/helpers/parse_link_label.py
+++ /dev/null
@@ -1,43 +0,0 @@
-"""
-Parse link label
-
-this function assumes that first character ("[") already matches
-returns the end of the label
-
-"""
-from markdown_it.rules_inline import StateInline
-
-
-def parseLinkLabel(state: StateInline, start: int, disableNested: bool = False) -> int:
- labelEnd = -1
- oldPos = state.pos
- found = False
-
- state.pos = start + 1
- level = 1
-
- while state.pos < state.posMax:
- marker = state.src[state.pos]
- if marker == "]":
- level -= 1
- if level == 0:
- found = True
- break
-
- prevPos = state.pos
- state.md.inline.skipToken(state)
- if marker == "[":
- if prevPos == state.pos - 1:
- # increase level if we find text `[`,
- # which is not a part of any token
- level += 1
- elif disableNested:
- state.pos = oldPos
- return -1
- if found:
- labelEnd = state.pos
-
- # restore old state
- state.pos = oldPos
-
- return labelEnd
diff --git a/spaces/derful/Chatgpt-academic/crazy_functions/test_project/latex/attention/introduction.tex b/spaces/derful/Chatgpt-academic/crazy_functions/test_project/latex/attention/introduction.tex
deleted file mode 100644
index 1baa8915f4cf7aec2520894a87470fc9436d954b..0000000000000000000000000000000000000000
--- a/spaces/derful/Chatgpt-academic/crazy_functions/test_project/latex/attention/introduction.tex
+++ /dev/null
@@ -1,18 +0,0 @@
-Recurrent neural networks, long short-term memory \citep{hochreiter1997} and gated recurrent \citep{gruEval14} neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and transduction problems such as language modeling and machine translation \citep{sutskever14, bahdanau2014neural, cho2014learning}. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures \citep{wu2016google,luong2015effective,jozefowicz2016exploring}.
-
-Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden states $h_t$, as a function of the previous hidden state $h_{t-1}$ and the input for position $t$. This inherently sequential nature precludes parallelization within training examples, which becomes critical at longer sequence lengths, as memory constraints limit batching across examples.
-%\marginpar{not sure if the memory constraints are understandable here}
-Recent work has achieved significant improvements in computational efficiency through factorization tricks \citep{Kuchaiev2017Factorization} and conditional computation \citep{shazeer2017outrageously}, while also improving model performance in case of the latter. The fundamental constraint of sequential computation, however, remains.
-
-%\marginpar{@all: there is work on analyzing what attention really does in seq2seq models, couldn't find it right away}
-
-Attention mechanisms have become an integral part of compelling sequence modeling and transduction models in various tasks, allowing modeling of dependencies without regard to their distance in the input or output sequences \citep{bahdanau2014neural, structuredAttentionNetworks}. In all but a few cases \citep{decomposableAttnModel}, however, such attention mechanisms are used in conjunction with a recurrent network.
-
-%\marginpar{not sure if "cross-positional communication" is understandable without explanation}
-%\marginpar{insert exact training times and stats for the model that reaches sota earliest, maybe even a single GPU model?}
-
-In this work we propose the Transformer, a model architecture eschewing recurrence and instead relying entirely on an attention mechanism to draw global dependencies between input and output. The Transformer allows for significantly more parallelization and can reach a new state of the art in translation quality after being trained for as little as twelve hours on eight P100 GPUs.
-%\marginpar{you removed the constant number of repetitions part. I wrote it because I wanted to make it clear that the model does not only perform attention once, while it's also not recurrent. I thought that might be important to get across early.}
-
-% Just a standard paragraph with citations, rewrite.
-%After the seminal papers of \citep{sutskever14}, \citep{bahdanau2014neural}, and \citep{cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation and language modeling with recurrent sequence models. Recent effort \citep{shazeer2017outrageously} has combined the power of conditional computation with sequence models to train very large models for machine translation, pushing SOTA at lower computational cost. Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state encumbers recurrnet models to process multiple inputs at once, and their time complexity is a linear function of the length of the input and output, both during training and inference. [What I want to say here is that although this is fine during decoding, at training time, we are given both input and output and this linear nature does not allow the RNN to process all inputs and outputs simultaneously and haven't been used on datasets that are the of the scale of the web. What's the largest dataset we have ? . Talk about Nividia and possibly other's effors to speed up things, and possibly other efforts that alleviate this, but are still limited by it's comptuational nature]. Rest of the intro: What if you could construct the state based on the actual inputs and outputs, then you could construct them all at once. This has been the foundation of many promising recent efforts, bytenet,facenet (Also talk about quasi rnn here). Now we talk about attention!! Along with cell architectures such as long short-term meory (LSTM) \citep{hochreiter1997}, and gated recurrent units (GRUs) \citep{cho2014learning}, attention has emerged as an essential ingredient in successful sequence models, in particular for machine translation. In recent years, many, if not all, state-of-the-art (SOTA) results in machine translation have been achieved with attention-based sequence models \citep{wu2016google,luong2015effective,jozefowicz2016exploring}. Talk about the neon work on how it played with attention to do self attention! Then talk about what we do.
\ No newline at end of file
diff --git a/spaces/dhanilka/illusion-image-ai/app.py b/spaces/dhanilka/illusion-image-ai/app.py
deleted file mode 100644
index d82460d88330310696dff806bba6d7ba531e409e..0000000000000000000000000000000000000000
--- a/spaces/dhanilka/illusion-image-ai/app.py
+++ /dev/null
@@ -1,281 +0,0 @@
-import torch
-import gradio as gr
-from gradio import processing_utils, utils
-from PIL import Image
-import random
-from diffusers import (
- DiffusionPipeline,
- AutoencoderKL,
- StableDiffusionControlNetPipeline,
- ControlNetModel,
- StableDiffusionLatentUpscalePipeline,
- StableDiffusionImg2ImgPipeline,
- StableDiffusionControlNetImg2ImgPipeline,
- DPMSolverMultistepScheduler, # <-- Added import
- EulerDiscreteScheduler # <-- Added import
-)
-import time
-from share_btn import community_icon_html, loading_icon_html, share_js
-import user_history
-from illusion_style import css
-
-BASE_MODEL = "SG161222/Realistic_Vision_V5.1_noVAE"
-
-# Initialize both pipelines
-vae = AutoencoderKL.from_pretrained("stabilityai/sd-vae-ft-mse", torch_dtype=torch.float16)
-#init_pipe = DiffusionPipeline.from_pretrained("SG161222/Realistic_Vision_V5.1_noVAE", torch_dtype=torch.float16)
-controlnet = ControlNetModel.from_pretrained("monster-labs/control_v1p_sd15_qrcode_monster", torch_dtype=torch.float16)#, torch_dtype=torch.float16)
-main_pipe = StableDiffusionControlNetPipeline.from_pretrained(
- BASE_MODEL,
- controlnet=controlnet,
- vae=vae,
- safety_checker=None,
- torch_dtype=torch.float16,
-).to("cuda")
-
-#main_pipe.unet = torch.compile(main_pipe.unet, mode="reduce-overhead", fullgraph=True)
-#main_pipe.unet.to(memory_format=torch.channels_last)
-#main_pipe.unet = torch.compile(main_pipe.unet, mode="reduce-overhead", fullgraph=True)
-#model_id = "stabilityai/sd-x2-latent-upscaler"
-image_pipe = StableDiffusionControlNetImg2ImgPipeline(**main_pipe.components)
-
-#image_pipe.unet = torch.compile(image_pipe.unet, mode="reduce-overhead", fullgraph=True)
-#upscaler = StableDiffusionLatentUpscalePipeline.from_pretrained(model_id, torch_dtype=torch.float16)
-#upscaler.to("cuda")
-
-
-# Sampler map
-SAMPLER_MAP = {
- "DPM++ Karras SDE": lambda config: DPMSolverMultistepScheduler.from_config(config, use_karras=True, algorithm_type="sde-dpmsolver++"),
- "Euler": lambda config: EulerDiscreteScheduler.from_config(config),
-}
-
-def center_crop_resize(img, output_size=(512, 512)):
- width, height = img.size
-
- # Calculate dimensions to crop to the center
- new_dimension = min(width, height)
- left = (width - new_dimension)/2
- top = (height - new_dimension)/2
- right = (width + new_dimension)/2
- bottom = (height + new_dimension)/2
-
- # Crop and resize
- img = img.crop((left, top, right, bottom))
- img = img.resize(output_size)
-
- return img
-
-def common_upscale(samples, width, height, upscale_method, crop=False):
- if crop == "center":
- old_width = samples.shape[3]
- old_height = samples.shape[2]
- old_aspect = old_width / old_height
- new_aspect = width / height
- x = 0
- y = 0
- if old_aspect > new_aspect:
- x = round((old_width - old_width * (new_aspect / old_aspect)) / 2)
- elif old_aspect < new_aspect:
- y = round((old_height - old_height * (old_aspect / new_aspect)) / 2)
- s = samples[:,:,y:old_height-y,x:old_width-x]
- else:
- s = samples
-
- return torch.nn.functional.interpolate(s, size=(height, width), mode=upscale_method)
-
-def upscale(samples, upscale_method, scale_by):
- #s = samples.copy()
- width = round(samples["images"].shape[3] * scale_by)
- height = round(samples["images"].shape[2] * scale_by)
- s = common_upscale(samples["images"], width, height, upscale_method, "disabled")
- return (s)
-
-def check_inputs(prompt: str, control_image: Image.Image):
- if control_image is None:
- raise gr.Error("Please select or upload an Input Illusion")
- if prompt is None or prompt == "":
- raise gr.Error("Prompt is required")
-
-def convert_to_pil(base64_image):
- pil_image = processing_utils.decode_base64_to_image(base64_image)
- return pil_image
-
-def convert_to_base64(pil_image):
- base64_image = processing_utils.encode_pil_to_base64(pil_image)
- return base64_image
-
-# Inference function
-def inference(
- control_image: Image.Image,
- prompt: str,
- negative_prompt: str,
- guidance_scale: float = 8.0,
- controlnet_conditioning_scale: float = 1,
- control_guidance_start: float = 1,
- control_guidance_end: float = 1,
- upscaler_strength: float = 0.5,
- seed: int = -1,
- sampler = "DPM++ Karras SDE",
- progress = gr.Progress(track_tqdm=True),
- profile: gr.OAuthProfile | None = None,
-):
- start_time = time.time()
- start_time_struct = time.localtime(start_time)
- start_time_formatted = time.strftime("%H:%M:%S", start_time_struct)
- print(f"Inference started at {start_time_formatted}")
-
- # Generate the initial image
- #init_image = init_pipe(prompt).images[0]
-
- # Rest of your existing code
- control_image_small = center_crop_resize(control_image)
- control_image_large = center_crop_resize(control_image, (1024, 1024))
-
- main_pipe.scheduler = SAMPLER_MAP[sampler](main_pipe.scheduler.config)
- my_seed = random.randint(0, 2**32 - 1) if seed == -1 else seed
- generator = torch.Generator(device="cuda").manual_seed(my_seed)
-
- out = main_pipe(
- prompt=prompt,
- negative_prompt=negative_prompt,
- image=control_image_small,
- guidance_scale=float(guidance_scale),
- controlnet_conditioning_scale=float(controlnet_conditioning_scale),
- generator=generator,
- control_guidance_start=float(control_guidance_start),
- control_guidance_end=float(control_guidance_end),
- num_inference_steps=15,
- output_type="latent"
- )
- upscaled_latents = upscale(out, "nearest-exact", 2)
- out_image = image_pipe(
- prompt=prompt,
- negative_prompt=negative_prompt,
- control_image=control_image_large,
- image=upscaled_latents,
- guidance_scale=float(guidance_scale),
- generator=generator,
- num_inference_steps=20,
- strength=upscaler_strength,
- control_guidance_start=float(control_guidance_start),
- control_guidance_end=float(control_guidance_end),
- controlnet_conditioning_scale=float(controlnet_conditioning_scale)
- )
- end_time = time.time()
- end_time_struct = time.localtime(end_time)
- end_time_formatted = time.strftime("%H:%M:%S", end_time_struct)
- print(f"Inference ended at {end_time_formatted}, taking {end_time-start_time}s")
-
- # Save image + metadata
- user_history.save_image(
- label=prompt,
- image=out_image["images"][0],
- profile=profile,
- metadata={
- "prompt": prompt,
- "negative_prompt": negative_prompt,
- "guidance_scale": guidance_scale,
- "controlnet_conditioning_scale": controlnet_conditioning_scale,
- "control_guidance_start": control_guidance_start,
- "control_guidance_end": control_guidance_end,
- "upscaler_strength": upscaler_strength,
- "seed": seed,
- "sampler": sampler,
- },
- )
-
- return out_image["images"][0], gr.update(visible=True), gr.update(visible=True), my_seed
-
-with gr.Blocks() as app:
- gr.Markdown(
- '''
- Illusion Diffusion HQ 🌀
- Generate stunning high quality illusion artwork with Stable Diffusion
- Drivers Windows 7 Packard Bell Alp Horus G 5
Download File ✅ https://gohhs.com/2uFVsr
-
-Dec 22, 2021 - Coub is a YouTube for video loops. You can take any video, trim the best part, combine it with other videos, and add a soundtrack. The first episode of the series was made in December 2011.
-In February 2012, the first finale, Festivals of the Future, was announced, featuring former band member, David Bowie.
-The series finale was released in August 2012. It featured David and Iman Bowie, Paul McCartney, Ozzy Osbourne, Mariah Carey, Tim Hetherington, and several other members.
-In March 2013, the final "World Tour" was released, featuring Mick Fleetwood of Fleetwood Mac. 8a78ff9644
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/El-hombre-tranquilo-(1952)-[HDRip-AC3-XviD-Esp].md b/spaces/diacanFperku/AutoGPT/El-hombre-tranquilo-(1952)-[HDRip-AC3-XviD-Esp].md
deleted file mode 100644
index b6db65299ac70b887f58d162871fa2de7f3cacaa..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/El-hombre-tranquilo-(1952)-[HDRip-AC3-XviD-Esp].md
+++ /dev/null
@@ -1,6 +0,0 @@
-El-hombre-tranquilo-(1952)-[HDRip-AC3-XviD-Esp]
Download File ➡ https://gohhs.com/2uFTWR
-
-archicad 16 build 3010 x64 x86 crack only nitro · El-hombre-tranquilo-(1952)-[HDRip-AC3-XviD-Esp]. Tags: download tracepro 7.0 ... 4d29de3e1b
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/Fotosizer Final Edition Serials Key.md b/spaces/diacanFperku/AutoGPT/Fotosizer Final Edition Serials Key.md
deleted file mode 100644
index c5d5034c9d09fccfadb4a9eca3792e84c0323646..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Fotosizer Final Edition Serials Key.md
+++ /dev/null
@@ -1,131 +0,0 @@
-
-Fotosizer Final Edition serials key
-
-If you are looking for a simple and effective way to resize and optimize your photos, you might want to try Fotosizer Final Edition serials key. This is a software that can help you batch resize hundreds of photos in a matter of minutes, with various options and features. In this article, we will tell you what Fotosizer Final Edition serials key is, how to download and install it, and what benefits it offers.
-Fotosizer Final Edition serials key
Download >>> https://gohhs.com/2uFTVB
-
-What is Fotosizer Final Edition serials key?
-
-Fotosizer Final Edition serials key is a software that can help you resize and optimize your photos in bulk. It lets you drag and drop your photos to the program, choose the desired size and quality, and apply various effects and adjustments. You can also add text and image watermarks, rotate and flip your photos, apply rounded corners, and more. Fotosizer Final Edition serials key can output your resized photos to a compressed ZIP file, or to a folder of your choice. You can also preview your photos before resizing them.
-
-Fotosizer Final Edition serials key is not a free software. You need to pay for a license to use it. However, some people look for Fotosizer Final Edition serials key crack, which is a way to bypass the activation process and use the software for free. However, this is not a legal or safe way to use the software. You might face some risks such as malware infection, data loss, legal issues, or poor performance if you use Fotosizer Final Edition serials key crack.
-
-How to Download and Install Fotosizer Final Edition serials key?
-
-If you want to download and install Fotosizer Final Edition serials key, you need to follow these steps:
-
-
-
-
-What are the Benefits of Fotosizer Final Edition serials key?
-
-By using Fotosizer Final Edition serials key, you can enjoy some benefits that can make your photo resizing and optimization easier and faster. Some of these benefits are:
-
-
-
-
-Conclusion
-
-Fotosizer Final Edition serials key is a software that can help you resize and optimize your photos in bulk. It lets you drag and drop your photos to the program, choose the desired size and quality, and apply various effects and adjustments. However, if you want to use it for free, you might be tempted to download Fotosizer Final Edition serials key crack, which is a way to bypass the activation process and use the software without paying for a license. However, this is not a legal or safe way to use the software. You might face some risks such as malware infection, data loss, legal issues, or poor performance if you use Fotosizer Final Edition serials key crack. Therefore, we recommend that you buy a license from the official website of Fotosizer. This way, you can get regular updates, technical support, and security protection from Fotosizer.
-
-How to Use Fotosizer Final Edition serials key?
-
-After you have downloaded and installed Fotosizer Final Edition serials key, you can start using it to resize and optimize your photos. Here are some steps that you can follow to use the software:
-
-
-
-
-How to Uninstall Fotosizer Final Edition serials key?
-
-If you want to uninstall Fotosizer Final Edition serials key, you can follow these steps:
-
-
-
-
-How to Get Fotosizer Final Edition Legally and Safely?
-
-If you want to get Fotosizer Final Edition legally and safely, you should buy a license from the official website of Fotosizer. This way, you can get the following benefits:
-
-
-
-
-To buy a license for Fotosizer Final Edition, you can visit this link: https://www.fotosizer.com/Buy.aspx
-What are the Alternatives to Fotosizer Final Edition serials key?
-
-If you are not satisfied with Fotosizer Final Edition serials key, or if you want to try some other photo resizing and optimization software that are free and reliable, you can check out some of these alternatives:
-
-
-
-
-Conclusion
-
-Fotosizer Final Edition serials key is a software that can help you resize and optimize your photos in bulk. It lets you drag and drop your photos to the program, choose the desired size and quality, and apply various effects and adjustments. However, if you want to use it for free, you might be tempted to download Fotosizer Final Edition serials key crack, which is a way to bypass the activation process and use the software without paying for a license. However, this is not a legal or safe way to use the software. You might face some risks such as malware infection, data loss, legal issues, or poor performance if you use Fotosizer Final Edition serials key crack. Therefore, we recommend that you buy a license from the official website of Fotosizer. This way, you can get regular updates, technical support, and security protection from Fotosizer. You can also try some alternatives to Fotosizer Final Edition serials key that are free and reliable, such as FastStone Photo Resizer, Image Resizer for Windows, or IrfanView.
-How to Use Fotosizer Final Edition serials key?
-
-After you have downloaded and installed Fotosizer Final Edition serials key, you can start using it to resize and optimize your photos. Here are some steps that you can follow to use the software:
-
-
-
-
-How to Uninstall Fotosizer Final Edition serials key?
-
-If you want to uninstall Fotosizer Final Edition serials key, you can follow these steps:
-
-
-
-
-How to Get Fotosizer Final Edition Legally and Safely?
-
-If you want to get Fotosizer Final Edition legally and safely, you should buy a license from the official website of Fotosizer. This way, you can get the following benefits:
-
-
-
-
-To buy a license for Fotosizer Final Edition, you can visit this link: https://www.fotosizer.com/Buy.aspx
-Fotosizer Final Edition serials key is a software that can help you resize and optimize your photos in bulk. It lets you drag and drop your photos to the program, choose the desired size and quality, and apply various effects and adjustments. However, if you want to use it for free, you might be tempted to download Fotosizer Final Edition serials key crack, which is a way to bypass the activation process and use the software without paying for a license. However, this is not a legal or safe way to use the software. You might face some risks such as malware infection, data loss, legal issues, or poor performance if you use Fotosizer Final Edition serials key crack. Therefore, we recommend that you buy a license from the official website of Fotosizer. This way, you can get regular updates, technical support, and security protection from Fotosizer. You can also try some alternatives to Fotosizer Final Edition serials key that are free and reliable, such as FastStone Photo Resizer, Image Resizer for Windows, or IrfanView.
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/diacanFperku/AutoGPT/Ls Land Anya Forbidden Fruit [UPDATED].md b/spaces/diacanFperku/AutoGPT/Ls Land Anya Forbidden Fruit [UPDATED].md
deleted file mode 100644
index 35fd3f53746c07db792551663f60d24b22c5e100..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Ls Land Anya Forbidden Fruit [UPDATED].md
+++ /dev/null
@@ -1,36 +0,0 @@
-Ls Land Anya Forbidden Fruit
Download Zip ⏩ https://gohhs.com/2uFUZO
-
-Ls Land Anya Forbidden Fruit 1288d90c24 16, 2021 n Ls Land Anya Forbid Activation Torrent Build Full. Forbidden Fruit provides a home for musical and artistic takeovers from all over the . so that OSPF routers can direct traffic to that destination. The local router uses an IP address to advertise a link to the remote router. The local router may advertise the link using multiple IP addresses, either in a unicast or multicast format.
-
-IP unicast sends packets only to a single destination. IP multicast sends packets to more than one destination. In a multicast packet, each IP packet contains information to be received by multiple, destination nodes. IP multicast requires IP Group Address identification in the destination field of a packet so that a switch can direct a packet to the group address. IP multicast is a broadcast protocol and only one destination address is specified in a packet; therefore, it is used for broadcasting information to all nodes in the network, including the destination.
-
-In a multi-homed network, however, IP multicast is not useful. A packet destined for a group address is sent out all interfaces and the packet will arrive at all network nodes. The destination node that is not the node to which the packet is destined will discard the packet. It is therefore desirable to provide an improved method for multicast communications in a multi-homed network.Q:
-
-json parse error in IE8
-
-Trying to parse JSON to handle IE8 compatibility issue with json parsing but getting error.
-
-getData: function (name)
-
- return this.ajax(
-
- type: "GET",
-
- url: "json/",
-
- dataType: "json",
-
- timeout: 15000
-
- );
-
- ,
-
-"records":[["abc","12"],["pqr","13"]]
-
-the json string is coming from external source. json is working fine in chrome but not in IE8.
-
-Error is Uncaught Error 4fefd39f24
-
-
-
diff --git a/spaces/diacanFperku/AutoGPT/Progress Openedge 102b Serial.md b/spaces/diacanFperku/AutoGPT/Progress Openedge 102b Serial.md
deleted file mode 100644
index 8584380f7ef10e7db3a7d21dc338ae29f04810bd..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Progress Openedge 102b Serial.md
+++ /dev/null
@@ -1,41 +0,0 @@
-
-How to Find and Use Your Progress Openedge 102b Serial Number
-Progress Openedge is a powerful and reliable platform for developing and deploying mission-critical business applications. If you have purchased a license for Progress Openedge 102b, you will need to find and use your serial number to activate and register your product.
-A serial number is a unique alphanumeric code that identifies your product and its license type. You can find your serial number in one of the following ways:
-Progress Openedge 102b Serial
Download File ✦ https://gohhs.com/2uFT7b
-
-
-To use your serial number, you need to enter it during the installation process or when prompted by the product activation wizard. The serial number will be validated and registered with Progress, and you will be able to access all the features and benefits of your licensed product.
-If you have any questions or issues regarding your serial number or product activation, please contact Progress Customer Support at 1-800-477-6473 or visit https://www.progress.com/support.
-
-Progress Openedge 102b is a comprehensive and integrated platform that offers a range of features and benefits for developing and deploying business applications. Some of the key features of Progress Openedge 102b are:
-
-
-With Progress Openedge 102b, you can leverage the power and flexibility of the Openedge platform to create and deliver innovative and competitive business solutions.
-
-Progress Openedge 102b is not only a powerful platform, but also a reliable and secure one. Progress Openedge 102b supports data encryption, authentication, authorization, auditing, and backup and recovery features to ensure the safety and integrity of your data and applications. You can also leverage the Progress OpenEdge Transparent Data Encryption (TDE) feature to encrypt your data at rest without requiring any application changes.
-Progress Openedge 102b is also a platform that has been trusted and recommended by many customers across various industries and regions. According to Gartner Peer Insights, Progress Openedge has received an average rating of 4.5 out of 5 stars from 21 reviews as of January 2023. Customers have praised Progress Openedge for its performance, scalability, stability, ease of use, and support. Some of the customer testimonials are:
-
-"Progress is our competitive advantage! Progress has provided an excellent reliable and cost effective environment to run our company's DB needs since 1991."
-Software Industry
-
-
-"OpenEdge allows us to be agile. We can quickly develop and deploy new features and functionality to meet our customers' needs."
-
-Manufacturing Industry
-
-
-"OpenEdge is a great platform for building and running mission-critical applications. It has a rich set of features and tools that enable us to create high-quality solutions."
-Services Industry
-
-If you are looking for a platform that can help you create and deliver innovative and competitive business solutions, Progress Openedge 102b is the right choice for you.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/djillegal/illegal_stable_img2img/app.py b/spaces/djillegal/illegal_stable_img2img/app.py
deleted file mode 100644
index e731bfa328413a320e408db786d87b7b767f6de6..0000000000000000000000000000000000000000
--- a/spaces/djillegal/illegal_stable_img2img/app.py
+++ /dev/null
@@ -1,67 +0,0 @@
-import gradio as gr
-import torch
-#from torch import autocast // only for GPU
-
-from PIL import Image
-import numpy as np
-from io import BytesIO
-import os
-MY_SECRET_TOKEN=os.environ.get('HF_TOKEN_SD')
-
-#from diffusers import StableDiffusionPipeline
-from diffusers import StableDiffusionImg2ImgPipeline
-
-print("hello sylvain")
-
-YOUR_TOKEN=MY_SECRET_TOKEN
-
-device="cpu"
-
-#prompt_pipe = StableDiffusionPipeline.from_pretrained("CompVis/stable-diffusion-v1-4", use_auth_token=YOUR_TOKEN)
-#prompt_pipe.to(device)
-
-img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", use_auth_token=YOUR_TOKEN)
-img_pipe.to(device)
-
-source_img = gr.Image(source="upload", type="filepath", label="init_img | 512*512 px")
-gallery = gr.Gallery(label="Generated images", show_label=False, elem_id="gallery").style(grid=[1], height="auto")
-
-def resize(value,img):
- #baseheight = value
- img = Image.open(img)
- #hpercent = (baseheight/float(img.size[1]))
- #wsize = int((float(img.size[0])*float(hpercent)))
- #img = img.resize((wsize,baseheight), Image.Resampling.LANCZOS)
- img = img.resize((value,value), Image.Resampling.LANCZOS)
- return img
-
-
-def infer(source_img, prompt, guide, steps, seed, strength):
- generator = torch.Generator('cpu').manual_seed(seed)
-
- source_image = resize(512, source_img)
- source_image.save('source.png')
-
- images_list = img_pipe([prompt] * 1, init_image=source_image, strength=strength, guidance_scale=guide, num_inference_steps=steps)
- images = []
- safe_image = Image.open(r"unsafe.png")
-
- for i, image in enumerate(images_list["images"]):
- if(images_list["nsfw_content_detected"][i]):
- images.append(safe_image)
- else:
- images.append(image)
- return images
-
-print("Great sylvain ! Everything is working fine !")
-
-title="Img2Img Stable Diffusion CPU"
-description="Img2Img .
Warning: Slow process... ~5/10 min inference time. Please maske sure the image resolution is 512*512 px [NSFW filter enabled.]
"
-
-gr.Interface(fn=infer, inputs=[source_img,
- "text",
- gr.Slider(2, 15, value = 7, label = 'Guidence Scale'),
- gr.Slider(10, 50, value = 25, step = 1, label = 'Number of Iterations'),
- gr.Slider(label = "Seed", minimum = 0, maximum = 2147483647, step = 1, randomize = True),
- gr.Slider(label='Strength', minimum = 0, maximum = 1, step = .05, value = .75)],
- outputs=gallery,title=title,description=description, allow_flagging="manual", flagging_dir="flagged").queue(max_size=100).launch(enable_queue=True)
\ No newline at end of file
diff --git a/spaces/dmeck/RVC-Speakers/vits/monotonic_align/setup.py b/spaces/dmeck/RVC-Speakers/vits/monotonic_align/setup.py
deleted file mode 100644
index 1212a234a61fef403ed4600e6b80b4f28a8be0c5..0000000000000000000000000000000000000000
--- a/spaces/dmeck/RVC-Speakers/vits/monotonic_align/setup.py
+++ /dev/null
@@ -1,9 +0,0 @@
-from distutils.core import setup
-from Cython.Build import cythonize
-import numpy
-
-setup(
- name='monotonic_align',
- ext_modules=cythonize("core.pyx"),
- include_dirs=[numpy.get_include()]
-)
diff --git a/spaces/dongyi/MMFS/tools/test_export_video_groups.py b/spaces/dongyi/MMFS/tools/test_export_video_groups.py
deleted file mode 100644
index 40ded011dff06cffb6491567dc745a4c67afd93f..0000000000000000000000000000000000000000
--- a/spaces/dongyi/MMFS/tools/test_export_video_groups.py
+++ /dev/null
@@ -1,139 +0,0 @@
-import os, sys, cv2, subprocess
-import yaml, shutil
-from tqdm import tqdm
-from multiprocessing import Process, Pool
-from tools.concat_images_or_videos import ConcatVideos, default_concat_mapping, default_model_postfix_mapping
-
-def revise_yaml_config(yaml_folder, save_img_folder, save_yaml_folder, gpu):
-
- yaml_config = yaml.safe_load(open(yaml_folder, "r"))
- yaml_config["common"]["gpu_ids"] = list(map(int, gpu.split()))
- yaml_config["testing"]["results_dir"] = save_img_folder
- yaml_config["dataset"]["data_type"] = ['paired']
- t_yaml_folder = os.path.join(save_yaml_folder, yaml_folder.split('/')[-1])
- yaml.safe_dump(yaml_config, open(t_yaml_folder, "w"), default_flow_style=False)
-
-
-def run_test_single_process(gpu_ids_list, yaml_list, test_folder_list, ckpt_list):
-
- assert len(gpu_ids_list) == len(yaml_list)
- assert len(gpu_ids_list) == len(test_folder_list)
- assert len(gpu_ids_list) == len(ckpt_list)
-
- total_single_process_number = len(gpu_ids_list)
-
- for process_idx in range(total_single_process_number):
- t_gpu_ids = gpu_ids_list[process_idx]
- t_yaml = yaml_list[process_idx]
- t_test_folder = test_folder_list[process_idx]
- t_ckpt = ckpt_list[process_idx]
-
- print("python3 -u test.py " + \
- " --cfg_file " + t_yaml + \
- " --test_video " + t_test_folder + \
- " --ckpt " + t_ckpt)
- p = subprocess.Popen("python3 -u test.py " + \
- " --cfg_file " + t_yaml + \
- " --test_video " + t_test_folder + \
- " --ckpt " + t_ckpt, shell=True)
- p.wait()
- print("finish " + t_yaml.split('/')[-1])
-
-
-def concat_videos(save_folder_list):
-
- concat_videos_manager = ConcatVideos()
- total_save_folder_number = len(save_folder_list)
-
- print("export_list:\n", "\n".join(map(str, export_list)))
- t_export_name_list = [str(export_list[t_idx]["export_name"]) for t_idx in range(total_save_folder_number)]
- t_export_name_list = [concat_ori_video_name] + t_export_name_list
-
- t_export_video_path = [concat_ori_video_path] + [os.path.join(save_folder_list[i], 'fake_B.mp4') for i in range(total_save_folder_number)]
-
- assert len(t_export_name_list) == len(t_export_video_path), "Not match len(video_numbers) and len(video_names)"
-
- concat_videos_manager.run_concat_videos(concat_save_video_path, t_export_video_path, t_export_name_list, *default_concat_mapping[total_save_folder_number + 1], flag_readd_video_name)
-
-
-def run():
- # init env
- os.makedirs(save_yaml_folder, exist_ok=True)
- shutil.rmtree(save_yaml_folder)
- os.makedirs(save_yaml_folder, exist_ok=True)
-
- t_gpu_list = [[] for t_idx in range(gpu_number)]
- t_yaml_folder_list = [[] for t_idx in range(gpu_number)]
- t_test_folder_list = [[] for t_idx in range(gpu_number)]
- t_ckpt_list = [[] for t_idx in range(gpu_number)]
- t_concat_folder_list = []
-
- # Load yaml config
- export_number = len(export_list)
- for t_idx in range(export_number):
- t_gpu = str(gpu_ids[t_idx % gpu_number])
- t_yaml_folder = str(export_list[t_idx]["export_yaml"])
- t_ckpt = str(export_list[t_idx]["export_ckpt"])
-
- t_test_type = str(export_list[t_idx]["export_test_type"])
- t_test_folder = str(globals()["test_" + t_test_type + "_data_path"])
- t_save_folder_root = str(export_list[t_idx]["export_save_folder"])
-
- t_yaml_config = yaml.safe_load(open(t_yaml_folder, "r"))
- t_export_exp_name = t_yaml_config["common"]["name"]
-
- t_save_folder = os.path.join(t_save_folder_root, t_export_exp_name, t_export_exp_name)
-
-
- t_flag_concat_videos = export_list[t_idx]["export_flag_concat"]
- if t_flag_concat_videos == True:
- t_concat_folder_list += [t_save_folder]
-
- t_generate = export_list[t_idx]["export_flag_generate"]
-
- assert t_generate == True or t_generate == False, "Error generate type..."
- print(t_generate, type(t_generate))
- if t_generate == True:
- os.makedirs(t_save_folder, exist_ok=True)
- shutil.rmtree(t_save_folder)
- os.makedirs(t_save_folder, exist_ok=True)
- revise_yaml_config(t_yaml_folder, t_save_folder_root, save_yaml_folder, t_gpu)
- t_yaml_folder = os.path.join(save_yaml_folder, t_yaml_folder.split('/')[-1])
-
- t_gpu_list[t_idx % gpu_number] += [t_gpu]
- t_yaml_folder_list[t_idx % gpu_number] += [t_yaml_folder]
- t_test_folder_list[t_idx % gpu_number] += [t_test_folder]
- t_ckpt_list[t_idx % gpu_number] += [t_ckpt]
- else:
- assert os.path.isdir(t_save_folder) and len(os.listdir(t_save_folder)) != 0, "No files in {}".format("%s"%t_save_folder)
-
- print("begin export videos...")
- # Multi-process inference
- p = Pool(export_number)
- for gpu_idx in range(gpu_number):
- p.apply_async(run_test_single_process, args=(t_gpu_list[gpu_idx],
- t_yaml_folder_list[gpu_idx],
- t_test_folder_list[gpu_idx],
- t_ckpt_list[gpu_idx]))
-
- p.close()
- p.join()
- print("finish export videos...")
-
- if flag_concat_videos == True:
- print("begin concat {} videos...".format("%d"%(len(t_concat_folder_list) + 1)))
- concat_videos(t_concat_folder_list)
- print("finish concat videos...")
-
- print("finish all process steps...")
-
-
-if __name__ == '__main__':
-
- yaml_path = sys.argv[1]
-
- config = yaml.safe_load(open(yaml_path))
- for k, v in config.items():
- globals()[k] = v
-
- run()
diff --git a/spaces/dorkai/ChatUIPro/app/components/header.tsx b/spaces/dorkai/ChatUIPro/app/components/header.tsx
deleted file mode 100644
index 2513696706e74b9425e97ff09dc8e8ef5df28eca..0000000000000000000000000000000000000000
--- a/spaces/dorkai/ChatUIPro/app/components/header.tsx
+++ /dev/null
@@ -1,48 +0,0 @@
-import type { FC } from 'react'
-import React from 'react'
-import {
- Bars3Icon,
- PencilSquareIcon,
-} from '@heroicons/react/24/solid'
-import AppIcon from '@/app/components/base/app-icon'
-export type IHeaderProps = {
- title: string
- isMobile?: boolean
- onShowSideBar?: () => void
- onCreateNewChat?: () => void
-}
-const Header: FC = ({
- title,
- isMobile,
- onShowSideBar,
- onCreateNewChat,
-}) => {
- return (
-
- {isMobile
- ? (
- onShowSideBar?.()}
- >
- Charlie And The Chocolate Factory Full Movie Download Youtubeinstmankl
Download Zip ✏ https://urlca.com/2uDcZP
-
-html. A Film on, Charlie And The Chocolate Factory full movie download [Hello Guest] - Xvidtodvdmov - HD videosean7 - xvidtodvdmov. O filme de Charlie And The Chocolate Factory de Roald Dahl está disponível online para baixar. Apele, provavelmente, para ver o trailer para assistir ao filme!
-
-[image] Charlie And The Chocolate Factory Full Movie Download Youtubeinstmankl - DOWNLOAD com/stories/3076124-dil-maange-more.html. Charlie And The Chocolate Factory - Phil DeFranco - The Unbelievable - Phil DeFranco. Charlie And The Chocolate Factory é uma animação produzida pela Warner Brothers e está disponível para baixar em vídeo, DVD, Blu-ray e stream tanto para download de fonte, como para streaming do vídeo.
-
-[image] Charlie And The Chocolate Factory Full Movie Download Youtubeinstmankl - DOWNLOAD com/stories/3076124-dil-maange-more.html. Charlie And The Chocolate Factory filme. Charlie and the Chocolate Factory, pelo cineasta de origem australiana Andrew Adamson, chega ao Brasil com as primeiras adaptações do filme original: da realizadora belga The Girl With The Pearl Earring para a Playstation, e da Tim Burton, da Disney, para a Playstation.
-
-[image] Charlie And The Chocolate Factory Full Movie Download Youtubeinstmankl - DOWNLOAD com/stories/3076124-dil-maange-more.html. Charlie And The Chocolate Factory filme. Charlie and the Chocolate Factory, produto da Warner Brothers, o filme chega ao Brasil com a estreia do Tim Burton pelo Sony e da Belle Diniz, da Disney, no Netflix.
-
-[image] Charlie And The Chocolate Factory Full Movie Download Youtubeinstmankl - DOWNLOAD com/stories/3076124-dil-maange-more.html. O filme estreia na Netflix e até o dia da estreia oficial da Disney, o filme já estava disponível para download de fonte no iTunes e para streaming de vídeo na Apple TV.
-
-[ 4fefd39f24
-
-
-
diff --git a/spaces/falterWliame/Face_Mask_Detection/Easyplc Simulador Full Mega BEST.md b/spaces/falterWliame/Face_Mask_Detection/Easyplc Simulador Full Mega BEST.md
deleted file mode 100644
index 03bb13d3807947378e1d5d432bb8e2651ceacd25..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Easyplc Simulador Full Mega BEST.md
+++ /dev/null
@@ -1,6 +0,0 @@
-easyplc simulador full mega
Download Zip ► https://urlca.com/2uDdzO
-
-easyplc simulador full mega · Zindagi 5050 Tamil Dubbed Movies · Borderlands 2 GOTY [v1.8.2 46 DLC][2xDVD5] Repack Mr DJ Torrent 1fdad05405
-
-
-
diff --git a/spaces/fclong/summary/fengshen/examples/clue_sim/__init__.py b/spaces/fclong/summary/fengshen/examples/clue_sim/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/fengmuxi/ChatGpt-Web/app/components/mask.tsx b/spaces/fengmuxi/ChatGpt-Web/app/components/mask.tsx
deleted file mode 100644
index 095a56d015147fa0c162e0ace8b6a7aa65354818..0000000000000000000000000000000000000000
--- a/spaces/fengmuxi/ChatGpt-Web/app/components/mask.tsx
+++ /dev/null
@@ -1,448 +0,0 @@
-import { IconButton } from "./button";
-import { ErrorBoundary } from "./error";
-
-import styles from "./mask.module.scss";
-
-import DownloadIcon from "../icons/download.svg";
-import UploadIcon from "../icons/upload.svg";
-import EditIcon from "../icons/edit.svg";
-import AddIcon from "../icons/add.svg";
-import CloseIcon from "../icons/close.svg";
-import DeleteIcon from "../icons/delete.svg";
-import EyeIcon from "../icons/eye.svg";
-import CopyIcon from "../icons/copy.svg";
-
-import { DEFAULT_MASK_AVATAR, Mask, useMaskStore } from "../store/mask";
-import { Message, ModelConfig, ROLES, useChatStore } from "../store";
-import { Input, List, ListItem, Modal, Popover,Select } from "./ui-lib";
-import { Avatar, AvatarPicker } from "./emoji";
-import Locale, { AllLangs, Lang } from "../locales";
-import { useNavigate } from "react-router-dom";
-
-import chatStyle from "./chat.module.scss";
-import { useState } from "react";
-import { downloadAs, readFromFile } from "../utils";
-import { Updater } from "../api/openai/typing";
-import { ModelConfigList } from "./model-config";
-import { FileName, Path } from "../constant";
-import { BUILTIN_MASK_STORE } from "../masks";
-
-export function MaskAvatar(props: { mask: Mask }) {
- return props.mask.avatar !== DEFAULT_MASK_AVATAR ? (
- ;
- extraListItems?: JSX.Element;
- readonly?: boolean;
-}) {
- const [showPicker, setShowPicker] = useState(false);
-
- const updateConfig = (updater: (config: ModelConfig) => void) => {
- if (props.readonly) return;
-
- const config = { ...props.mask.modelConfig };
- updater(config);
- props.updateMask((mask) => (mask.modelConfig = config));
- };
-
- return (
- <>
- {
- const context = props.mask.context.slice();
- updater(context);
- props.updateMask((mask) => (mask.context = context));
- }}
- />
-
-
-
- {
- props.updateMask((mask) => (mask.avatar = emoji));
- setShowPicker(false);
- }}
- >
- }
- open={showPicker}
- onClose={() => setShowPicker(false)}
- >
- setShowPicker(true)}
- style={{ cursor: "pointer" }}
- >
-
-
-
-
- props.updateMask((mask) => (mask.name = e.currentTarget.value))
- }
- >
-
-
-
-
-
-
- );
-}
-
-function ContextPromptItem(props: {
- prompt: Message;
- update: (prompt: Message) => void;
- remove: () => void;
-}) {
- const [focusingInput, setFocusingInput] = useState(false);
-
- return (
-
- {!focusingInput && (
-
- )}
- setFocusingInput(true)}
- onBlur={() => setFocusingInput(false)}
- onInput={(e) =>
- props.update({
- ...props.prompt,
- content: e.currentTarget.value as any,
- })
- }
- />
- {!focusingInput && (
- updateContextPrompt(i, prompt)}
- remove={() => removeContextPrompt(i)}
- />
- ))}
-
-
-
-
- );
-}
-
-export function MaskPage() {
- const navigate = useNavigate();
-
- const maskStore = useMaskStore();
- const chatStore = useChatStore();
-
- const [filterLang, setFilterLang] = useState();
-
- const allMasks = maskStore
- .getAll()
- .filter((m) => !filterLang || m.lang === filterLang);
-
- const [searchMasks, setSearchMasks] = useState([]);
- const [searchText, setSearchText] = useState("");
- const masks = searchText.length > 0 ? searchMasks : allMasks;
-
- // simple search, will refactor later
- const onSearch = (text: string) => {
- setSearchText(text);
- if (text.length > 0) {
- const result = allMasks.filter((m) => m.name.includes(text));
- setSearchMasks(result);
- } else {
- setSearchMasks(allMasks);
- }
- };
-
- const [editingMaskId, setEditingMaskId] = useState();
- const editingMask =
- maskStore.get(editingMaskId) ?? BUILTIN_MASK_STORE.get(editingMaskId);
- const closeMaskModal = () => setEditingMaskId(undefined);
-
- const downloadAll = () => {
- downloadAs(JSON.stringify(masks), FileName.Masks);
- };
-
- const importFromFile = () => {
- readFromFile().then((content) => {
- try {
- const importMasks = JSON.parse(content);
- if (Array.isArray(importMasks)) {
- for (const mask of importMasks) {
- if (mask.name) {
- maskStore.create(mask);
- }
- }
- return;
- }
- //if the content is a single mask.
- if (importMasks.name) {
- maskStore.create(importMasks);
- }
- } catch {}
- });
- };
-
- return (
-
-
-
-
-
- {Locale.Mask.Page.Title}
-
-
- {Locale.Mask.Page.SubTitle(allMasks.length)}
-
-
-
-
-
-
- maskStore.update(editingMaskId!, updater)
- }
- readonly={editingMask.builtin}
- />
-
-
- )}
-
- );
-}
diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/assert/strict.d.ts b/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/assert/strict.d.ts
deleted file mode 100644
index b4319b974861f6cad84b745485af55264b13c3d8..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/assert/strict.d.ts
+++ /dev/null
@@ -1,8 +0,0 @@
-declare module 'assert/strict' {
- import { strict } from 'node:assert';
- export = strict;
-}
-declare module 'node:assert/strict' {
- import { strict } from 'node:assert';
- export = strict;
-}
diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/ipaddr.js/README.md b/spaces/fffiloni/controlnet-animation-doodle/node_modules/ipaddr.js/README.md
deleted file mode 100644
index f57725b0fed3b74b2ed13d99c0fe8ee65ab29f3c..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/ipaddr.js/README.md
+++ /dev/null
@@ -1,233 +0,0 @@
-# ipaddr.js — an IPv6 and IPv4 address manipulation library [](https://travis-ci.org/whitequark/ipaddr.js)
-
-ipaddr.js is a small (1.9K minified and gzipped) library for manipulating
-IP addresses in JavaScript environments. It runs on both CommonJS runtimes
-(e.g. [nodejs]) and in a web browser.
-
-ipaddr.js allows you to verify and parse string representation of an IP
-address, match it against a CIDR range or range list, determine if it falls
-into some reserved ranges (examples include loopback and private ranges),
-and convert between IPv4 and IPv4-mapped IPv6 addresses.
-
-[nodejs]: http://nodejs.org
-
-## Installation
-
-`npm install ipaddr.js`
-
-or
-
-`bower install ipaddr.js`
-
-## API
-
-ipaddr.js defines one object in the global scope: `ipaddr`. In CommonJS,
-it is exported from the module:
-
-```js
-var ipaddr = require('ipaddr.js');
-```
-
-The API consists of several global methods and two classes: ipaddr.IPv6 and ipaddr.IPv4.
-
-### Global methods
-
-There are three global methods defined: `ipaddr.isValid`, `ipaddr.parse` and
-`ipaddr.process`. All of them receive a string as a single parameter.
-
-The `ipaddr.isValid` method returns `true` if the address is a valid IPv4 or
-IPv6 address, and `false` otherwise. It does not throw any exceptions.
-
-The `ipaddr.parse` method returns an object representing the IP address,
-or throws an `Error` if the passed string is not a valid representation of an
-IP address.
-
-The `ipaddr.process` method works just like the `ipaddr.parse` one, but it
-automatically converts IPv4-mapped IPv6 addresses to their IPv4 counterparts
-before returning. It is useful when you have a Node.js instance listening
-on an IPv6 socket, and the `net.ivp6.bindv6only` sysctl parameter (or its
-equivalent on non-Linux OS) is set to 0. In this case, you can accept IPv4
-connections on your IPv6-only socket, but the remote address will be mangled.
-Use `ipaddr.process` method to automatically demangle it.
-
-### Object representation
-
-Parsing methods return an object which descends from `ipaddr.IPv6` or
-`ipaddr.IPv4`. These objects share some properties, but most of them differ.
-
-#### Shared properties
-
-One can determine the type of address by calling `addr.kind()`. It will return
-either `"ipv6"` or `"ipv4"`.
-
-An address can be converted back to its string representation with `addr.toString()`.
-Note that this method:
- * does not return the original string used to create the object (in fact, there is
- no way of getting that string)
- * returns a compact representation (when it is applicable)
-
-A `match(range, bits)` method can be used to check if the address falls into a
-certain CIDR range.
-Note that an address can be (obviously) matched only against an address of the same type.
-
-For example:
-
-```js
-var addr = ipaddr.parse("2001:db8:1234::1");
-var range = ipaddr.parse("2001:db8::");
-
-addr.match(range, 32); // => true
-```
-
-Alternatively, `match` can also be called as `match([range, bits])`. In this way,
-it can be used together with the `parseCIDR(string)` method, which parses an IP
-address together with a CIDR range.
-
-For example:
-
-```js
-var addr = ipaddr.parse("2001:db8:1234::1");
-
-addr.match(ipaddr.parseCIDR("2001:db8::/32")); // => true
-```
-
-A `range()` method returns one of predefined names for several special ranges defined
-by IP protocols. The exact names (and their respective CIDR ranges) can be looked up
-in the source: [IPv6 ranges] and [IPv4 ranges]. Some common ones include `"unicast"`
-(the default one) and `"reserved"`.
-
-You can match against your own range list by using
-`ipaddr.subnetMatch(address, rangeList, defaultName)` method. It can work with a mix of IPv6 or IPv4 addresses, and accepts a name-to-subnet map as the range list. For example:
-
-```js
-var rangeList = {
- documentationOnly: [ ipaddr.parse('2001:db8::'), 32 ],
- tunnelProviders: [
- [ ipaddr.parse('2001:470::'), 32 ], // he.net
- [ ipaddr.parse('2001:5c0::'), 32 ] // freenet6
- ]
-};
-ipaddr.subnetMatch(ipaddr.parse('2001:470:8:66::1'), rangeList, 'unknown'); // => "tunnelProviders"
-```
-
-The addresses can be converted to their byte representation with `toByteArray()`.
-(Actually, JavaScript mostly does not know about byte buffers. They are emulated with
-arrays of numbers, each in range of 0..255.)
-
-```js
-var bytes = ipaddr.parse('2a00:1450:8007::68').toByteArray(); // ipv6.google.com
-bytes // => [42, 0x00, 0x14, 0x50, 0x80, 0x07, 0x00, , 0x00, 0x68 ]
-```
-
-The `ipaddr.IPv4` and `ipaddr.IPv6` objects have some methods defined, too. All of them
-have the same interface for both protocols, and are similar to global methods.
-
-`ipaddr.IPvX.isValid(string)` can be used to check if the string is a valid address
-for particular protocol, and `ipaddr.IPvX.parse(string)` is the error-throwing parser.
-
-`ipaddr.IPvX.isValid(string)` uses the same format for parsing as the POSIX `inet_ntoa` function, which accepts unusual formats like `0xc0.168.1.1` or `0x10000000`. The function `ipaddr.IPv4.isValidFourPartDecimal(string)` validates the IPv4 address and also ensures that it is written in four-part decimal format.
-
-[IPv6 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L186
-[IPv4 ranges]: https://github.com/whitequark/ipaddr.js/blob/master/src/ipaddr.coffee#L71
-
-#### IPv6 properties
-
-Sometimes you will want to convert IPv6 not to a compact string representation (with
-the `::` substitution); the `toNormalizedString()` method will return an address where
-all zeroes are explicit.
-
-For example:
-
-```js
-var addr = ipaddr.parse("2001:0db8::0001");
-addr.toString(); // => "2001:db8::1"
-addr.toNormalizedString(); // => "2001:db8:0:0:0:0:0:1"
-```
-
-The `isIPv4MappedAddress()` method will return `true` if this address is an IPv4-mapped
-one, and `toIPv4Address()` will return an IPv4 object address.
-
-To access the underlying binary representation of the address, use `addr.parts`.
-
-```js
-var addr = ipaddr.parse("2001:db8:10::1234:DEAD");
-addr.parts // => [0x2001, 0xdb8, 0x10, 0, 0, 0, 0x1234, 0xdead]
-```
-
-A IPv6 zone index can be accessed via `addr.zoneId`:
-
-```js
-var addr = ipaddr.parse("2001:db8::%eth0");
-addr.zoneId // => 'eth0'
-```
-
-#### IPv4 properties
-
-`toIPv4MappedAddress()` will return a corresponding IPv4-mapped IPv6 address.
-
-To access the underlying representation of the address, use `addr.octets`.
-
-```js
-var addr = ipaddr.parse("192.168.1.1");
-addr.octets // => [192, 168, 1, 1]
-```
-
-`prefixLengthFromSubnetMask()` will return a CIDR prefix length for a valid IPv4 netmask or
-null if the netmask is not valid.
-
-```js
-ipaddr.IPv4.parse('255.255.255.240').prefixLengthFromSubnetMask() == 28
-ipaddr.IPv4.parse('255.192.164.0').prefixLengthFromSubnetMask() == null
-```
-
-`subnetMaskFromPrefixLength()` will return an IPv4 netmask for a valid CIDR prefix length.
-
-```js
-ipaddr.IPv4.subnetMaskFromPrefixLength(24) == "255.255.255.0"
-ipaddr.IPv4.subnetMaskFromPrefixLength(29) == "255.255.255.248"
-```
-
-`broadcastAddressFromCIDR()` will return the broadcast address for a given IPv4 interface and netmask in CIDR notation.
-```js
-ipaddr.IPv4.broadcastAddressFromCIDR("172.0.0.1/24") == "172.0.0.255"
-```
-`networkAddressFromCIDR()` will return the network address for a given IPv4 interface and netmask in CIDR notation.
-```js
-ipaddr.IPv4.networkAddressFromCIDR("172.0.0.1/24") == "172.0.0.0"
-```
-
-#### Conversion
-
-IPv4 and IPv6 can be converted bidirectionally to and from network byte order (MSB) byte arrays.
-
-The `fromByteArray()` method will take an array and create an appropriate IPv4 or IPv6 object
-if the input satisfies the requirements. For IPv4 it has to be an array of four 8-bit values,
-while for IPv6 it has to be an array of sixteen 8-bit values.
-
-For example:
-```js
-var addr = ipaddr.fromByteArray([0x7f, 0, 0, 1]);
-addr.toString(); // => "127.0.0.1"
-```
-
-or
-
-```js
-var addr = ipaddr.fromByteArray([0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1])
-addr.toString(); // => "2001:db8::1"
-```
-
-Both objects also offer a `toByteArray()` method, which returns an array in network byte order (MSB).
-
-For example:
-```js
-var addr = ipaddr.parse("127.0.0.1");
-addr.toByteArray(); // => [0x7f, 0, 0, 1]
-```
-
-or
-
-```js
-var addr = ipaddr.parse("2001:db8::1");
-addr.toByteArray(); // => [0x20, 1, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
-```
diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/qs/README.md b/spaces/fffiloni/controlnet-animation-doodle/node_modules/qs/README.md
deleted file mode 100644
index 11be8531dd587984a378408c61dee80057842c63..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/qs/README.md
+++ /dev/null
@@ -1,625 +0,0 @@
-# qs [![Version Badge][npm-version-svg]][package-url]
-
-[![github actions][actions-image]][actions-url]
-[![coverage][codecov-image]][codecov-url]
-[![dependency status][deps-svg]][deps-url]
-[![dev dependency status][dev-deps-svg]][dev-deps-url]
-[![License][license-image]][license-url]
-[![Downloads][downloads-image]][downloads-url]
-
-[![npm badge][npm-badge-png]][package-url]
-
-A querystring parsing and stringifying library with some added security.
-
-Lead Maintainer: [Jordan Harband](https://github.com/ljharb)
-
-The **qs** module was originally created and maintained by [TJ Holowaychuk](https://github.com/visionmedia/node-querystring).
-
-## Usage
-
-```javascript
-var qs = require('qs');
-var assert = require('assert');
-
-var obj = qs.parse('a=c');
-assert.deepEqual(obj, { a: 'c' });
-
-var str = qs.stringify(obj);
-assert.equal(str, 'a=c');
-```
-
-### Parsing Objects
-
-[](#preventEval)
-```javascript
-qs.parse(string, [options]);
-```
-
-**qs** allows you to create nested objects within your query strings, by surrounding the name of sub-keys with square brackets `[]`.
-For example, the string `'foo[bar]=baz'` converts to:
-
-```javascript
-assert.deepEqual(qs.parse('foo[bar]=baz'), {
- foo: {
- bar: 'baz'
- }
-});
-```
-
-When using the `plainObjects` option the parsed value is returned as a null object, created via `Object.create(null)` and as such you should be aware that prototype methods will not exist on it and a user may set those names to whatever value they like:
-
-```javascript
-var nullObject = qs.parse('a[hasOwnProperty]=b', { plainObjects: true });
-assert.deepEqual(nullObject, { a: { hasOwnProperty: 'b' } });
-```
-
-By default parameters that would overwrite properties on the object prototype are ignored, if you wish to keep the data from those fields either use `plainObjects` as mentioned above, or set `allowPrototypes` to `true` which will allow user input to overwrite those properties. *WARNING* It is generally a bad idea to enable this option as it can cause problems when attempting to use the properties that have been overwritten. Always be careful with this option.
-
-```javascript
-var protoObject = qs.parse('a[hasOwnProperty]=b', { allowPrototypes: true });
-assert.deepEqual(protoObject, { a: { hasOwnProperty: 'b' } });
-```
-
-URI encoded strings work too:
-
-```javascript
-assert.deepEqual(qs.parse('a%5Bb%5D=c'), {
- a: { b: 'c' }
-});
-```
-
-You can also nest your objects, like `'foo[bar][baz]=foobarbaz'`:
-
-```javascript
-assert.deepEqual(qs.parse('foo[bar][baz]=foobarbaz'), {
- foo: {
- bar: {
- baz: 'foobarbaz'
- }
- }
-});
-```
-
-By default, when nesting objects **qs** will only parse up to 5 children deep. This means if you attempt to parse a string like
-`'a[b][c][d][e][f][g][h][i]=j'` your resulting object will be:
-
-```javascript
-var expected = {
- a: {
- b: {
- c: {
- d: {
- e: {
- f: {
- '[g][h][i]': 'j'
- }
- }
- }
- }
- }
- }
-};
-var string = 'a[b][c][d][e][f][g][h][i]=j';
-assert.deepEqual(qs.parse(string), expected);
-```
-
-This depth can be overridden by passing a `depth` option to `qs.parse(string, [options])`:
-
-```javascript
-var deep = qs.parse('a[b][c][d][e][f][g][h][i]=j', { depth: 1 });
-assert.deepEqual(deep, { a: { b: { '[c][d][e][f][g][h][i]': 'j' } } });
-```
-
-The depth limit helps mitigate abuse when **qs** is used to parse user input, and it is recommended to keep it a reasonably small number.
-
-For similar reasons, by default **qs** will only parse up to 1000 parameters. This can be overridden by passing a `parameterLimit` option:
-
-```javascript
-var limited = qs.parse('a=b&c=d', { parameterLimit: 1 });
-assert.deepEqual(limited, { a: 'b' });
-```
-
-To bypass the leading question mark, use `ignoreQueryPrefix`:
-
-```javascript
-var prefixed = qs.parse('?a=b&c=d', { ignoreQueryPrefix: true });
-assert.deepEqual(prefixed, { a: 'b', c: 'd' });
-```
-
-An optional delimiter can also be passed:
-
-```javascript
-var delimited = qs.parse('a=b;c=d', { delimiter: ';' });
-assert.deepEqual(delimited, { a: 'b', c: 'd' });
-```
-
-Delimiters can be a regular expression too:
-
-```javascript
-var regexed = qs.parse('a=b;c=d,e=f', { delimiter: /[;,]/ });
-assert.deepEqual(regexed, { a: 'b', c: 'd', e: 'f' });
-```
-
-Option `allowDots` can be used to enable dot notation:
-
-```javascript
-var withDots = qs.parse('a.b=c', { allowDots: true });
-assert.deepEqual(withDots, { a: { b: 'c' } });
-```
-
-If you have to deal with legacy browsers or services, there's
-also support for decoding percent-encoded octets as iso-8859-1:
-
-```javascript
-var oldCharset = qs.parse('a=%A7', { charset: 'iso-8859-1' });
-assert.deepEqual(oldCharset, { a: '§' });
-```
-
-Some services add an initial `utf8=✓` value to forms so that old
-Internet Explorer versions are more likely to submit the form as
-utf-8. Additionally, the server can check the value against wrong
-encodings of the checkmark character and detect that a query string
-or `application/x-www-form-urlencoded` body was *not* sent as
-utf-8, eg. if the form had an `accept-charset` parameter or the
-containing page had a different character set.
-
-**qs** supports this mechanism via the `charsetSentinel` option.
-If specified, the `utf8` parameter will be omitted from the
-returned object. It will be used to switch to `iso-8859-1`/`utf-8`
-mode depending on how the checkmark is encoded.
-
-**Important**: When you specify both the `charset` option and the
-`charsetSentinel` option, the `charset` will be overridden when
-the request contains a `utf8` parameter from which the actual
-charset can be deduced. In that sense the `charset` will behave
-as the default charset rather than the authoritative charset.
-
-```javascript
-var detectedAsUtf8 = qs.parse('utf8=%E2%9C%93&a=%C3%B8', {
- charset: 'iso-8859-1',
- charsetSentinel: true
-});
-assert.deepEqual(detectedAsUtf8, { a: 'ø' });
-
-// Browsers encode the checkmark as ✓ when submitting as iso-8859-1:
-var detectedAsIso8859_1 = qs.parse('utf8=%26%2310003%3B&a=%F8', {
- charset: 'utf-8',
- charsetSentinel: true
-});
-assert.deepEqual(detectedAsIso8859_1, { a: 'ø' });
-```
-
-If you want to decode the `&#...;` syntax to the actual character,
-you can specify the `interpretNumericEntities` option as well:
-
-```javascript
-var detectedAsIso8859_1 = qs.parse('a=%26%239786%3B', {
- charset: 'iso-8859-1',
- interpretNumericEntities: true
-});
-assert.deepEqual(detectedAsIso8859_1, { a: '☺' });
-```
-
-It also works when the charset has been detected in `charsetSentinel`
-mode.
-
-### Parsing Arrays
-
-**qs** can also parse arrays using a similar `[]` notation:
-
-```javascript
-var withArray = qs.parse('a[]=b&a[]=c');
-assert.deepEqual(withArray, { a: ['b', 'c'] });
-```
-
-You may specify an index as well:
-
-```javascript
-var withIndexes = qs.parse('a[1]=c&a[0]=b');
-assert.deepEqual(withIndexes, { a: ['b', 'c'] });
-```
-
-Note that the only difference between an index in an array and a key in an object is that the value between the brackets must be a number
-to create an array. When creating arrays with specific indices, **qs** will compact a sparse array to only the existing values preserving
-their order:
-
-```javascript
-var noSparse = qs.parse('a[1]=b&a[15]=c');
-assert.deepEqual(noSparse, { a: ['b', 'c'] });
-```
-
-You may also use `allowSparse` option to parse sparse arrays:
-
-```javascript
-var sparseArray = qs.parse('a[1]=2&a[3]=5', { allowSparse: true });
-assert.deepEqual(sparseArray, { a: [, '2', , '5'] });
-```
-
-Note that an empty string is also a value, and will be preserved:
-
-```javascript
-var withEmptyString = qs.parse('a[]=&a[]=b');
-assert.deepEqual(withEmptyString, { a: ['', 'b'] });
-
-var withIndexedEmptyString = qs.parse('a[0]=b&a[1]=&a[2]=c');
-assert.deepEqual(withIndexedEmptyString, { a: ['b', '', 'c'] });
-```
-
-**qs** will also limit specifying indices in an array to a maximum index of `20`. Any array members with an index of greater than `20` will
-instead be converted to an object with the index as the key. This is needed to handle cases when someone sent, for example, `a[999999999]` and it will take significant time to iterate over this huge array.
-
-```javascript
-var withMaxIndex = qs.parse('a[100]=b');
-assert.deepEqual(withMaxIndex, { a: { '100': 'b' } });
-```
-
-This limit can be overridden by passing an `arrayLimit` option:
-
-```javascript
-var withArrayLimit = qs.parse('a[1]=b', { arrayLimit: 0 });
-assert.deepEqual(withArrayLimit, { a: { '1': 'b' } });
-```
-
-To disable array parsing entirely, set `parseArrays` to `false`.
-
-```javascript
-var noParsingArrays = qs.parse('a[]=b', { parseArrays: false });
-assert.deepEqual(noParsingArrays, { a: { '0': 'b' } });
-```
-
-If you mix notations, **qs** will merge the two items into an object:
-
-```javascript
-var mixedNotation = qs.parse('a[0]=b&a[b]=c');
-assert.deepEqual(mixedNotation, { a: { '0': 'b', b: 'c' } });
-```
-
-You can also create arrays of objects:
-
-```javascript
-var arraysOfObjects = qs.parse('a[][b]=c');
-assert.deepEqual(arraysOfObjects, { a: [{ b: 'c' }] });
-```
-
-Some people use comma to join array, **qs** can parse it:
-```javascript
-var arraysOfObjects = qs.parse('a=b,c', { comma: true })
-assert.deepEqual(arraysOfObjects, { a: ['b', 'c'] })
-```
-(_this cannot convert nested objects, such as `a={b:1},{c:d}`_)
-
-### Parsing primitive/scalar values (numbers, booleans, null, etc)
-
-By default, all values are parsed as strings. This behavior will not change and is explained in [issue #91](https://github.com/ljharb/qs/issues/91).
-
-```javascript
-var primitiveValues = qs.parse('a=15&b=true&c=null');
-assert.deepEqual(primitiveValues, { a: '15', b: 'true', c: 'null' });
-```
-
-If you wish to auto-convert values which look like numbers, booleans, and other values into their primitive counterparts, you can use the [query-types Express JS middleware](https://github.com/xpepermint/query-types) which will auto-convert all request query parameters.
-
-### Stringifying
-
-[](#preventEval)
-```javascript
-qs.stringify(object, [options]);
-```
-
-When stringifying, **qs** by default URI encodes output. Objects are stringified as you would expect:
-
-```javascript
-assert.equal(qs.stringify({ a: 'b' }), 'a=b');
-assert.equal(qs.stringify({ a: { b: 'c' } }), 'a%5Bb%5D=c');
-```
-
-This encoding can be disabled by setting the `encode` option to `false`:
-
-```javascript
-var unencoded = qs.stringify({ a: { b: 'c' } }, { encode: false });
-assert.equal(unencoded, 'a[b]=c');
-```
-
-Encoding can be disabled for keys by setting the `encodeValuesOnly` option to `true`:
-```javascript
-var encodedValues = qs.stringify(
- { a: 'b', c: ['d', 'e=f'], f: [['g'], ['h']] },
- { encodeValuesOnly: true }
-);
-assert.equal(encodedValues,'a=b&c[0]=d&c[1]=e%3Df&f[0][0]=g&f[1][0]=h');
-```
-
-This encoding can also be replaced by a custom encoding method set as `encoder` option:
-
-```javascript
-var encoded = qs.stringify({ a: { b: 'c' } }, { encoder: function (str) {
- // Passed in values `a`, `b`, `c`
- return // Return encoded string
-}})
-```
-
-_(Note: the `encoder` option does not apply if `encode` is `false`)_
-
-Analogue to the `encoder` there is a `decoder` option for `parse` to override decoding of properties and values:
-
-```javascript
-var decoded = qs.parse('x=z', { decoder: function (str) {
- // Passed in values `x`, `z`
- return // Return decoded string
-}})
-```
-
-You can encode keys and values using different logic by using the type argument provided to the encoder:
-
-```javascript
-var encoded = qs.stringify({ a: { b: 'c' } }, { encoder: function (str, defaultEncoder, charset, type) {
- if (type === 'key') {
- return // Encoded key
- } else if (type === 'value') {
- return // Encoded value
- }
-}})
-```
-
-The type argument is also provided to the decoder:
-
-```javascript
-var decoded = qs.parse('x=z', { decoder: function (str, defaultDecoder, charset, type) {
- if (type === 'key') {
- return // Decoded key
- } else if (type === 'value') {
- return // Decoded value
- }
-}})
-```
-
-Examples beyond this point will be shown as though the output is not URI encoded for clarity. Please note that the return values in these cases *will* be URI encoded during real usage.
-
-When arrays are stringified, by default they are given explicit indices:
-
-```javascript
-qs.stringify({ a: ['b', 'c', 'd'] });
-// 'a[0]=b&a[1]=c&a[2]=d'
-```
-
-You may override this by setting the `indices` option to `false`:
-
-```javascript
-qs.stringify({ a: ['b', 'c', 'd'] }, { indices: false });
-// 'a=b&a=c&a=d'
-```
-
-You may use the `arrayFormat` option to specify the format of the output array:
-
-```javascript
-qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'indices' })
-// 'a[0]=b&a[1]=c'
-qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'brackets' })
-// 'a[]=b&a[]=c'
-qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'repeat' })
-// 'a=b&a=c'
-qs.stringify({ a: ['b', 'c'] }, { arrayFormat: 'comma' })
-// 'a=b,c'
-```
-
-Note: when using `arrayFormat` set to `'comma'`, you can also pass the `commaRoundTrip` option set to `true` or `false`, to append `[]` on single-item arrays, so that they can round trip through a parse.
-
-When objects are stringified, by default they use bracket notation:
-
-```javascript
-qs.stringify({ a: { b: { c: 'd', e: 'f' } } });
-// 'a[b][c]=d&a[b][e]=f'
-```
-
-You may override this to use dot notation by setting the `allowDots` option to `true`:
-
-```javascript
-qs.stringify({ a: { b: { c: 'd', e: 'f' } } }, { allowDots: true });
-// 'a.b.c=d&a.b.e=f'
-```
-
-Empty strings and null values will omit the value, but the equals sign (=) remains in place:
-
-```javascript
-assert.equal(qs.stringify({ a: '' }), 'a=');
-```
-
-Key with no values (such as an empty object or array) will return nothing:
-
-```javascript
-assert.equal(qs.stringify({ a: [] }), '');
-assert.equal(qs.stringify({ a: {} }), '');
-assert.equal(qs.stringify({ a: [{}] }), '');
-assert.equal(qs.stringify({ a: { b: []} }), '');
-assert.equal(qs.stringify({ a: { b: {}} }), '');
-```
-
-Properties that are set to `undefined` will be omitted entirely:
-
-```javascript
-assert.equal(qs.stringify({ a: null, b: undefined }), 'a=');
-```
-
-The query string may optionally be prepended with a question mark:
-
-```javascript
-assert.equal(qs.stringify({ a: 'b', c: 'd' }, { addQueryPrefix: true }), '?a=b&c=d');
-```
-
-The delimiter may be overridden with stringify as well:
-
-```javascript
-assert.equal(qs.stringify({ a: 'b', c: 'd' }, { delimiter: ';' }), 'a=b;c=d');
-```
-
-If you only want to override the serialization of `Date` objects, you can provide a `serializeDate` option:
-
-```javascript
-var date = new Date(7);
-assert.equal(qs.stringify({ a: date }), 'a=1970-01-01T00:00:00.007Z'.replace(/:/g, '%3A'));
-assert.equal(
- qs.stringify({ a: date }, { serializeDate: function (d) { return d.getTime(); } }),
- 'a=7'
-);
-```
-
-You may use the `sort` option to affect the order of parameter keys:
-
-```javascript
-function alphabeticalSort(a, b) {
- return a.localeCompare(b);
-}
-assert.equal(qs.stringify({ a: 'c', z: 'y', b : 'f' }, { sort: alphabeticalSort }), 'a=c&b=f&z=y');
-```
-
-Finally, you can use the `filter` option to restrict which keys will be included in the stringified output.
-If you pass a function, it will be called for each key to obtain the replacement value. Otherwise, if you
-pass an array, it will be used to select properties and array indices for stringification:
-
-```javascript
-function filterFunc(prefix, value) {
- if (prefix == 'b') {
- // Return an `undefined` value to omit a property.
- return;
- }
- if (prefix == 'e[f]') {
- return value.getTime();
- }
- if (prefix == 'e[g][0]') {
- return value * 2;
- }
- return value;
-}
-qs.stringify({ a: 'b', c: 'd', e: { f: new Date(123), g: [2] } }, { filter: filterFunc });
-// 'a=b&c=d&e[f]=123&e[g][0]=4'
-qs.stringify({ a: 'b', c: 'd', e: 'f' }, { filter: ['a', 'e'] });
-// 'a=b&e=f'
-qs.stringify({ a: ['b', 'c', 'd'], e: 'f' }, { filter: ['a', 0, 2] });
-// 'a[0]=b&a[2]=d'
-```
-
-### Handling of `null` values
-
-By default, `null` values are treated like empty strings:
-
-```javascript
-var withNull = qs.stringify({ a: null, b: '' });
-assert.equal(withNull, 'a=&b=');
-```
-
-Parsing does not distinguish between parameters with and without equal signs. Both are converted to empty strings.
-
-```javascript
-var equalsInsensitive = qs.parse('a&b=');
-assert.deepEqual(equalsInsensitive, { a: '', b: '' });
-```
-
-To distinguish between `null` values and empty strings use the `strictNullHandling` flag. In the result string the `null`
-values have no `=` sign:
-
-```javascript
-var strictNull = qs.stringify({ a: null, b: '' }, { strictNullHandling: true });
-assert.equal(strictNull, 'a&b=');
-```
-
-To parse values without `=` back to `null` use the `strictNullHandling` flag:
-
-```javascript
-var parsedStrictNull = qs.parse('a&b=', { strictNullHandling: true });
-assert.deepEqual(parsedStrictNull, { a: null, b: '' });
-```
-
-To completely skip rendering keys with `null` values, use the `skipNulls` flag:
-
-```javascript
-var nullsSkipped = qs.stringify({ a: 'b', c: null}, { skipNulls: true });
-assert.equal(nullsSkipped, 'a=b');
-```
-
-If you're communicating with legacy systems, you can switch to `iso-8859-1`
-using the `charset` option:
-
-```javascript
-var iso = qs.stringify({ æ: 'æ' }, { charset: 'iso-8859-1' });
-assert.equal(iso, '%E6=%E6');
-```
-
-Characters that don't exist in `iso-8859-1` will be converted to numeric
-entities, similar to what browsers do:
-
-```javascript
-var numeric = qs.stringify({ a: '☺' }, { charset: 'iso-8859-1' });
-assert.equal(numeric, 'a=%26%239786%3B');
-```
-
-You can use the `charsetSentinel` option to announce the character by
-including an `utf8=✓` parameter with the proper encoding if the checkmark,
-similar to what Ruby on Rails and others do when submitting forms.
-
-```javascript
-var sentinel = qs.stringify({ a: '☺' }, { charsetSentinel: true });
-assert.equal(sentinel, 'utf8=%E2%9C%93&a=%E2%98%BA');
-
-var isoSentinel = qs.stringify({ a: 'æ' }, { charsetSentinel: true, charset: 'iso-8859-1' });
-assert.equal(isoSentinel, 'utf8=%26%2310003%3B&a=%E6');
-```
-
-### Dealing with special character sets
-
-By default the encoding and decoding of characters is done in `utf-8`,
-and `iso-8859-1` support is also built in via the `charset` parameter.
-
-If you wish to encode querystrings to a different character set (i.e.
-[Shift JIS](https://en.wikipedia.org/wiki/Shift_JIS)) you can use the
-[`qs-iconv`](https://github.com/martinheidegger/qs-iconv) library:
-
-```javascript
-var encoder = require('qs-iconv/encoder')('shift_jis');
-var shiftJISEncoded = qs.stringify({ a: 'こんにちは！' }, { encoder: encoder });
-assert.equal(shiftJISEncoded, 'a=%82%B1%82%F1%82%C9%82%BF%82%CD%81I');
-```
-
-This also works for decoding of query strings:
-
-```javascript
-var decoder = require('qs-iconv/decoder')('shift_jis');
-var obj = qs.parse('a=%82%B1%82%F1%82%C9%82%BF%82%CD%81I', { decoder: decoder });
-assert.deepEqual(obj, { a: 'こんにちは！' });
-```
-
-### RFC 3986 and RFC 1738 space encoding
-
-RFC3986 used as default option and encodes ' ' to *%20* which is backward compatible.
-In the same time, output can be stringified as per RFC1738 with ' ' equal to '+'.
-
-```
-assert.equal(qs.stringify({ a: 'b c' }), 'a=b%20c');
-assert.equal(qs.stringify({ a: 'b c' }, { format : 'RFC3986' }), 'a=b%20c');
-assert.equal(qs.stringify({ a: 'b c' }, { format : 'RFC1738' }), 'a=b+c');
-```
-
-## Security
-
-Please email [@ljharb](https://github.com/ljharb) or see https://tidelift.com/security if you have a potential security vulnerability to report.
-
-## qs for enterprise
-
-Available as part of the Tidelift Subscription
-
-The maintainers of qs and thousands of other packages are working with Tidelift to deliver commercial support and maintenance for the open source dependencies you use to build your applications. Save time, reduce risk, and improve code health, while paying the maintainers of the exact dependencies you use. [Learn more.](https://tidelift.com/subscription/pkg/npm-qs?utm_source=npm-qs&utm_medium=referral&utm_campaign=enterprise&utm_term=repo)
-
-[package-url]: https://npmjs.org/package/qs
-[npm-version-svg]: https://versionbadg.es/ljharb/qs.svg
-[deps-svg]: https://david-dm.org/ljharb/qs.svg
-[deps-url]: https://david-dm.org/ljharb/qs
-[dev-deps-svg]: https://david-dm.org/ljharb/qs/dev-status.svg
-[dev-deps-url]: https://david-dm.org/ljharb/qs#info=devDependencies
-[npm-badge-png]: https://nodei.co/npm/qs.png?downloads=true&stars=true
-[license-image]: https://img.shields.io/npm/l/qs.svg
-[license-url]: LICENSE
-[downloads-image]: https://img.shields.io/npm/dm/qs.svg
-[downloads-url]: https://npm-stat.com/charts.html?package=qs
-[codecov-image]: https://codecov.io/gh/ljharb/qs/branch/main/graphs/badge.svg
-[codecov-url]: https://app.codecov.io/gh/ljharb/qs/
-[actions-image]: https://img.shields.io/endpoint?url=https://github-actions-badge-u3jn4tfpocch.runkit.sh/ljharb/qs
-[actions-url]: https://github.com/ljharb/qs/actions
diff --git a/spaces/fffiloni/imagic-stable-diffusion/imagic.py b/spaces/fffiloni/imagic-stable-diffusion/imagic.py
deleted file mode 100644
index 9bdf4788f5dc14a088e187cb565b233588af1b9e..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/imagic-stable-diffusion/imagic.py
+++ /dev/null
@@ -1,498 +0,0 @@
-"""
- modeled after the textual_inversion.py / train_dreambooth.py and the work
- of justinpinkney here: https://github.com/justinpinkney/stable-diffusion/blob/main/notebooks/imagic.ipynb
-"""
-import inspect
-import warnings
-from typing import List, Optional, Union
-import bitsandbytes as bnb
-import numpy as np
-import torch
-import torch.nn.functional as F
-
-import PIL
-from accelerate import Accelerator
-from diffusers.models import AutoencoderKL, UNet2DConditionModel
-from diffusers.pipeline_utils import DiffusionPipeline
-from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
-from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-from diffusers.schedulers import DDIMScheduler, LMSDiscreteScheduler, PNDMScheduler
-from diffusers.utils import logging
-
-# TODO: remove and import from diffusers.utils when the new version of diffusers is released
-from packaging import version
-from tqdm.auto import tqdm
-from transformers import CLIPFeatureExtractor, CLIPTextModel, CLIPTokenizer
-
-
-if version.parse(version.parse(PIL.__version__).base_version) >= version.parse("9.1.0"):
- PIL_INTERPOLATION = {
- "linear": PIL.Image.Resampling.BILINEAR,
- "bilinear": PIL.Image.Resampling.BILINEAR,
- "bicubic": PIL.Image.Resampling.BICUBIC,
- "lanczos": PIL.Image.Resampling.LANCZOS,
- "nearest": PIL.Image.Resampling.NEAREST,
- }
-else:
- PIL_INTERPOLATION = {
- "linear": PIL.Image.LINEAR,
- "bilinear": PIL.Image.BILINEAR,
- "bicubic": PIL.Image.BICUBIC,
- "lanczos": PIL.Image.LANCZOS,
- "nearest": PIL.Image.NEAREST,
- }
-# ------------------------------------------------------------------------------
-
-logger = logging.get_logger(__name__) # pylint: disable=invalid-name
-
-
-def preprocess(image):
- w, h = image.size
- w, h = map(lambda x: x - x % 32, (w, h)) # resize to integer multiple of 32
- image = image.resize((w, h), resample=PIL_INTERPOLATION["lanczos"])
- image = np.array(image).astype(np.float32) / 255.0
- image = image[None].transpose(0, 3, 1, 2)
- image = torch.from_numpy(image)
- return 2.0 * image - 1.0
-
-
-class ImagicStableDiffusionPipeline(DiffusionPipeline):
- r"""
- Pipeline for imagic image editing.
- See paper here: https://arxiv.org/pdf/2210.09276.pdf
-
- 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 offsensive or harmful.
- Please, refer to the [model card](https://huggingface.co/CompVis/stable-diffusion-v1-4) for details.
- feature_extractor ([`CLIPFeatureExtractor`]):
- Model that extracts features from generated images to be used as inputs for the `safety_checker`.
- """
-
- def __init__(
- self,
- vae: AutoencoderKL,
- text_encoder: CLIPTextModel,
- tokenizer: CLIPTokenizer,
- unet: UNet2DConditionModel,
- scheduler: Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],
- safety_checker: StableDiffusionSafetyChecker,
- feature_extractor: CLIPFeatureExtractor,
- ):
- super().__init__()
- self.register_modules(
- vae=vae,
- text_encoder=text_encoder,
- tokenizer=tokenizer,
- unet=unet,
- scheduler=scheduler,
- safety_checker=safety_checker,
- feature_extractor=feature_extractor,
- )
-
- 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":
- # half the attention head size is usually a good trade-off between
- # speed and memory
- slice_size = self.unet.config.attention_head_dim // 2
- 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 train(
- self,
- prompt: Union[str, List[str]],
- init_image: Union[torch.FloatTensor, PIL.Image.Image],
- height: Optional[int] = 512,
- width: Optional[int] = 512,
- generator: Optional[torch.Generator] = None,
- embedding_learning_rate: float = 0.001,
- diffusion_model_learning_rate: float = 2e-6,
- text_embedding_optimization_steps: int = 100,
- model_fine_tuning_optimization_steps: int = 500,
- **kwargs,
- ):
- 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 512):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to 512):
- The width in pixels of the generated image.
- num_inference_steps (`int`, *optional*, defaults to 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.
- 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 `nd.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
- plain tuple.
- 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`.
- """
- accelerator = Accelerator(
- gradient_accumulation_steps=1,
- mixed_precision="fp16",
- )
-
- if "torch_device" in kwargs:
- device = kwargs.pop("torch_device")
- warnings.warn(
- "`torch_device` is deprecated as an input argument to `__call__` and will be removed in v0.3.0."
- " Consider using `pipe.to(torch_device)` instead."
- )
-
- if device is None:
- device = "cuda" if torch.cuda.is_available() else "cpu"
- self.to(device)
-
- 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}.")
-
- # Freeze vae and unet
- self.vae.requires_grad_(False)
- self.unet.requires_grad_(False)
- self.text_encoder.requires_grad_(False)
- self.unet.eval()
- self.vae.eval()
- self.text_encoder.eval()
-
- if accelerator.is_main_process:
- accelerator.init_trackers(
- "imagic",
- config={
- "embedding_learning_rate": embedding_learning_rate,
- "text_embedding_optimization_steps": text_embedding_optimization_steps,
- },
- )
-
- # get text embeddings for prompt
- text_input = self.tokenizer(
- prompt,
- padding="max_length",
- max_length=self.tokenizer.model_max_length,
- truncation=True,
- return_tensors="pt",
- )
- text_embeddings = torch.nn.Parameter(
- self.text_encoder(text_input.input_ids.to(self.device))[0], requires_grad=True
- )
- text_embeddings = text_embeddings.detach()
- text_embeddings.requires_grad_()
- text_embeddings_orig = text_embeddings.clone()
-
- # Initialize the optimizer
-
- optimizer = bnb.optim.Adam8bit(
- [text_embeddings], # only optimize the embeddings
- lr=embedding_learning_rate,
- )
-
- if isinstance(init_image, PIL.Image.Image):
- init_image = preprocess(init_image)
-
- latents_dtype = text_embeddings.dtype
- init_image = init_image.to(device=self.device, dtype=latents_dtype)
- init_latent_image_dist = self.vae.encode(init_image).latent_dist
- init_image_latents = init_latent_image_dist.sample(generator=generator)
- init_image_latents = 0.18215 * init_image_latents
-
- progress_bar = tqdm(range(text_embedding_optimization_steps), disable=not accelerator.is_local_main_process)
- progress_bar.set_description("Steps")
-
- global_step = 0
-
- logger.info("First optimizing the text embedding to better reconstruct the init image")
- for _ in range(text_embedding_optimization_steps):
- with accelerator.accumulate(text_embeddings):
- # Sample noise that we'll add to the latents
- noise = torch.randn(init_image_latents.shape).to(init_image_latents.device)
- timesteps = torch.randint(1000, (1,), device=init_image_latents.device)
-
- # Add noise to the latents according to the noise magnitude at each timestep
- # (this is the forward diffusion process)
- noisy_latents = self.scheduler.add_noise(init_image_latents, noise, timesteps)
-
- # Predict the noise residual
- noise_pred = self.unet(noisy_latents, timesteps, text_embeddings).sample
-
- loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
- accelerator.backward(loss)
-
- optimizer.step()
- optimizer.zero_grad()
-
- # Checks if the accelerator has performed an optimization step behind the scenes
- if accelerator.sync_gradients:
- progress_bar.update(1)
- global_step += 1
-
- logs = {"loss": loss.detach().item()} # , "lr": lr_scheduler.get_last_lr()[0]}
- progress_bar.set_postfix(**logs)
- accelerator.log(logs, step=global_step)
-
- accelerator.wait_for_everyone()
-
- text_embeddings.requires_grad_(False)
-
- # Now we fine tune the unet to better reconstruct the image
- self.unet.requires_grad_(True)
- self.unet.train()
- optimizer = bnb.optim.Adam8bit(
- self.unet.parameters(), # only optimize unet
- lr=diffusion_model_learning_rate,
- )
- progress_bar = tqdm(range(model_fine_tuning_optimization_steps), disable=not accelerator.is_local_main_process)
-
- logger.info("Next fine tuning the entire model to better reconstruct the init image")
- for _ in range(model_fine_tuning_optimization_steps):
- with accelerator.accumulate(self.unet.parameters()):
- # Sample noise that we'll add to the latents
- noise = torch.randn(init_image_latents.shape).to(init_image_latents.device)
- timesteps = torch.randint(1000, (1,), device=init_image_latents.device)
-
- # Add noise to the latents according to the noise magnitude at each timestep
- # (this is the forward diffusion process)
- noisy_latents = self.scheduler.add_noise(init_image_latents, noise, timesteps)
-
- # Predict the noise residual
- noise_pred = self.unet(noisy_latents, timesteps, text_embeddings).sample
-
- loss = F.mse_loss(noise_pred, noise, reduction="none").mean([1, 2, 3]).mean()
- accelerator.backward(loss)
-
- optimizer.step()
- optimizer.zero_grad()
-
- # Checks if the accelerator has performed an optimization step behind the scenes
- if accelerator.sync_gradients:
- progress_bar.update(1)
- global_step += 1
-
- logs = {"loss": loss.detach().item()} # , "lr": lr_scheduler.get_last_lr()[0]}
- progress_bar.set_postfix(**logs)
- accelerator.log(logs, step=global_step)
-
- accelerator.wait_for_everyone()
- self.text_embeddings_orig = text_embeddings_orig
- self.text_embeddings = text_embeddings
-
- @torch.no_grad()
- def __call__(
- self,
- alpha: float = 1.2,
- height: Optional[int] = 512,
- width: Optional[int] = 512,
- num_inference_steps: Optional[int] = 50,
- generator: Optional[torch.Generator] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- guidance_scale: float = 7.5,
- eta: float = 0.0,
- **kwargs,
- ):
- 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 512):
- The height in pixels of the generated image.
- width (`int`, *optional*, defaults to 512):
- The width in pixels of the generated image.
- num_inference_steps (`int`, *optional*, defaults to 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.
- 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 `nd.array`.
- return_dict (`bool`, *optional*, defaults to `True`):
- Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
- plain tuple.
- 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`.
- """
- 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 self.text_embeddings is None:
- raise ValueError("Please run the pipe.train() before trying to generate an image.")
- if self.text_embeddings_orig is None:
- raise ValueError("Please run the pipe.train() before trying to generate an image.")
-
- text_embeddings = alpha * self.text_embeddings_orig + (1 - alpha) * self.text_embeddings
-
- # 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
- # get unconditional embeddings for classifier free guidance
- if do_classifier_free_guidance:
- uncond_tokens = [""]
- max_length = self.tokenizer.model_max_length
- uncond_input = self.tokenizer(
- uncond_tokens,
- padding="max_length",
- max_length=max_length,
- truncation=True,
- return_tensors="pt",
- )
- uncond_embeddings = self.text_encoder(uncond_input.input_ids.to(self.device))[0]
-
- # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
- seq_len = uncond_embeddings.shape[1]
- uncond_embeddings = uncond_embeddings.view(1, 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])
-
- # get the initial random noise unless the user supplied it
-
- # Unlike in other pipelines, latents need to be generated in the target device
- # for 1-to-1 results reproducibility with the CompVis implementation.
- # However this currently doesn't work in `mps`.
- latents_shape = (1, self.unet.in_channels, height // 8, width // 8)
- latents_dtype = text_embeddings.dtype
- if self.device.type == "mps":
- # randn does not exist on mps
- latents = torch.randn(latents_shape, generator=generator, device="cpu", dtype=latents_dtype).to(
- self.device
- )
- else:
- latents = torch.randn(latents_shape, generator=generator, device=self.device, dtype=latents_dtype)
-
- # set timesteps
- self.scheduler.set_timesteps(num_inference_steps)
-
- # Some schedulers like PNDM have timesteps as arrays
- # It's more optimized to move all timesteps to correct device beforehand
- timesteps_tensor = self.scheduler.timesteps.to(self.device)
-
- # scale the initial noise by the standard deviation required by the scheduler
- latents = latents * self.scheduler.init_noise_sigma
-
- # 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
-
- for i, t in enumerate(self.progress_bar(timesteps_tensor)):
- # 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
-
- 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()
-
- if self.safety_checker is not None:
- safety_checker_input = self.feature_extractor(self.numpy_to_pil(image), return_tensors="pt").to(
- self.device
- )
- image, has_nsfw_concept = self.safety_checker(
- images=image, clip_input=safety_checker_input.pixel_values.to(text_embeddings.dtype)
- )
- else:
- has_nsfw_concept = None
-
- 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)
\ No newline at end of file
diff --git a/spaces/fffiloni/mmpose-estimation/README.md b/spaces/fffiloni/mmpose-estimation/README.md
deleted file mode 100644
index 280d59b219a20cf993ffe42fdd64df9732e79efb..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/mmpose-estimation/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: MMPose estimation
-emoji: 🏃
-colorFrom: pink
-colorTo: indigo
-python_version: 3.9.16
-sdk: gradio
-sdk_version: 3.34.0
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: test1444/test_mmpose
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/fffiloni/video2mmpose/app.py b/spaces/fffiloni/video2mmpose/app.py
deleted file mode 100644
index bfd12610d4b3421e5ece0c7db82e404b4f96c7f3..0000000000000000000000000000000000000000
--- a/spaces/fffiloni/video2mmpose/app.py
+++ /dev/null
@@ -1,146 +0,0 @@
-import gradio as gr
-
-import os
-import cv2
-import numpy as np
-from PIL import Image
-from moviepy.editor import *
-
-mmpose = gr.Interface.load(name="spaces/fffiloni/mmpose-estimation")
-
-def get_frames(video_in):
- frames = []
- #resize the video
- clip = VideoFileClip(video_in)
-
- #check fps
- if clip.fps > 30:
- print("vide rate is over 30, resetting to 30")
- clip_resized = clip.resize(height=512)
- clip_resized.write_videofile("video_resized.mp4", fps=30)
- else:
- print("video rate is OK")
- clip_resized = clip.resize(height=512)
- clip_resized.write_videofile("video_resized.mp4", fps=clip.fps)
-
- print("video resized to 512 height")
-
- # Opens the Video file with CV2
- cap= cv2.VideoCapture("video_resized.mp4")
-
- fps = cap.get(cv2.CAP_PROP_FPS)
- print("video fps: " + str(fps))
- i=0
- while(cap.isOpened()):
- ret, frame = cap.read()
- if ret == False:
- break
- cv2.imwrite('kang'+str(i)+'.jpg',frame)
- frames.append('kang'+str(i)+'.jpg')
- i+=1
-
- cap.release()
- cv2.destroyAllWindows()
- print("broke the video into frames")
-
- return frames, fps
-
-def get_mmpose_filter(i):
- #image = Image.open(i)
-
- #image = np.array(image)
-
- image = mmpose(i, fn_index=0)[1]
- image = Image.open(image)
- #image = Image.fromarray(image)
- image.save("mmpose_frame_" + str(i) + ".jpeg")
- return "mmpose_frame_" + str(i) + ".jpeg"
-
-def create_video(frames, fps, type):
- print("building video result")
- clip = ImageSequenceClip(frames, fps=fps)
- clip.write_videofile(type + "_result.mp4", fps=fps)
-
- return type + "_result.mp4"
-
-def convertG2V(imported_gif):
- clip = VideoFileClip(imported_gif.name)
- clip.write_videofile("my_gif_video.mp4")
- return "my_gif_video.mp4"
-
-def infer(video_in):
-
-
- # 1. break video into frames and get FPS
- break_vid = get_frames(video_in)
- frames_list= break_vid[0]
- fps = break_vid[1]
- #n_frame = int(trim_value*fps)
- n_frame = len(frames_list)
-
- if n_frame >= len(frames_list):
- print("video is shorter than the cut value")
- n_frame = len(frames_list)
-
- # 2. prepare frames result arrays
- result_frames = []
- print("set stop frames to: " + str(n_frame))
-
- for i in frames_list[0:int(n_frame)]:
- mmpose_frame = get_mmpose_filter(i)
- result_frames.append(mmpose_frame)
- print("frame " + i + "/" + str(n_frame) + ": done;")
-
-
- final_vid = create_video(result_frames, fps, "mmpose")
-
- files = [final_vid]
-
- return final_vid, files
-
-title="""
-
-
-
- Video to MMPose
-
-
-
- Convert any video or gif to a MMPose sequence.
- Once you got your converted video, you can use it with the FollowYourPose demo
-
-"""
-
-with gr.Blocks() as demo:
- with gr.Column():
- gr.HTML(title)
- with gr.Row():
- with gr.Column():
- video_input = gr.Video(source="upload", type="filepath")
- gif_input = gr.File(label="import a GIF instead", file_types=['.gif'])
- gif_input.change(fn=convertG2V, inputs=gif_input, outputs=video_input)
- submit_btn = gr.Button("Submit")
-
- with gr.Column():
- video_output = gr.Video()
- file_output = gr.Files()
-
- gr.Examples(
- examples=["./examples/childishgambino.mp4", "./examples/jimmyfallon.mp4"],
- fn=infer,
- inputs=[video_input],
- outputs=[video_output,file_output],
- cache_examples=False
- )
-
- submit_btn.click(fn=infer, inputs=[video_input], outputs=[video_output, file_output])
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/firefighter/TransDis-CreativityAutoAssessment/utils/pipeline.py b/spaces/firefighter/TransDis-CreativityAutoAssessment/utils/pipeline.py
deleted file mode 100644
index bab4730fab5802f6e7ac8e8f8876a578a1b3740b..0000000000000000000000000000000000000000
--- a/spaces/firefighter/TransDis-CreativityAutoAssessment/utils/pipeline.py
+++ /dev/null
@@ -1,59 +0,0 @@
-from typing import List
-
-import pandas as pd
-from sentence_transformers.util import cos_sim
-
-from utils.models import ModelWithPooling
-
-
-def p0_originality(df: pd.DataFrame, model_name: str, pooling: str) -> pd.DataFrame:
- """
- row-wise
- :param df:
- :param model_name:
- :return:
- """
- assert 'prompt' in df.columns
- assert 'response' in df.columns
- model = ModelWithPooling(model_name)
-
- def get_cos_sim(prompt: str, response: str) -> float:
- prompt_vec = model(text=prompt, pooling=pooling)
- response_vec = model(text=response, pooling=pooling)
- score = cos_sim(prompt_vec, response_vec).item()
- return score
-
- df['originality'] = df.apply(lambda x: 1 - get_cos_sim(x['prompt'], x['response']), axis=1)
- return df
-
-
-def p1_flexibility(df: pd.DataFrame, model_name: str, pooling: str) -> pd.DataFrame:
- """
- group-wise
- :param df:
- :param model_name:
- :return:
- """
- assert 'prompt' in df.columns
- assert 'response' in df.columns
- assert 'id' in df.columns
- model = ModelWithPooling(model_name)
-
- def get_flexibility(responses: List[str]) -> float:
- responses_vec = [model(text=_, pooling=pooling) for _ in responses]
- score = 0
- for i in range(len(responses_vec) - 1):
- score += 1 - cos_sim(responses_vec[i], responses_vec[i + 1]).item()
- return score
-
- df_out = df.groupby(by=['id', 'prompt']) \
- .agg({'id': 'first', 'prompt': 'first', 'response': get_flexibility}) \
- .rename(columns={'response': 'flexibility'}) \
- .reset_index(drop=True)
- return df_out
-
-
-if __name__ == '__main__':
- _df_input = pd.read_csv('data/tmp/example_3.csv')
- _df_0 = p0_originality(_df_input, 'paraphrase-multilingual-MiniLM-L12-v2')
- _df_1 = p1_flexibility(_df_input, 'paraphrase-multilingual-MiniLM-L12-v2')
diff --git a/spaces/flax-community/spanish-image-captioning/model/flax_clip_vision_marian/__init__.py b/spaces/flax-community/spanish-image-captioning/model/flax_clip_vision_marian/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/florim/MedGPT/ui/app.py b/spaces/florim/MedGPT/ui/app.py
deleted file mode 100644
index d7dbd31e901969d090292215935bdbc3d9d75e37..0000000000000000000000000000000000000000
--- a/spaces/florim/MedGPT/ui/app.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import gradio as gr
-import utils
-from api import AutoAPI, get_openai_api_key
-import os, shutil
-import json
-
-FILE_DIR = os.path.dirname(os.path.abspath(__file__))
-OUTPUT_DIR = os.path.join(os.path.dirname(FILE_DIR), "auto_gpt_workspace")
-if not os.path.exists(OUTPUT_DIR):
- os.mkdir(OUTPUT_DIR)
-
-CSS = """
-#chatbot {font-family: monospace;}
-#files .generating {display: none;}
-#files .min {min-height: 0px;}
-"""
-
-with gr.Blocks(css=CSS) as app:
- with gr.Column() as setup_pane:
- gr.Markdown(f"""# Auto-GPT
- 1. Duplicate this Space: 
This will **NOT** work without duplication!
- 2. Enter your OpenAI API Key below.
- """)
- with gr.Row():
- open_ai_key = gr.Textbox(
- value=get_openai_api_key(),
- label="OpenAI API Key",
- type="password",
- )
- gr.Markdown(
- "3. Fill the values below, then click 'Start'. There are example values you can load at the bottom of this page."
- )
- with gr.Row():
- ai_name = gr.Textbox(label="AI Name", placeholder="e.g. Entrepreneur-GPT")
- ai_role = gr.Textbox(
- label="AI Role",
- placeholder="e.g. an AI designed to autonomously develop and run businesses with the sole goal of increasing your net worth.",
- )
- top_5_goals = gr.Dataframe(
- row_count=(5, "fixed"),
- col_count=(1, "fixed"),
- headers=["AI Goals - Enter up to 5"],
- type="array"
- )
- start_btn = gr.Button("Start", variant="primary")
- with open(os.path.join(FILE_DIR, "examples.json"), "r") as f:
- example_values = json.load(f)
- gr.Examples(
- example_values,
- [ai_name, ai_role, top_5_goals],
- )
- with gr.Column(visible=False) as main_pane:
- with gr.Row():
- with gr.Column(scale=2):
- chatbot = gr.Chatbot(elem_id="chatbot")
- with gr.Row():
- yes_btn = gr.Button("Yes", variant="primary", interactive=False)
- consecutive_yes = gr.Slider(
- 1, 10, 1, step=1, label="Consecutive Yes", interactive=False
- )
- custom_response = gr.Textbox(
- label="Custom Response",
- placeholder="Press 'Enter' to Submit.",
- interactive=False,
- )
- with gr.Column(scale=1):
- gr.HTML(
- lambda: f"""
- Generated Files
- {utils.format_directory(OUTPUT_DIR)}
- """, every=3, elem_id="files"
- )
- download_btn = gr.Button("Download All Files")
-
- chat_history = gr.State([[None, None]])
- api = gr.State(None)
-
- def start(open_ai_key, ai_name, ai_role, top_5_goals):
- auto_api = AutoAPI(open_ai_key, ai_name, ai_role, top_5_goals)
- return gr.Column.update(visible=False), gr.Column.update(visible=True), auto_api
-
- def bot_response(chat, api):
- messages = []
- for message in api.get_chatbot_response():
- messages.append(message)
- chat[-1][1] = "\n".join(messages) + "..."
- yield chat
- chat[-1][1] = "\n".join(messages)
- yield chat
-
- def send_message(count, chat, api, message="Y"):
- if message != "Y":
- count = 1
- for i in range(count):
- chat.append([message, None])
- yield chat, count - i
- api.send_message(message)
- for updated_chat in bot_response(chat, api):
- yield updated_chat, count - i
-
- def activate_inputs():
- return {
- yes_btn: gr.Button.update(interactive=True),
- consecutive_yes: gr.Slider.update(interactive=True),
- custom_response: gr.Textbox.update(interactive=True),
- }
-
- def deactivate_inputs():
- return {
- yes_btn: gr.Button.update(interactive=False),
- consecutive_yes: gr.Slider.update(interactive=False),
- custom_response: gr.Textbox.update(interactive=False),
- }
-
- start_btn.click(
- start,
- [open_ai_key, ai_name, ai_role, top_5_goals],
- [setup_pane, main_pane, api],
- ).then(bot_response, [chat_history, api], chatbot).then(
- activate_inputs, None, [yes_btn, consecutive_yes, custom_response]
- )
-
- yes_btn.click(
- deactivate_inputs, None, [yes_btn, consecutive_yes, custom_response]
- ).then(
- send_message, [consecutive_yes, chat_history, api], [chatbot, consecutive_yes]
- ).then(
- activate_inputs, None, [yes_btn, consecutive_yes, custom_response]
- )
- custom_response.submit(
- deactivate_inputs, None, [yes_btn, consecutive_yes, custom_response]
- ).then(
- send_message,
- [consecutive_yes, chat_history, api, custom_response],
- [chatbot, consecutive_yes],
- ).then(
- activate_inputs, None, [yes_btn, consecutive_yes, custom_response]
- )
-
- def download_all_files():
- shutil.make_archive("outputs", "zip", OUTPUT_DIR)
-
- download_btn.click(download_all_files).then(None, _js=utils.DOWNLOAD_OUTPUTS_JS)
-
-app.queue(concurrency_count=20).launch(file_directories=[OUTPUT_DIR])
diff --git a/spaces/geniusguy777/Face_Recognition/style.css b/spaces/geniusguy777/Face_Recognition/style.css
deleted file mode 100644
index ec3ee34e87dd302756e8746fe264d70f4f454454..0000000000000000000000000000000000000000
--- a/spaces/geniusguy777/Face_Recognition/style.css
+++ /dev/null
@@ -1,7 +0,0 @@
-h1 {
- text-align: center;
-}
-
-#content_align {
- text-align: center;
-}
diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/exp/upernet_global_small/test_config_w32.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/exp/upernet_global_small/test_config_w32.py
deleted file mode 100644
index 3d9e06f029e46c14cb9ddb39319cabe86fef9b44..0000000000000000000000000000000000000000
--- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/exp/upernet_global_small/test_config_w32.py
+++ /dev/null
@@ -1,39 +0,0 @@
-_base_ = [
- '../../configs/_base_/models/upernet_uniformer.py',
- '../../configs/_base_/datasets/ade20k.py',
- '../../configs/_base_/default_runtime.py',
- '../../configs/_base_/schedules/schedule_160k.py'
-]
-model = dict(
- backbone=dict(
- type='UniFormer',
- embed_dim=[64, 128, 320, 512],
- layers=[3, 4, 8, 3],
- head_dim=64,
- drop_path_rate=0.25,
- windows=True,
- hybrid=False,
- window_size=32
- ),
- decode_head=dict(
- in_channels=[64, 128, 320, 512],
- num_classes=150
- ),
- auxiliary_head=dict(
- in_channels=320,
- num_classes=150
- ))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm in backbone
-optimizer = dict(_delete_=True, type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01,
- paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
- 'relative_position_bias_table': dict(decay_mult=0.),
- 'norm': dict(decay_mult=0.)}))
-
-lr_config = dict(_delete_=True, policy='poly',
- warmup='linear',
- warmup_iters=1500,
- warmup_ratio=1e-6,
- power=1.0, min_lr=0.0, by_epoch=False)
-
-data=dict(samples_per_gpu=2)
\ No newline at end of file
diff --git a/spaces/gorkemgoknar/movie_chat_gpt_yourtts_fileinput/app.py b/spaces/gorkemgoknar/movie_chat_gpt_yourtts_fileinput/app.py
deleted file mode 100644
index f9c1cbb6c519f610f0b3f4b402da5f48c7ccb5c6..0000000000000000000000000000000000000000
--- a/spaces/gorkemgoknar/movie_chat_gpt_yourtts_fileinput/app.py
+++ /dev/null
@@ -1,205 +0,0 @@
-import gradio as gr
-import random
-import torch
-from transformers import AutoConfig, AutoTokenizer, AutoModelWithLMHead
-from transformers import GPT2Tokenizer, GPT2LMHeadModel
-from itertools import chain
-
-import os
-
-import tempfile
-from typing import Optional
-from TTS.config import load_config
-import numpy as np
-from TTS.utils.manage import ModelManager
-from TTS.utils.synthesizer import Synthesizer
-
-#emotion_tokenizer = AutoTokenizer.from_pretrained("mrm8488/t5-base-finetuned-emotion")
-#emotion_model = AutoModelWithLMHead.from_pretrained("mrm8488/t5-base-finetuned-emotion")
-
-def get_emotion(text):
- input_ids = tokenizer.encode(text + '', return_tensors='pt')
- output = model.generate(input_ids=input_ids,max_length=2)
- dec = [tokenizer.decode(ids) for ids in output]
- label = dec[0]
- return label.split()[1]
-
-
-config = AutoConfig.from_pretrained('gorkemgoknar/gpt2chatbotenglish')
-model = GPT2LMHeadModel.from_pretrained('gorkemgoknar/gpt2chatbotenglish', config=config)
-
-tokenizer = GPT2Tokenizer.from_pretrained('gorkemgoknar/gpt2chatbotenglish')
-tokenizer.model_max_length = 1024
-
-#Dynamic Temperature
-#See experiment https://www.linkedin.com/pulse/ai-goes-job-interview-g%25C3%25B6rkem-g%25C3%25B6knar
-
-base_temperature = 1.2
-dynamic_temperature_range = 0.15
-
-rand_range = random.uniform(-1 * dynamic_temperature_range , dynamic_temperature_range )
-temperature = base_temperature + rand_range
-
-SPECIAL_TOKENS = ["", "", "", "", ""]
-
-#See document for experiment https://www.linkedin.com/pulse/ai-goes-job-interview-g%C3%B6rkem-g%C3%B6knar/
-
-def get_chat_response(name,history=[], input_txt = "Hello , what is your name?"):
-
- ai_history = history.copy()
-
- #ai_history.append(input_txt)
- ai_history_e = [tokenizer.encode(e) for e in ai_history]
-
- personality = "My name is " + name
-
- bos, eos, speaker1, speaker2 = tokenizer.convert_tokens_to_ids(SPECIAL_TOKENS[:-1])
-
- #persona first, history next, input text must be at the end
- #[[bos, persona] , [history] , [input]]
- sequence = [[bos] + tokenizer.encode(personality)] + ai_history_e + [tokenizer.encode(input_txt)]
- ##[[bos, persona] , [speaker1 .., speakser2 .., speaker1 ... speaker2 ... , [input]]
- sequence = [sequence[0]] + [[speaker2 if (len(sequence)-i) % 2 else speaker1] + s for i, s in enumerate(sequence[1:])]
-
- sequence = list(chain(*sequence))
-
- #bot_input_ids = tokenizer.encode(personality + tokenizer.eos_token + input_txt + tokenizer.eos_token , return_tensors='pt')
- sequence_len = len(sequence)
-
- #optimum response and speed
- chat_history_ids = model.generate(
- torch.tensor(sequence).unsqueeze(0), max_length=50,
- pad_token_id=tokenizer.eos_token_id,
- no_repeat_ngram_size=3,
- do_sample=True,
- top_k=60,
- top_p=0.8,
- temperature = 1.3
- )
- out_str = tokenizer.decode(chat_history_ids[0][sequence_len:], skip_special_tokens=True)
- #out_str = tokenizer.decode(chat_history_ids[:, sequence.shape[-1]:][0], skip_special_tokens=False)
- return out_str
-
-##you can use anyone from below
-'''
-| Macleod | Moran | Brenda | Ramirez | Peter Parker | Quentin Beck | Andy
-| Red | Norton | Willard | Chief | Chef | Kilgore | Kurtz | Westley | Buttercup
-| Vizzini | Fezzik | Inigo | Man In Black | Taylor | Zira | Zaius | Cornelius
-| Bud | Lindsey | Hippy | Erin | Ed | George | Donna | Trinity | Agent Smith
-| Morpheus | Neo | Tank | Meryl | Truman | Marlon | Christof | Stromboli | Bumstead
-| Schreber | Walker | Korben | Cornelius | Loc Rhod | Anakin | Obi-Wan | Palpatine
-| Padme | Superman | Luthor | Dude | Walter | Donny | Maude | General | Starkiller
-| Indiana | Willie | Short Round | John | Sarah | Terminator | Miller | Sarge | Reiben
-| Jackson | Upham | Chuckie | Will | Lambeau | Sean | Skylar | Saavik | Spock
-| Kirk | Bones | Khan | Kirk | Spock | Sybok | Scotty | Bourne | Pamela | Abbott
-| Nicky | Marshall | Korshunov | Troy | Vig | Archie Gates | Doc | Interrogator
-| Ellie | Ted | Peter | Drumlin | Joss | Macready | Childs | Nicholas | Conrad
-| Feingold | Christine | Adam | Barbara | Delia | Lydia | Cathy | Charles | Otho
-| Schaefer | Han | Luke | Leia | Threepio | Vader | Yoda | Lando | Elaine | Striker
-| Dr. Rumack | Kramer | David | Saavik | Kirk | Kruge | Holden | Deckard | Rachael
-| Batty | Sebastian | Sam | Frodo | Pippin | Gandalf | Kay | Edwards | Laurel
-| Edgar | Zed | Jay | Malloy | Plissken | Steve Rogers | Tony Stark | Scott Lang
-| Bruce Banner | Bruce | Edward | Two-Face | Batman | Chase | Alfred | Dick
-| Riddler | Din Djarin | Greef Karga | Kuiil | Ig-11 | Cara Dune | Peli Motto
-| Toro Calican | Ripley | Meredith | Dickie | Marge | Peter | Lambert | Kane
-| Dallas | Ripley | Ash | Parker | Threepio | Luke | Leia | Ben | Han | Common Bob
-| Common Alice | Jack | Tyler | Marla | Dana | Stantz | Venkman | Spengler | Louis
-| Fry | Johns | Riddick | Kirk | Decker | Spock | "Ilia | Indy | Belloq | Marion
-| Brother | Allnut | Rose | Qui-Gon | Jar Jar
-'''
-
-MODEL_NAME= "tts_models/multilingual/multi-dataset/your_tts"
-
-
-
-def greet(character,your_voice,message,history):
-
- #gradios set_state/get_state had problems on embedded html!
- history = history or {"character": character, "message_history" : [] }
- #gradios set_state/get_state does not persist session for now using global
- #global history
-
- if history["character"] != character:
- #switching character
- history = {"character": character, "message_history" : [] }
-
-
- response = get_chat_response(character,history=history["message_history"],input_txt=message)
- os.system('tts --text "'+response+'" --model_name tts_models/multilingual/multi-dataset/your_tts --speaker_wav '+your_voice+' --language_idx "en"')
-
- history["message_history"].append((message, response))
-
- #emotion = get_emotion(response)
-
- html = ""
- for user_msg, resp_msg in history["message_history"]:
- html += f"You: {user_msg}"
- html += f"{character}: {resp_msg}"
- html += ""
-
- return html,history,"tts_output.wav"
-
-
-def greet_textonly(character,message,history):
-
- #gradios set_state/get_state had problems on embedded html!
- history = history or {"character": character, "message_history" : [] }
- #gradios set_state/get_state does not persist session for now using global
- #global history
-
- if history["character"] != character:
- #switching character
- history = {"character": character, "message_history" : [] }
-
-
- response = get_chat_response(character,history=history["message_history"],input_txt=message)
-
- history["message_history"].append((message, response))
-
- #emotion = get_emotion(response)
-
- html = ""
- for user_msg, resp_msg in history["message_history"]:
- html += f"You: {user_msg}"
- html += f"{character}: {resp_msg}"
- html += ""
-
- return html,history
-
-
-personality_choices = ["Gandalf", "Riddick", "Macleod", "Morpheus", "Neo","Spock","Vader","Indy"]
-
-examples= ["Gandalf", "What is your name?"]
-
-css="""
- .chatbox {display:flex;flex-direction:column}
- .user_msg, .resp_msg {padding:4px;margin-bottom:4px;border-radius:4px;width:80%}
- .user_msg {background-color:cornflowerblue;color:white;align-self:start}
- .resp_msg {background-color:lightgray;align-self:self-end}
-"""
-
-
-#some selected ones are in for demo use
-personality_choices = ["Gandalf", "Riddick", "Macleod", "Morpheus", "Neo","Spock","Vader","Indy", "Ig-11","Threepio","Tony Stark","Batman","Vizzini"]
-title = "Movie Chatbot with Coqui YourTTS - File Input"
-description = "Chat with your favorite movie characters, making characters voice like you. Test it out in metayazar.com/chatbot for more movie/character options. See Coqui Space for more TTS models https://huggingface.co/spaces/coqui/CoquiTTS"
-article = "AI Goes to Job Interview | Metayazar AI Writer |Görkem Göknar
"
-
-#History not implemented in this demo, use metayazar.com/chatbot for a movie and character dropdown chat interface
-##interface = gr.Interface(fn=greet, inputs=[gr.inputs.Dropdown(personality_choices) ,"text"], title=title, description=description, outputs="text")
-
-examples=[['Gandalf','dragon.wav','Who are you sir?',{}]]
-
-history = {"character": "None", "message_history" : [] }
-
-interface_file= gr.Interface(fn=greet,
- inputs=[gr.inputs.Dropdown(personality_choices),
- gr.inputs.Audio(type="filepath"),
- "text",
- "state"],
- outputs=["html","state",gr.outputs.Audio(type="filepath")],
- css=css, title=title, description=description,article=article )
-
-
-if __name__ == "__main__":
- interface_file.launch()
\ No newline at end of file
diff --git a/spaces/gotiQspiryo/whisper-ui/Naruto-Shippuden-Ultimate-Ninja-Storm-5-Psp-Iso-23.md b/spaces/gotiQspiryo/whisper-ui/Naruto-Shippuden-Ultimate-Ninja-Storm-5-Psp-Iso-23.md
deleted file mode 100644
index f127d7ad53f45b7119cff043f2bc203ef16a2640..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/Naruto-Shippuden-Ultimate-Ninja-Storm-5-Psp-Iso-23.md
+++ /dev/null
@@ -1,70 +0,0 @@
-## naruto shippuden ultimate ninja storm 5 psp iso 23
-
-
-
-
-
-
-
-
-
-**LINK --->>> [https://miimms.com/2txSTe](https://miimms.com/2txSTe)**
-
-
-
-
-
-
-
-
-
-
-
- Here is a possible title and article for the keyword "naruto shippuden ultimate ninja storm 5 psp iso 23". I have used code blocks to encapsulate the html formatting.
-
-# Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23: How to Download and Play
-
-
-
-If you are a fan of Naruto Shippuden, you might be interested in playing Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23. This is a modified version of the original Naruto Shippuden Ultimate Ninja Storm 5 game that was released for PlayStation 4 and Xbox One in 2016. The PSP ISO 23 version has some new features and improvements, such as new characters, new stages, new modes, and better graphics.
-
-
-
-In this article, we will show you how to download and play Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 on your Android device. You will need a PSP emulator app and a file manager app to do this. Follow these steps:
-
-
-
-1. Download the Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 file from a reliable source. You can search for it on Google or use the link below. The file size is about 1.2 GB, so make sure you have enough space on your device.
-
-2. Download the PPSSPP Gold emulator app from the Google Play Store or use the link below. This is a paid app that costs $4.99, but it is worth it because it has better performance and features than the free version.
-
-3. Install the PPSSPP Gold app on your device and open it.
-
-4. Locate the Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 file on your device using a file manager app. You can use any file manager app that you like, such as ES File Explorer or ZArchiver.
-
-5. Tap on the Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 file and select "Open with PPSSPP". The game will start loading on the emulator.
-
-6. Enjoy playing Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 on your Android device. You can customize the settings and controls of the emulator according to your preference.
-
-
-
-Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 is a fun and exciting game that will keep you entertained for hours. You can play as your favorite characters from the Naruto Shippuden series and experience their epic battles and adventures. You can also play with your friends online or offline using the multiplayer mode. If you are a Naruto fan, you should definitely try this game.
-
-Here are a few more paragraphs for the article. I have used code blocks to encapsulate the html formatting.
-
-Naruto Shippuden Ultimate Ninja Storm 5 PSP ISO 23 is a modified version of Naruto Shippuden Narutimate Accel 3, which is a 2D fighting game created by CyberConnect2 and published by BANDAI NAMACO Entertainment. The game is based on the Naruto anime series and features many characters and stages from the show. You can play as Naruto, Sasuke, Sakura, Kakashi, and many more in various modes and scenarios.
-
-
-
-The game has several features that make it different from the original Naruto Shippuden Narutimate Accel 3. For example, the game has a new front, a new battle selection menu, and a new character selection menu. The game also has improved graphics and textures that make it look more realistic and detailed. The game also has some new characters and stages that were not available in the original game.
-
-
-
-Some of the new characters include Boruto Uzumaki, Sarada Uchiha, Mitsuki, Kawaki, Momoshiki Otsutsuki, Kinshiki Otsutsuki, and Urashiki Otsutsuki. These are characters from the Boruto: Naruto Next Generations anime series, which is a sequel to Naruto Shippuden. Some of the new stages include Konoha Village, Hidden Leaf Forest, Hidden Sand Village, Hidden Mist Village, and Hidden Cloud Village. These are locations from the Naruto world that have different environments and effects.
-
- dfd1c89656
-
-
-
-
-
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Download Being Heumann An Unrepentant Memoir by Judith Heumann (.ePUB) - A Powerful and Honest Account of Her Life and Struggles.md b/spaces/gotiQspiryo/whisper-ui/examples/Download Being Heumann An Unrepentant Memoir by Judith Heumann (.ePUB) - A Powerful and Honest Account of Her Life and Struggles.md
deleted file mode 100644
index adeda478d91938509761aed7c464b889dc7fce40..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/Download Being Heumann An Unrepentant Memoir by Judith Heumann (.ePUB) - A Powerful and Honest Account of Her Life and Struggles.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Download Being Heumann: An Unrepentant Memoir by Judith Heumann (.ePUB)
Download File --->>> https://urlgoal.com/2uyNAa
-
- aaccfb2cb3
-
-
-
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Ea Vp6 Encoder Download.md b/spaces/gotiQspiryo/whisper-ui/examples/Ea Vp6 Encoder Download.md
deleted file mode 100644
index 7b092a8ebd6af08ca4aca710ee99a3d1827f67fb..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/Ea Vp6 Encoder Download.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Ea vp6 encoder download
Download –––––>>> https://urlgoal.com/2uyLZY
-
-Go to http://freedv.org/, download "Codec 2 source archive". Build and ... For a list of supported modes, run ffmpeg -h encoder=libcodec2 . Raw codec2 ... Electronic Arts cdata, X. Electronic ... On2 VP6, X, fourcc: VP60,VP61,VP62. On2 VP7, XÂ ... 4d29de3e1b
-
-
-
diff --git a/spaces/gradio/longformer/tests/test_readme.py b/spaces/gradio/longformer/tests/test_readme.py
deleted file mode 100644
index add727cf189b7e3ee1e436e0261a16ebf1f1bb0d..0000000000000000000000000000000000000000
--- a/spaces/gradio/longformer/tests/test_readme.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import os
-import tarfile
-import unittest
-import urllib
-
-import torch
-from transformers import RobertaTokenizer
-
-from longformer.longformer import Longformer, LongformerConfig
-from longformer.sliding_chunks import pad_to_window_size
-
-
-class TestReadme(unittest.TestCase):
- def setUp(self) -> None:
- self.model_dir = "/tmp/longformer-base-4096"
- if os.path.exists(self.model_dir):
- # already have the model. nothing to do
- return
-
- # download zip
- print("Downloading model...")
- urllib.request.urlretrieve(
- "https://ai2-s2-research.s3-us-west-2.amazonaws.com/longformer/longformer-base-4096.tar.gz",
- "/tmp/longformer-base-4096.tar.gz")
-
- # unpack
- print("unpacking....")
- with tarfile.open("/tmp/longformer-base-4096.tar.gz") as tar:
- tar.extractall("/tmp")
-
- def test_something(self):
- config = LongformerConfig.from_pretrained(self.model_dir)
- # choose the attention mode 'n2', 'tvm' or 'sliding_chunks'
- # 'n2': for regular n2 attantion
- # 'tvm': a custom CUDA kernel implementation of our sliding window attention
- # 'sliding_chunks': a PyTorch implementation of our sliding window attention
- config.attention_mode = 'sliding_chunks'
-
- model = Longformer.from_pretrained(self.model_dir, config=config)
- tokenizer = RobertaTokenizer.from_pretrained('roberta-base')
- tokenizer.model_max_length = model.config.max_position_embeddings
-
- SAMPLE_TEXT = ' '.join(['Hello world! '] * 1000) # long input document
-
- input_ids = torch.tensor(tokenizer.encode(SAMPLE_TEXT)).unsqueeze(
- 0) # batch of size 1
-
- # TVM code doesn't work on CPU. Uncomment this if `config.attention_mode = 'tvm'`
- # model = model.cuda(); input_ids = input_ids.cuda()
-
- # Attention mask values -- 0: no attention, 1: local attention, 2: global attention
- attention_mask = torch.ones(input_ids.shape, dtype=torch.long,
- device=input_ids.device) # initialize to local attention
- attention_mask[:,
- [1, 4, 21, ]] = 2 # Set global attention based on the task. For example,
- # classification: the token
- # QA: question tokens
-
- # padding seqlen to the nearest multiple of 512. Needed for the 'sliding_chunks' attention
- input_ids, attention_mask = pad_to_window_size(
- input_ids, attention_mask, config.attention_window[0],
- tokenizer.pad_token_id)
-
- output = model(input_ids, attention_mask=attention_mask)[0]
-
- # could have done more here....
- self.assertIsNotNone(output)
-
-if __name__ == '__main__':
- unittest.main()
diff --git a/spaces/gradio/timeseries-forecasting-with-prophet/README.md b/spaces/gradio/timeseries-forecasting-with-prophet/README.md
deleted file mode 100644
index 4919040b7b432f9b2c62ee8af2724e6c80bd308f..0000000000000000000000000000000000000000
--- a/spaces/gradio/timeseries-forecasting-with-prophet/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
-
----
-title: timeseries-forecasting-with-prophet
-emoji: 🔥
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 4.1.2
-app_file: run.py
-pinned: false
-hf_oauth: true
----
diff --git a/spaces/gstaff/MagicGen/colab-data-test/css/keyrune.min.css b/spaces/gstaff/MagicGen/colab-data-test/css/keyrune.min.css
deleted file mode 100644
index cdf35e6bd769f6c225e253d78704de45cdad69b3..0000000000000000000000000000000000000000
--- a/spaces/gstaff/MagicGen/colab-data-test/css/keyrune.min.css
+++ /dev/null
@@ -1 +0,0 @@
-@font-face{font-family:Keyrune;src:url(../fonts/keyrune.eot?v=1.6.0);src:url(../fonts/keyrune.eot?#iefix&v=1.6.0) format('embedded-opentype'),url(../fonts/keyrune.woff2?v=1.6.0) format('woff2'),url(../fonts/keyrune.woff?v=1.6.0) format('woff'),url(../fonts/keyrune.ttf?v=1.6.0) format('truetype'),url(../fonts/keyrune.svg?v=1.6.0#keyrune) format('svg');font-weight:400;font-style:normal}.ss{display:inline-block;font:normal normal normal 14px/1 Keyrune;font-size:inherit;line-height:1em;text-rendering:auto;transform:translate(0,0);speak:none;text-transform:none;vertical-align:middle;-webkit-font-smoothing:antialiased;-moz-osx-font-smoothing:grayscale}.ss:before{content:"\e684"}.ss-2x{font-size:2em}.ss-3x{font-size:3em}.ss-4x{font-size:4em}.ss-5x{font-size:5em}.ss-6x{font-size:6em}.ss-common{color:#1A1718}.ss-common.ss-grad{background:-webkit-gradient(linear,left top,right top,color-stop(1%,#302b2c),color-stop(50%,#474040),color-stop(100%,#302b2c));background:-webkit-linear-gradient(left,#302b2c 1%,#474040 50%,#302b2c 100%);-webkit-text-stroke:.03em #000;-webkit-background-clip:text;-webkit-text-fill-color:transparent}.ss-common.ss-grad.ss-no-border{-webkit-text-stroke:0}.ss-uncommon{color:#707883}.ss-uncommon.ss-grad{background:-webkit-gradient(linear,left top,right top,color-stop(0,#5a6572),color-stop(50%,#9e9e9e),color-stop(100%,#5a6572));background:-webkit-linear-gradient(left,#5a6572 0,#9e9e9e 50%,#5a6572 100%);-webkit-text-stroke:.03em #111;-webkit-background-clip:text;-webkit-text-fill-color:transparent}.ss-uncommon.ss-grad.ss-no-border{-webkit-text-stroke:0}.ss-rare{color:#A58E4A}.ss-rare.ss-grad{background:-webkit-gradient(linear,left top,right top,color-stop(0,#876a3b),color-stop(50%,#dfbd6b),color-stop(100%,#876a3b));background:-webkit-linear-gradient(left,#876a3b 0,#dfbd6b 50%,#876a3b 100%);-webkit-text-stroke:.03em #333;-webkit-background-clip:text;-webkit-text-fill-color:transparent}.ss-rare.ss-grad.ss-no-border{-webkit-text-stroke:0}.ss-mythic{color:#BF4427}.ss-mythic.ss-grad{background:-webkit-gradient(linear,left top,right top,color-stop(0,#b21f0f),color-stop(50%,#f38300),color-stop(100%,#b21f0f));background:-webkit-linear-gradient(left,#b21f0f 0,#f38300 50%,#b21f0f 100%);-webkit-text-stroke:.03em #333;-webkit-background-clip:text;-webkit-text-fill-color:transparent}.ss-mythic.ss-grad.ss-no-border{-webkit-text-stroke:0}.ss-fw{width:1.28571429em;text-align:center}.ss-lea:before{content:"\e600"}.ss-leb:before{content:"\e601"}.ss-2ed:before{content:"\e602"}.ss-3ed:before{content:"\e603"}.ss-4ed:before{content:"\e604"}.ss-psum:before{content:"\e605"}.ss-5ed:before{content:"\e606"}.ss-6ed:before{content:"\e607"}.ss-7ed:before{content:"\e608"}.ss-8ed:before{content:"\e609"}.ss-9ed:before{content:"\e60a"}.ss-10e:before{content:"\e60b"}.ss-m10:before{content:"\e60c"}.ss-m11:before{content:"\e60d"}.ss-m12:before{content:"\e60e"}.ss-m13:before{content:"\e60f"}.ss-m14:before{content:"\e610"}.ss-m15:before{content:"\e611"}.ss-bcore:before{content:"\e612"}.ss-ori:before{content:"\e697"}.ss-arn:before{content:"\e613"}.ss-atq:before{content:"\e614"}.ss-leg:before{content:"\e615"}.ss-drk:before{content:"\e616"}.ss-fem:before{content:"\e617"}.ss-hml:before{content:"\e618"}.ss-ice:before{content:"\e619"}.ss-all:before{content:"\e61a"}.ss-csp:before{content:"\e61b"}.ss-mir:before{content:"\e61c"}.ss-vis:before{content:"\e61d"}.ss-wth:before{content:"\e61e"}.ss-tmp:before{content:"\e61f"}.ss-sth:before{content:"\e620"}.ss-exo:before{content:"\e621"}.ss-usg:before{content:"\e622"}.ss-ulg:before{content:"\e623"}.ss-uds:before{content:"\e624"}.ss-mmq:before{content:"\e625"}.ss-nms:before{content:"\e626"}.ss-pcy:before{content:"\e627"}.ss-inv:before{content:"\e628"}.ss-pls:before{content:"\e629"}.ss-apc:before{content:"\e62a"}.ss-ody:before{content:"\e62b"}.ss-tor:before{content:"\e62c"}.ss-jud:before{content:"\e62d"}.ss-ons:before{content:"\e62e"}.ss-lgn:before{content:"\e62f"}.ss-scg:before{content:"\e630"}.ss-mrd:before{content:"\e631"}.ss-dst:before{content:"\e632"}.ss-5dn:before{content:"\e633"}.ss-chk:before{content:"\e634"}.ss-bok:before{content:"\e635"}.ss-sok:before{content:"\e636"}.ss-rav:before{content:"\e637"}.ss-gpt:before{content:"\e638"}.ss-dis:before{content:"\e639"}.ss-tsp:before{content:"\e63a"}.ss-plc:before{content:"\e63b"}.ss-fut:before{content:"\e63c"}.ss-lrw:before{content:"\e63d"}.ss-mor:before{content:"\e63e"}.ss-shm:before{content:"\e63f"}.ss-eve:before{content:"\e640"}.ss-ala:before{content:"\e641"}.ss-con:before{content:"\e642"}.ss-arb:before{content:"\e643"}.ss-zen:before{content:"\e644"}.ss-wwk:before{content:"\e645"}.ss-roe:before{content:"\e646"}.ss-som:before{content:"\e647"}.ss-mbs:before{content:"\e648"}.ss-nph:before{content:"\e649"}.ss-isd:before{content:"\e64a"}.ss-dka:before{content:"\e64b"}.ss-avr:before{content:"\e64c"}.ss-rtr:before{content:"\e64d"}.ss-gtc:before{content:"\e64e"}.ss-dgm:before{content:"\e64f"}.ss-ths:before{content:"\e650"}.ss-bng:before{content:"\e651"}.ss-jou:before{content:"\e652"}.ss-ktk:before{content:"\e653"}.ss-frf:before{content:"\e654"}.ss-dtk:before{content:"\e693"}.ss-bfz:before{content:"\e699"}.ss-ogw:before{content:"\e901"}.ss-soi:before{content:"\e902"}.ss-emn:before{content:"\e90b"}.ss-van:before{content:"\e655"}.ss-hop:before{content:"\e656"}.ss-arc:before{content:"\e657"}.ss-cmd:before{content:"\e658"}.ss-pc2:before{content:"\e659"}.ss-cm1:before{content:"\e65a"}.ss-c13:before{content:"\e65b"}.ss-cns:before{content:"\e65c"}.ss-c14:before{content:"\e65d"}.ss-c15:before{content:"\e900"}.ss-cn2:before{content:"\e904"}.ss-chr:before{content:"\e65e"}.ss-ath:before{content:"\e65f"}.ss-brb:before{content:"\e660"}.ss-btd:before{content:"\e661"}.ss-dkm:before{content:"\e662"}.ss-mma:before{content:"\e663"}.ss-mm2:before{content:"\e695"}.ss-ema:before{content:"\e903"}.ss-por:before{content:"\e664"}.ss-po2:before{content:"\e665"}.ss-ptk:before{content:"\e666"}.ss-s99:before{content:"\e667"}.ss-s00:before{content:"\e668"}.ss-w16:before{content:"\e907"}.ss-evg:before{content:"\e669"}.ss-dd2:before{content:"\e66a"}.ss-ddc:before{content:"\e66b"}.ss-ddd:before{content:"\e66c"}.ss-dde:before{content:"\e66d"}.ss-ddf:before{content:"\e66e"}.ss-ddg:before{content:"\e66f"}.ss-ddh:before{content:"\e670"}.ss-ddi:before{content:"\e671"}.ss-ddj:before{content:"\e672"}.ss-ddk:before{content:"\e673"}.ss-ddl:before{content:"\e674"}.ss-ddm:before{content:"\e675"}.ss-ddn:before{content:"\e676"}.ss-ddo:before{content:"\e677"}.ss-ddp:before{content:"\e698"}.ss-ddq:before{content:"\e908"}.ss-drb:before{content:"\e678"}.ss-v09:before{content:"\e679"}.ss-v10:before{content:"\e67a"}.ss-v11:before{content:"\e67b"}.ss-v12:before{content:"\e67c"}.ss-v13:before{content:"\e67d"}.ss-v14:before{content:"\e67e"}.ss-v15:before{content:"\e905"}.ss-v16:before{content:"\e906"}.ss-h09:before{content:"\e67f"}.ss-pd2:before{content:"\e680"}.ss-pd3:before{content:"\e681"}.ss-md1:before{content:"\e682"}.ss-pgru:before{content:"\e683"}.ss-pmtg1:before{content:"\e684"}.ss-pmtg2:before{content:"\e685"}.ss-pleaf:before{content:"\e686"}.ss-pmei:before{content:"\e687"}.ss-parl:before{content:"\e688"}.ss-dpa:before{content:"\e689"}.ss-pbook:before{content:"\e68a"}.ss-past:before{content:"\e68b"}.ss-parl2:before{content:"\e68c"}.ss-exp:before{content:"\e69a"}.ss-psalvat05:before{content:"\e909"}.ss-psalvat11:before{content:"\e90a"}.ss-med:before{content:"\e68d"}.ss-me2:before{content:"\e68e"}.ss-me3:before{content:"\e68f"}.ss-me4:before{content:"\e690"}.ss-tpr:before{content:"\e694"}.ss-vma:before{content:"\e696"}.ss-ugl:before{content:"\e691"}.ss-unh:before{content:"\e692"}.ss-border:after{content:"";position:absolute;left:-.05em;top:0;color:#fff;font-size:1.15em;z-index:-1;background:#fff;-webkit-text-stroke:.05em #fff;-webkit-background-clip:text;-webkit-text-fill-color:transparent}.ss-border.ss-van:after{content:"\e655"}.ss-border.ss-hop:after{content:"\e656"}.ss-border.ss-arc:after{content:"\e657"}.ss-border.ss-cmd:after{content:"\e658"}.ss-border.ss-pc2:after{content:"\e659"}.ss-border.ss-cm1:after{content:"\e65a"}.ss-border.ss-c13:after{content:"\e65b"}.ss-border.ss-cns:after{content:"\e65c"}.ss-border.ss-c14:after{content:"\e65d"}.ss-border.ss-c15:after{content:"\e900"}
\ No newline at end of file
diff --git a/spaces/h2oai/wave-tour/examples/form_markup.py b/spaces/h2oai/wave-tour/examples/form_markup.py
deleted file mode 100644
index bccbcc4953665cda85caac66b68761156434169f..0000000000000000000000000000000000000000
--- a/spaces/h2oai/wave-tour/examples/form_markup.py
+++ /dev/null
@@ -1,23 +0,0 @@
-# Form / Markup
-# Use a #markup component to display formatted content using #HTML.
-# #form
-# ---
-from h2o_wave import site, ui
-
-page = site['/demo']
-
-menu = '''
-
-
-'''
-
-page['example'] = ui.form_card(
- box='1 1 2 2',
- items=[
- ui.markup(content=menu)
- ]
-)
-page.save()
diff --git a/spaces/hamelcubsfan/AutoGPT/autogpt/memory/pinecone.py b/spaces/hamelcubsfan/AutoGPT/autogpt/memory/pinecone.py
deleted file mode 100644
index 27fcd62482d0cf44e02fa1c339195be58cb745b0..0000000000000000000000000000000000000000
--- a/spaces/hamelcubsfan/AutoGPT/autogpt/memory/pinecone.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import pinecone
-from colorama import Fore, Style
-
-from autogpt.llm_utils import create_embedding_with_ada
-from autogpt.logs import logger
-from autogpt.memory.base import MemoryProviderSingleton
-
-
-class PineconeMemory(MemoryProviderSingleton):
- def __init__(self, cfg):
- pinecone_api_key = cfg.pinecone_api_key
- pinecone_region = cfg.pinecone_region
- pinecone.init(api_key=pinecone_api_key, environment=pinecone_region)
- dimension = 1536
- metric = "cosine"
- pod_type = "p1"
- table_name = "auto-gpt"
- # this assumes we don't start with memory.
- # for now this works.
- # we'll need a more complicated and robust system if we want to start with
- # memory.
- self.vec_num = 0
-
- try:
- pinecone.whoami()
- except Exception as e:
- logger.typewriter_log(
- "FAILED TO CONNECT TO PINECONE",
- Fore.RED,
- Style.BRIGHT + str(e) + Style.RESET_ALL,
- )
- logger.double_check(
- "Please ensure you have setup and configured Pinecone properly for use."
- + f"You can check out {Fore.CYAN + Style.BRIGHT}"
- "https://github.com/Torantulino/Auto-GPT#-pinecone-api-key-setup"
- f"{Style.RESET_ALL} to ensure you've set up everything correctly."
- )
- exit(1)
-
- if table_name not in pinecone.list_indexes():
- pinecone.create_index(
- table_name, dimension=dimension, metric=metric, pod_type=pod_type
- )
- self.index = pinecone.Index(table_name)
-
- def add(self, data):
- vector = create_embedding_with_ada(data)
- # no metadata here. We may wish to change that long term.
- self.index.upsert([(str(self.vec_num), vector, {"raw_text": data})])
- _text = f"Inserting data into memory at index: {self.vec_num}:\n data: {data}"
- self.vec_num += 1
- return _text
-
- def get(self, data):
- return self.get_relevant(data, 1)
-
- def clear(self):
- self.index.delete(deleteAll=True)
- return "Obliviated"
-
- def get_relevant(self, data, num_relevant=5):
- """
- Returns all the data in the memory that is relevant to the given data.
- :param data: The data to compare to.
- :param num_relevant: The number of relevant data to return. Defaults to 5
- """
- query_embedding = create_embedding_with_ada(data)
- results = self.index.query(
- query_embedding, top_k=num_relevant, include_metadata=True
- )
- sorted_results = sorted(results.matches, key=lambda x: x.score)
- return [str(item["metadata"]["raw_text"]) for item in sorted_results]
-
- def get_stats(self):
- return self.index.describe_index_stats()
diff --git a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/registry.py b/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/registry.py
deleted file mode 100644
index dca130c07ef96b6f4bcb649675ec4d405b7a4728..0000000000000000000000000000000000000000
--- a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/registry.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-from maskrcnn_benchmark.utils.registry import Registry
-
-BACKBONES = Registry()
-
-LANGUAGE_BACKBONES = Registry()
-
-ROI_BOX_FEATURE_EXTRACTORS = Registry()
-RPN_HEADS = Registry()
diff --git a/spaces/hf-accelerate/accelerate_examples/Makefile b/spaces/hf-accelerate/accelerate_examples/Makefile
deleted file mode 100644
index cd8a44d83ecaccb9cae6043701a7eca8a7c6f418..0000000000000000000000000000000000000000
--- a/spaces/hf-accelerate/accelerate_examples/Makefile
+++ /dev/null
@@ -1,19 +0,0 @@
-.PHONY: quality style test docs
-
-# Check that source code meets quality standards
-
-extra_quality_checks:
- doc-builder style src --max_len 119
-
-# this target runs checks on all files
-quality:
- black --check src
- isort --check-only src
- flake8 src
- doc-builder style src --max_len 119 --check_only
-
-# Format source code automatically and check is there are any problems left that need manual fixing
-style:
- black src
- isort src
- doc-builder style src --max_len 119
\ No newline at end of file
diff --git a/spaces/huggingface/data-measurements-tool/app.py b/spaces/huggingface/data-measurements-tool/app.py
deleted file mode 100644
index 37dd6784f3d6353803f7a1abfd608abfae40dbaa..0000000000000000000000000000000000000000
--- a/spaces/huggingface/data-measurements-tool/app.py
+++ /dev/null
@@ -1,290 +0,0 @@
-# Copyright 2021 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 logging
-from os import mkdir
-from os.path import exists, isdir
-from pathlib import Path
-
-import streamlit as st
-
-from data_measurements import dataset_statistics, dataset_utils
-from data_measurements import streamlit_utils as st_utils
-
-logs = logging.getLogger(__name__)
-logs.setLevel(logging.WARNING)
-logs.propagate = False
-
-if not logs.handlers:
-
- Path('./log_files').mkdir(exist_ok=True)
-
- # Logging info to log file
- file = logging.FileHandler("./log_files/app.log")
- fileformat = logging.Formatter("%(asctime)s:%(message)s")
- file.setLevel(logging.INFO)
- file.setFormatter(fileformat)
-
- # Logging debug messages to stream
- stream = logging.StreamHandler()
- streamformat = logging.Formatter("[data_measurements_tool] %(message)s")
- stream.setLevel(logging.WARNING)
- stream.setFormatter(streamformat)
-
- logs.addHandler(file)
- logs.addHandler(stream)
-
-st.set_page_config(
- page_title="Demo to showcase dataset metrics",
- page_icon="https://huggingface.co/front/assets/huggingface_logo.svg",
- layout="wide",
- initial_sidebar_state="auto",
-)
-
-# colorblind-friendly colors
-colors = [
- "#332288",
- "#117733",
- "#882255",
- "#AA4499",
- "#CC6677",
- "#44AA99",
- "#DDCC77",
- "#88CCEE",
-]
-
-CACHE_DIR = dataset_utils.CACHE_DIR
-# String names we are using (not coming from the stored dataset).
-OUR_TEXT_FIELD = dataset_utils.OUR_TEXT_FIELD
-OUR_LABEL_FIELD = dataset_utils.OUR_LABEL_FIELD
-TOKENIZED_FIELD = dataset_utils.TOKENIZED_FIELD
-EMBEDDING_FIELD = dataset_utils.EMBEDDING_FIELD
-LENGTH_FIELD = dataset_utils.LENGTH_FIELD
-# TODO: Allow users to specify this.
-_MIN_VOCAB_COUNT = 10
-_SHOW_TOP_N_WORDS = 10
-
-
-@st.cache(
- hash_funcs={
- dataset_statistics.DatasetStatisticsCacheClass: lambda dstats: dstats.cache_path
- },
- allow_output_mutation=True,
-)
-def load_or_prepare(ds_args, show_embeddings, use_cache=False):
- """
- Takes the dataset arguments from the GUI and uses them to load a dataset from the Hub or, if
- a cache for those arguments is available, to load it from the cache.
- Args:
- ds_args (dict): the dataset arguments defined via the streamlit app GUI
- show_embeddings (Bool): whether embeddings should we loaded and displayed for this dataset
- use_cache (Bool) : whether the cache is used by default or not
- Returns:
- dstats: the computed dataset statistics (from the dataset_statistics class)
- """
- if not isdir(CACHE_DIR):
- logs.warning("Creating cache")
- # We need to preprocess everything.
- # This should eventually all go into a prepare_dataset CLI
- mkdir(CACHE_DIR)
- if use_cache:
- logs.warning("Using cache")
- dstats = dataset_statistics.DatasetStatisticsCacheClass(CACHE_DIR, **ds_args, use_cache=use_cache)
- logs.warning("Loading dataset")
- dstats.load_or_prepare_dataset()
- logs.warning("Loading labels")
- dstats.load_or_prepare_labels()
- logs.warning("Loading text lengths")
- dstats.load_or_prepare_text_lengths()
- logs.warning("Loading duplicates")
- dstats.load_or_prepare_text_duplicates()
- logs.warning("Loading vocabulary")
- dstats.load_or_prepare_vocab()
- logs.warning("Loading general statistics...")
- dstats.load_or_prepare_general_stats()
- if show_embeddings:
- logs.warning("Loading Embeddings")
- dstats.load_or_prepare_embeddings()
- logs.warning("Loading nPMI")
- try:
- dstats.load_or_prepare_npmi()
- except:
- logs.warning("Missing a cache for npmi")
- logs.warning("Loading Zipf")
- dstats.load_or_prepare_zipf()
- return dstats
-
-@st.cache(
- hash_funcs={
- dataset_statistics.DatasetStatisticsCacheClass: lambda dstats: dstats.cache_path
- },
- allow_output_mutation=True,
-)
-def load_or_prepare_widgets(ds_args, show_embeddings, use_cache=False):
- """
- Loader specifically for the widgets used in the app.
- Args:
- ds_args:
- show_embeddings:
- use_cache:
-
- Returns:
-
- """
-
- if use_cache:
- logs.warning("Using cache")
- if True:
- #try:
- dstats = dataset_statistics.DatasetStatisticsCacheClass(CACHE_DIR, **ds_args, use_cache=use_cache)
- # Don't recalculate; we're live
- dstats.set_deployment(True)
- # checks whether the cache_dir exists in deployment mode
- # creates cache_dir if not and if in development mode
- cache_dir_exists = dstats.check_cache_dir()
- #except:
- # logs.warning("We're screwed")
- if cache_dir_exists:
- try:
- # We need to have the text_dset loaded for further load_or_prepare
- dstats.load_or_prepare_dataset()
- except:
- logs.warning("Missing a cache for load or prepare dataset")
- try:
- # Header widget
- dstats.load_or_prepare_dset_peek()
- except:
- logs.warning("Missing a cache for dset peek")
- try:
- # General stats widget
- dstats.load_or_prepare_general_stats()
- except:
- logs.warning("Missing a cache for general stats")
- try:
- # Labels widget
- dstats.load_or_prepare_labels()
- except:
- logs.warning("Missing a cache for prepare labels")
- try:
- # Text lengths widget
- dstats.load_or_prepare_text_lengths()
- except:
- logs.warning("Missing a cache for text lengths")
- if show_embeddings:
- try:
- # Embeddings widget
- dstats.load_or_prepare_embeddings()
- except:
- logs.warning("Missing a cache for embeddings")
- try:
- dstats.load_or_prepare_text_duplicates()
- except:
- logs.warning("Missing a cache for text duplicates")
- try:
- dstats.load_or_prepare_npmi()
- except:
- logs.warning("Missing a cache for npmi")
- try:
- dstats.load_or_prepare_zipf()
- except:
- logs.warning("Missing a cache for zipf")
- return dstats, cache_dir_exists
-
-def show_column(dstats, ds_name_to_dict, show_embeddings, column_id):
- """
- Function for displaying the elements in the right column of the streamlit app.
- Args:
- ds_name_to_dict (dict): the dataset name and options in dictionary form
- show_embeddings (Bool): whether embeddings should we loaded and displayed for this dataset
- column_id (str): what column of the dataset the analysis is done on
- Returns:
- The function displays the information using the functions defined in the st_utils class.
- """
- # Note that at this point we assume we can use cache; default value is True.
- # start showing stuff
- title_str = f"### Showing{column_id}: {dstats.dset_name} - {dstats.dset_config} - {dstats.split_name} - {'-'.join(dstats.text_field)}"
- st.markdown(title_str)
- logs.info("showing header")
- st_utils.expander_header(dstats, ds_name_to_dict, column_id)
- logs.info("showing general stats")
- st_utils.expander_general_stats(dstats, column_id)
- st_utils.expander_label_distribution(dstats.fig_labels, column_id)
- st_utils.expander_text_lengths(dstats, column_id)
- st_utils.expander_text_duplicates(dstats, column_id)
- # Uses an interaction; handled a bit differently than other widgets.
- logs.info("showing npmi widget")
- st_utils.npmi_widget(dstats.npmi_stats, _MIN_VOCAB_COUNT, column_id)
- logs.info("showing zipf")
- st_utils.expander_zipf(dstats.z, dstats.zipf_fig, column_id)
- if show_embeddings:
- st_utils.expander_text_embeddings(
- dstats.text_dset,
- dstats.fig_tree,
- dstats.node_list,
- dstats.embeddings,
- OUR_TEXT_FIELD,
- column_id,
- )
-
-
-def main():
- """ Sidebar description and selection """
- ds_name_to_dict = dataset_utils.get_dataset_info_dicts()
- st.title("Data Measurements Tool")
- # Get the sidebar details
- st_utils.sidebar_header()
- # Set up naming, configs, and cache path.
- compare_mode = st.sidebar.checkbox("Comparison mode")
-
- # When not doing new development, use the cache.
- use_cache = True
- show_embeddings = st.sidebar.checkbox("Show text clusters")
- # List of datasets for which embeddings are hard to compute:
-
- if compare_mode:
- logs.warning("Using Comparison Mode")
- dataset_args_left = st_utils.sidebar_selection(ds_name_to_dict, " A")
- dataset_args_right = st_utils.sidebar_selection(ds_name_to_dict, " B")
- left_col, _, right_col = st.columns([10, 1, 10])
- dstats_left, cache_exists_left = load_or_prepare_widgets(
- dataset_args_left, show_embeddings, use_cache=use_cache
- )
- with left_col:
- if cache_exists_left:
- show_column(dstats_left, ds_name_to_dict, show_embeddings, " A")
- else:
- st.markdown("### Missing pre-computed data measures!")
- st.write(dataset_args_left)
- dstats_right, cache_exists_right = load_or_prepare_widgets(
- dataset_args_right, show_embeddings, use_cache=use_cache
- )
- with right_col:
- if cache_exists_right:
- show_column(dstats_right, ds_name_to_dict, show_embeddings, " B")
- else:
- st.markdown("### Missing pre-computed data measures!")
- st.write(dataset_args_right)
- else:
- logs.warning("Using Single Dataset Mode")
- dataset_args = st_utils.sidebar_selection(ds_name_to_dict, "")
- dstats, cache_exists = load_or_prepare_widgets(dataset_args, show_embeddings, use_cache=use_cache)
- if cache_exists:
- show_column(dstats, ds_name_to_dict, show_embeddings, "")
- else:
- st.markdown("### Missing pre-computed data measures!")
- st.write(dataset_args)
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/hwchase17/langchain-demo/app.py b/spaces/hwchase17/langchain-demo/app.py
deleted file mode 100644
index 069bcb36ecf2f10f44909ae700932644b81964a8..0000000000000000000000000000000000000000
--- a/spaces/hwchase17/langchain-demo/app.py
+++ /dev/null
@@ -1,93 +0,0 @@
-import os
-from typing import Optional, Tuple
-
-import gradio as gr
-from langchain.chains import ConversationChain
-from langchain.llms import OpenAI
-
-
-def load_chain():
- """Logic for loading the chain you want to use should go here."""
- llm = OpenAI(temperature=0)
- chain = ConversationChain(llm=llm)
- return chain
-
-
-def set_openai_api_key(api_key: str):
- """Set the api key and return chain.
-
- If no api_key, then None is returned.
- """
- if api_key:
- os.environ["OPENAI_API_KEY"] = api_key
- chain = load_chain()
- os.environ["OPENAI_API_KEY"] = ""
- return chain
-
-
-def chat(
- inp: str, history: Optional[Tuple[str, str]], chain: Optional[ConversationChain]
-):
- """Execute the chat functionality."""
- history = history or []
- # If chain is None, that is because no API key was provided.
- if chain is None:
- history.append((inp, "Please paste your OpenAI key to use"))
- return history, history
- # Run chain and append input.
- output = chain.run(input=inp)
- history.append((inp, output))
- return history, history
-
-
-block = gr.Blocks(css=".gradio-container {background-color: lightgray}")
-
-with block:
- with gr.Row():
- gr.Markdown("LangChain Demo
")
-
- openai_api_key_textbox = gr.Textbox(
- placeholder="Paste your OpenAI API key (sk-...)",
- show_label=False,
- lines=1,
- type="password",
- )
-
- chatbot = gr.Chatbot()
-
- with gr.Row():
- message = gr.Textbox(
- label="What's your question?",
- placeholder="What's the answer to life, the universe, and everything?",
- lines=1,
- )
- submit = gr.Button(value="Send", variant="secondary").style(full_width=False)
-
- gr.Examples(
- examples=[
- "Hi! How's it going?",
- "What should I do tonight?",
- "Whats 2 + 2?",
- ],
- inputs=message,
- )
-
- gr.HTML("Demo application of a LangChain chain.")
-
- gr.HTML(
- "Powered by LangChain 🦜️🔗 "
- )
-
- state = gr.State()
- agent_state = gr.State()
-
- submit.click(chat, inputs=[message, state, agent_state], outputs=[chatbot, state])
- message.submit(chat, inputs=[message, state, agent_state], outputs=[chatbot, state])
-
- openai_api_key_textbox.change(
- set_openai_api_key,
- inputs=[openai_api_key_textbox],
- outputs=[agent_state],
- )
-
-block.launch(debug=True)
diff --git a/spaces/hyxue/HiFiFace-inference-demo/arcface_torch/configs/ms1mv3_r50.py b/spaces/hyxue/HiFiFace-inference-demo/arcface_torch/configs/ms1mv3_r50.py
deleted file mode 100644
index ef1a4b5d7eebf5df9a7340e07a003450fd1df976..0000000000000000000000000000000000000000
--- a/spaces/hyxue/HiFiFace-inference-demo/arcface_torch/configs/ms1mv3_r50.py
+++ /dev/null
@@ -1,27 +0,0 @@
-from easydict import EasyDict as edict
-
-# make training faster
-# our RAM is 256G
-# mount -t tmpfs -o size=140G tmpfs /train_tmp
-
-config = edict()
-config.margin_list = (1.0, 0.5, 0.0)
-config.network = "r50"
-config.resume = False
-config.output = None
-config.embedding_size = 512
-config.sample_rate = 1.0
-config.fp16 = True
-config.momentum = 0.9
-config.weight_decay = 5e-4
-config.batch_size = 128
-config.lr = 0.1
-config.verbose = 2000
-config.dali = False
-
-config.rec = "/train_tmp/ms1m-retinaface-t1"
-config.num_classes = 93431
-config.num_image = 5179510
-config.num_epoch = 20
-config.warmup_epoch = 0
-config.val_targets = ["lfw", "cfp_fp", "agedb_30"]
diff --git a/spaces/hzy123/bingo/src/lib/hooks/use-enter-submit.tsx b/spaces/hzy123/bingo/src/lib/hooks/use-enter-submit.tsx
deleted file mode 100644
index d66b2d3253baff164235d4ca791aae6d84721835..0000000000000000000000000000000000000000
--- a/spaces/hzy123/bingo/src/lib/hooks/use-enter-submit.tsx
+++ /dev/null
@@ -1,23 +0,0 @@
-import { useRef, type RefObject } from 'react'
-
-export function useEnterSubmit(): {
- formRef: RefObject
- onKeyDown: (event: React.KeyboardEvent) => void
-} {
- const formRef = useRef(null)
-
- const handleKeyDown = (
- event: React.KeyboardEvent
- ): void => {
- if (
- event.key === 'Enter' &&
- !event.shiftKey &&
- !event.nativeEvent.isComposing
- ) {
- formRef.current?.requestSubmit()
- event.preventDefault()
- }
- }
-
- return { formRef, onKeyDown: handleKeyDown }
-}
diff --git a/spaces/ichsanprmn/papersumm/README.md b/spaces/ichsanprmn/papersumm/README.md
deleted file mode 100644
index 003a9ff5b63b760021bdd3c9d6749ab986667521..0000000000000000000000000000000000000000
--- a/spaces/ichsanprmn/papersumm/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Papersumm
-emoji: 🐍➡🐛
-colorFrom: indigo
-colorTo: green
-sdk: streamlit
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_
-Display title for the Space
-
-`emoji`: _string_
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_
-Only applicable for `streamlit` SDK.
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_
-Whether the Space stays on top of your list.
diff --git a/spaces/inamXcontru/PoeticTTS/Auslogics Internet Optimizer 2.0.6.55 Portable BEST.md b/spaces/inamXcontru/PoeticTTS/Auslogics Internet Optimizer 2.0.6.55 Portable BEST.md
deleted file mode 100644
index fa5b744ee7d3496e509503d900dfed3087b9b916..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Auslogics Internet Optimizer 2.0.6.55 Portable BEST.md
+++ /dev/null
@@ -1,14 +0,0 @@
-Auslogics Internet Optimizer 2.0.6.55 Portable
Download Zip ->>->>->> https://gohhs.com/2uz3aK
-
-Auslogics Internet Optimizer 2.0 .6.55 Portable Motoimei Frank Zeitler V0.0.1 Rar deep freeze melt for 18 · user avatar micmedsdogbi. Download music for free and without registration in good quality, with convenient online listening - thousands of top songs are waiting for you on the MzMuz portal.
-Download music for every taste on our website, download any music from vk com and other social networks on our website for free.
-On our site top-muzon you can download for free or listen online the newest and most popular songs of 2017-2019 and Linux utorrent deep freeze melt for 18 . And also: - Improves.
-Internet filter for Windows Auslogics Internet Optimizer 2.0.6.55 Portable free download.
-Free download » Internet » Auslogics Internet Optimizer 2.0.
-For Windows, Mac and Linux.
-Download Auslogics Internet Optimizer 2.0.
-For Windows.
-AusLogics Internet Optimizer is a free portable utility for optimizing your Internet connection and improving stability 8a78ff9644
-
-
-
diff --git a/spaces/innnky/nyaru4.0/vdecoder/__init__.py b/spaces/innnky/nyaru4.0/vdecoder/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Brian Lara International Cricket 2007 Crack Gamecopyworld.md b/spaces/inplisQlawa/anything-midjourney-v4-1/Brian Lara International Cricket 2007 Crack Gamecopyworld.md
deleted file mode 100644
index 91c9c7c234440ec8ad10e5d0256def7df09de654..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Brian Lara International Cricket 2007 Crack Gamecopyworld.md
+++ /dev/null
@@ -1,26 +0,0 @@
-
-Brian Lara International Cricket 2007 Crack Gamecopyworld: How to Download and Play the Game for Free
-If you are a fan of cricket and want to enjoy the thrill of playing as one of the legends of the sport, you might be interested in Brian Lara International Cricket 2007. This game is a simulation of cricket that features realistic graphics, gameplay, and commentary. You can choose from various modes such as test matches, one-day internationals, tournaments, and challenges. You can also customize your own team and players, and compete with other players online.
-Brian Lara International Cricket 2007 Crack Gamecopyworld
Download ✶ https://urlin.us/2uEyAQ
-However, if you don't want to spend money on buying the game or don't have a CD-ROM drive to install it, you might be looking for a way to download and play the game for free. That's where Brian Lara International Cricket 2007 Crack Gamecopyworld comes in. This is a website that provides cracked versions of various games, including Brian Lara International Cricket 2007. By downloading and installing the crack from this website, you can bypass the copy protection and play the game without any restrictions.
-How to Download and Install Brian Lara International Cricket 2007 Crack Gamecopyworld
-Before you download and install the crack from Brian Lara International Cricket 2007 Crack Gamecopyworld, you need to have the original game installed on your PC. You can either buy it from an online store or download it from a torrent site. Once you have the game installed, follow these steps to download and install the crack:
-
-
-Tips and Warnings
-
-
- d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Call Of Duty Modern Warfare 3 Psp Iso Download [WORK].md b/spaces/inplisQlawa/anything-midjourney-v4-1/Call Of Duty Modern Warfare 3 Psp Iso Download [WORK].md
deleted file mode 100644
index 6ba5e23ae9b1ef98815bc2aa77d0437ac0d1c303..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Call Of Duty Modern Warfare 3 Psp Iso Download [WORK].md
+++ /dev/null
@@ -1,205 +0,0 @@
-
-Call of Duty Modern Warfare 3 PSP Iso Download: How to Play the Best Shooter Game on Your Android Device
-
-If you are a fan of the Call of Duty series, you probably know that the latest instalment, Modern Warfare 3, is one of the most popular and critically acclaimed games of all time. The game features a thrilling single-player campaign that takes you to various locations around the world, such as New York, London, and Paris, to stop a terrorist plot that threatens to destroy the world. The game also has a robust multiplayer mode that supports up to 10 players and offers various game types, such as Team Deathmatch and Domination. There is also a new cooperative mode called Survival, where you have to team up with other players to fight against waves of enemies.
-
-But what if you don't have a PlayStation 3, Xbox 360, or Wii console to play the game? Don't worry, because there is a way to play Call of Duty Modern Warfare 3 on your Android device using a PSP emulator called PPSSPP. PPSSPP is a free and open-source emulator that allows you to run PSP games on your Android device with high-quality graphics and sound. You can download PPSSPP from the Google Play Store or from its official website.
-call of duty modern warfare 3 psp iso download
DOWNLOAD ——— https://urlin.us/2uEwOo
-
-To play Call of Duty Modern Warfare 3 on your Android device using PPSSPP, you will need two things: the PPSSPP app and the Call of Duty Modern Warfare 3 PSP iso file. The iso file is a compressed version of the game that can be read by the emulator. You can download the Call of Duty Modern Warfare 3 PSP iso file from various websites on the internet, such as IsoRomulator or IsoRoms. Make sure you download the file from a trusted source and scan it for viruses before opening it.
-
-Once you have downloaded both the PPSSPP app and the Call of Duty Modern Warfare 3 PSP iso file, you can follow these steps to play the game on your Android device:
-
-
-
-
-That's it! You can now enjoy one of the best shooter games ever made on your Android device using PPSSPP. You can play both the single-player and multiplayer modes of Call of Duty Modern Warfare 3 with high-quality graphics and sound. You can also save your progress and resume it anytime you want. Playing Call of Duty Modern Warfare 3 on your Android device using PPSSPP is a great way to experience this amazing game without having to buy a console or a PC.
-
-Conclusion
-
-Call of Duty Modern Warfare 3 is one of the most popular and critically acclaimed games of all time. The game features a thrilling single-player campaign that takes you to various locations around the world, such as New York, London, and Paris, to stop a terrorist plot that threatens to destroy the world. The game also has a robust multiplayer mode that supports up to 10 players and offers various game types, such as Team Deathmatch and Domination. There is also a new cooperative mode called Survival, where you have to team up with other players to fight against waves of enemies.
-
-If you don't have a PlayStation 3, Xbox 360, or Wii console to play the game, you can still play it on your Android device using a PSP emulator called PPSSPP. PPSSPP is a free and open-source emulator that allows you to run PSP games on your Android device with high-quality graphics and sound. You can download PPSSPP from the Google Play Store or from its official website.
-
-To play Call of Duty Modern Warfare 3 on your Android device using PPSSPP, you will need two things: the PPSSPP app and the Call of Duty Modern Warfare 3 PSP iso file. The iso file is a compressed version of the game that can be read by the emulator. You can download the Call of Duty Modern Warfare 3 PSP iso file from various websites on the internet, such as IsoRomulator or IsoRoms. Make sure you download the file from a trusted source and scan it for viruses before opening it.
-
-
-Once you have downloaded both the PPSSPP app and the Call of Duty Modern Warfare 3 PSP iso file, you can follow these steps to play the game on your Android device:
-
-
-
-
-We hope this article has helped you learn how to play Call of Duty Modern Warfare 3 on your Android device using PPSSPP. If you have any questions or feedback, please feel free to leave a comment below. Happy gaming!
-
-
-
-
-
-These are some of the tips and tricks for playing Call of Duty Modern Warfare 3 on your PSP device using PPSSPP. If you follow these tips and tricks, you will surely become a better player and enjoy the game more.
-
-Conclusion
-
-Call of Duty Modern Warfare 3 is one of the best shooter games ever made.
-It features a thrilling single-player campaign that takes you to various locations around the world,
-such as New York,
-London,
-Paris,
-Berlin,
-Prague,
-Dubai,
-Somalia,
-Sierra Leone,
-and Moscow.
-It also has a robust multiplayer mode that supports up to 10 players and offers various game types,
-such as Team Deathmatch,
-Domination,
-Kill Confirmed,
-Capture the Flag,
-Search and Destroy,
-Sabotage,
-Headquarters Pro,
-Demolition Pro,
-Team Defender Pro
-and Drop Zone Pro.
-It also has a new cooperative mode called Survival Mode where you have to team up with another player or play solo
-to survive against waves of increasingly difficult enemies.
-
-If you want to play Call of Duty Modern Warfare 3 on your PSP device,
-you can do so using a PSP emulator called PPSSPP.
-PPSSPP is a free
-and open-source emulator that allows you
-to run PSP games on your PSP device
-with high-quality graphics
-and sound.
-You can download PPSSPP from
-the Google Play Store or from its official website.
-
-To play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP,
-you will need two things:
-the PPSSPP app
-and
-the Call of Duty Modern Warfare 3 PSP iso file.
-The iso file is
-a compressed version
-of
-the game
-that can be read by
-the emulator.
-You can download
-the Call of Duty Modern Warfare 3 PSP iso file
-from various websites on
-the internet,
-such as IsoRomulator or IsoRoms.
-Make sure you download
-the file from
-a trusted source
-and scan it for viruses before opening it.
-
-In this article, we have told you everything you need to know about Call of Duty Modern Warfare 3 and its features. We have also given you some tips and tricks on how to play the game on your PSP device using PPSSPP. We hope this article has helped you learn how
-to play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP.
-If you have any questions or feedback,
-please feel free
-to leave a comment below.
-Happy gaming!
-The reviews of Call of Duty Modern Warfare 3 PSP Iso Download
-
-Call of Duty Modern Warfare 3 has received positive reviews from critics and players alike. The game has been praised for its immersive and thrilling single-player campaign, its addictive and diverse multiplayer mode, its new and improved cooperative mode, and its high-quality graphics and sound. The game has also been criticized for its lack of innovation, its short and linear campaign, its repetitive and scripted gameplay, and its technical issues and bugs. Here are some of the reviews of Call of Duty Modern Warfare 3 from various sources:
-
-
-
-
-These are some of the reviews of Call of Duty Modern Warfare 3 from various sources. The game has received mostly positive feedback from critics and mixed feedback from players. The game is considered to be one of the best shooter games ever made, but also one of the most controversial ones.
-
-Conclusion
-
-Call of Duty Modern Warfare 3 is one of the best shooter games ever made.
-It features a thrilling single-player campaign that takes you to various locations around the world,
-such as New York,
-London,
-Paris,
-Berlin,
-Prague,
-Dubai,
-Somalia,
-Sierra Leone,
-and Moscow.
-It also has a robust multiplayer mode that supports up to 10 players and offers various game types,
-such as Team Deathmatch,
-Domination,
-Kill Confirmed,
-Capture the Flag,
-Search and Destroy,
-Sabotage,
-Headquarters Pro,
-Demolition Pro,
-Team Defender Pro
-and Drop Zone Pro.
-It also has a new cooperative mode called Survival Mode where you have to team up with another player or play solo
-to survive against waves of increasingly difficult enemies.
-
-If you want to play Call of Duty Modern Warfare 3 on your PSP device,
-you can do so using a PSP emulator called PPSSPP.
-PPSSPP is a free
-and open-source emulator that allows you
-to run PSP games on your PSP device
-with high-quality graphics
-and sound.
-You can download PPSSPP from
-the Google Play Store or from its official website.
-
-To play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP,
-you will need two things:
-the PPSSPP app
-and
-the Call of Duty Modern Warfare 3 PSP iso file.
-The iso file is
-a compressed version
-of
-the game
-that can be read by
-the emulator.
-You can download
-the Call of Duty Modern Warfare 3 PSP iso file
-from various websites on
-the internet,
-such as IsoRomulator or IsoRoms.
-Make sure you download
-the file from
-a trusted source
-and scan it for viruses before opening it.
-
-In this article, we have told you everything you need to know about Call of Duty Modern Warfare 3 and its features. We have also given you some tips and tricks on how to play the game on your PSP device using PPSSPP. We have also discussed some of the challenges you may face while playing the game on your PSP device using PPSSPP. We have also shared some of the reviews of Call of Duty Modern Warfare 3 from various sources. We hope this article has helped you learn how
-to play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP.
-If you have any questions or feedback,
-please feel free
-to leave a comment below.
-Happy gaming!
-Conclusion
-
-Call of Duty Modern Warfare 3 is one of the best shooter games ever made. It features a thrilling single-player campaign that takes you to various locations around the world, such as New York, London, Paris, Berlin, Prague, Dubai, Somalia, Sierra Leone, and Moscow. It also has a robust multiplayer mode that supports up to 10 players and offers various game types, such as Team Deathmatch, Domination, Kill Confirmed, Capture the Flag, Search and Destroy, Sabotage, Headquarters Pro, Demolition Pro, Team Defender Pro and Drop Zone Pro. It also has a new cooperative mode called Survival Mode where you have to team up with another player or play solo to survive against waves of increasingly difficult enemies.
-
-If you want to play Call of Duty Modern Warfare 3 on your PSP device, you can do so using a PSP emulator called PPSSPP. PPSSPP is a free and open-source emulator that allows you to run PSP games on your PSP device with high-quality graphics and sound. You can download PPSSPP from the Google Play Store or from its official website.
-
-To play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP, you will need two things: the PPSSPP app and the Call of Duty Modern Warfare 3 PSP iso file. The iso file is a compressed version of the game that can be read by the emulator. You can download the Call of Duty Modern Warfare 3 PSP iso file from various websites on the internet, such as IsoRomulator or IsoRoms. Make sure you download the file from a trusted source and scan it for viruses before opening it.
-
-In this article, we have told you everything you need to know about Call of Duty Modern Warfare 3 and its features. We have also given you some tips and tricks on how to play the game on your PSP device using PPSSPP. We have also discussed some of the challenges you may face while playing the game on your PSP device using PPSSPP. We have also shared some of the reviews of Call of Duty Modern Warfare 3 from various sources.
-
-We hope this article has helped you learn how to play Call of Duty Modern Warfare 3 on your PSP device using PPSSPP. If you have any questions or feedback, please feel free to leave a comment below. Happy gaming!
3cee63e6c2
-
-
\ No newline at end of file
diff --git a/spaces/inreVtussa/clothingai/Examples/Bandicut 3.1.5.511 Crack Serial Key Full Version Download _VERIFIED_.md b/spaces/inreVtussa/clothingai/Examples/Bandicut 3.1.5.511 Crack Serial Key Full Version Download _VERIFIED_.md
deleted file mode 100644
index 899156edd6a43d90370949fce3650e98e643245f..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/Bandicut 3.1.5.511 Crack Serial Key Full Version Download _VERIFIED_.md
+++ /dev/null
@@ -1,32 +0,0 @@
-Bandicut 3.1.5.511 Crack Serial Key Full Version Download
DOWNLOAD 🗸🗸🗸 https://tiurll.com/2uCmkm
-
-Do you like this game? Then you can download it from here.
-
-Greetings from GoToMeeting Crack has been updated by applying the latest patches and fixes of the game. Now download the game directly from the link and enjoy. You can download GoToMeeting Crack with Serial Keygen and with Crack fully working.
-
-Download GoToMeeting Crack
-
-Download GoToMeeting 3.6.6 Crack is a desktop application that is used to interact with people using video conferencing. If you are running on a Windows-based system then you can download this program from the link below. It is an English version of the program that is used for the desktop application. You can download GoToMeeting Crack.
-
-Bandicut 3.0.4.461 Crack 2020
-
-Bandicut 3.0.4.461 Crack has released by Game It Media. If you have a Windows-based system then you can download this program from the link below. It is an English version of the program that is used for the desktop application. You can download Bandicut 3.0.4.461 Crack.
-
-Bandicut 2.0.3.567 Serial Key With Crack Full Working 2020
-
-Bandicut 2.0.3.567 Serial Key is an English version of the program that is used for the desktop application. You can download the Bandicut 2.0.3.567 Serial Key with full working and free. It is a program of a remote desktop.
-
-Bandicut 3.0.4.512 Crack Download
-
-Bandicut 3.0.4.512 Crack has been updated by applying the latest patches and fixes of the game. Now download the game directly from the link and enjoy. You can download Bandicut 3.0.4.512 Crack.
-
-Bandicut 3.1.5.511 Crack With Serial Key Full Torrent 2021
-
-Bandicut 3.1.5.511 Crack has been updated by applying the latest patches and fixes of the game. Now download the game directly from the link and enjoy. You can download Bandicut 3.1.5.511 Crack.
-
-Bandicut 3.6.1.636 Crack Download With Keygen Full Working 2020
-
-Bandicut 3.6.1.636 Crack has been updated by applying the latest patches and fixes of the game. Now download the game directly from the link and enjoy. You can 4fefd39f24
-
-
-
diff --git a/spaces/inreVtussa/clothingai/Examples/CardRecovery V5.30 Build 1206 Software 58.md b/spaces/inreVtussa/clothingai/Examples/CardRecovery V5.30 Build 1206 Software 58.md
deleted file mode 100644
index 4c0dca546bd5724a1e877f38bb0f50606199ed44..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/CardRecovery V5.30 Build 1206 Software 58.md
+++ /dev/null
@@ -1,22 +0,0 @@
-
-How to Recover Lost Photos with CardRecovery v5.30 Build 1206 Software
-If you have accidentally deleted, formatted or corrupted your photos and videos from your memory card, you may be wondering how to get them back. Fortunately, there is a software that can help you recover your precious memories in minutes. It is called CardRecovery v5.30 Build 1206 Software[^1^].
-CardRecovery v5.30 Build 1206 Software 58
Download ⚙⚙⚙ https://tiurll.com/2uClxw
-CardRecovery v5.30 Build 1206 Software is a leading photo recovery software for memory card used by digital camera or phone[^2^]. It can effectively recover lost, deleted, corrupted or formatted photos and video files from various memory cards. It supports almost all memory card types including SD Card, MicroSD, SDHC, CF Card, xD Picture Card, Memory Stick and more[^2^].
-CardRecovery v5.30 Build 1206 Software is easy to use and has a user-friendly interface. You just need to follow these simple steps to recover your photos:
-
-
-That's it! You have successfully recovered your lost photos with CardRecovery v5.30 Build 1206 Software. You can now enjoy your memories again.
CardRecovery v5.30 Build 1206 Software is not only a photo recovery software, but also a video recovery software. It can recover video files from memory cards that are damaged, corrupted, formatted or inaccessible. It can recover videos of various formats such as AVI, MOV, MP4, 3GP, WMV, etc. It can also recover videos from HD cameras, camcorders, mobile phones and other devices.
-
-CardRecovery v5.30 Build 1206 Software is a safe and reliable software that does not write or modify any data on your memory card. It only performs read-only operations on your memory card to ensure the safety of your data. It also supports Windows 10/8/7/Vista/XP and Mac OS X operating systems.
-CardRecovery v5.30 Build 1206 Software is a must-have software for anyone who uses memory cards to store photos and videos. It can help you recover your lost memories in minutes and save you from the frustration of losing your precious data. You can download CardRecovery v5.30 Build 1206 Software from its official website and try it for free.
CardRecovery v5.30 Build 1206 Software is a powerful and professional software that can recover photos and videos from various scenarios. Whether you have accidentally deleted your files, formatted your card, encountered a virus attack, pulled out your card while the camera was on, or experienced a power failure, CardRecovery v5.30 Build 1206 Software can help you restore your data. It can also recover photos and videos from corrupted or unreadable memory cards.
-CardRecovery v5.30 Build 1206 Software is a fast and efficient software that can scan and recover your files in minutes. It has a smart scan technology that can find and recover your files even if they are not listed in the file system. It can also recover files from fragmented or partially overwritten memory cards. It can recover files of various sizes and resolutions, including high-resolution photos and HD videos.
-CardRecovery v5.30 Build 1206 Software is a trusted and recommended software that has been used by millions of users around the world. It has received positive feedback and reviews from customers and experts alike. It has also won many awards and certifications from reputable organizations. It is compatible with all major brands of memory cards and cameras.
d5da3c52bf
-
-
\ No newline at end of file
diff --git a/spaces/iqovocn/ChuanhuChatGPT/assets/Kelpy-Codos.js b/spaces/iqovocn/ChuanhuChatGPT/assets/Kelpy-Codos.js
deleted file mode 100644
index cfbaeedb4f371dfb5fe157db545b364046fca3e1..0000000000000000000000000000000000000000
--- a/spaces/iqovocn/ChuanhuChatGPT/assets/Kelpy-Codos.js
+++ /dev/null
@@ -1,76 +0,0 @@
-// ==UserScript==
-// @name Kelpy Codos
-// @namespace https://github.com/Keldos-Li/Kelpy-Codos
-// @version 1.0.5
-// @author Keldos; https://keldos.me/
-// @description Add copy button to PRE tags before CODE tag, for Chuanhu ChatGPT especially.
-// Based on Chuanhu ChatGPT version: ac04408 (2023-3-22)
-// @license GPL-3.0
-// @grant none
-// ==/UserScript==
-
-(function () {
- 'use strict';
-
- function addCopyButton(pre) {
- var code = pre.querySelector('code');
- if (!code) {
- return; // 如果没有找到 元素，则不添加按钮
- }
- var firstChild = code.firstChild;
- if (!firstChild) {
- return; // 如果 元素没有子节点，则不添加按钮
- }
- var button = document.createElement('button');
- button.textContent = '\uD83D\uDCCE'; // 使用 📎 符号作为“复制”按钮的文本
- button.style.position = 'relative';
- button.style.float = 'right';
- button.style.fontSize = '1em'; // 可选：调整按钮大小
- button.style.background = 'none'; // 可选：去掉背景颜色
- button.style.border = 'none'; // 可选：去掉边框
- button.style.cursor = 'pointer'; // 可选：显示指针样式
- button.addEventListener('click', function () {
- var range = document.createRange();
- range.selectNodeContents(code);
- range.setStartBefore(firstChild); // 将范围设置为第一个子节点之前
- var selection = window.getSelection();
- selection.removeAllRanges();
- selection.addRange(range);
-
- try {
- var success = document.execCommand('copy');
- if (success) {
- button.textContent = '\u2714';
- setTimeout(function () {
- button.textContent = '\uD83D\uDCCE'; // 恢复按钮为“复制”
- }, 2000);
- } else {
- button.textContent = '\u2716';
- }
- } catch (e) {
- console.error(e);
- button.textContent = '\u2716';
- }
-
- selection.removeAllRanges();
- });
- code.insertBefore(button, firstChild); // 将按钮插入到第一个子元素之前
- }
-
- function handleNewElements(mutationsList, observer) {
- for (var mutation of mutationsList) {
- if (mutation.type === 'childList') {
- for (var node of mutation.addedNodes) {
- if (node.nodeName === 'PRE') {
- addCopyButton(node);
- }
- }
- }
- }
- }
-
- var observer = new MutationObserver(handleNewElements);
- observer.observe(document.documentElement, { childList: true, subtree: true });
-
- document.querySelectorAll('pre').forEach(addCopyButton);
-})();
diff --git a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model_arch.py b/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model_arch.py
deleted file mode 100644
index bec5962b595cfc0e6c52d916275538c9c4252068..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/modules/esrgan_model_arch.py
+++ /dev/null
@@ -1,464 +0,0 @@
-# this file is adapted from https://github.com/victorca25/iNNfer
-
-from collections import OrderedDict
-import math
-import functools
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-
-####################
-# RRDBNet Generator
-####################
-
-class RRDBNet(nn.Module):
- def __init__(self, in_nc, out_nc, nf, nb, nr=3, gc=32, upscale=4, norm_type=None,
- act_type='leakyrelu', mode='CNA', upsample_mode='upconv', convtype='Conv2D',
- finalact=None, gaussian_noise=False, plus=False):
- super(RRDBNet, self).__init__()
- n_upscale = int(math.log(upscale, 2))
- if upscale == 3:
- n_upscale = 1
-
- self.resrgan_scale = 0
- if in_nc % 16 == 0:
- self.resrgan_scale = 1
- elif in_nc != 4 and in_nc % 4 == 0:
- self.resrgan_scale = 2
-
- fea_conv = conv_block(in_nc, nf, kernel_size=3, norm_type=None, act_type=None, convtype=convtype)
- rb_blocks = [RRDB(nf, nr, kernel_size=3, gc=32, stride=1, bias=1, pad_type='zero',
- norm_type=norm_type, act_type=act_type, mode='CNA', convtype=convtype,
- gaussian_noise=gaussian_noise, plus=plus) for _ in range(nb)]
- LR_conv = conv_block(nf, nf, kernel_size=3, norm_type=norm_type, act_type=None, mode=mode, convtype=convtype)
-
- if upsample_mode == 'upconv':
- upsample_block = upconv_block
- elif upsample_mode == 'pixelshuffle':
- upsample_block = pixelshuffle_block
- else:
- raise NotImplementedError('upsample mode [{:s}] is not found'.format(upsample_mode))
- if upscale == 3:
- upsampler = upsample_block(nf, nf, 3, act_type=act_type, convtype=convtype)
- else:
- upsampler = [upsample_block(nf, nf, act_type=act_type, convtype=convtype) for _ in range(n_upscale)]
- HR_conv0 = conv_block(nf, nf, kernel_size=3, norm_type=None, act_type=act_type, convtype=convtype)
- HR_conv1 = conv_block(nf, out_nc, kernel_size=3, norm_type=None, act_type=None, convtype=convtype)
-
- outact = act(finalact) if finalact else None
-
- self.model = sequential(fea_conv, ShortcutBlock(sequential(*rb_blocks, LR_conv)),
- *upsampler, HR_conv0, HR_conv1, outact)
-
- def forward(self, x, outm=None):
- if self.resrgan_scale == 1:
- feat = pixel_unshuffle(x, scale=4)
- elif self.resrgan_scale == 2:
- feat = pixel_unshuffle(x, scale=2)
- else:
- feat = x
-
- return self.model(feat)
-
-
-class RRDB(nn.Module):
- """
- Residual in Residual Dense Block
- (ESRGAN: Enhanced Super-Resolution Generative Adversarial Networks)
- """
-
- def __init__(self, nf, nr=3, kernel_size=3, gc=32, stride=1, bias=1, pad_type='zero',
- norm_type=None, act_type='leakyrelu', mode='CNA', convtype='Conv2D',
- spectral_norm=False, gaussian_noise=False, plus=False):
- super(RRDB, self).__init__()
- # This is for backwards compatibility with existing models
- if nr == 3:
- self.RDB1 = ResidualDenseBlock_5C(nf, kernel_size, gc, stride, bias, pad_type,
- norm_type, act_type, mode, convtype, spectral_norm=spectral_norm,
- gaussian_noise=gaussian_noise, plus=plus)
- self.RDB2 = ResidualDenseBlock_5C(nf, kernel_size, gc, stride, bias, pad_type,
- norm_type, act_type, mode, convtype, spectral_norm=spectral_norm,
- gaussian_noise=gaussian_noise, plus=plus)
- self.RDB3 = ResidualDenseBlock_5C(nf, kernel_size, gc, stride, bias, pad_type,
- norm_type, act_type, mode, convtype, spectral_norm=spectral_norm,
- gaussian_noise=gaussian_noise, plus=plus)
- else:
- RDB_list = [ResidualDenseBlock_5C(nf, kernel_size, gc, stride, bias, pad_type,
- norm_type, act_type, mode, convtype, spectral_norm=spectral_norm,
- gaussian_noise=gaussian_noise, plus=plus) for _ in range(nr)]
- self.RDBs = nn.Sequential(*RDB_list)
-
- def forward(self, x):
- if hasattr(self, 'RDB1'):
- out = self.RDB1(x)
- out = self.RDB2(out)
- out = self.RDB3(out)
- else:
- out = self.RDBs(x)
- return out * 0.2 + x
-
-
-class ResidualDenseBlock_5C(nn.Module):
- """
- Residual Dense Block
- The core module of paper: (Residual Dense Network for Image Super-Resolution, CVPR 18)
- Modified options that can be used:
- - "Partial Convolution based Padding" arXiv:1811.11718
- - "Spectral normalization" arXiv:1802.05957
- - "ICASSP 2020 - ESRGAN+ : Further Improving ESRGAN" N. C.
- {Rakotonirina} and A. {Rasoanaivo}
- """
-
- def __init__(self, nf=64, kernel_size=3, gc=32, stride=1, bias=1, pad_type='zero',
- norm_type=None, act_type='leakyrelu', mode='CNA', convtype='Conv2D',
- spectral_norm=False, gaussian_noise=False, plus=False):
- super(ResidualDenseBlock_5C, self).__init__()
-
- self.noise = GaussianNoise() if gaussian_noise else None
- self.conv1x1 = conv1x1(nf, gc) if plus else None
-
- self.conv1 = conv_block(nf, gc, kernel_size, stride, bias=bias, pad_type=pad_type,
- norm_type=norm_type, act_type=act_type, mode=mode, convtype=convtype,
- spectral_norm=spectral_norm)
- self.conv2 = conv_block(nf+gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type,
- norm_type=norm_type, act_type=act_type, mode=mode, convtype=convtype,
- spectral_norm=spectral_norm)
- self.conv3 = conv_block(nf+2*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type,
- norm_type=norm_type, act_type=act_type, mode=mode, convtype=convtype,
- spectral_norm=spectral_norm)
- self.conv4 = conv_block(nf+3*gc, gc, kernel_size, stride, bias=bias, pad_type=pad_type,
- norm_type=norm_type, act_type=act_type, mode=mode, convtype=convtype,
- spectral_norm=spectral_norm)
- if mode == 'CNA':
- last_act = None
- else:
- last_act = act_type
- self.conv5 = conv_block(nf+4*gc, nf, 3, stride, bias=bias, pad_type=pad_type,
- norm_type=norm_type, act_type=last_act, mode=mode, convtype=convtype,
- spectral_norm=spectral_norm)
-
- def forward(self, x):
- x1 = self.conv1(x)
- x2 = self.conv2(torch.cat((x, x1), 1))
- if self.conv1x1:
- x2 = x2 + self.conv1x1(x)
- x3 = self.conv3(torch.cat((x, x1, x2), 1))
- x4 = self.conv4(torch.cat((x, x1, x2, x3), 1))
- if self.conv1x1:
- x4 = x4 + x2
- x5 = self.conv5(torch.cat((x, x1, x2, x3, x4), 1))
- if self.noise:
- return self.noise(x5.mul(0.2) + x)
- else:
- return x5 * 0.2 + x
-
-
-####################
-# ESRGANplus
-####################
-
-class GaussianNoise(nn.Module):
- def __init__(self, sigma=0.1, is_relative_detach=False):
- super().__init__()
- self.sigma = sigma
- self.is_relative_detach = is_relative_detach
- self.noise = torch.tensor(0, dtype=torch.float)
-
- def forward(self, x):
- if self.training and self.sigma != 0:
- self.noise = self.noise.to(x.device)
- scale = self.sigma * x.detach() if self.is_relative_detach else self.sigma * x
- sampled_noise = self.noise.repeat(*x.size()).normal_() * scale
- x = x + sampled_noise
- return x
-
-def conv1x1(in_planes, out_planes, stride=1):
- return nn.Conv2d(in_planes, out_planes, kernel_size=1, stride=stride, bias=False)
-
-
-####################
-# SRVGGNetCompact
-####################
-
-class SRVGGNetCompact(nn.Module):
- """A compact VGG-style network structure for super-resolution.
- This class is copied from https://github.com/xinntao/Real-ESRGAN
- """
-
- def __init__(self, num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=16, upscale=4, act_type='prelu'):
- super(SRVGGNetCompact, self).__init__()
- self.num_in_ch = num_in_ch
- self.num_out_ch = num_out_ch
- self.num_feat = num_feat
- self.num_conv = num_conv
- self.upscale = upscale
- self.act_type = act_type
-
- self.body = nn.ModuleList()
- # the first conv
- self.body.append(nn.Conv2d(num_in_ch, num_feat, 3, 1, 1))
- # the first activation
- if act_type == 'relu':
- activation = nn.ReLU(inplace=True)
- elif act_type == 'prelu':
- activation = nn.PReLU(num_parameters=num_feat)
- elif act_type == 'leakyrelu':
- activation = nn.LeakyReLU(negative_slope=0.1, inplace=True)
- self.body.append(activation)
-
- # the body structure
- for _ in range(num_conv):
- self.body.append(nn.Conv2d(num_feat, num_feat, 3, 1, 1))
- # activation
- if act_type == 'relu':
- activation = nn.ReLU(inplace=True)
- elif act_type == 'prelu':
- activation = nn.PReLU(num_parameters=num_feat)
- elif act_type == 'leakyrelu':
- activation = nn.LeakyReLU(negative_slope=0.1, inplace=True)
- self.body.append(activation)
-
- # the last conv
- self.body.append(nn.Conv2d(num_feat, num_out_ch * upscale * upscale, 3, 1, 1))
- # upsample
- self.upsampler = nn.PixelShuffle(upscale)
-
- def forward(self, x):
- out = x
- for i in range(0, len(self.body)):
- out = self.body[i](out)
-
- out = self.upsampler(out)
- # add the nearest upsampled image, so that the network learns the residual
- base = F.interpolate(x, scale_factor=self.upscale, mode='nearest')
- out += base
- return out
-
-
-####################
-# Upsampler
-####################
-
-class Upsample(nn.Module):
- r"""Upsamples a given multi-channel 1D (temporal), 2D (spatial) or 3D (volumetric) data.
- The input data is assumed to be of the form
- `minibatch x channels x [optional depth] x [optional height] x width`.
- """
-
- def __init__(self, size=None, scale_factor=None, mode="nearest", align_corners=None):
- super(Upsample, self).__init__()
- if isinstance(scale_factor, tuple):
- self.scale_factor = tuple(float(factor) for factor in scale_factor)
- else:
- self.scale_factor = float(scale_factor) if scale_factor else None
- self.mode = mode
- self.size = size
- self.align_corners = align_corners
-
- def forward(self, x):
- return nn.functional.interpolate(x, size=self.size, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners)
-
- def extra_repr(self):
- if self.scale_factor is not None:
- info = 'scale_factor=' + str(self.scale_factor)
- else:
- info = 'size=' + str(self.size)
- info += ', mode=' + self.mode
- return info
-
-
-def pixel_unshuffle(x, scale):
- """ Pixel unshuffle.
- Args:
- x (Tensor): Input feature with shape (b, c, hh, hw).
- scale (int): Downsample ratio.
- Returns:
- Tensor: the pixel unshuffled feature.
- """
- b, c, hh, hw = x.size()
- out_channel = c * (scale**2)
- assert hh % scale == 0 and hw % scale == 0
- h = hh // scale
- w = hw // scale
- x_view = x.view(b, c, h, scale, w, scale)
- return x_view.permute(0, 1, 3, 5, 2, 4).reshape(b, out_channel, h, w)
-
-
-def pixelshuffle_block(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True,
- pad_type='zero', norm_type=None, act_type='relu', convtype='Conv2D'):
- """
- Pixel shuffle layer
- (Real-Time Single Image and Video Super-Resolution Using an Efficient Sub-Pixel Convolutional
- Neural Network, CVPR17)
- """
- conv = conv_block(in_nc, out_nc * (upscale_factor ** 2), kernel_size, stride, bias=bias,
- pad_type=pad_type, norm_type=None, act_type=None, convtype=convtype)
- pixel_shuffle = nn.PixelShuffle(upscale_factor)
-
- n = norm(norm_type, out_nc) if norm_type else None
- a = act(act_type) if act_type else None
- return sequential(conv, pixel_shuffle, n, a)
-
-
-def upconv_block(in_nc, out_nc, upscale_factor=2, kernel_size=3, stride=1, bias=True,
- pad_type='zero', norm_type=None, act_type='relu', mode='nearest', convtype='Conv2D'):
- """ Upconv layer """
- upscale_factor = (1, upscale_factor, upscale_factor) if convtype == 'Conv3D' else upscale_factor
- upsample = Upsample(scale_factor=upscale_factor, mode=mode)
- conv = conv_block(in_nc, out_nc, kernel_size, stride, bias=bias,
- pad_type=pad_type, norm_type=norm_type, act_type=act_type, convtype=convtype)
- return sequential(upsample, conv)
-
-
-
-
-
-
-
-
-####################
-# Basic blocks
-####################
-
-
-def make_layer(basic_block, num_basic_block, **kwarg):
- """Make layers by stacking the same blocks.
- Args:
- basic_block (nn.module): nn.module class for basic block. (block)
- num_basic_block (int): number of blocks. (n_layers)
- Returns:
- nn.Sequential: Stacked blocks in nn.Sequential.
- """
- layers = []
- for _ in range(num_basic_block):
- layers.append(basic_block(**kwarg))
- return nn.Sequential(*layers)
-
-
-def act(act_type, inplace=True, neg_slope=0.2, n_prelu=1, beta=1.0):
- """ activation helper """
- act_type = act_type.lower()
- if act_type == 'relu':
- layer = nn.ReLU(inplace)
- elif act_type in ('leakyrelu', 'lrelu'):
- layer = nn.LeakyReLU(neg_slope, inplace)
- elif act_type == 'prelu':
- layer = nn.PReLU(num_parameters=n_prelu, init=neg_slope)
- elif act_type == 'tanh': # [-1, 1] range output
- layer = nn.Tanh()
- elif act_type == 'sigmoid': # [0, 1] range output
- layer = nn.Sigmoid()
- else:
- raise NotImplementedError('activation layer [{:s}] is not found'.format(act_type))
- return layer
-
-
-class Identity(nn.Module):
- def __init__(self, *kwargs):
- super(Identity, self).__init__()
-
- def forward(self, x, *kwargs):
- return x
-
-
-def norm(norm_type, nc):
- """ Return a normalization layer """
- norm_type = norm_type.lower()
- if norm_type == 'batch':
- layer = nn.BatchNorm2d(nc, affine=True)
- elif norm_type == 'instance':
- layer = nn.InstanceNorm2d(nc, affine=False)
- elif norm_type == 'none':
- def norm_layer(x): return Identity()
- else:
- raise NotImplementedError('normalization layer [{:s}] is not found'.format(norm_type))
- return layer
-
-
-def pad(pad_type, padding):
- """ padding layer helper """
- pad_type = pad_type.lower()
- if padding == 0:
- return None
- if pad_type == 'reflect':
- layer = nn.ReflectionPad2d(padding)
- elif pad_type == 'replicate':
- layer = nn.ReplicationPad2d(padding)
- elif pad_type == 'zero':
- layer = nn.ZeroPad2d(padding)
- else:
- raise NotImplementedError('padding layer [{:s}] is not implemented'.format(pad_type))
- return layer
-
-
-def get_valid_padding(kernel_size, dilation):
- kernel_size = kernel_size + (kernel_size - 1) * (dilation - 1)
- padding = (kernel_size - 1) // 2
- return padding
-
-
-class ShortcutBlock(nn.Module):
- """ Elementwise sum the output of a submodule to its input """
- def __init__(self, submodule):
- super(ShortcutBlock, self).__init__()
- self.sub = submodule
-
- def forward(self, x):
- output = x + self.sub(x)
- return output
-
- def __repr__(self):
- return 'Identity + \n|' + self.sub.__repr__().replace('\n', '\n|')
-
-
-def sequential(*args):
- """ Flatten Sequential. It unwraps nn.Sequential. """
- if len(args) == 1:
- if isinstance(args[0], OrderedDict):
- raise NotImplementedError('sequential does not support OrderedDict input.')
- return args[0] # No sequential is needed.
- modules = []
- for module in args:
- if isinstance(module, nn.Sequential):
- for submodule in module.children():
- modules.append(submodule)
- elif isinstance(module, nn.Module):
- modules.append(module)
- return nn.Sequential(*modules)
-
-
-def conv_block(in_nc, out_nc, kernel_size, stride=1, dilation=1, groups=1, bias=True,
- pad_type='zero', norm_type=None, act_type='relu', mode='CNA', convtype='Conv2D',
- spectral_norm=False):
- """ Conv layer with padding, normalization, activation """
- assert mode in ['CNA', 'NAC', 'CNAC'], 'Wrong conv mode [{:s}]'.format(mode)
- padding = get_valid_padding(kernel_size, dilation)
- p = pad(pad_type, padding) if pad_type and pad_type != 'zero' else None
- padding = padding if pad_type == 'zero' else 0
-
- if convtype=='PartialConv2D':
- c = PartialConv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,
- dilation=dilation, bias=bias, groups=groups)
- elif convtype=='DeformConv2D':
- c = DeformConv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,
- dilation=dilation, bias=bias, groups=groups)
- elif convtype=='Conv3D':
- c = nn.Conv3d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,
- dilation=dilation, bias=bias, groups=groups)
- else:
- c = nn.Conv2d(in_nc, out_nc, kernel_size=kernel_size, stride=stride, padding=padding,
- dilation=dilation, bias=bias, groups=groups)
-
- if spectral_norm:
- c = nn.utils.spectral_norm(c)
-
- a = act(act_type) if act_type else None
- if 'CNA' in mode:
- n = norm(norm_type, out_nc) if norm_type else None
- return sequential(p, c, n, a)
- elif mode == 'NAC':
- if norm_type is None and act_type is not None:
- a = act(act_type, inplace=False)
- n = norm(norm_type, in_nc) if norm_type else None
- return sequential(n, a, p, c)
diff --git a/spaces/james-oldfield/PandA/networks/genforce/runners/controllers/progress_scheduler.py b/spaces/james-oldfield/PandA/networks/genforce/runners/controllers/progress_scheduler.py
deleted file mode 100644
index eef2b4d67bccbb30da6e7ee562844aa8c6ea3daa..0000000000000000000000000000000000000000
--- a/spaces/james-oldfield/PandA/networks/genforce/runners/controllers/progress_scheduler.py
+++ /dev/null
@@ -1,162 +0,0 @@
-# python3.7
-"""Contains the running controller to control progressive training.
-
-This controller is applicable to the models that need to progressively change
-the batch size, learning rate, etc.
-"""
-
-import numpy as np
-
-from .base_controller import BaseController
-
-__all__ = ['ProgressScheduler']
-
-_BATCH_SIZE_SCHEDULE_DICT = {
- 4: 16, 8: 8, 16: 4, 32: 2, 64: 1, 128: 1, 256: 1, 512: 1, 1024: 1,
-}
-_MAX_BATCH_SIZE = 64
-
-_LEARNING_RATE_SCHEDULE_DICT = {
- 4: 1, 8: 1, 16: 1, 32: 1, 64: 1, 128: 1.5, 256: 2, 512: 3, 1024: 3,
-}
-
-
-class ProgressScheduler(BaseController):
- """Defines the running controller to control progressive training.
-
- NOTE: The controller is set to `HIGH` priority by default.
- """
-
- def __init__(self, config):
- assert isinstance(config, dict)
- config.setdefault('priority', 'HIGH')
- config.setdefault('every_n_iters', 1)
- super().__init__(config)
-
- self.base_batch_size = 0
- self.base_lrs = dict()
-
- self.total_img = 0
- self.init_res = config.get('init_res', 4)
- self.final_res = self.init_res
- self.init_lod = 0
- self.batch_size_schedule = config.get('batch_size_schedule', dict())
- self.lr_schedule = config.get('lr_schedule', dict())
- self.minibatch_repeats = config.get('minibatch_repeats', 4)
-
- self.lod_training_img = config.get('lod_training_img', 600_000)
- self.lod_transition_img = config.get('lod_transition_img', 600_000)
- self.lod_duration = (self.lod_training_img + self.lod_transition_img)
-
- # Whether to reset the optimizer state at the beginning of each phase.
- self.reset_optimizer = config.get('reset_optimizer', True)
-
- def get_batch_size(self, resolution):
- """Gets batch size for a particular resolution."""
- if self.batch_size_schedule:
- return self.batch_size_schedule.get(
- f'res{resolution}', self.base_batch_size)
- batch_size_scale = _BATCH_SIZE_SCHEDULE_DICT[resolution]
- return min(_MAX_BATCH_SIZE, self.base_batch_size * batch_size_scale)
-
- def get_lr_scale(self, resolution):
- """Gets learning rate scale for a particular resolution."""
- if self.lr_schedule:
- return self.lr_schedule.get(f'res{resolution}', 1)
- return _LEARNING_RATE_SCHEDULE_DICT[resolution]
-
- def setup(self, runner):
- # Set level of detail (lod).
- self.final_res = runner.resolution
- self.init_lod = np.log2(self.final_res // self.init_res)
- runner.lod = -1.0
-
- # Save default batch size and learning rate.
- self.base_batch_size = runner.batch_size
- for lr_name, lr_scheduler in runner.lr_schedulers.items():
- self.base_lrs[lr_name] = lr_scheduler.base_lrs
-
- # Add running stats for logging.
- runner.running_stats.add(
- 'kimg', log_format='7.1f', log_name='kimg', log_strategy='CURRENT')
- runner.running_stats.add(
- 'lod', log_format='4.2f', log_name='lod', log_strategy='CURRENT')
- runner.running_stats.add(
- 'minibatch', log_format='4d', log_name='minibatch',
- log_strategy='CURRENT')
-
- # Log progressive schedule.
- runner.logger.info(f'Progressive Schedule:')
- res = self.init_res
- lod = int(self.init_lod)
- while res <= self.final_res:
- batch_size = self.get_batch_size(res)
- lr_scale = self.get_lr_scale(res)
- runner.logger.info(f' Resolution {res:4d} (lod {lod}): '
- f'batch size '
- f'{batch_size:3d} * {runner.world_size:2d}, '
- f'learning rate scale {lr_scale:.1f}')
- res *= 2
- lod -= 1
- assert lod == -1 and res == self.final_res * 2
-
- # Compute total running iterations.
- assert hasattr(runner.config, 'total_img')
- self.total_img = runner.config.total_img
- current_img = 0
- num_iters = 0
- while current_img < self.total_img:
- phase = (current_img + self.lod_transition_img) // self.lod_duration
- phase = np.clip(phase, 0, self.init_lod)
- if num_iters % self.minibatch_repeats == 0:
- resolution = self.init_res * (2 ** int(phase))
- current_img += self.get_batch_size(resolution) * runner.world_size
- num_iters += 1
- runner.total_iters = num_iters
-
- def execute_before_iteration(self, runner):
- is_first_iter = (runner.iter - runner.start_iter == 1)
-
- # Adjust hyper-parameters only at some particular iteration.
- if (not is_first_iter) and (runner.iter % self.minibatch_repeats != 1):
- return
-
- # Compute level-of-details.
- phase, subphase = divmod(runner.seen_img, self.lod_duration)
- lod = self.init_lod - phase
- if self.lod_transition_img:
- transition_img = max(subphase - self.lod_training_img, 0)
- lod = lod - transition_img / self.lod_transition_img
- lod = max(lod, 0.0)
- resolution = self.init_res * (2 ** int(np.ceil(self.init_lod - lod)))
- batch_size = self.get_batch_size(resolution)
- lr_scale = self.get_lr_scale(resolution)
-
- pre_lod = runner.lod
- pre_resolution = runner.train_loader.dataset.resolution
- runner.lod = lod
-
- # Reset optimizer state if needed.
- if self.reset_optimizer:
- if int(lod) != int(pre_lod) or np.ceil(lod) != np.ceil(pre_lod):
- runner.logger.info(f'Reset the optimizer state at '
- f'iter {runner.iter:06d} (lod {lod:.6f}).')
- for name in runner.optimizers:
- runner.optimizers[name].state.clear()
-
- # Rebuild the dataset and adjust the learing rate if needed.
- if is_first_iter or resolution != pre_resolution:
- runner.logger.info(f'Rebuild the dataset at '
- f'iter {runner.iter:06d} (lod {lod:.6f}).')
- runner.train_loader.overwrite_param(
- batch_size=batch_size, resolution=resolution)
- runner.batch_size = batch_size
- for lr_name, base_lrs in self.base_lrs.items():
- runner.lr_schedulers[lr_name].base_lrs = [
- lr * lr_scale for lr in base_lrs]
-
- def execute_after_iteration(self, runner):
- minibatch = runner.batch_size * runner.world_size
- runner.running_stats.update({'kimg': runner.seen_img / 1000})
- runner.running_stats.update({'lod': runner.lod})
- runner.running_stats.update({'minibatch': minibatch})
diff --git a/spaces/james-oldfield/PandA/networks/stylegan3/calc_metrics.py b/spaces/james-oldfield/PandA/networks/stylegan3/calc_metrics.py
deleted file mode 100644
index 52e1e9404dbaa8901352fc74475e6052e103f760..0000000000000000000000000000000000000000
--- a/spaces/james-oldfield/PandA/networks/stylegan3/calc_metrics.py
+++ /dev/null
@@ -1,188 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-"""Calculate quality metrics for previous training run or pretrained network pickle."""
-
-import os
-import click
-import json
-import tempfile
-import copy
-import torch
-
-import dnnlib
-import legacy
-from metrics import metric_main
-from metrics import metric_utils
-from torch_utils import training_stats
-from torch_utils import custom_ops
-from torch_utils import misc
-from torch_utils.ops import conv2d_gradfix
-
-#----------------------------------------------------------------------------
-
-def subprocess_fn(rank, args, temp_dir):
- dnnlib.util.Logger(should_flush=True)
-
- # Init torch.distributed.
- if args.num_gpus > 1:
- init_file = os.path.abspath(os.path.join(temp_dir, '.torch_distributed_init'))
- if os.name == 'nt':
- init_method = 'file:///' + init_file.replace('\\', '/')
- torch.distributed.init_process_group(backend='gloo', init_method=init_method, rank=rank, world_size=args.num_gpus)
- else:
- init_method = f'file://{init_file}'
- torch.distributed.init_process_group(backend='nccl', init_method=init_method, rank=rank, world_size=args.num_gpus)
-
- # Init torch_utils.
- sync_device = torch.device('cuda', rank) if args.num_gpus > 1 else None
- training_stats.init_multiprocessing(rank=rank, sync_device=sync_device)
- if rank != 0 or not args.verbose:
- custom_ops.verbosity = 'none'
-
- # Configure torch.
- device = torch.device('cuda', rank)
- torch.backends.cuda.matmul.allow_tf32 = False
- torch.backends.cudnn.allow_tf32 = False
- conv2d_gradfix.enabled = True
-
- # Print network summary.
- G = copy.deepcopy(args.G).eval().requires_grad_(False).to(device)
- if rank == 0 and args.verbose:
- z = torch.empty([1, G.z_dim], device=device)
- c = torch.empty([1, G.c_dim], device=device)
- misc.print_module_summary(G, [z, c])
-
- # Calculate each metric.
- for metric in args.metrics:
- if rank == 0 and args.verbose:
- print(f'Calculating {metric}...')
- progress = metric_utils.ProgressMonitor(verbose=args.verbose)
- result_dict = metric_main.calc_metric(metric=metric, G=G, dataset_kwargs=args.dataset_kwargs,
- num_gpus=args.num_gpus, rank=rank, device=device, progress=progress)
- if rank == 0:
- metric_main.report_metric(result_dict, run_dir=args.run_dir, snapshot_pkl=args.network_pkl)
- if rank == 0 and args.verbose:
- print()
-
- # Done.
- if rank == 0 and args.verbose:
- print('Exiting...')
-
-#----------------------------------------------------------------------------
-
-def parse_comma_separated_list(s):
- if isinstance(s, list):
- return s
- if s is None or s.lower() == 'none' or s == '':
- return []
- return s.split(',')
-
-#----------------------------------------------------------------------------
-
-@click.command()
-@click.pass_context
-@click.option('network_pkl', '--network', help='Network pickle filename or URL', metavar='PATH', required=True)
-@click.option('--metrics', help='Quality metrics', metavar='[NAME|A,B,C|none]', type=parse_comma_separated_list, default='fid50k_full', show_default=True)
-@click.option('--data', help='Dataset to evaluate against [default: look up]', metavar='[ZIP|DIR]')
-@click.option('--mirror', help='Enable dataset x-flips [default: look up]', type=bool, metavar='BOOL')
-@click.option('--gpus', help='Number of GPUs to use', type=int, default=1, metavar='INT', show_default=True)
-@click.option('--verbose', help='Print optional information', type=bool, default=True, metavar='BOOL', show_default=True)
-
-def calc_metrics(ctx, network_pkl, metrics, data, mirror, gpus, verbose):
- """Calculate quality metrics for previous training run or pretrained network pickle.
-
- Examples:
-
- \b
- # Previous training run: look up options automatically, save result to JSONL file.
- python calc_metrics.py --metrics=eqt50k_int,eqr50k \\
- --network=~/training-runs/00000-stylegan3-r-mydataset/network-snapshot-000000.pkl
-
- \b
- # Pre-trained network pickle: specify dataset explicitly, print result to stdout.
- python calc_metrics.py --metrics=fid50k_full --data=~/datasets/ffhq-1024x1024.zip --mirror=1 \\
- --network=https://api.ngc.nvidia.com/v2/models/nvidia/research/stylegan3/versions/1/files/stylegan3-t-ffhq-1024x1024.pkl
-
- \b
- Recommended metrics:
- fid50k_full Frechet inception distance against the full dataset.
- kid50k_full Kernel inception distance against the full dataset.
- pr50k3_full Precision and recall againt the full dataset.
- ppl2_wend Perceptual path length in W, endpoints, full image.
- eqt50k_int Equivariance w.r.t. integer translation (EQ-T).
- eqt50k_frac Equivariance w.r.t. fractional translation (EQ-T_frac).
- eqr50k Equivariance w.r.t. rotation (EQ-R).
-
- \b
- Legacy metrics:
- fid50k Frechet inception distance against 50k real images.
- kid50k Kernel inception distance against 50k real images.
- pr50k3 Precision and recall against 50k real images.
- is50k Inception score for CIFAR-10.
- """
- dnnlib.util.Logger(should_flush=True)
-
- # Validate arguments.
- args = dnnlib.EasyDict(metrics=metrics, num_gpus=gpus, network_pkl=network_pkl, verbose=verbose)
- if not all(metric_main.is_valid_metric(metric) for metric in args.metrics):
- ctx.fail('\n'.join(['--metrics can only contain the following values:'] + metric_main.list_valid_metrics()))
- if not args.num_gpus >= 1:
- ctx.fail('--gpus must be at least 1')
-
- # Load network.
- if not dnnlib.util.is_url(network_pkl, allow_file_urls=True) and not os.path.isfile(network_pkl):
- ctx.fail('--network must point to a file or URL')
- if args.verbose:
- print(f'Loading network from "{network_pkl}"...')
- with dnnlib.util.open_url(network_pkl, verbose=args.verbose) as f:
- network_dict = legacy.load_network_pkl(f)
- args.G = network_dict['G_ema'] # subclass of torch.nn.Module
-
- # Initialize dataset options.
- if data is not None:
- args.dataset_kwargs = dnnlib.EasyDict(class_name='training.dataset.ImageFolderDataset', path=data)
- elif network_dict['training_set_kwargs'] is not None:
- args.dataset_kwargs = dnnlib.EasyDict(network_dict['training_set_kwargs'])
- else:
- ctx.fail('Could not look up dataset options; please specify --data')
-
- # Finalize dataset options.
- args.dataset_kwargs.resolution = args.G.img_resolution
- args.dataset_kwargs.use_labels = (args.G.c_dim != 0)
- if mirror is not None:
- args.dataset_kwargs.xflip = mirror
-
- # Print dataset options.
- if args.verbose:
- print('Dataset options:')
- print(json.dumps(args.dataset_kwargs, indent=2))
-
- # Locate run dir.
- args.run_dir = None
- if os.path.isfile(network_pkl):
- pkl_dir = os.path.dirname(network_pkl)
- if os.path.isfile(os.path.join(pkl_dir, 'training_options.json')):
- args.run_dir = pkl_dir
-
- # Launch processes.
- if args.verbose:
- print('Launching processes...')
- torch.multiprocessing.set_start_method('spawn')
- with tempfile.TemporaryDirectory() as temp_dir:
- if args.num_gpus == 1:
- subprocess_fn(rank=0, args=args, temp_dir=temp_dir)
- else:
- torch.multiprocessing.spawn(fn=subprocess_fn, args=(args, temp_dir), nprocs=args.num_gpus)
-
-#----------------------------------------------------------------------------
-
-if __name__ == "__main__":
- calc_metrics() # pylint: disable=no-value-for-parameter
-
-#----------------------------------------------------------------------------
diff --git a/spaces/jangocheng/stable-diffusion-webui-cpu_with_prompt_pub/README.md b/spaces/jangocheng/stable-diffusion-webui-cpu_with_prompt_pub/README.md
deleted file mode 100644
index e216906e0828834241b7195278762f81be2a90ea..0000000000000000000000000000000000000000
--- a/spaces/jangocheng/stable-diffusion-webui-cpu_with_prompt_pub/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: Stable Diffusion Webui on Cpu
-emoji: 🏃
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.32.0
-app_file: app.py
-pinned: false
-python_version: 3.10.6
-duplicated_from: jangocheng/stable-diffusion-webui-cpu_with_prompt
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/jbilcke-hf/media-server/converter.js b/spaces/jbilcke-hf/media-server/converter.js
deleted file mode 100644
index f2d7b5dafabfa57a6d419377124480cd2973e3d2..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/media-server/converter.js
+++ /dev/null
@@ -1,49 +0,0 @@
-const { v4 } = require('uuid')
-const raw = {
- "input": "Scenes from a movie about a young magician who explore a damp, misty forest, see a majestic deer, who transform into a beautiful and friendly witch, which talks to the magician. She gives him a magical wand. The magician travels back to his magical school of magic on his witch broom, just in time to fight a huge orc goblin which is trying to destroy the magical school. The magical schools is beautiful, looking a bit like an eerie chapel, alone in the middle of a misty lake. The shots should all be beautiful, using appropriate large or shot range shots, with golden hour for the castle shot, nice camera movement etc.",
-
- "captions": [
- "Photorealistic movie shot of a young magician, with his navy blue wizard robes adorned with silver moons and stars, his brown leather boots, and his feathered hat stepping hesitantly into a damp, misty forest filled with moss-laden ancient trees and ferns underbrush in the morning light, shot in Cinema 4D, showcasing a high degree of photorealism.",
-
- "Cinematic video of a majestic deer, its majestic antlers laced with flourishing green foliage, emerging from the foggy backdrop bathed in the warm glow of the morning sun, forming a stark contrast against the earthly hues of the surrounding misty forest, captured in 8K UHD, to unveil the breathtakingly realistic details.",
-
- "Cinematic rendition of the deer morphing into the earth-toned witch, in ethereal display of light and magical elements, the misty forest alive with twinkling fairy lights that perfectly mimic the real world counterparts, shot in 4k UHD, reveling in its award-winning photorealism.",
-
- "Movie scene of the witch and the young magician, dressed in his navy robe with starry print, in earnest conversation on a moss-covered bridge, washed in the dewy morn's light, with their expressive eyes twinkling, the Cinema 4D camera movement emulating the human eyes' attention to detail.",
-
- "Feature film quality shot of the kind witch, in her botanical-themed earthy toned robe, gifting the young magician, in his iconic starry, navy robe, the intricately designed magical wand aglow with magical energy, in the dimly lit yet mystifying forest, brought to life in unparalleled photorealistic detail by an 8K UHD camera.",
-
- "HD video in Cinema 4D capturing the young magician in his navy blue robes, etched with silver stars and moons, his feathered hat still firmly in place, riding his enchanted broomstick over lush forests, under the morning sky painted with pastel hues, showcasing its award-winning photorealistic details.",
-
- "Photorealistic, wide-angle video of the grand magical school, resembling a serene, slightly eerie chapel, in the middle of a misty lake, bathed in the ethereal glow of the setting sun, masterfully captured in 8K UHD that showcases each texture, color, and the play of lights and shadows in high detail.",
-
- "Award winning movie snapshot of the looming Orc Goblin, its hideous features enhanced by the subtly dramatic sunlight, emerging ominously onto the school's sacred grounds, painted in sharp, realistic detail and contrasted against the seemingly tranquil lake and verdant surroundings, all captured in 4K UHD with photorealistic CGI effects.",
-
- "High quality 4k UHD video featuring the young magician, still garbed in his signature navy robes adorned with silver moons and stars, ready to confront the monster through the plush velvet drapes and marble archways of the school, the surrounding fog adding a sense of ethereal beauty to the tense scenario, captured in ultra-realistic Cinema 4D.",
-
- "Cinematic highlight video in 4K quality portraying the young magician, in his iconic wizard outfit with shimmering moons and stars, standing defiantly as he casts a spell that illuminates the ornate interiors of the dark school, serving a visual feast of rich colors, deep shadows, and flawless textures, embodying the true essence of ultra-realistic cinematography."
- ]
-}
-const result = {
- "sequenceId": v4(),
- "skip": false,
- "lastGenerationAt": "",
- "videoPrompt": raw.input,
- "audioPrompt": "epic orchestral music, for a movie about magicians",
- "tags": [
- "trailer",
- "cinema",
- "fantasy",
- "adventure"
- ],
- "channel": "main",
- "shots": raw.captions.map((cap, i) => ({
- shotId: v4(),
- "index": i,
- "lastGenerationAt": "",
- "videoPrompt": cap,
- "audioPrompt": ""
- }))
-}
-
-console.log(JSON.stringify(result, null, 2))
\ No newline at end of file
diff --git a/spaces/jbilcke-hf/space-factory/public/placeholder.html b/spaces/jbilcke-hf/space-factory/public/placeholder.html
deleted file mode 100644
index 634e0d7233aa37d8366464d5fe727c555442c43a..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/space-factory/public/placeholder.html
+++ /dev/null
@@ -1,16 +0,0 @@
-
-
- Nothing to show (yet)
-
-
-
-
-
-
-
- Waiting for content..
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/jessica6105/Lu-Bert-VITS2/bert/chinese-roberta-wwm-ext-large/README.md b/spaces/jessica6105/Lu-Bert-VITS2/bert/chinese-roberta-wwm-ext-large/README.md
deleted file mode 100644
index ebc4b2e6fb6b95ddc5f678b4a7f829466799f2da..0000000000000000000000000000000000000000
--- a/spaces/jessica6105/Lu-Bert-VITS2/bert/chinese-roberta-wwm-ext-large/README.md
+++ /dev/null
@@ -1,57 +0,0 @@
----
-language:
-- zh
-tags:
-- bert
-license: "apache-2.0"
----
-
-# Please use 'Bert' related functions to load this model!
-
-## Chinese BERT with Whole Word Masking
-For further accelerating Chinese natural language processing, we provide **Chinese pre-trained BERT with Whole Word Masking**.
-
-**[Pre-Training with Whole Word Masking for Chinese BERT](https://arxiv.org/abs/1906.08101)**
-Yiming Cui, Wanxiang Che, Ting Liu, Bing Qin, Ziqing Yang, Shijin Wang, Guoping Hu
-
-This repository is developed based on：https://github.com/google-research/bert
-
-You may also interested in,
-- Chinese BERT series: https://github.com/ymcui/Chinese-BERT-wwm
-- Chinese MacBERT: https://github.com/ymcui/MacBERT
-- Chinese ELECTRA: https://github.com/ymcui/Chinese-ELECTRA
-- Chinese XLNet: https://github.com/ymcui/Chinese-XLNet
-- Knowledge Distillation Toolkit - TextBrewer: https://github.com/airaria/TextBrewer
-
-More resources by HFL: https://github.com/ymcui/HFL-Anthology
-
-## Citation
-If you find the technical report or resource is useful, please cite the following technical report in your paper.
-- Primary: https://arxiv.org/abs/2004.13922
-```
-@inproceedings{cui-etal-2020-revisiting,
- title = "Revisiting Pre-Trained Models for {C}hinese Natural Language Processing",
- author = "Cui, Yiming and
- Che, Wanxiang and
- Liu, Ting and
- Qin, Bing and
- Wang, Shijin and
- Hu, Guoping",
- booktitle = "Proceedings of the 2020 Conference on Empirical Methods in Natural Language Processing: Findings",
- month = nov,
- year = "2020",
- address = "Online",
- publisher = "Association for Computational Linguistics",
- url = "https://www.aclweb.org/anthology/2020.findings-emnlp.58",
- pages = "657--668",
-}
-```
-- Secondary: https://arxiv.org/abs/1906.08101
-```
-@article{chinese-bert-wwm,
- title={Pre-Training with Whole Word Masking for Chinese BERT},
- author={Cui, Yiming and Che, Wanxiang and Liu, Ting and Qin, Bing and Yang, Ziqing and Wang, Shijin and Hu, Guoping},
- journal={arXiv preprint arXiv:1906.08101},
- year={2019}
- }
-```
diff --git a/spaces/jessica6105/Lu-Bert-VITS2/modules.py b/spaces/jessica6105/Lu-Bert-VITS2/modules.py
deleted file mode 100644
index b1f89a2f837f190a3dd5de52e7a4e183f1024306..0000000000000000000000000000000000000000
--- a/spaces/jessica6105/Lu-Bert-VITS2/modules.py
+++ /dev/null
@@ -1,597 +0,0 @@
-import math
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-from torch.nn import Conv1d
-from torch.nn.utils import weight_norm, remove_weight_norm
-
-import commons
-from commons import init_weights, get_padding
-from transforms import piecewise_rational_quadratic_transform
-from attentions import Encoder
-
-LRELU_SLOPE = 0.1
-
-
-class LayerNorm(nn.Module):
- def __init__(self, channels, eps=1e-5):
- super().__init__()
- self.channels = channels
- self.eps = eps
-
- self.gamma = nn.Parameter(torch.ones(channels))
- self.beta = nn.Parameter(torch.zeros(channels))
-
- def forward(self, x):
- x = x.transpose(1, -1)
- x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)
- return x.transpose(1, -1)
-
-
-class ConvReluNorm(nn.Module):
- def __init__(
- self,
- in_channels,
- hidden_channels,
- out_channels,
- kernel_size,
- n_layers,
- p_dropout,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.hidden_channels = hidden_channels
- self.out_channels = out_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
- assert n_layers > 1, "Number of layers should be larger than 0."
-
- self.conv_layers = nn.ModuleList()
- self.norm_layers = nn.ModuleList()
- self.conv_layers.append(
- nn.Conv1d(
- in_channels, hidden_channels, kernel_size, padding=kernel_size // 2
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.relu_drop = nn.Sequential(nn.ReLU(), nn.Dropout(p_dropout))
- for _ in range(n_layers - 1):
- self.conv_layers.append(
- nn.Conv1d(
- hidden_channels,
- hidden_channels,
- kernel_size,
- padding=kernel_size // 2,
- )
- )
- self.norm_layers.append(LayerNorm(hidden_channels))
- self.proj = nn.Conv1d(hidden_channels, out_channels, 1)
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask):
- x_org = x
- for i in range(self.n_layers):
- x = self.conv_layers[i](x * x_mask)
- x = self.norm_layers[i](x)
- x = self.relu_drop(x)
- x = x_org + self.proj(x)
- return x * x_mask
-
-
-class DDSConv(nn.Module):
- """
- Dialted and Depth-Separable Convolution
- """
-
- def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):
- super().__init__()
- self.channels = channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.p_dropout = p_dropout
-
- self.drop = nn.Dropout(p_dropout)
- self.convs_sep = nn.ModuleList()
- self.convs_1x1 = nn.ModuleList()
- self.norms_1 = nn.ModuleList()
- self.norms_2 = nn.ModuleList()
- for i in range(n_layers):
- dilation = kernel_size**i
- padding = (kernel_size * dilation - dilation) // 2
- self.convs_sep.append(
- nn.Conv1d(
- channels,
- channels,
- kernel_size,
- groups=channels,
- dilation=dilation,
- padding=padding,
- )
- )
- self.convs_1x1.append(nn.Conv1d(channels, channels, 1))
- self.norms_1.append(LayerNorm(channels))
- self.norms_2.append(LayerNorm(channels))
-
- def forward(self, x, x_mask, g=None):
- if g is not None:
- x = x + g
- for i in range(self.n_layers):
- y = self.convs_sep[i](x * x_mask)
- y = self.norms_1[i](y)
- y = F.gelu(y)
- y = self.convs_1x1[i](y)
- y = self.norms_2[i](y)
- y = F.gelu(y)
- y = self.drop(y)
- x = x + y
- return x * x_mask
-
-
-class WN(torch.nn.Module):
- def __init__(
- self,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- p_dropout=0,
- ):
- super(WN, self).__init__()
- assert kernel_size % 2 == 1
- self.hidden_channels = hidden_channels
- self.kernel_size = (kernel_size,)
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
- self.p_dropout = p_dropout
-
- self.in_layers = torch.nn.ModuleList()
- self.res_skip_layers = torch.nn.ModuleList()
- self.drop = nn.Dropout(p_dropout)
-
- if gin_channels != 0:
- cond_layer = torch.nn.Conv1d(
- gin_channels, 2 * hidden_channels * n_layers, 1
- )
- self.cond_layer = torch.nn.utils.weight_norm(cond_layer, name="weight")
-
- for i in range(n_layers):
- dilation = dilation_rate**i
- padding = int((kernel_size * dilation - dilation) / 2)
- in_layer = torch.nn.Conv1d(
- hidden_channels,
- 2 * hidden_channels,
- kernel_size,
- dilation=dilation,
- padding=padding,
- )
- in_layer = torch.nn.utils.weight_norm(in_layer, name="weight")
- self.in_layers.append(in_layer)
-
- # last one is not necessary
- if i < n_layers - 1:
- res_skip_channels = 2 * hidden_channels
- else:
- res_skip_channels = hidden_channels
-
- res_skip_layer = torch.nn.Conv1d(hidden_channels, res_skip_channels, 1)
- res_skip_layer = torch.nn.utils.weight_norm(res_skip_layer, name="weight")
- self.res_skip_layers.append(res_skip_layer)
-
- def forward(self, x, x_mask, g=None, **kwargs):
- output = torch.zeros_like(x)
- n_channels_tensor = torch.IntTensor([self.hidden_channels])
-
- if g is not None:
- g = self.cond_layer(g)
-
- for i in range(self.n_layers):
- x_in = self.in_layers[i](x)
- if g is not None:
- cond_offset = i * 2 * self.hidden_channels
- g_l = g[:, cond_offset : cond_offset + 2 * self.hidden_channels, :]
- else:
- g_l = torch.zeros_like(x_in)
-
- acts = commons.fused_add_tanh_sigmoid_multiply(x_in, g_l, n_channels_tensor)
- acts = self.drop(acts)
-
- res_skip_acts = self.res_skip_layers[i](acts)
- if i < self.n_layers - 1:
- res_acts = res_skip_acts[:, : self.hidden_channels, :]
- x = (x + res_acts) * x_mask
- output = output + res_skip_acts[:, self.hidden_channels :, :]
- else:
- output = output + res_skip_acts
- return output * x_mask
-
- def remove_weight_norm(self):
- if self.gin_channels != 0:
- torch.nn.utils.remove_weight_norm(self.cond_layer)
- for l in self.in_layers:
- torch.nn.utils.remove_weight_norm(l)
- for l in self.res_skip_layers:
- torch.nn.utils.remove_weight_norm(l)
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.convs1 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2]),
- )
- ),
- ]
- )
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=1,
- padding=get_padding(kernel_size, 1),
- )
- ),
- ]
- )
- self.convs2.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c2(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.convs = nn.ModuleList(
- [
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]),
- )
- ),
- weight_norm(
- Conv1d(
- channels,
- channels,
- kernel_size,
- 1,
- dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]),
- )
- ),
- ]
- )
- self.convs.apply(init_weights)
-
- def forward(self, x, x_mask=None):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- if x_mask is not None:
- xt = xt * x_mask
- xt = c(xt)
- x = xt + x
- if x_mask is not None:
- x = x * x_mask
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-class Log(nn.Module):
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = torch.log(torch.clamp_min(x, 1e-5)) * x_mask
- logdet = torch.sum(-y, [1, 2])
- return y, logdet
- else:
- x = torch.exp(x) * x_mask
- return x
-
-
-class Flip(nn.Module):
- def forward(self, x, *args, reverse=False, **kwargs):
- x = torch.flip(x, [1])
- if not reverse:
- logdet = torch.zeros(x.size(0)).to(dtype=x.dtype, device=x.device)
- return x, logdet
- else:
- return x
-
-
-class ElementwiseAffine(nn.Module):
- def __init__(self, channels):
- super().__init__()
- self.channels = channels
- self.m = nn.Parameter(torch.zeros(channels, 1))
- self.logs = nn.Parameter(torch.zeros(channels, 1))
-
- def forward(self, x, x_mask, reverse=False, **kwargs):
- if not reverse:
- y = self.m + torch.exp(self.logs) * x
- y = y * x_mask
- logdet = torch.sum(self.logs * x_mask, [1, 2])
- return y, logdet
- else:
- x = (x - self.m) * torch.exp(-self.logs) * x_mask
- return x
-
-
-class ResidualCouplingLayer(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=0,
- gin_channels=0,
- mean_only=False,
- ):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- p_dropout=p_dropout,
- gin_channels=gin_channels,
- )
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels] * 2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1, 2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
-
-class ConvFlow(nn.Module):
- def __init__(
- self,
- in_channels,
- filter_channels,
- kernel_size,
- n_layers,
- num_bins=10,
- tail_bound=5.0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.filter_channels = filter_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.num_bins = num_bins
- self.tail_bound = tail_bound
- self.half_channels = in_channels // 2
-
- self.pre = nn.Conv1d(self.half_channels, filter_channels, 1)
- self.convs = DDSConv(filter_channels, kernel_size, n_layers, p_dropout=0.0)
- self.proj = nn.Conv1d(
- filter_channels, self.half_channels * (num_bins * 3 - 1), 1
- )
- self.proj.weight.data.zero_()
- self.proj.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0)
- h = self.convs(h, x_mask, g=g)
- h = self.proj(h) * x_mask
-
- b, c, t = x0.shape
- h = h.reshape(b, c, -1, t).permute(0, 1, 3, 2) # [b, cx?, t] -> [b, c, t, ?]
-
- unnormalized_widths = h[..., : self.num_bins] / math.sqrt(self.filter_channels)
- unnormalized_heights = h[..., self.num_bins : 2 * self.num_bins] / math.sqrt(
- self.filter_channels
- )
- unnormalized_derivatives = h[..., 2 * self.num_bins :]
-
- x1, logabsdet = piecewise_rational_quadratic_transform(
- x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails="linear",
- tail_bound=self.tail_bound,
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1, 2])
- if not reverse:
- return x, logdet
- else:
- return x
-
-
-class TransformerCouplingLayer(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- n_layers,
- n_heads,
- p_dropout=0,
- filter_channels=0,
- mean_only=False,
- wn_sharing_parameter=None,
- gin_channels=0,
- ):
- assert channels % 2 == 0, "channels should be divisible by 2"
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.n_layers = n_layers
- self.half_channels = channels // 2
- self.mean_only = mean_only
-
- self.pre = nn.Conv1d(self.half_channels, hidden_channels, 1)
- self.enc = (
- Encoder(
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- isflow=True,
- gin_channels=gin_channels,
- )
- if wn_sharing_parameter is None
- else wn_sharing_parameter
- )
- self.post = nn.Conv1d(hidden_channels, self.half_channels * (2 - mean_only), 1)
- self.post.weight.data.zero_()
- self.post.bias.data.zero_()
-
- def forward(self, x, x_mask, g=None, reverse=False):
- x0, x1 = torch.split(x, [self.half_channels] * 2, 1)
- h = self.pre(x0) * x_mask
- h = self.enc(h, x_mask, g=g)
- stats = self.post(h) * x_mask
- if not self.mean_only:
- m, logs = torch.split(stats, [self.half_channels] * 2, 1)
- else:
- m = stats
- logs = torch.zeros_like(m)
-
- if not reverse:
- x1 = m + x1 * torch.exp(logs) * x_mask
- x = torch.cat([x0, x1], 1)
- logdet = torch.sum(logs, [1, 2])
- return x, logdet
- else:
- x1 = (x1 - m) * torch.exp(-logs) * x_mask
- x = torch.cat([x0, x1], 1)
- return x
-
- x1, logabsdet = piecewise_rational_quadratic_transform(
- x1,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=reverse,
- tails="linear",
- tail_bound=self.tail_bound,
- )
-
- x = torch.cat([x0, x1], 1) * x_mask
- logdet = torch.sum(logabsdet * x_mask, [1, 2])
- if not reverse:
- return x, logdet
- else:
- return x
diff --git a/spaces/jhwen/bingo/src/components/ui/dropdown-menu.tsx b/spaces/jhwen/bingo/src/components/ui/dropdown-menu.tsx
deleted file mode 100644
index 184d4e6007ef85187446362f69532ab077897fea..0000000000000000000000000000000000000000
--- a/spaces/jhwen/bingo/src/components/ui/dropdown-menu.tsx
+++ /dev/null
@@ -1,128 +0,0 @@
-'use client'
-
-import * as React from 'react'
-import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu'
-
-import { cn } from '@/lib/utils'
-
-const DropdownMenu = DropdownMenuPrimitive.Root
-
-const DropdownMenuTrigger = DropdownMenuPrimitive.Trigger
-
-const DropdownMenuGroup = DropdownMenuPrimitive.Group
-
-const DropdownMenuPortal = DropdownMenuPrimitive.Portal
-
-const DropdownMenuSub = DropdownMenuPrimitive.Sub
-
-const DropdownMenuRadioGroup = DropdownMenuPrimitive.RadioGroup
-
-const DropdownMenuSubContent = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, sideOffset = 4, ...props }, ref) => (
-
-
-))
-DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName
-
-const DropdownMenuItem = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef & {
- inset?: boolean
- }
->(({ className, inset, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef & {
- inset?: boolean
- }
->(({ className, inset, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ) => {
- return (
-
- )
-}
-DropdownMenuShortcut.displayName = 'DropdownMenuShortcut'
-
-export {
- DropdownMenu,
- DropdownMenuTrigger,
- DropdownMenuContent,
- DropdownMenuItem,
- DropdownMenuLabel,
- DropdownMenuSeparator,
- DropdownMenuShortcut,
- DropdownMenuGroup,
- DropdownMenuPortal,
- DropdownMenuSub,
- DropdownMenuSubContent,
- DropdownMenuRadioGroup
-}
diff --git a/spaces/jie1/succ1/DLKcat/DeeplearningApproach/Code/preprocess/brenda_get_smiles.py b/spaces/jie1/succ1/DLKcat/DeeplearningApproach/Code/preprocess/brenda_get_smiles.py
deleted file mode 100644
index 27f7edeaed4d4a847170f084562248028d505720..0000000000000000000000000000000000000000
--- a/spaces/jie1/succ1/DLKcat/DeeplearningApproach/Code/preprocess/brenda_get_smiles.py
+++ /dev/null
@@ -1,130 +0,0 @@
-#!/usr/bin/python
-# coding: utf-8
-
-# Author: LE YUAN
-# Date: 2020-07-23
-
-# This python script is to obtain canonical SMILES just by chemical name using PubChem API
-import json
-import time
-import requests
-import multiprocessing as mp
-from multiprocessing.dummy import Pool
-from pubchempy import Compound, get_compounds
-
-
-# Small example:
-# results = get_compounds('aspirin', 'name')
-# for compound in results :
-# print(compound.canonical_smiles)
-
-# have a try by running 100 case
-# with open("../complementaryData/Kcat_sabio_clean_unisubstrate.tsv", "r", encoding='utf-8') as file :
-# lines = file.readlines()[1:]
-# substrates = [line.strip().split('\t')[2] for line in lines]
-
-# print(len(substrates))
-# print(substrates[:10])
-
-# for substrate in substrates[:100] :
-# print(substrate)
-# results = get_compounds(substrate, 'name')
-# print(len(results))
-# if len(results) >0 :
-# print(results[0].canonical_smiles)
-# else :
-# print('-------------------------------------------------')
-
-name_smiles = dict()
-
-# One method to obtain SMILES by PubChem API using the website
-def get_smiles(name):
- # smiles = redis_cli.get(name)
- # if smiles is None:
- try :
- url = 'https://pubchem.ncbi.nlm.nih.gov/rest/pug/compound/name/%s/property/CanonicalSMILES/TXT' % name
- req = requests.get(url)
- if req.status_code != 200:
- smiles = None
- else:
- smiles = req.content.splitlines()[0].decode()
- print(smiles)
- # redis_cli.set(name, smiles, ex=None)
-
- # print smiles
- except :
- smiles = None
-
- name_smiles[name] = smiles
-
-
-# Another method to retrieve SMILES by Pubchempy
-# def get_smiles(name):
-# time.sleep(0.5)
-# results = get_compounds(name, 'name')
-
-# # print(len(results))
-# if len(results) >0 :
-# smiles = results[0].canonical_smiles
-# print(smiles)
-# else :
-# smiles = None
-# print(smiles)
-# print('-------------------------------------------------')
-
-# name_smiles[name] = smiles
-
-
-# # To obtain SMILES for substrates using provided API by PubChem
-# def main():
-# # with open('./smiles_data.json') as f:
-# # names = json.load(f)
-# # print(len(names))
-
-# with open("../complementaryData/Kcat_brenda_clean.tsv", "r", encoding='utf-8') as file :
-# lines = file.readlines()[1:]
-
-# substrates = [line.strip().split('\t')[2] for line in lines]
-
-# print(len(substrates)) # 52390
-
-# names = list(set(substrates))
-# print(len(names)) # 14457
-
-# # for substrate in substrates[:100] :
-# # print(substrate)
-
-# # thread_pool = mp.Pool(4)
-# thread_pool = Pool(4)
-# thread_pool.map(get_smiles, names)
-
-# with open('../complementaryData/Kcat_brenda_smiles.json', 'w') as outfile:
-# json.dump(name_smiles, outfile, indent=2)
-
-
-# To test how many entries having SMILES for Sabio-RK database
-def main():
- with open('../../Data/database/Kcat_brenda_smiles.json', 'r') as infile:
- name_smiles = json.load(infile)
-
- with open("../../Data/database/Kcat_brenda_clean.tsv", "r", encoding='utf-8') as file :
- lines = file.readlines()[1:]
-
- substrates = [line.strip().split('\t')[2] for line in lines]
-
- print(len(substrates)) # 52390
-
- substrate_smiles = list()
- for substrate in substrates :
- # print(substrate)
- smiles = name_smiles[substrate]
- # print(smiles)
- if smiles is not None :
- # print(smiles)
- substrate_smiles.append(smiles)
-
- print(len(substrate_smiles)) # 34857 have SMILES
-
-
-if __name__ == '__main__':
- main()
\ No newline at end of file
diff --git a/spaces/jmcob/AR-VR-IOT-Demo/style.css b/spaces/jmcob/AR-VR-IOT-Demo/style.css
deleted file mode 100644
index 114adf441e9032febb46bc056b2a8bb651075f0d..0000000000000000000000000000000000000000
--- a/spaces/jmcob/AR-VR-IOT-Demo/style.css
+++ /dev/null
@@ -1,28 +0,0 @@
-body {
- padding: 2rem;
- font-family: -apple-system, BlinkMacSystemFont, "Arial", sans-serif;
-}
-
-h1 {
- font-size: 16px;
- margin-top: 0;
-}
-
-p {
- color: rgb(107, 114, 128);
- font-size: 15px;
- margin-bottom: 10px;
- margin-top: 5px;
-}
-
-.card {
- max-width: 620px;
- margin: 0 auto;
- padding: 16px;
- border: 1px solid lightgray;
- border-radius: 16px;
-}
-
-.card p:last-child {
- margin-bottom: 0;
-}
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py
deleted file mode 100644
index 704b44a2dda9e21997acf52c268e414d01bd2eb5..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/anyio/abc/_subprocesses.py
+++ /dev/null
@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-from abc import abstractmethod
-from signal import Signals
-
-from ._resources import AsyncResource
-from ._streams import ByteReceiveStream, ByteSendStream
-
-
-class Process(AsyncResource):
- """An asynchronous version of :class:`subprocess.Popen`."""
-
- @abstractmethod
- async def wait(self) -> int:
- """
- Wait until the process exits.
-
- :return: the exit code of the process
- """
-
- @abstractmethod
- def terminate(self) -> None:
- """
- Terminates the process, gracefully if possible.
-
- On Windows, this calls ``TerminateProcess()``.
- On POSIX systems, this sends ``SIGTERM`` to the process.
-
- .. seealso:: :meth:`subprocess.Popen.terminate`
- """
-
- @abstractmethod
- def kill(self) -> None:
- """
- Kills the process.
-
- On Windows, this calls ``TerminateProcess()``.
- On POSIX systems, this sends ``SIGKILL`` to the process.
-
- .. seealso:: :meth:`subprocess.Popen.kill`
- """
-
- @abstractmethod
- def send_signal(self, signal: Signals) -> None:
- """
- Send a signal to the subprocess.
-
- .. seealso:: :meth:`subprocess.Popen.send_signal`
-
- :param signal: the signal number (e.g. :data:`signal.SIGHUP`)
- """
-
- @property
- @abstractmethod
- def pid(self) -> int:
- """The process ID of the process."""
-
- @property
- @abstractmethod
- def returncode(self) -> int | None:
- """
- The return code of the process. If the process has not yet terminated, this will be
- ``None``.
- """
-
- @property
- @abstractmethod
- def stdin(self) -> ByteSendStream | None:
- """The stream for the standard input of the process."""
-
- @property
- @abstractmethod
- def stdout(self) -> ByteReceiveStream | None:
- """The stream for the standard output of the process."""
-
- @property
- @abstractmethod
- def stderr(self) -> ByteReceiveStream | None:
- """The stream for the standard error output of the process."""
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/G_P_O_S_.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/G_P_O_S_.py
deleted file mode 100644
index ca8290bab440e31196dd009c5125e022a079d7af..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/G_P_O_S_.py
+++ /dev/null
@@ -1,5 +0,0 @@
-from .otBase import BaseTTXConverter
-
-
-class table_G_P_O_S_(BaseTTXConverter):
- pass
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/indices/common/struct_store/__init__.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/indices/common/struct_store/__init__.py
deleted file mode 100644
index c637335013c599b07de054fba07b47ecb86ad3e8..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/gpt_index/indices/common/struct_store/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-"""Init params."""
diff --git a/spaces/jordonpeter01/ai-comic-factory/src/app/interface/zoom/index.tsx b/spaces/jordonpeter01/ai-comic-factory/src/app/interface/zoom/index.tsx
deleted file mode 100644
index 5c8d31a3af1c80f8a9ef15330bb84c0d2c3069de..0000000000000000000000000000000000000000
--- a/spaces/jordonpeter01/ai-comic-factory/src/app/interface/zoom/index.tsx
+++ /dev/null
@@ -1,35 +0,0 @@
-import { useStore } from "@/app/store"
-import { VerticalSlider } from "@/components/ui/vertical-slider"
-import { cn } from "@/lib/utils"
-
-export function Zoom() {
- const zoomLevel = useStore((state) => state.zoomLevel)
- const setZoomLevel = useStore((state) => state.setZoomLevel)
- const isGeneratingStory = useStore((state) => state.isGeneratingStory)
-
- return (
-
-
- Zoom
-
-
- setZoomLevel(value[0] || 10)}
- value={[zoomLevel]}
- className="h-64 md:h-80"
- orientation="vertical"
- />
-
-
- )
-}
\ No newline at end of file
diff --git a/spaces/justin-zk/Personalize-SAM/show.py b/spaces/justin-zk/Personalize-SAM/show.py
deleted file mode 100644
index c07e4fe530942e1670a7299edde3294a7fc571da..0000000000000000000000000000000000000000
--- a/spaces/justin-zk/Personalize-SAM/show.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import numpy as np
-import torch
-import matplotlib.pyplot as plt
-import cv2
-
-
-
-def show_mask(mask, ax, random_color=False):
- if random_color:
- color = np.concatenate([np.random.random(3), np.array([0.6])], axis=0)
- else:
- color = np.array([30/255, 144/255, 255/255, 0.4])
- h, w = mask.shape[-2:]
- mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
- ax.imshow(mask_image)
-
-
-def show_points(coords, labels, ax, marker_size=375):
- pos_points = coords[labels==1]
- neg_points = coords[labels==0]
- ax.scatter(pos_points[:, 0], pos_points[:, 1], color='green', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)
- ax.scatter(neg_points[:, 0], neg_points[:, 1], color='red', marker='*', s=marker_size, edgecolor='white', linewidth=1.25)
-
-
-def show_box(box, ax):
- x0, y0 = box[0], box[1]
- w, h = box[2] - box[0], box[3] - box[1]
- ax.add_patch(plt.Rectangle((x0, y0), w, h, edgecolor='green', facecolor=(0,0,0,0), lw=2))
\ No newline at end of file
diff --git a/spaces/kalebu/LangChain_heyooBot/app.py b/spaces/kalebu/LangChain_heyooBot/app.py
deleted file mode 100644
index ae3a8d316c06df5b2acbe9ddf2ab0431fe946888..0000000000000000000000000000000000000000
--- a/spaces/kalebu/LangChain_heyooBot/app.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from langchain.llms import OpenAI
-from langchain.chains.qa_with_sources import load_qa_with_sources_chain
-from langchain.docstore.document import Document
-import requests
-import pathlib
-import subprocess
-import tempfile
-import os
-import gradio as gr
-import pickle
-
-# using a vector space for our search
-from langchain.embeddings.openai import OpenAIEmbeddings
-from langchain.vectorstores.faiss import FAISS
-from langchain.text_splitter import CharacterTextSplitter
-
-#loading FAISS search index from disk
-with open("search_index.pickle", "rb") as f:
- search_index = pickle.load(f)
-
-#Get GPT3 response using Langchain
-def print_answer(question, openai): #openai_embeddings
- #search_index = get_search_index()
- chain = load_qa_with_sources_chain(openai) #(OpenAI(temperature=0))
- response = (
- chain(
- {
- "input_documents": search_index.similarity_search(question, k=4),
- "question": question,
- },
- return_only_outputs=True,
- )["output_text"]
- )
- if len(response.split('\n')[-1].split())>2:
- response = response.split('\n')[0] + ', '.join([' Click Link' + str(i) + '' for i in range(1,len(response.split('\n')[-1].split()))])
- else:
- response = response.split('\n')[0] + ' Click Link'
- return response
-
-
-def chat(message, history, openai_api_key):
- #openai_embeddings = OpenAIEmbeddings(openai_api_key=openai_api_key)
- openai = OpenAI(temperature=0, openai_api_key=openai_api_key )
- #os.environ["OPENAI_API_KEY"] = openai_api_key
- history = history or []
- message = message.lower()
- response = print_answer(message, openai) #openai_embeddings
- history.append((message, response))
- return history, history
-
-
-with gr.Blocks() as demo:
- gr.HTML("""
-
-
- heyoo QandA - LangChain Bot
-
-
-
- Hi, I'm a Q and A heyoo expert bot, start by typing in your OpenAI API key, questions/issues you are facing in your heyoo implementations and then press enter.
- Duplicate Space with GPU Upgrade for fast Inference & no queue
- Built using LangChain and Gradio for the heyoo Repo
-
- """)
- with gr.Row():
- question = gr.Textbox(label = 'Type in your questions about heyoo here and press Enter!', placeholder = 'What questions do you want to ask about the heyoo library?')
- openai_api_key = gr.Textbox(type='password', label="Enter your OpenAI API key here")
- state = gr.State()
- chatbot = gr.Chatbot()
- question.submit(chat, [question, state, openai_api_key], [chatbot, state])
-
-if __name__ == "__main__":
- demo.launch()
\ No newline at end of file
diff --git a/spaces/kcagle/AutoGPT/tests/integration/milvus_memory_tests.py b/spaces/kcagle/AutoGPT/tests/integration/milvus_memory_tests.py
deleted file mode 100644
index ec38bf2f72087b5da679d26594ebff97d8a09b19..0000000000000000000000000000000000000000
--- a/spaces/kcagle/AutoGPT/tests/integration/milvus_memory_tests.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# sourcery skip: snake-case-functions
-"""Tests for the MilvusMemory class."""
-import random
-import string
-import unittest
-
-from autogpt.config import Config
-from autogpt.memory.milvus import MilvusMemory
-
-try:
-
- class TestMilvusMemory(unittest.TestCase):
- """Tests for the MilvusMemory class."""
-
- def random_string(self, length: int) -> str:
- """Generate a random string of the given length."""
- return "".join(random.choice(string.ascii_letters) for _ in range(length))
-
- def setUp(self) -> None:
- """Set up the test environment."""
- cfg = Config()
- cfg.milvus_addr = "localhost:19530"
- self.memory = MilvusMemory(cfg)
- self.memory.clear()
-
- # Add example texts to the cache
- self.example_texts = [
- "The quick brown fox jumps over the lazy dog",
- "I love machine learning and natural language processing",
- "The cake is a lie, but the pie is always true",
- "ChatGPT is an advanced AI model for conversation",
- ]
-
- for text in self.example_texts:
- self.memory.add(text)
-
- # Add some random strings to test noise
- for _ in range(5):
- self.memory.add(self.random_string(10))
-
- def test_get_relevant(self) -> None:
- """Test getting relevant texts from the cache."""
- query = "I'm interested in artificial intelligence and NLP"
- num_relevant = 3
- relevant_texts = self.memory.get_relevant(query, num_relevant)
-
- print(f"Top {k} relevant texts for the query '{query}':")
- for i, text in enumerate(relevant_texts, start=1):
- print(f"{i}. {text}")
-
- self.assertEqual(len(relevant_texts), k)
- self.assertIn(self.example_texts[1], relevant_texts)
-
-except:
- print(
- "Skipping tests/integration/milvus_memory_tests.py as Milvus is not installed."
- )
diff --git a/spaces/keras-io/keras-video-classification-cnn-rnn/README.md b/spaces/keras-io/keras-video-classification-cnn-rnn/README.md
deleted file mode 100644
index 4a7e56589f222c675e00ba348573abe3bc86b825..0000000000000000000000000000000000000000
--- a/spaces/keras-io/keras-video-classification-cnn-rnn/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Video Classification with CNN-RNN
-emoji: 🎬
-colorFrom: red
-colorTo: yellow
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/kevinwang676/ChatGLM2-SadTalker-VC/src/face3d/models/arcface_torch/partial_fc.py b/spaces/kevinwang676/ChatGLM2-SadTalker-VC/src/face3d/models/arcface_torch/partial_fc.py
deleted file mode 100644
index 17e2d25715d10ba446c957e1d2528b0687ed71d5..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/ChatGLM2-SadTalker-VC/src/face3d/models/arcface_torch/partial_fc.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import logging
-import os
-
-import torch
-import torch.distributed as dist
-from torch.nn import Module
-from torch.nn.functional import normalize, linear
-from torch.nn.parameter import Parameter
-
-
-class PartialFC(Module):
- """
- Author: {Xiang An, Yang Xiao, XuHan Zhu} in DeepGlint,
- Partial FC: Training 10 Million Identities on a Single Machine
- See the original paper:
- https://arxiv.org/abs/2010.05222
- """
-
- @torch.no_grad()
- def __init__(self, rank, local_rank, world_size, batch_size, resume,
- margin_softmax, num_classes, sample_rate=1.0, embedding_size=512, prefix="./"):
- """
- rank: int
- Unique process(GPU) ID from 0 to world_size - 1.
- local_rank: int
- Unique process(GPU) ID within the server from 0 to 7.
- world_size: int
- Number of GPU.
- batch_size: int
- Batch size on current rank(GPU).
- resume: bool
- Select whether to restore the weight of softmax.
- margin_softmax: callable
- A function of margin softmax, eg: cosface, arcface.
- num_classes: int
- The number of class center storage in current rank(CPU/GPU), usually is total_classes // world_size,
- required.
- sample_rate: float
- The partial fc sampling rate, when the number of classes increases to more than 2 millions, Sampling
- can greatly speed up training, and reduce a lot of GPU memory, default is 1.0.
- embedding_size: int
- The feature dimension, default is 512.
- prefix: str
- Path for save checkpoint, default is './'.
- """
- super(PartialFC, self).__init__()
- #
- self.num_classes: int = num_classes
- self.rank: int = rank
- self.local_rank: int = local_rank
- self.device: torch.device = torch.device("cuda:{}".format(self.local_rank))
- self.world_size: int = world_size
- self.batch_size: int = batch_size
- self.margin_softmax: callable = margin_softmax
- self.sample_rate: float = sample_rate
- self.embedding_size: int = embedding_size
- self.prefix: str = prefix
- self.num_local: int = num_classes // world_size + int(rank < num_classes % world_size)
- self.class_start: int = num_classes // world_size * rank + min(rank, num_classes % world_size)
- self.num_sample: int = int(self.sample_rate * self.num_local)
-
- self.weight_name = os.path.join(self.prefix, "rank_{}_softmax_weight.pt".format(self.rank))
- self.weight_mom_name = os.path.join(self.prefix, "rank_{}_softmax_weight_mom.pt".format(self.rank))
-
- if resume:
- try:
- self.weight: torch.Tensor = torch.load(self.weight_name)
- self.weight_mom: torch.Tensor = torch.load(self.weight_mom_name)
- if self.weight.shape[0] != self.num_local or self.weight_mom.shape[0] != self.num_local:
- raise IndexError
- logging.info("softmax weight resume successfully!")
- logging.info("softmax weight mom resume successfully!")
- except (FileNotFoundError, KeyError, IndexError):
- self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
- self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
- logging.info("softmax weight init!")
- logging.info("softmax weight mom init!")
- else:
- self.weight = torch.normal(0, 0.01, (self.num_local, self.embedding_size), device=self.device)
- self.weight_mom: torch.Tensor = torch.zeros_like(self.weight)
- logging.info("softmax weight init successfully!")
- logging.info("softmax weight mom init successfully!")
- self.stream: torch.cuda.Stream = torch.cuda.Stream(local_rank)
-
- self.index = None
- if int(self.sample_rate) == 1:
- self.update = lambda: 0
- self.sub_weight = Parameter(self.weight)
- self.sub_weight_mom = self.weight_mom
- else:
- self.sub_weight = Parameter(torch.empty((0, 0)).cuda(local_rank))
-
- def save_params(self):
- """ Save softmax weight for each rank on prefix
- """
- torch.save(self.weight.data, self.weight_name)
- torch.save(self.weight_mom, self.weight_mom_name)
-
- @torch.no_grad()
- def sample(self, total_label):
- """
- Sample all positive class centers in each rank, and random select neg class centers to filling a fixed
- `num_sample`.
-
- total_label: tensor
- Label after all gather, which cross all GPUs.
- """
- index_positive = (self.class_start <= total_label) & (total_label < self.class_start + self.num_local)
- total_label[~index_positive] = -1
- total_label[index_positive] -= self.class_start
- if int(self.sample_rate) != 1:
- positive = torch.unique(total_label[index_positive], sorted=True)
- if self.num_sample - positive.size(0) >= 0:
- perm = torch.rand(size=[self.num_local], device=self.device)
- perm[positive] = 2.0
- index = torch.topk(perm, k=self.num_sample)[1]
- index = index.sort()[0]
- else:
- index = positive
- self.index = index
- total_label[index_positive] = torch.searchsorted(index, total_label[index_positive])
- self.sub_weight = Parameter(self.weight[index])
- self.sub_weight_mom = self.weight_mom[index]
-
- def forward(self, total_features, norm_weight):
- """ Partial fc forward, `logits = X * sample(W)`
- """
- torch.cuda.current_stream().wait_stream(self.stream)
- logits = linear(total_features, norm_weight)
- return logits
-
- @torch.no_grad()
- def update(self):
- """ Set updated weight and weight_mom to memory bank.
- """
- self.weight_mom[self.index] = self.sub_weight_mom
- self.weight[self.index] = self.sub_weight
-
- def prepare(self, label, optimizer):
- """
- get sampled class centers for cal softmax.
-
- label: tensor
- Label tensor on each rank.
- optimizer: opt
- Optimizer for partial fc, which need to get weight mom.
- """
- with torch.cuda.stream(self.stream):
- total_label = torch.zeros(
- size=[self.batch_size * self.world_size], device=self.device, dtype=torch.long)
- dist.all_gather(list(total_label.chunk(self.world_size, dim=0)), label)
- self.sample(total_label)
- optimizer.state.pop(optimizer.param_groups[-1]['params'][0], None)
- optimizer.param_groups[-1]['params'][0] = self.sub_weight
- optimizer.state[self.sub_weight]['momentum_buffer'] = self.sub_weight_mom
- norm_weight = normalize(self.sub_weight)
- return total_label, norm_weight
-
- def forward_backward(self, label, features, optimizer):
- """
- Partial fc forward and backward with model parallel
-
- label: tensor
- Label tensor on each rank(GPU)
- features: tensor
- Features tensor on each rank(GPU)
- optimizer: optimizer
- Optimizer for partial fc
-
- Returns:
- --------
- x_grad: tensor
- The gradient of features.
- loss_v: tensor
- Loss value for cross entropy.
- """
- total_label, norm_weight = self.prepare(label, optimizer)
- total_features = torch.zeros(
- size=[self.batch_size * self.world_size, self.embedding_size], device=self.device)
- dist.all_gather(list(total_features.chunk(self.world_size, dim=0)), features.data)
- total_features.requires_grad = True
-
- logits = self.forward(total_features, norm_weight)
- logits = self.margin_softmax(logits, total_label)
-
- with torch.no_grad():
- max_fc = torch.max(logits, dim=1, keepdim=True)[0]
- dist.all_reduce(max_fc, dist.ReduceOp.MAX)
-
- # calculate exp(logits) and all-reduce
- logits_exp = torch.exp(logits - max_fc)
- logits_sum_exp = logits_exp.sum(dim=1, keepdims=True)
- dist.all_reduce(logits_sum_exp, dist.ReduceOp.SUM)
-
- # calculate prob
- logits_exp.div_(logits_sum_exp)
-
- # get one-hot
- grad = logits_exp
- index = torch.where(total_label != -1)[0]
- one_hot = torch.zeros(size=[index.size()[0], grad.size()[1]], device=grad.device)
- one_hot.scatter_(1, total_label[index, None], 1)
-
- # calculate loss
- loss = torch.zeros(grad.size()[0], 1, device=grad.device)
- loss[index] = grad[index].gather(1, total_label[index, None])
- dist.all_reduce(loss, dist.ReduceOp.SUM)
- loss_v = loss.clamp_min_(1e-30).log_().mean() * (-1)
-
- # calculate grad
- grad[index] -= one_hot
- grad.div_(self.batch_size * self.world_size)
-
- logits.backward(grad)
- if total_features.grad is not None:
- total_features.grad.detach_()
- x_grad: torch.Tensor = torch.zeros_like(features, requires_grad=True)
- # feature gradient all-reduce
- dist.reduce_scatter(x_grad, list(total_features.grad.chunk(self.world_size, dim=0)))
- x_grad = x_grad * self.world_size
- # backward backbone
- return x_grad, loss_v
diff --git a/spaces/kevinwang676/SadTalker/src/utils/paste_pic.py b/spaces/kevinwang676/SadTalker/src/utils/paste_pic.py
deleted file mode 100644
index f9989e21e48e64f620f9b148e65fdfe806c53b14..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/SadTalker/src/utils/paste_pic.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import cv2, os
-import numpy as np
-from tqdm import tqdm
-import uuid
-
-from src.utils.videoio import save_video_with_watermark
-
-def paste_pic(video_path, pic_path, crop_info, new_audio_path, full_video_path, extended_crop=False):
-
- if not os.path.isfile(pic_path):
- raise ValueError('pic_path must be a valid path to video/image file')
- elif pic_path.split('.')[-1] in ['jpg', 'png', 'jpeg']:
- # loader for first frame
- full_img = cv2.imread(pic_path)
- else:
- # loader for videos
- video_stream = cv2.VideoCapture(pic_path)
- fps = video_stream.get(cv2.CAP_PROP_FPS)
- full_frames = []
- while 1:
- still_reading, frame = video_stream.read()
- if not still_reading:
- video_stream.release()
- break
- break
- full_img = frame
- frame_h = full_img.shape[0]
- frame_w = full_img.shape[1]
-
- video_stream = cv2.VideoCapture(video_path)
- fps = video_stream.get(cv2.CAP_PROP_FPS)
- crop_frames = []
- while 1:
- still_reading, frame = video_stream.read()
- if not still_reading:
- video_stream.release()
- break
- crop_frames.append(frame)
-
- if len(crop_info) != 3:
- print("you didn't crop the image")
- return
- else:
- r_w, r_h = crop_info[0]
- clx, cly, crx, cry = crop_info[1]
- lx, ly, rx, ry = crop_info[2]
- lx, ly, rx, ry = int(lx), int(ly), int(rx), int(ry)
- # oy1, oy2, ox1, ox2 = cly+ly, cly+ry, clx+lx, clx+rx
- # oy1, oy2, ox1, ox2 = cly+ly, cly+ry, clx+lx, clx+rx
-
- if extended_crop:
- oy1, oy2, ox1, ox2 = cly, cry, clx, crx
- else:
- oy1, oy2, ox1, ox2 = cly+ly, cly+ry, clx+lx, clx+rx
-
- tmp_path = str(uuid.uuid4())+'.mp4'
- out_tmp = cv2.VideoWriter(tmp_path, cv2.VideoWriter_fourcc(*'MP4V'), fps, (frame_w, frame_h))
- for crop_frame in tqdm(crop_frames, 'seamlessClone:'):
- p = cv2.resize(crop_frame.astype(np.uint8), (ox2-ox1, oy2 - oy1))
-
- mask = 255*np.ones(p.shape, p.dtype)
- location = ((ox1+ox2) // 2, (oy1+oy2) // 2)
- gen_img = cv2.seamlessClone(p, full_img, mask, location, cv2.NORMAL_CLONE)
- out_tmp.write(gen_img)
-
- out_tmp.release()
-
- save_video_with_watermark(tmp_path, new_audio_path, full_video_path, watermark=False)
- os.remove(tmp_path)
diff --git a/spaces/kevinwang676/VoiceChanger/src/face3d/data/base_dataset.py b/spaces/kevinwang676/VoiceChanger/src/face3d/data/base_dataset.py
deleted file mode 100644
index 1bd57d082d519f512d7114b4f867b6695fb7de06..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/VoiceChanger/src/face3d/data/base_dataset.py
+++ /dev/null
@@ -1,125 +0,0 @@
-"""This module implements an abstract base class (ABC) 'BaseDataset' for datasets.
-
-It also includes common transformation functions (e.g., get_transform, __scale_width), which can be later used in subclasses.
-"""
-import random
-import numpy as np
-import torch.utils.data as data
-from PIL import Image
-import torchvision.transforms as transforms
-from abc import ABC, abstractmethod
-
-
-class BaseDataset(data.Dataset, ABC):
- """This class is an abstract base class (ABC) for datasets.
-
- To create a subclass, you need to implement the following four functions:
- -- <__init__>: initialize the class, first call BaseDataset.__init__(self, opt).
- -- <__len__>: return the size of dataset.
- -- <__getitem__>: get a data point.
- -- : (optionally) add dataset-specific options and set default options.
- """
-
- def __init__(self, opt):
- """Initialize the class; save the options in the class
-
- Parameters:
- opt (Option class)-- stores all the experiment flags; needs to be a subclass of BaseOptions
- """
- self.opt = opt
- # self.root = opt.dataroot
- self.current_epoch = 0
-
- @staticmethod
- def modify_commandline_options(parser, is_train):
- """Add new dataset-specific options, and rewrite default values for existing options.
-
- Parameters:
- parser -- original option parser
- is_train (bool) -- whether training phase or test phase. You can use this flag to add training-specific or test-specific options.
-
- Returns:
- the modified parser.
- """
- return parser
-
- @abstractmethod
- def __len__(self):
- """Return the total number of images in the dataset."""
- return 0
-
- @abstractmethod
- def __getitem__(self, index):
- """Return a data point and its metadata information.
-
- Parameters:
- index - - a random integer for data indexing
-
- Returns:
- a dictionary of data with their names. It ususally contains the data itself and its metadata information.
- """
- pass
-
-
-def get_transform(grayscale=False):
- transform_list = []
- if grayscale:
- transform_list.append(transforms.Grayscale(1))
- transform_list += [transforms.ToTensor()]
- return transforms.Compose(transform_list)
-
-def get_affine_mat(opt, size):
- shift_x, shift_y, scale, rot_angle, flip = 0., 0., 1., 0., False
- w, h = size
-
- if 'shift' in opt.preprocess:
- shift_pixs = int(opt.shift_pixs)
- shift_x = random.randint(-shift_pixs, shift_pixs)
- shift_y = random.randint(-shift_pixs, shift_pixs)
- if 'scale' in opt.preprocess:
- scale = 1 + opt.scale_delta * (2 * random.random() - 1)
- if 'rot' in opt.preprocess:
- rot_angle = opt.rot_angle * (2 * random.random() - 1)
- rot_rad = -rot_angle * np.pi/180
- if 'flip' in opt.preprocess:
- flip = random.random() > 0.5
-
- shift_to_origin = np.array([1, 0, -w//2, 0, 1, -h//2, 0, 0, 1]).reshape([3, 3])
- flip_mat = np.array([-1 if flip else 1, 0, 0, 0, 1, 0, 0, 0, 1]).reshape([3, 3])
- shift_mat = np.array([1, 0, shift_x, 0, 1, shift_y, 0, 0, 1]).reshape([3, 3])
- rot_mat = np.array([np.cos(rot_rad), np.sin(rot_rad), 0, -np.sin(rot_rad), np.cos(rot_rad), 0, 0, 0, 1]).reshape([3, 3])
- scale_mat = np.array([scale, 0, 0, 0, scale, 0, 0, 0, 1]).reshape([3, 3])
- shift_to_center = np.array([1, 0, w//2, 0, 1, h//2, 0, 0, 1]).reshape([3, 3])
-
- affine = shift_to_center @ scale_mat @ rot_mat @ shift_mat @ flip_mat @ shift_to_origin
- affine_inv = np.linalg.inv(affine)
- return affine, affine_inv, flip
-
-def apply_img_affine(img, affine_inv, method=Image.BICUBIC):
- return img.transform(img.size, Image.AFFINE, data=affine_inv.flatten()[:6], resample=Image.BICUBIC)
-
-def apply_lm_affine(landmark, affine, flip, size):
- _, h = size
- lm = landmark.copy()
- lm[:, 1] = h - 1 - lm[:, 1]
- lm = np.concatenate((lm, np.ones([lm.shape[0], 1])), -1)
- lm = lm @ np.transpose(affine)
- lm[:, :2] = lm[:, :2] / lm[:, 2:]
- lm = lm[:, :2]
- lm[:, 1] = h - 1 - lm[:, 1]
- if flip:
- lm_ = lm.copy()
- lm_[:17] = lm[16::-1]
- lm_[17:22] = lm[26:21:-1]
- lm_[22:27] = lm[21:16:-1]
- lm_[31:36] = lm[35:30:-1]
- lm_[36:40] = lm[45:41:-1]
- lm_[40:42] = lm[47:45:-1]
- lm_[42:46] = lm[39:35:-1]
- lm_[46:48] = lm[41:39:-1]
- lm_[48:55] = lm[54:47:-1]
- lm_[55:60] = lm[59:54:-1]
- lm_[60:65] = lm[64:59:-1]
- lm_[65:68] = lm[67:64:-1]
- lm = lm_
- return lm
diff --git a/spaces/kevinwang676/VoiceChangers/scripts/extension.py b/spaces/kevinwang676/VoiceChangers/scripts/extension.py
deleted file mode 100644
index c90ec25c2811d87a00a2e2a14e270c75d07d713d..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/VoiceChangers/scripts/extension.py
+++ /dev/null
@@ -1,189 +0,0 @@
-import os, sys
-from pathlib import Path
-import tempfile
-import gradio as gr
-from modules.call_queue import wrap_gradio_gpu_call, wrap_queued_call
-from modules.shared import opts, OptionInfo
-from modules import shared, paths, script_callbacks
-import launch
-import glob
-from huggingface_hub import snapshot_download
-
-
-
-def check_all_files_safetensor(current_dir):
- kv = {
- "SadTalker_V0.0.2_256.safetensors": "sadtalker-256",
- "SadTalker_V0.0.2_512.safetensors": "sadtalker-512",
- "mapping_00109-model.pth.tar" : "mapping-109" ,
- "mapping_00229-model.pth.tar" : "mapping-229" ,
- }
-
- if not os.path.isdir(current_dir):
- return False
-
- dirs = os.listdir(current_dir)
-
- for f in dirs:
- if f in kv.keys():
- del kv[f]
-
- return len(kv.keys()) == 0
-
-def check_all_files(current_dir):
- kv = {
- "auido2exp_00300-model.pth": "audio2exp",
- "auido2pose_00140-model.pth": "audio2pose",
- "epoch_20.pth": "face_recon",
- "facevid2vid_00189-model.pth.tar": "face-render",
- "mapping_00109-model.pth.tar" : "mapping-109" ,
- "mapping_00229-model.pth.tar" : "mapping-229" ,
- "wav2lip.pth": "wav2lip",
- "shape_predictor_68_face_landmarks.dat": "dlib",
- }
-
- if not os.path.isdir(current_dir):
- return False
-
- dirs = os.listdir(current_dir)
-
- for f in dirs:
- if f in kv.keys():
- del kv[f]
-
- return len(kv.keys()) == 0
-
-
-
-def download_model(local_dir='./checkpoints'):
- REPO_ID = 'vinthony/SadTalker'
- snapshot_download(repo_id=REPO_ID, local_dir=local_dir, local_dir_use_symlinks=False)
-
-def get_source_image(image):
- return image
-
-def get_img_from_txt2img(x):
- talker_path = Path(paths.script_path) / "outputs"
- imgs_from_txt_dir = str(talker_path / "txt2img-images/")
- imgs = glob.glob(imgs_from_txt_dir+'/*/*.png')
- imgs.sort(key=lambda x:os.path.getmtime(os.path.join(imgs_from_txt_dir, x)))
- img_from_txt_path = os.path.join(imgs_from_txt_dir, imgs[-1])
- return img_from_txt_path, img_from_txt_path
-
-def get_img_from_img2img(x):
- talker_path = Path(paths.script_path) / "outputs"
- imgs_from_img_dir = str(talker_path / "img2img-images/")
- imgs = glob.glob(imgs_from_img_dir+'/*/*.png')
- imgs.sort(key=lambda x:os.path.getmtime(os.path.join(imgs_from_img_dir, x)))
- img_from_img_path = os.path.join(imgs_from_img_dir, imgs[-1])
- return img_from_img_path, img_from_img_path
-
-def get_default_checkpoint_path():
- # check the path of models/checkpoints and extensions/
- checkpoint_path = Path(paths.script_path) / "models"/ "SadTalker"
- extension_checkpoint_path = Path(paths.script_path) / "extensions"/ "SadTalker" / "checkpoints"
-
- if check_all_files_safetensor(checkpoint_path):
- # print('founding sadtalker checkpoint in ' + str(checkpoint_path))
- return checkpoint_path
-
- if check_all_files_safetensor(extension_checkpoint_path):
- # print('founding sadtalker checkpoint in ' + str(extension_checkpoint_path))
- return extension_checkpoint_path
-
- if check_all_files(checkpoint_path):
- # print('founding sadtalker checkpoint in ' + str(checkpoint_path))
- return checkpoint_path
-
- if check_all_files(extension_checkpoint_path):
- # print('founding sadtalker checkpoint in ' + str(extension_checkpoint_path))
- return extension_checkpoint_path
-
- return None
-
-
-
-def install():
-
- kv = {
- "face_alignment": "face-alignment==1.3.5",
- "imageio": "imageio==2.19.3",
- "imageio_ffmpeg": "imageio-ffmpeg==0.4.7",
- "librosa":"librosa==0.8.0",
- "pydub":"pydub==0.25.1",
- "scipy":"scipy==1.8.1",
- "tqdm": "tqdm",
- "yacs":"yacs==0.1.8",
- "yaml": "pyyaml",
- "av":"av",
- "gfpgan": "gfpgan",
- }
-
- # # dlib is not necessary currently
- # if 'darwin' in sys.platform:
- # kv['dlib'] = "dlib"
- # else:
- # kv['dlib'] = 'dlib-bin'
-
- # #### we need to have a newer version of imageio for our method.
- # launch.run_pip("install imageio==2.19.3", "requirements for SadTalker")
-
- for k,v in kv.items():
- if not launch.is_installed(k):
- print(k, launch.is_installed(k))
- launch.run_pip("install "+ v, "requirements for SadTalker")
-
- if os.getenv('SADTALKER_CHECKPOINTS'):
- print('load Sadtalker Checkpoints from '+ os.getenv('SADTALKER_CHECKPOINTS'))
-
- elif get_default_checkpoint_path() is not None:
- os.environ['SADTALKER_CHECKPOINTS'] = str(get_default_checkpoint_path())
- else:
-
- print(
- """"
- SadTalker will not support download all the files from hugging face, which will take a long time.
-
- please manually set the SADTALKER_CHECKPOINTS in `webui_user.bat`(windows) or `webui_user.sh`(linux)
- """
- )
-
- # python = sys.executable
-
- # launch.run(f'"{python}" -m pip uninstall -y huggingface_hub', live=True)
- # launch.run(f'"{python}" -m pip install --upgrade git+https://github.com/huggingface/huggingface_hub@main', live=True)
- # ### run the scripts to downlod models to correct localtion.
- # # print('download models for SadTalker')
- # # launch.run("cd " + paths.script_path+"/extensions/SadTalker && bash ./scripts/download_models.sh", live=True)
- # # print('SadTalker is successfully installed!')
- # download_model(paths.script_path+'/extensions/SadTalker/checkpoints')
-
-
-def on_ui_tabs():
- install()
-
- sys.path.extend([paths.script_path+'/extensions/SadTalker'])
-
- repo_dir = paths.script_path+'/extensions/SadTalker/'
-
- result_dir = opts.sadtalker_result_dir
- os.makedirs(result_dir, exist_ok=True)
-
- from app_sadtalker import sadtalker_demo
-
- if os.getenv('SADTALKER_CHECKPOINTS'):
- checkpoint_path = os.getenv('SADTALKER_CHECKPOINTS')
- else:
- checkpoint_path = repo_dir+'checkpoints/'
-
- audio_to_video = sadtalker_demo(checkpoint_path=checkpoint_path, config_path=repo_dir+'src/config', warpfn = wrap_queued_call)
-
- return [(audio_to_video, "SadTalker", "extension")]
-
-def on_ui_settings():
- talker_path = Path(paths.script_path) / "outputs"
- section = ('extension', "SadTalker")
- opts.add_option("sadtalker_result_dir", OptionInfo(str(talker_path / "SadTalker/"), "Path to save results of sadtalker", section=section))
-
-script_callbacks.on_ui_settings(on_ui_settings)
-script_callbacks.on_ui_tabs(on_ui_tabs)
diff --git a/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/conv_ws.py b/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/conv_ws.py
deleted file mode 100644
index a3941e27874993418b3b5708d5a7485f175ff9c8..0000000000000000000000000000000000000000
--- a/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/cnn/bricks/conv_ws.py
+++ /dev/null
@@ -1,148 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .registry import CONV_LAYERS
-
-
-def conv_ws_2d(input,
- weight,
- bias=None,
- stride=1,
- padding=0,
- dilation=1,
- groups=1,
- eps=1e-5):
- c_in = weight.size(0)
- weight_flat = weight.view(c_in, -1)
- mean = weight_flat.mean(dim=1, keepdim=True).view(c_in, 1, 1, 1)
- std = weight_flat.std(dim=1, keepdim=True).view(c_in, 1, 1, 1)
- weight = (weight - mean) / (std + eps)
- return F.conv2d(input, weight, bias, stride, padding, dilation, groups)
-
-
-@CONV_LAYERS.register_module('ConvWS')
-class ConvWS2d(nn.Conv2d):
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size,
- stride=1,
- padding=0,
- dilation=1,
- groups=1,
- bias=True,
- eps=1e-5):
- super(ConvWS2d, self).__init__(
- in_channels,
- out_channels,
- kernel_size,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups,
- bias=bias)
- self.eps = eps
-
- def forward(self, x):
- return conv_ws_2d(x, self.weight, self.bias, self.stride, self.padding,
- self.dilation, self.groups, self.eps)
-
-
-@CONV_LAYERS.register_module(name='ConvAWS')
-class ConvAWS2d(nn.Conv2d):
- """AWS (Adaptive Weight Standardization)
-
- This is a variant of Weight Standardization
- (https://arxiv.org/pdf/1903.10520.pdf)
- It is used in DetectoRS to avoid NaN
- (https://arxiv.org/pdf/2006.02334.pdf)
-
- Args:
- in_channels (int): Number of channels in the input image
- out_channels (int): Number of channels produced by the convolution
- kernel_size (int or tuple): Size of the conv kernel
- stride (int or tuple, optional): Stride of the convolution. Default: 1
- padding (int or tuple, optional): Zero-padding added to both sides of
- the input. Default: 0
- dilation (int or tuple, optional): Spacing between kernel elements.
- Default: 1
- groups (int, optional): Number of blocked connections from input
- channels to output channels. Default: 1
- bias (bool, optional): If set True, adds a learnable bias to the
- output. Default: True
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size,
- stride=1,
- padding=0,
- dilation=1,
- groups=1,
- bias=True):
- super().__init__(
- in_channels,
- out_channels,
- kernel_size,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups,
- bias=bias)
- self.register_buffer('weight_gamma',
- torch.ones(self.out_channels, 1, 1, 1))
- self.register_buffer('weight_beta',
- torch.zeros(self.out_channels, 1, 1, 1))
-
- def _get_weight(self, weight):
- weight_flat = weight.view(weight.size(0), -1)
- mean = weight_flat.mean(dim=1).view(-1, 1, 1, 1)
- std = torch.sqrt(weight_flat.var(dim=1) + 1e-5).view(-1, 1, 1, 1)
- weight = (weight - mean) / std
- weight = self.weight_gamma * weight + self.weight_beta
- return weight
-
- def forward(self, x):
- weight = self._get_weight(self.weight)
- return F.conv2d(x, weight, self.bias, self.stride, self.padding,
- self.dilation, self.groups)
-
- def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict,
- missing_keys, unexpected_keys, error_msgs):
- """Override default load function.
-
- AWS overrides the function _load_from_state_dict to recover
- weight_gamma and weight_beta if they are missing. If weight_gamma and
- weight_beta are found in the checkpoint, this function will return
- after super()._load_from_state_dict. Otherwise, it will compute the
- mean and std of the pretrained weights and store them in weight_beta
- and weight_gamma.
- """
-
- self.weight_gamma.data.fill_(-1)
- local_missing_keys = []
- super()._load_from_state_dict(state_dict, prefix, local_metadata,
- strict, local_missing_keys,
- unexpected_keys, error_msgs)
- if self.weight_gamma.data.mean() > 0:
- for k in local_missing_keys:
- missing_keys.append(k)
- return
- weight = self.weight.data
- weight_flat = weight.view(weight.size(0), -1)
- mean = weight_flat.mean(dim=1).view(-1, 1, 1, 1)
- std = torch.sqrt(weight_flat.var(dim=1) + 1e-5).view(-1, 1, 1, 1)
- self.weight_beta.data.copy_(mean)
- self.weight_gamma.data.copy_(std)
- missing_gamma_beta = [
- k for k in local_missing_keys
- if k.endswith('weight_gamma') or k.endswith('weight_beta')
- ]
- for k in missing_gamma_beta:
- local_missing_keys.remove(k)
- for k in local_missing_keys:
- missing_keys.append(k)
diff --git a/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/ops/sync_bn.py b/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/ops/sync_bn.py
deleted file mode 100644
index c9b016fcbe860989c56cd1040034bcfa60e146d2..0000000000000000000000000000000000000000
--- a/spaces/kirch/Text2Video-Zero/annotator/uniformer/mmcv/ops/sync_bn.py
+++ /dev/null
@@ -1,279 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.distributed as dist
-import torch.nn.functional as F
-from torch.autograd import Function
-from torch.autograd.function import once_differentiable
-from torch.nn.modules.module import Module
-from torch.nn.parameter import Parameter
-
-from annotator.uniformer.mmcv.cnn import NORM_LAYERS
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', [
- 'sync_bn_forward_mean', 'sync_bn_forward_var', 'sync_bn_forward_output',
- 'sync_bn_backward_param', 'sync_bn_backward_data'
-])
-
-
-class SyncBatchNormFunction(Function):
-
- @staticmethod
- def symbolic(g, input, running_mean, running_var, weight, bias, momentum,
- eps, group, group_size, stats_mode):
- return g.op(
- 'mmcv::MMCVSyncBatchNorm',
- input,
- running_mean,
- running_var,
- weight,
- bias,
- momentum_f=momentum,
- eps_f=eps,
- group_i=group,
- group_size_i=group_size,
- stats_mode=stats_mode)
-
- @staticmethod
- def forward(self, input, running_mean, running_var, weight, bias, momentum,
- eps, group, group_size, stats_mode):
- self.momentum = momentum
- self.eps = eps
- self.group = group
- self.group_size = group_size
- self.stats_mode = stats_mode
-
- assert isinstance(
- input, (torch.HalfTensor, torch.FloatTensor,
- torch.cuda.HalfTensor, torch.cuda.FloatTensor)), \
- f'only support Half or Float Tensor, but {input.type()}'
- output = torch.zeros_like(input)
- input3d = input.flatten(start_dim=2)
- output3d = output.view_as(input3d)
- num_channels = input3d.size(1)
-
- # ensure mean/var/norm/std are initialized as zeros
- # ``torch.empty()`` does not guarantee that
- mean = torch.zeros(
- num_channels, dtype=torch.float, device=input3d.device)
- var = torch.zeros(
- num_channels, dtype=torch.float, device=input3d.device)
- norm = torch.zeros_like(
- input3d, dtype=torch.float, device=input3d.device)
- std = torch.zeros(
- num_channels, dtype=torch.float, device=input3d.device)
-
- batch_size = input3d.size(0)
- if batch_size > 0:
- ext_module.sync_bn_forward_mean(input3d, mean)
- batch_flag = torch.ones([1], device=mean.device, dtype=mean.dtype)
- else:
- # skip updating mean and leave it as zeros when the input is empty
- batch_flag = torch.zeros([1], device=mean.device, dtype=mean.dtype)
-
- # synchronize mean and the batch flag
- vec = torch.cat([mean, batch_flag])
- if self.stats_mode == 'N':
- vec *= batch_size
- if self.group_size > 1:
- dist.all_reduce(vec, group=self.group)
- total_batch = vec[-1].detach()
- mean = vec[:num_channels]
-
- if self.stats_mode == 'default':
- mean = mean / self.group_size
- elif self.stats_mode == 'N':
- mean = mean / total_batch.clamp(min=1)
- else:
- raise NotImplementedError
-
- # leave var as zeros when the input is empty
- if batch_size > 0:
- ext_module.sync_bn_forward_var(input3d, mean, var)
-
- if self.stats_mode == 'N':
- var *= batch_size
- if self.group_size > 1:
- dist.all_reduce(var, group=self.group)
-
- if self.stats_mode == 'default':
- var /= self.group_size
- elif self.stats_mode == 'N':
- var /= total_batch.clamp(min=1)
- else:
- raise NotImplementedError
-
- # if the total batch size over all the ranks is zero,
- # we should not update the statistics in the current batch
- update_flag = total_batch.clamp(max=1)
- momentum = update_flag * self.momentum
- ext_module.sync_bn_forward_output(
- input3d,
- mean,
- var,
- weight,
- bias,
- running_mean,
- running_var,
- norm,
- std,
- output3d,
- eps=self.eps,
- momentum=momentum,
- group_size=self.group_size)
- self.save_for_backward(norm, std, weight)
- return output
-
- @staticmethod
- @once_differentiable
- def backward(self, grad_output):
- norm, std, weight = self.saved_tensors
- grad_weight = torch.zeros_like(weight)
- grad_bias = torch.zeros_like(weight)
- grad_input = torch.zeros_like(grad_output)
- grad_output3d = grad_output.flatten(start_dim=2)
- grad_input3d = grad_input.view_as(grad_output3d)
-
- batch_size = grad_input3d.size(0)
- if batch_size > 0:
- ext_module.sync_bn_backward_param(grad_output3d, norm, grad_weight,
- grad_bias)
-
- # all reduce
- if self.group_size > 1:
- dist.all_reduce(grad_weight, group=self.group)
- dist.all_reduce(grad_bias, group=self.group)
- grad_weight /= self.group_size
- grad_bias /= self.group_size
-
- if batch_size > 0:
- ext_module.sync_bn_backward_data(grad_output3d, weight,
- grad_weight, grad_bias, norm, std,
- grad_input3d)
-
- return grad_input, None, None, grad_weight, grad_bias, \
- None, None, None, None, None
-
-
-@NORM_LAYERS.register_module(name='MMSyncBN')
-class SyncBatchNorm(Module):
- """Synchronized Batch Normalization.
-
- Args:
- num_features (int): number of features/chennels in input tensor
- eps (float, optional): a value added to the denominator for numerical
- stability. Defaults to 1e-5.
- momentum (float, optional): the value used for the running_mean and
- running_var computation. Defaults to 0.1.
- affine (bool, optional): whether to use learnable affine parameters.
- Defaults to True.
- track_running_stats (bool, optional): whether to track the running
- mean and variance during training. When set to False, this
- module does not track such statistics, and initializes statistics
- buffers ``running_mean`` and ``running_var`` as ``None``. When
- these buffers are ``None``, this module always uses batch
- statistics in both training and eval modes. Defaults to True.
- group (int, optional): synchronization of stats happen within
- each process group individually. By default it is synchronization
- across the whole world. Defaults to None.
- stats_mode (str, optional): The statistical mode. Available options
- includes ``'default'`` and ``'N'``. Defaults to 'default'.
- When ``stats_mode=='default'``, it computes the overall statistics
- using those from each worker with equal weight, i.e., the
- statistics are synchronized and simply divied by ``group``. This
- mode will produce inaccurate statistics when empty tensors occur.
- When ``stats_mode=='N'``, it compute the overall statistics using
- the total number of batches in each worker ignoring the number of
- group, i.e., the statistics are synchronized and then divied by
- the total batch ``N``. This mode is beneficial when empty tensors
- occur during training, as it average the total mean by the real
- number of batch.
- """
-
- def __init__(self,
- num_features,
- eps=1e-5,
- momentum=0.1,
- affine=True,
- track_running_stats=True,
- group=None,
- stats_mode='default'):
- super(SyncBatchNorm, self).__init__()
- self.num_features = num_features
- self.eps = eps
- self.momentum = momentum
- self.affine = affine
- self.track_running_stats = track_running_stats
- group = dist.group.WORLD if group is None else group
- self.group = group
- self.group_size = dist.get_world_size(group)
- assert stats_mode in ['default', 'N'], \
- f'"stats_mode" only accepts "default" and "N", got "{stats_mode}"'
- self.stats_mode = stats_mode
- if self.affine:
- self.weight = Parameter(torch.Tensor(num_features))
- self.bias = Parameter(torch.Tensor(num_features))
- else:
- self.register_parameter('weight', None)
- self.register_parameter('bias', None)
- if self.track_running_stats:
- self.register_buffer('running_mean', torch.zeros(num_features))
- self.register_buffer('running_var', torch.ones(num_features))
- self.register_buffer('num_batches_tracked',
- torch.tensor(0, dtype=torch.long))
- else:
- self.register_buffer('running_mean', None)
- self.register_buffer('running_var', None)
- self.register_buffer('num_batches_tracked', None)
- self.reset_parameters()
-
- def reset_running_stats(self):
- if self.track_running_stats:
- self.running_mean.zero_()
- self.running_var.fill_(1)
- self.num_batches_tracked.zero_()
-
- def reset_parameters(self):
- self.reset_running_stats()
- if self.affine:
- self.weight.data.uniform_() # pytorch use ones_()
- self.bias.data.zero_()
-
- def forward(self, input):
- if input.dim() < 2:
- raise ValueError(
- f'expected at least 2D input, got {input.dim()}D input')
- if self.momentum is None:
- exponential_average_factor = 0.0
- else:
- exponential_average_factor = self.momentum
-
- if self.training and self.track_running_stats:
- if self.num_batches_tracked is not None:
- self.num_batches_tracked += 1
- if self.momentum is None: # use cumulative moving average
- exponential_average_factor = 1.0 / float(
- self.num_batches_tracked)
- else: # use exponential moving average
- exponential_average_factor = self.momentum
-
- if self.training or not self.track_running_stats:
- return SyncBatchNormFunction.apply(
- input, self.running_mean, self.running_var, self.weight,
- self.bias, exponential_average_factor, self.eps, self.group,
- self.group_size, self.stats_mode)
- else:
- return F.batch_norm(input, self.running_mean, self.running_var,
- self.weight, self.bias, False,
- exponential_average_factor, self.eps)
-
- def __repr__(self):
- s = self.__class__.__name__
- s += f'({self.num_features}, '
- s += f'eps={self.eps}, '
- s += f'momentum={self.momentum}, '
- s += f'affine={self.affine}, '
- s += f'track_running_stats={self.track_running_stats}, '
- s += f'group_size={self.group_size},'
- s += f'stats_mode={self.stats_mode})'
- return s
diff --git a/spaces/koajoel/PolyFormer/fairseq/examples/nonautoregressive_translation/README.md b/spaces/koajoel/PolyFormer/fairseq/examples/nonautoregressive_translation/README.md
deleted file mode 100644
index 8793e225c99732c42c9c19e22075cde37c73341d..0000000000000000000000000000000000000000
--- a/spaces/koajoel/PolyFormer/fairseq/examples/nonautoregressive_translation/README.md
+++ /dev/null
@@ -1,146 +0,0 @@
-# Non-autoregressive Neural Machine Translation (NAT)
-
-This page mainly includes instructions for reproducing results from the following papers
-* [Levenshtein Transformer (Gu et al., 2019)](https://arxiv.org/abs/1905.11006).
-* [Understanding Knowledge Distillation in Non-autoregressive Machine Translation (Zhou et al., 2019)](https://arxiv.org/abs/1911.02727).
-
-We also provided our own implementations for several popular non-autoregressive-based models as reference:
-* [Non-Autoregressive Neural Machine Translation (Gu et al., 2017)](https://arxiv.org/abs/1711.02281)
-* [Deterministic Non-Autoregressive Neural Sequence Modeling by Iterative Refinement (Lee et al., 2018)](https://arxiv.org/abs/1802.06901)
-* [Insertion Transformer: Flexible Sequence Generation via Insertion Operations (Stern et al., 2019)](https://arxiv.org/abs/1902.03249)
-* [Mask-Predict: Parallel Decoding of Conditional Masked Language Models (Ghazvininejad et al., 2019)](https://arxiv.org/abs/1904.09324v2)
-* [Fast Structured Decoding for Sequence Models (Sun et al., 2019)](https://arxiv.org/abs/1910.11555)
-
-## Dataset
-
-First, follow the [instructions to download and preprocess the WMT'14 En-De dataset](../translation#wmt14-english-to-german-convolutional).
-Make sure to learn a joint vocabulary by passing the `--joined-dictionary` option to `fairseq-preprocess`.
-
-### Knowledge Distillation
-Following [Gu et al. 2019](https://arxiv.org/abs/1905.11006), [knowledge distillation](https://arxiv.org/abs/1606.07947) from an autoregressive model can effectively simplify the training data distribution, which is sometimes essential for NAT-based models to learn good translations.
-The easiest way of performing distillation is to follow the [instructions of training a standard transformer model](../translation) on the same data, and then decode the training set to produce a distillation dataset for NAT.
-
-### Download
-We also provided the preprocessed [original](http://dl.fbaipublicfiles.com/nat/original_dataset.zip) and [distillation](http://dl.fbaipublicfiles.com/nat/distill_dataset.zip) datasets. Please build the binarized dataset on your own.
-
-
-## Train a model
-
-Then we can train a nonautoregressive model using the `translation_lev` task and a new criterion `nat_loss`.
-Use the `--noise` flag to specify the input noise used on the target sentences.
-In default, we run the task for *Levenshtein Transformer*, with `--noise='random_delete'`. Full scripts to run other models can also be found [here](./scripts.md).
-
-The following command will train a *Levenshtein Transformer* on the binarized dataset.
-
-```bash
-fairseq-train \
- data-bin/wmt14_en_de_distill \
- --save-dir checkpoints \
- --ddp-backend=legacy_ddp \
- --task translation_lev \
- --criterion nat_loss \
- --arch levenshtein_transformer \
- --noise random_delete \
- --share-all-embeddings \
- --optimizer adam --adam-betas '(0.9,0.98)' \
- --lr 0.0005 --lr-scheduler inverse_sqrt \
- --stop-min-lr '1e-09' --warmup-updates 10000 \
- --warmup-init-lr '1e-07' --label-smoothing 0.1 \
- --dropout 0.3 --weight-decay 0.01 \
- --decoder-learned-pos \
- --encoder-learned-pos \
- --apply-bert-init \
- --log-format 'simple' --log-interval 100 \
- --fixed-validation-seed 7 \
- --max-tokens 8000 \
- --save-interval-updates 10000 \
- --max-update 300000
-```
-
-## Translate
-
-Once a model is trained, we can generate translations using an `iterative_refinement_generator` which will based on the model's initial output and iteratively read and greedily refine the translation until (1) the model predicts the same translations for two consecutive iterations; or (2) the generator reaches the maximum iterations (`--iter-decode-max-iter`). Use `--print-step` to check the actual # of iteration for each sentence.
-
-For *Levenshtein Transformer*, it sometimes helps to apply a `--iter-decode-eos-penalty` (typically, 0~3) to penalize the model finishing generation too early and generating too short translations.
-
-For example, to generate with `--iter-decode-max-iter=9`:
-```bash
-fairseq-generate \
- data-bin/wmt14_en_de_distill \
- --gen-subset test \
- --task translation_lev \
- --path checkpoints/checkpoint_best.pt \
- --iter-decode-max-iter 9 \
- --iter-decode-eos-penalty 0 \
- --beam 1 --remove-bpe \
- --print-step \
- --batch-size 400
-```
-In the end of the generation, we can see the tokenized BLEU score for the translation.
-
-## Advanced Decoding Methods
-### Ensemble
-The NAT models use special implementations of [ensembling](https://github.com/fairinternal/fairseq-py/blob/b98d88da52f2f21f1b169bab8c70c1c4ca19a768/fairseq/sequence_generator.py#L522) to support iterative refinement and a variety of parallel operations in different models, while it shares the same API as standard autoregressive models as follows:
-```bash
-fairseq-generate \
- data-bin/wmt14_en_de_distill \
- --gen-subset test \
- --task translation_lev \
- --path checkpoint_1.pt:checkpoint_2.pt:checkpoint_3.pt \
- --iter-decode-max-iter 9 \
- --iter-decode-eos-penalty 0 \
- --beam 1 --remove-bpe \
- --print-step \
- --batch-size 400
-```
-We use ``:`` to split multiple models. Note that, not all NAT models support ensembling for now.
-
-
-### Length-beam
-For models that predict lengths before decoding (e.g. the vanilla NAT, Mask-Predict, etc), it is possible to improve the translation quality by varying the target lengths around the predicted value, and translating the same example multiple times in parallel. We can select the best translation with the highest scores defined by your model's output.
-
-Note that, not all models support length beams. For models which dynamically change the lengths (e.g. *Insertion Transformer*, *Levenshtein Transformer*), the same trick does not apply.
-
-### Re-ranking
-If the model generates multiple translations with length beam, we can also introduce an autoregressive model to rerank the translations considering scoring from an autoregressive model is much faster than decoding from that.
-
-For example, to generate translations with length beam and reranking,
-```bash
-fairseq-generate \
- data-bin/wmt14_en_de_distill \
- --gen-subset test \
- --task translation_lev \
- --path checkpoints/checkpoint_best.pt:at_checkpoints/checkpoint_best.pt \
- --iter-decode-max-iter 9 \
- --iter-decode-eos-penalty 0 \
- --iter-decode-with-beam 9 \
- --iter-decode-with-external-reranker \
- --beam 1 --remove-bpe \
- --print-step \
- --batch-size 100
-```
-Note that we need to make sure the autoregressive model shares the same vocabulary as our target non-autoregressive model.
-
-
-## Citation
-
-```bibtex
-@incollection{NIPS2019_9297,
- title = {Levenshtein Transformer},
- author = {Gu, Jiatao and Wang, Changhan and Zhao, Junbo},
- booktitle = {Advances in Neural Information Processing Systems 32},
- editor = {H. Wallach and H. Larochelle and A. Beygelzimer and F. d\textquotesingle Alch\'{e}-Buc and E. Fox and R. Garnett},
- pages = {11179--11189},
- year = {2019},
- publisher = {Curran Associates, Inc.},
- url = {http://papers.nips.cc/paper/9297-levenshtein-transformer.pdf}
-}
-```
-```bibtex
-@article{zhou2019understanding,
- title={Understanding Knowledge Distillation in Non-autoregressive Machine Translation},
- author={Zhou, Chunting and Neubig, Graham and Gu, Jiatao},
- journal={arXiv preprint arXiv:1911.02727},
- year={2019}
-}
-```
diff --git a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/misc/roundTools.py b/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/misc/roundTools.py
deleted file mode 100644
index 48a47c07c8575895f894a24065046bc308a69b97..0000000000000000000000000000000000000000
--- a/spaces/ky2k/Toxicity_Classifier_POC/.venv/lib/python3.9/site-packages/fontTools/misc/roundTools.py
+++ /dev/null
@@ -1,109 +0,0 @@
-"""
-Various round-to-integer helpers.
-"""
-
-import math
-import functools
-import logging
-
-log = logging.getLogger(__name__)
-
-__all__ = [
- "noRound",
- "otRound",
- "maybeRound",
- "roundFunc",
-]
-
-
-def noRound(value):
- return value
-
-
-def otRound(value):
- """Round float value to nearest integer towards ``+Infinity``.
-
- The OpenType spec (in the section on `"normalization" of OpenType Font Variations `_)
- defines the required method for converting floating point values to
- fixed-point. In particular it specifies the following rounding strategy:
-
- for fractional values of 0.5 and higher, take the next higher integer;
- for other fractional values, truncate.
-
- This function rounds the floating-point value according to this strategy
- in preparation for conversion to fixed-point.
-
- Args:
- value (float): The input floating-point value.
-
- Returns
- float: The rounded value.
- """
- # See this thread for how we ended up with this implementation:
- # https://github.com/fonttools/fonttools/issues/1248#issuecomment-383198166
- return int(math.floor(value + 0.5))
-
-
-def maybeRound(v, tolerance, round=otRound):
- rounded = round(v)
- return rounded if abs(rounded - v) <= tolerance else v
-
-
-def roundFunc(tolerance, round=otRound):
- if tolerance < 0:
- raise ValueError("Rounding tolerance must be positive")
-
- if tolerance == 0:
- return noRound
-
- if tolerance >= 0.5:
- return round
-
- return functools.partial(maybeRound, tolerance=tolerance, round=round)
-
-
-def nearestMultipleShortestRepr(value: float, factor: float) -> str:
- """Round to nearest multiple of factor and return shortest decimal representation.
-
- This chooses the float that is closer to a multiple of the given factor while
- having the shortest decimal representation (the least number of fractional decimal
- digits).
-
- For example, given the following:
-
- >>> nearestMultipleShortestRepr(-0.61883544921875, 1.0/(1<<14))
- '-0.61884'
-
- Useful when you need to serialize or print a fixed-point number (or multiples
- thereof, such as F2Dot14 fractions of 180 degrees in COLRv1 PaintRotate) in
- a human-readable form.
-
- Args:
- value (value): The value to be rounded and serialized.
- factor (float): The value which the result is a close multiple of.
-
- Returns:
- str: A compact string representation of the value.
- """
- if not value:
- return "0.0"
-
- value = otRound(value / factor) * factor
- eps = 0.5 * factor
- lo = value - eps
- hi = value + eps
- # If the range of valid choices spans an integer, return the integer.
- if int(lo) != int(hi):
- return str(float(round(value)))
-
- fmt = "%.8f"
- lo = fmt % lo
- hi = fmt % hi
- assert len(lo) == len(hi) and lo != hi
- for i in range(len(lo)):
- if lo[i] != hi[i]:
- break
- period = lo.find(".")
- assert period < i
- fmt = "%%.%df" % (i - period)
- return fmt % value
diff --git a/spaces/leogabraneth/text-generation-webui-main/api-examples/api-example-chat-stream.py b/spaces/leogabraneth/text-generation-webui-main/api-examples/api-example-chat-stream.py
deleted file mode 100644
index 3a1502dd4b12e095d90f45e32307af6ad87d313a..0000000000000000000000000000000000000000
--- a/spaces/leogabraneth/text-generation-webui-main/api-examples/api-example-chat-stream.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import asyncio
-import html
-import json
-import sys
-
-try:
- import websockets
-except ImportError:
- print("Websockets package not found. Make sure it's installed.")
-
-# For local streaming, the websockets are hosted without ssl - ws://
-HOST = 'localhost:5005'
-URI = f'ws://{HOST}/api/v1/chat-stream'
-
-# For reverse-proxied streaming, the remote will likely host with ssl - wss://
-# URI = 'wss://your-uri-here.trycloudflare.com/api/v1/stream'
-
-
-async def run(user_input, history):
- # Note: the selected defaults change from time to time.
- request = {
- 'user_input': user_input,
- 'max_new_tokens': 250,
- 'auto_max_new_tokens': False,
- 'max_tokens_second': 0,
- 'history': history,
- 'mode': 'instruct', # Valid options: 'chat', 'chat-instruct', 'instruct'
- 'character': 'Example',
- 'instruction_template': 'Vicuna-v1.1', # Will get autodetected if unset
- 'your_name': 'You',
- # 'name1': 'name of user', # Optional
- # 'name2': 'name of character', # Optional
- # 'context': 'character context', # Optional
- # 'greeting': 'greeting', # Optional
- # 'name1_instruct': 'You', # Optional
- # 'name2_instruct': 'Assistant', # Optional
- # 'context_instruct': 'context_instruct', # Optional
- # 'turn_template': 'turn_template', # Optional
- 'regenerate': False,
- '_continue': False,
- 'chat_instruct_command': 'Continue the chat dialogue below. Write a single reply for the character "<|character|>".\n\n<|prompt|>',
-
- # Generation params. If 'preset' is set to different than 'None', the values
- # in presets/preset-name.yaml are used instead of the individual numbers.
- 'preset': 'None',
- 'do_sample': True,
- 'temperature': 0.7,
- 'top_p': 0.1,
- 'typical_p': 1,
- 'epsilon_cutoff': 0, # In units of 1e-4
- 'eta_cutoff': 0, # In units of 1e-4
- 'tfs': 1,
- 'top_a': 0,
- 'repetition_penalty': 1.18,
- 'presence_penalty': 0,
- 'frequency_penalty': 0,
- 'repetition_penalty_range': 0,
- 'top_k': 40,
- 'min_length': 0,
- 'no_repeat_ngram_size': 0,
- 'num_beams': 1,
- 'penalty_alpha': 0,
- 'length_penalty': 1,
- 'early_stopping': False,
- 'mirostat_mode': 0,
- 'mirostat_tau': 5,
- 'mirostat_eta': 0.1,
- 'grammar_string': '',
- 'guidance_scale': 1,
- 'negative_prompt': '',
-
- 'seed': -1,
- 'add_bos_token': True,
- 'truncation_length': 2048,
- 'ban_eos_token': False,
- 'custom_token_bans': '',
- 'skip_special_tokens': True,
- 'stopping_strings': []
- }
-
- async with websockets.connect(URI, ping_interval=None) as websocket:
- await websocket.send(json.dumps(request))
-
- while True:
- incoming_data = await websocket.recv()
- incoming_data = json.loads(incoming_data)
-
- match incoming_data['event']:
- case 'text_stream':
- yield incoming_data['history']
- case 'stream_end':
- return
-
-
-async def print_response_stream(user_input, history):
- cur_len = 0
- async for new_history in run(user_input, history):
- cur_message = new_history['visible'][-1][1][cur_len:]
- cur_len += len(cur_message)
- print(html.unescape(cur_message), end='')
- sys.stdout.flush() # If we don't flush, we won't see tokens in realtime.
-
-
-if __name__ == '__main__':
- user_input = "Please give me a step-by-step guide on how to plant a tree in my backyard."
-
- # Basic example
- history = {'internal': [], 'visible': []}
-
- # "Continue" example. Make sure to set '_continue' to True above
- # arr = [user_input, 'Surely, here is']
- # history = {'internal': [arr], 'visible': [arr]}
-
- asyncio.run(print_response_stream(user_input, history))
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Download Rab Ne Bana Di Jodi 720p BEST.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Download Rab Ne Bana Di Jodi 720p BEST.md
deleted file mode 100644
index 53eafac38dfba296a09cef41711490a7c58e9415..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Download Rab Ne Bana Di Jodi 720p BEST.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-Now, you can download Hd quality full movie of Rab Ne Bana Di Jodi. All the movie download videos from here. The users can download the the full movie in a high-quality resolution and within a short time.
-download rab ne bana di jodi 720p
Download File ✑ ✑ ✑ https://bytlly.com/2uGvXL
-Upcomer To date, you can download not only pirated movies but also full HD movies of all categories. You can choose the screen size, between 4K, 1080p, and 720p. 1080p to download the film also users can find movies using search bar.Upcomer is a site known for its leaks of pirated films. It is also prohibited in many other countries, including India. You should not go download movies.
-It is not allowed to download the movie for free. If you like this movie you can buy Jodi 720p Rab ne Bana full movie from MovieLovers.
-Update about the movie: Rab Ne Bana Di Jodi is an upcoming Indian romantic comedy film that is directed by Ali Abbas Zafar, and co-directed by Karan Johar. The film will be released on August 14, 2018 by India’s leading distributor Fiac. The film is to be the sequel to Johar’s 2007 romantic comedy, My Name is Khan. It is based on the novel of the same name by Khushwant Singh, which is loosely based on the 1972 historical novel Court Scandal by William F. Buckley, Jr..
-Featured Mp4 is the Title : Rab Ne Bana Di Jodi 720p. The Bitrate is Normal and the size is 1080pMAY 2016, 2hrs 20 min. Video File Released Date : March 15, 2016 Video File Category : Movie Format : FLV
- 899543212b
-
-
\ No newline at end of file
diff --git a/spaces/lincquiQcaudo/Top-20-Diffusion/Initial D 5th Stage 1080p Torrent.md b/spaces/lincquiQcaudo/Top-20-Diffusion/Initial D 5th Stage 1080p Torrent.md
deleted file mode 100644
index d42f0a4fc72903628983796a608841b026c94dc3..0000000000000000000000000000000000000000
--- a/spaces/lincquiQcaudo/Top-20-Diffusion/Initial D 5th Stage 1080p Torrent.md
+++ /dev/null
@@ -1,10 +0,0 @@
-
-in children, immunosuppression is rare, and clinicians should not be so quick to prescribe systemic immunosuppression as a way to treat covid-19, dr. merks says. and indeed, there is no support for any form of immunosuppression in the best available guidelines, the authors note.
-sigma-aldrich is a leading science solutions provider for life, materials and diagnostic science. as both an academic research institution and in industry, the company's cutting-edge technologies, innovative solutions and advanced scientific support help clients around the world for progress.
-Initial D 5th Stage 1080p Torrent
DOWNLOAD >>>>> https://bytlly.com/2uGylH
-sigma-aldrich has a policy of objectivity and provides equal opportunity for qualified persons regardless of race, color, creed, religion, national origin, sex, age, disability, marital status, scientific evidence and socioeconomic class.
-its so huge in the women s industry now, like 50-70% of the female population is into it. its big for men, too. basically, theres no money in porn anymore. actors have to accept even lower wages, and production companies are less likely to continue to give them work if there are other options out there. what used to be a full time job for actors is now hit and miss. if a film is well done, it can do pretty good business, especially if its a popular title. but theres no guarantee that youll make a living on a title unless youre the producer.
-there are so many porn stars and directors today who focus on getting girls pregnant, or getting women hooked on cocaine or methamphetamines, or getting them to be brutally raped, or simulate rape. its very true today. and its a vicious cycle because these actresses usually cant keep their money when they have babies, and they cant find work because they have a baby, and so its a no-win situation for them. it takes so many years for actresses to get back into the business, and so many of them end up getting addicted. its not fair on them or their families, but thats the reality.
- 899543212b
-
-
\ No newline at end of file
diff --git a/spaces/lkeab/transfiner/configs/new_baselines/mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py b/spaces/lkeab/transfiner/configs/new_baselines/mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py
deleted file mode 100644
index 249387fffeed7c02f592ecc84ee5a295533b1ed7..0000000000000000000000000000000000000000
--- a/spaces/lkeab/transfiner/configs/new_baselines/mask_rcnn_regnetx_4gf_dds_FPN_100ep_LSJ.py
+++ /dev/null
@@ -1,29 +0,0 @@
-from .mask_rcnn_R_50_FPN_100ep_LSJ import (
- dataloader,
- lr_multiplier,
- model,
- optimizer,
- train,
-)
-from detectron2.config import LazyCall as L
-from detectron2.modeling.backbone import RegNet
-from detectron2.modeling.backbone.regnet import SimpleStem, ResBottleneckBlock
-
-# Config source:
-# https://github.com/facebookresearch/detectron2/blob/master/configs/COCO-InstanceSegmentation/mask_rcnn_regnetx_4gf_dds_fpn_1x.py # noqa
-model.backbone.bottom_up = L(RegNet)(
- stem_class=SimpleStem,
- stem_width=32,
- block_class=ResBottleneckBlock,
- depth=23,
- w_a=38.65,
- w_0=96,
- w_m=2.43,
- group_width=40,
- norm="SyncBN",
- out_features=["s1", "s2", "s3", "s4"],
-)
-model.pixel_std = [57.375, 57.120, 58.395]
-
-# RegNets benefit from enabling cudnn benchmark mode
-train.cudnn_benchmark = True
diff --git a/spaces/lora-x/Backpack/app.py b/spaces/lora-x/Backpack/app.py
deleted file mode 100644
index f189f226335bad729a094cb99ae9bd825dfc89c9..0000000000000000000000000000000000000000
--- a/spaces/lora-x/Backpack/app.py
+++ /dev/null
@@ -1,550 +0,0 @@
-import torch
-import transformers
-from transformers import AutoModelForCausalLM
-import pandas as pd
-import gradio as gr
-
-# Build model & get some layers
-tokenizer = transformers.AutoTokenizer.from_pretrained('gpt2')
-m = AutoModelForCausalLM.from_pretrained("stanfordnlp/backpack-gpt2", trust_remote_code=True)
-m.eval()
-
-lm_head = m.get_lm_head() # (V, d)
-word_embeddings = m.backpack.get_word_embeddings() # (V, d)
-sense_network = m.backpack.get_sense_network() # (V, nv, d)
-num_senses = m.backpack.get_num_senses()
-sense_names = [i for i in range(num_senses)]
-
-"""
-Single token sense lookup
-"""
-def visualize_word(word, count=10, remove_space=False):
-
- if not remove_space:
- word = ' ' + word
- print(f"Looking up word '{word}'...")
-
- token_ids = tokenizer(word)['input_ids']
- tokens = [tokenizer.decode(token_id) for token_id in token_ids]
- tokens = ", ".join(tokens) # display tokenization for user
- print(f"Tokenized as: {tokens}")
- # look up sense vectors only for the first token
- # contents = vecs[token_ids[0]] # torch.Size([16, 768])
- sense_input_embeds = word_embeddings(torch.tensor([token_ids[0]]).long().unsqueeze(0)) # (bs=1, s=1, d), sense_network expects bs dim
- senses = sense_network(sense_input_embeds) # -> (bs=1, nv, s=1, d)
- senses = torch.squeeze(senses) # (nv, s=1, d)
-
- # for pos and neg respectively, create a list (for each sense) of list (top k) of tuples (word, logit)
- pos_word_lists = []
- neg_word_lists = []
- sense_names = [] # column header
- for i in range(senses.shape[0]):
- logits = lm_head(senses[i,:])
- sorted_logits, sorted_indices = torch.sort(logits, descending=True)
- sense_names.append('sense {}'.format(i))
-
- pos_sorted_words = [tokenizer.decode(sorted_indices[j]) for j in range(count)]
- pos_sorted_logits = [sorted_logits[j].item() for j in range(count)]
- pos_word_lists.append(list(zip(pos_sorted_words, pos_sorted_logits)))
-
- neg_sorted_words = [tokenizer.decode(sorted_indices[-j-1]) for j in range(count)]
- neg_sorted_logits = [sorted_logits[-j-1].item() for j in range(count)]
- neg_word_lists.append(list(zip(neg_sorted_words, neg_sorted_logits)))
-
- def create_dataframe(word_lists, sense_names, count):
- data = dict(zip(sense_names, word_lists))
- df = pd.DataFrame(index=[i for i in range(count)],
- columns=list(data.keys()))
- for prop, word_list in data.items():
- for i, word_pair in enumerate(word_list):
- cell_value = "space ({:.2f})".format(word_pair[1])
- cell_value = "{} ({:.2f})".format(word_pair[0], word_pair[1])
- df.at[i, prop] = cell_value
- return df
-
- pos_df = create_dataframe(pos_word_lists, sense_names, count)
- neg_df = create_dataframe(neg_word_lists, sense_names, count)
-
- return pos_df, neg_df, tokens
-
-"""
-Returns:
- - tokens: the tokenization of the input sentence, also used as options to choose from for get_token_contextual_weights
- - top_k_words_df: a dataframe of the top k words predicted by the model
- - length: of the input sentence, stored as a gr.State variable so other methods can find the
- contextualization weights for the *last* token that's needed
- - contextualization_weights: gr.State variable, stores the contextualization weights for the input sentence
-"""
-def predict_next_word (sentence, top_k = 5, contextualization_weights = None):
-
- if sentence == "":
- return None, None, None, None
-
- # For better tokenization, by default, adds a space at the beginning of the sentence if it doesn't already have one
- # and remove trailing space
- sentence = sentence.strip()
- if sentence[0] != ' ':
- sentence = ' ' + sentence
- print(f"Sentence: '{sentence}'")
-
- # Make input, keeping track of original length
- token_ids = tokenizer(sentence)['input_ids']
- tokens = [[tokenizer.decode(token_id) for token_id in token_ids]] # a list of a single list because used as dataframe
- length = len(token_ids)
- inp = torch.zeros((1,512)).long()
- inp[0,:length] = torch.tensor(token_ids).long()
-
- # Get output at correct index
- if contextualization_weights is None:
- print("contextualization_weights IS None, freshly computing contextualization_weights")
- output = m(inp)
- logits, contextualization_weights = output.logits[0,length-1,:], output.contextualization
- # Store contextualization weights and return it as a gr.State var for use by get_token_contextual_weights
- else:
- print("contextualization_weights is NOT None, using passed in contextualization_weights")
- output = m.run_with_custom_contextualization(inp, contextualization_weights)
- logits = output.logits[0,length-1,:]
- probs = logits.softmax(dim=-1) # probs over next word
- probs, indices = torch.sort(probs, descending=True)
- top_k_words = [(tokenizer.decode(indices[i]), round(probs[i].item(), 3)) for i in range(top_k)]
- top_k_words_df = pd.DataFrame(top_k_words, columns=['word', 'probability'], index=range(1, top_k+1))
-
- top_k_words_df = top_k_words_df.T
-
- print(top_k_words_df)
-
- return tokens, top_k_words_df, length, contextualization_weights
-
-
-"""
-Returns a dataframe of senses with weights for the selected token.
-
-Args:
- contextualization_weights: a gr.State variable that stores the contextualization weights for the input sentence.
- length: length of the input sentence, used to get the contextualization weights for the last token
- token: the selected token
- token_index: the index of the selected token in the input sentence
- pos_count: how many top positive words to display for each sense
- neg_count: how many top negative words to display for each sense
-"""
-def get_token_contextual_weights (contextualization_weights, length, token, token_index, pos_count = 5, neg_count = 3):
- print(">>>>>in get_token_contextual_weights")
- print(f"Selected {token_index}th token: {token}")
-
- # get contextualization weights for the selected token
- # Only care about the weights for the last word, since that's what contributes to the output
- token_contextualization_weights = contextualization_weights[0, :, length-1, token_index]
- token_contextualization_weights_list = [round(x, 3) for x in token_contextualization_weights.tolist()]
-
- # get sense vectors of the selected token
- token_ids = tokenizer(token)['input_ids'] # keep as a list bc sense_network expects s dim
- sense_input_embeds = word_embeddings(torch.tensor(token_ids).long().unsqueeze(0)) # (bs=1, s=1, d), sense_network expects bs dim
- senses = sense_network(sense_input_embeds) # -> (bs=1, nv, s=1, d)
- senses = torch.squeeze(senses) # (nv, s=1, d)
-
- # build dataframe
- pos_dfs, neg_dfs = [], []
-
- for i in range(num_senses):
- logits = lm_head(senses[i,:]) # (vocab,) [768, 50257] -> [50257]
- sorted_logits, sorted_indices = torch.sort(logits, descending=True)
-
- pos_sorted_words = [tokenizer.decode(sorted_indices[j]) for j in range(pos_count)]
- pos_df = pd.DataFrame(pos_sorted_words, columns=["Sense {}".format(i)])
- pos_dfs.append(pos_df)
-
- neg_sorted_words = [tokenizer.decode(sorted_indices[-j-1]) for j in range(neg_count)]
- neg_df = pd.DataFrame(neg_sorted_words, columns=["Top Negative"])
- neg_dfs.append(neg_df)
-
- sense0words, sense1words, sense2words, sense3words, sense4words, sense5words, \
- sense6words, sense7words, sense8words, sense9words, sense10words, sense11words, \
- sense12words, sense13words, sense14words, sense15words = pos_dfs
-
- sense0negwords, sense1negwords, sense2negwords, sense3negwords, sense4negwords, sense5negwords, \
- sense6negwords, sense7negwords, sense8negwords, sense9negwords, sense10negwords, sense11negwords, \
- sense12negwords, sense13negwords, sense14negwords, sense15negwords = neg_dfs
-
- sense0slider, sense1slider, sense2slider, sense3slider, sense4slider, sense5slider, \
- sense6slider, sense7slider, sense8slider, sense9slider, sense10slider, sense11slider, \
- sense12slider, sense13slider, sense14slider, sense15slider = token_contextualization_weights_list
-
- return token, token_index, \
- sense0words, sense1words, sense2words, sense3words, sense4words, sense5words, sense6words, sense7words, \
- sense8words, sense9words, sense10words, sense11words, sense12words, sense13words, sense14words, sense15words, \
- sense0negwords, sense1negwords, sense2negwords, sense3negwords, sense4negwords, sense5negwords, sense6negwords, sense7negwords, \
- sense8negwords, sense9negwords, sense10negwords, sense11negwords, sense12negwords, sense13negwords, sense14negwords, sense15negwords, \
- sense0slider, sense1slider, sense2slider, sense3slider, sense4slider, sense5slider, sense6slider, sense7slider, \
- sense8slider, sense9slider, sense10slider, sense11slider, sense12slider, sense13slider, sense14slider, sense15slider
-
-"""
-Wrapper for when the user selects a new token in the tokens dataframe.
-Converts `evt` (the selected token) to `token` and `token_index` which are used by get_token_contextual_weights.
-"""
-def new_token_contextual_weights (contextualization_weights, length, evt: gr.SelectData, pos_count = 5, neg_count = 3):
- print(">>>>>in new_token_contextual_weights")
- token_index = evt.index[1] # selected token is the token_index-th token in the sentence
- token = evt.value
- if not token:
- return None, None, \
- None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, \
- None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, \
- None, None, None, None, None, None, None, None, None, None, None, None, None, None, None, None
- return get_token_contextual_weights (contextualization_weights, length, token, token_index, pos_count, neg_count)
-
-def change_sense0_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 0, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense1_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 1, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense2_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 2, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense3_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 3, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense4_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 4, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense5_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 5, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense6_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 6, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense7_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 7, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense8_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 8, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense9_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 9, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense10_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 10, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense11_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 11, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense12_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 12, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense13_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 13, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense14_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 14, length-1, token_index] = new_weight
- return contextualization_weights
-def change_sense15_weight(contextualization_weights, length, token_index, new_weight):
- contextualization_weights[0, 15, length-1, token_index] = new_weight
- return contextualization_weights
-
-"""
-Clears all gr.State variables used to store info across methods when the input sentence changes.
-"""
-def clear_states(contextualization_weights, token_index, length):
- contextualization_weights = None
- token_index = None
- length = 0
- return contextualization_weights, token_index, length
-
-def reset_weights(contextualization_weights):
- print("Resetting weights...")
- contextualization_weights = None
- return contextualization_weights
-
-with gr.Blocks( theme = gr.themes.Base(),
- css = """#sense0slider, #sense1slider, #sense2slider, #sense3slider, #sense4slider, #sense5slider, #sense6slider, #sense7slider,
- #sense8slider, #sense9slider, #sense1slider0, #sense11slider, #sense12slider, #sense13slider, #sense14slider, #sense15slider
- { height: 200px; width: 200px; transform: rotate(270deg); }"""
- ) as demo:
-
- gr.Markdown("""
- ## Backpack Sense Visualization
- """)
-
- with gr.Tab("Language Modeling"):
- contextualization_weights = gr.State(None) # store session data for sharing between functions
- token_index = gr.State(None)
- length = gr.State(0)
- top_k = gr.State(10)
- with gr.Row():
- with gr.Column(scale=8):
- input_sentence = gr.Textbox(label="Input Sentence", placeholder='Enter a sentence and click "Predict next word". Then, you can go to the Tokens section, click on a token, and see its contextualization weights.')
- with gr.Column(scale=1):
- predict = gr.Button(value="Predict next word", variant="primary")
- reset_weights_button = gr.Button("Reset weights")
- gr.Markdown("""#### Top-k predicted next word""")
- top_k_words = gr.Dataframe(interactive=False)
- gr.Markdown("""### **Token Breakdown:** click on a token below to see its senses and contextualization weights""")
- tokens = gr.DataFrame()
- with gr.Row():
- with gr.Column(scale=1):
- selected_token = gr.Textbox(label="Current Selected Token", interactive=False)
- with gr.Column(scale=8):
- gr.Markdown("""####
- Once a token is chosen, you can **use the sliders below to change the weight of any sense or multiple senses** for that token, \
- and then click "Predict next word" to see updated next-word predictions. Erase all changes with "Reset weights".
- """)
- # sense sliders and top sense words dataframes
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense0slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 0", elem_id="sense0slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense1slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 1", elem_id="sense1slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense2slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 2", elem_id="sense2slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense3slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 3", elem_id="sense3slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense4slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 4", elem_id="sense4slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense5slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 5", elem_id="sense5slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense6slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 6", elem_id="sense6slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense7slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 7", elem_id="sense7slider", interactive=True)
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense0words = gr.DataFrame(headers = ["Sense 0"])
- with gr.Column(scale=0, min_width=120):
- sense1words = gr.DataFrame(headers = ["Sense 1"])
- with gr.Column(scale=0, min_width=120):
- sense2words = gr.DataFrame(headers = ["Sense 2"])
- with gr.Column(scale=0, min_width=120):
- sense3words = gr.DataFrame(headers = ["Sense 3"])
- with gr.Column(scale=0, min_width=120):
- sense4words = gr.DataFrame(headers = ["Sense 4"])
- with gr.Column(scale=0, min_width=120):
- sense5words = gr.DataFrame(headers = ["Sense 5"])
- with gr.Column(scale=0, min_width=120):
- sense6words = gr.DataFrame(headers = ["Sense 6"])
- with gr.Column(scale=0, min_width=120):
- sense7words = gr.DataFrame(headers = ["Sense 7"])
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense0negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense1negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense2negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense3negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense4negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense5negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense6negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense7negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense8slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 8", elem_id="sense8slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense9slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 9", elem_id="sense9slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense10slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 10", elem_id="sense1slider0", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense11slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 11", elem_id="sense11slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense12slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 12", elem_id="sense12slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense13slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 13", elem_id="sense13slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense14slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 14", elem_id="sense14slider", interactive=True)
- with gr.Column(scale=0, min_width=120):
- sense15slider= gr.Slider(minimum=0, maximum=1, value=0, step=0.01, label="Sense 15", elem_id="sense15slider", interactive=True)
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense8words = gr.DataFrame(headers = ["Sense 8"])
- with gr.Column(scale=0, min_width=120):
- sense9words = gr.DataFrame(headers = ["Sense 9"])
- with gr.Column(scale=0, min_width=120):
- sense10words = gr.DataFrame(headers = ["Sense 10"])
- with gr.Column(scale=0, min_width=120):
- sense11words = gr.DataFrame(headers = ["Sense 11"])
- with gr.Column(scale=0, min_width=120):
- sense12words = gr.DataFrame(headers = ["Sense 12"])
- with gr.Column(scale=0, min_width=120):
- sense13words = gr.DataFrame(headers = ["Sense 13"])
- with gr.Column(scale=0, min_width=120):
- sense14words = gr.DataFrame(headers = ["Sense 14"])
- with gr.Column(scale=0, min_width=120):
- sense15words = gr.DataFrame(headers = ["Sense 15"])
- with gr.Row():
- with gr.Column(scale=0, min_width=120):
- sense8negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense9negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense10negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense11negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense12negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense13negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense14negwords = gr.DataFrame(headers = ["Top Negative"])
- with gr.Column(scale=0, min_width=120):
- sense15negwords = gr.DataFrame(headers = ["Top Negative"])
- gr.Markdown("""Note: **"Top Negative"** shows words that have the most negative dot products with the sense vector, which can exhibit more coherent meaning than those with the most positive dot products.
- To see more representative words of each sense, scroll to the top and use the **"Individual Word Sense Look Up"** tab.""")
- # gr.Examples(
- # examples=[["Messi plays for", top_k, None]],
- # inputs=[input_sentence, top_k, contextualization_weights],
- # outputs=[tokens, top_k_words, length, contextualization_weights],
- # fn=predict_next_word,
- # )
-
- sense0slider.change(fn=change_sense0_weight,
- inputs=[contextualization_weights, length, token_index, sense0slider],
- outputs=[contextualization_weights])
- sense1slider.change(fn=change_sense1_weight,
- inputs=[contextualization_weights, length, token_index, sense1slider],
- outputs=[contextualization_weights])
- sense2slider.change(fn=change_sense2_weight,
- inputs=[contextualization_weights, length, token_index, sense2slider],
- outputs=[contextualization_weights])
- sense3slider.change(fn=change_sense3_weight,
- inputs=[contextualization_weights, length, token_index, sense3slider],
- outputs=[contextualization_weights])
- sense4slider.change(fn=change_sense4_weight,
- inputs=[contextualization_weights, length, token_index, sense4slider],
- outputs=[contextualization_weights])
- sense5slider.change(fn=change_sense5_weight,
- inputs=[contextualization_weights, length, token_index, sense5slider],
- outputs=[contextualization_weights])
- sense6slider.change(fn=change_sense6_weight,
- inputs=[contextualization_weights, length, token_index, sense6slider],
- outputs=[contextualization_weights])
- sense7slider.change(fn=change_sense7_weight,
- inputs=[contextualization_weights, length, token_index, sense7slider],
- outputs=[contextualization_weights])
- sense8slider.change(fn=change_sense8_weight,
- inputs=[contextualization_weights, length, token_index, sense8slider],
- outputs=[contextualization_weights])
- sense9slider.change(fn=change_sense9_weight,
- inputs=[contextualization_weights, length, token_index, sense9slider],
- outputs=[contextualization_weights])
- sense10slider.change(fn=change_sense10_weight,
- inputs=[contextualization_weights, length, token_index, sense10slider],
- outputs=[contextualization_weights])
- sense11slider.change(fn=change_sense11_weight,
- inputs=[contextualization_weights, length, token_index, sense11slider],
- outputs=[contextualization_weights])
- sense12slider.change(fn=change_sense12_weight,
- inputs=[contextualization_weights, length, token_index, sense12slider],
- outputs=[contextualization_weights])
- sense13slider.change(fn=change_sense13_weight,
- inputs=[contextualization_weights, length, token_index, sense13slider],
- outputs=[contextualization_weights])
- sense14slider.change(fn=change_sense14_weight,
- inputs=[contextualization_weights, length, token_index, sense14slider],
- outputs=[contextualization_weights])
- sense15slider.change(fn=change_sense15_weight,
- inputs=[contextualization_weights, length, token_index, sense15slider],
- outputs=[contextualization_weights])
-
-
- predict.click(
- fn=predict_next_word,
- inputs = [input_sentence, top_k, contextualization_weights],
- outputs= [tokens, top_k_words, length, contextualization_weights],
- )
-
- tokens.select(fn=new_token_contextual_weights,
- inputs=[contextualization_weights, length],
- outputs= [selected_token, token_index,
-
- sense0words, sense1words, sense2words, sense3words, sense4words, sense5words, sense6words, sense7words,
- sense8words, sense9words, sense10words, sense11words, sense12words, sense13words, sense14words, sense15words,
-
- sense0negwords, sense1negwords, sense2negwords, sense3negwords, sense4negwords, sense5negwords, sense6negwords, sense7negwords,
- sense8negwords, sense9negwords, sense10negwords, sense11negwords, sense12negwords, sense13negwords, sense14negwords, sense15negwords,
-
- sense0slider, sense1slider, sense2slider, sense3slider, sense4slider, sense5slider, sense6slider, sense7slider,
- sense8slider, sense9slider, sense10slider, sense11slider, sense12slider, sense13slider, sense14slider, sense15slider]
- )
-
- reset_weights_button.click(
- fn=reset_weights,
- inputs=[contextualization_weights],
- outputs=[contextualization_weights]
- ).success(
- fn=predict_next_word,
- inputs = [input_sentence, top_k, contextualization_weights],
- outputs= [tokens, top_k_words, length, contextualization_weights],
- ).success(
- fn=get_token_contextual_weights,
- inputs=[contextualization_weights, length, selected_token, token_index],
- outputs= [selected_token, token_index,
-
- sense0words, sense1words, sense2words, sense3words, sense4words, sense5words, sense6words, sense7words,
- sense8words, sense9words, sense10words, sense11words, sense12words, sense13words, sense14words, sense15words,
-
- sense0negwords, sense1negwords, sense2negwords, sense3negwords, sense4negwords, sense5negwords, sense6negwords, sense7negwords,
- sense8negwords, sense9negwords, sense10negwords, sense11negwords, sense12negwords, sense13negwords, sense14negwords, sense15negwords,
-
- sense0slider, sense1slider, sense2slider, sense3slider, sense4slider, sense5slider, sense6slider, sense7slider,
- sense8slider, sense9slider, sense10slider, sense11slider, sense12slider, sense13slider, sense14slider, sense15slider]
- )
-
- input_sentence.change(
- fn=clear_states,
- inputs=[contextualization_weights, token_index, length],
- outputs=[contextualization_weights, token_index, length]
- )
-
- with gr.Tab("Individual Word Sense Look Up"):
- gr.Markdown("""> Note on tokenization: Backpack uses the GPT-2 tokenizer, which includes the space before a word as part \
- of the token, so by default, a space character `' '` is added to the beginning of the word \
- you look up. You can disable this by checking `Remove space before word`, but know this might \
- cause strange behaviors like breaking `afraid` into `af` and `raid`, or `slight` into `s` and `light`.
- """)
- with gr.Row():
- word = gr.Textbox(label="Word", placeholder="e.g. science")
- token_breakdown = gr.Textbox(label="Token Breakdown (senses are for the first token only)")
- remove_space = gr.Checkbox(label="Remove space before word", default=False)
- count = gr.Slider(minimum=1, maximum=50, value=10, label="Top K", step=1)
- look_up_button = gr.Button("Look up")
- pos_outputs = gr.Dataframe(label="Highest Scoring Senses")
- neg_outputs = gr.Dataframe(label="Lowest Scoring Senses")
- gr.Examples(
- examples=["science", "afraid", "book", "slight"],
- inputs=[word],
- outputs=[pos_outputs, neg_outputs, token_breakdown],
- fn=visualize_word,
- cache_examples=True,
- )
-
- look_up_button.click(
- fn=visualize_word,
- inputs= [word, count, remove_space],
- outputs= [pos_outputs, neg_outputs, token_breakdown],
- )
-
-demo.launch()
-
-
-# Code for generating slider functions & event listners
-
-# for i in range(16):
-# print(
-# f"""def change_sense{i}_weight(contextualization_weights, length, token_index, new_weight):
-# print(f"Changing weight for the {i}th sense of the {{token_index}}th token.")
-# print("new_weight to be assigned = ", new_weight)
-# contextualization_weights[0, {i}, length-1, token_index] = new_weight
-# print("contextualization_weights: ", contextualization_weights[0, :, length-1, token_index])
-# return contextualization_weights"""
-# )
-
-# for i in range(16):
-# print(
-# f""" sense{i}slider.change(fn=change_sense{i}_weight,
-# inputs=[contextualization_weights, length, token_index, sense{i}slider],
-# outputs=[contextualization_weights])"""
-# )
\ No newline at end of file
diff --git a/spaces/lout33/Youtube-Whisperer/README.md b/spaces/lout33/Youtube-Whisperer/README.md
deleted file mode 100644
index f30d4256155c480f0599698379f798a3365e5bc1..0000000000000000000000000000000000000000
--- a/spaces/lout33/Youtube-Whisperer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Youtube Whisperer
-emoji: ⚡
-colorFrom: purple
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.3.1
-app_file: app.py
-pinned: false
-duplicated_from: jeffistyping/Youtube-Whisperer
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/luost26/DiffAb/diffab/utils/misc.py b/spaces/luost26/DiffAb/diffab/utils/misc.py
deleted file mode 100644
index d3a47d038390b5fb93e399a0e4a6be00240643f8..0000000000000000000000000000000000000000
--- a/spaces/luost26/DiffAb/diffab/utils/misc.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import os
-import time
-import random
-import logging
-from typing import OrderedDict
-import torch
-import torch.linalg
-import numpy as np
-import yaml
-from easydict import EasyDict
-from glob import glob
-
-
-class BlackHole(object):
- def __setattr__(self, name, value):
- pass
-
- def __call__(self, *args, **kwargs):
- return self
-
- def __getattr__(self, name):
- return self
-
-
-class Counter(object):
- def __init__(self, start=0):
- super().__init__()
- self.now = start
-
- def step(self, delta=1):
- prev = self.now
- self.now += delta
- return prev
-
-
-def get_logger(name, log_dir=None):
- logger = logging.getLogger(name)
- logger.setLevel(logging.DEBUG)
- formatter = logging.Formatter('[%(asctime)s::%(name)s::%(levelname)s] %(message)s')
-
- stream_handler = logging.StreamHandler()
- stream_handler.setLevel(logging.DEBUG)
- stream_handler.setFormatter(formatter)
- logger.addHandler(stream_handler)
-
- if log_dir is not None:
- file_handler = logging.FileHandler(os.path.join(log_dir, 'log.txt'))
- file_handler.setLevel(logging.DEBUG)
- file_handler.setFormatter(formatter)
- logger.addHandler(file_handler)
-
- return logger
-
-
-def get_new_log_dir(root='./logs', prefix='', tag=''):
- fn = time.strftime('%Y_%m_%d__%H_%M_%S', time.localtime())
- if prefix != '':
- fn = prefix + '_' + fn
- if tag != '':
- fn = fn + '_' + tag
- log_dir = os.path.join(root, fn)
- os.makedirs(log_dir)
- return log_dir
-
-
-def seed_all(seed):
- torch.backends.cudnn.deterministic = True
- torch.manual_seed(seed)
- torch.cuda.manual_seed_all(seed)
- np.random.seed(seed)
- random.seed(seed)
-
-
-def inf_iterator(iterable):
- iterator = iterable.__iter__()
- while True:
- try:
- yield iterator.__next__()
- except StopIteration:
- iterator = iterable.__iter__()
-
-
-def log_hyperparams(writer, args):
- from torch.utils.tensorboard.summary import hparams
- vars_args = {k: v if isinstance(v, str) else repr(v) for k, v in vars(args).items()}
- exp, ssi, sei = hparams(vars_args, {})
- writer.file_writer.add_summary(exp)
- writer.file_writer.add_summary(ssi)
- writer.file_writer.add_summary(sei)
-
-
-def int_tuple(argstr):
- return tuple(map(int, argstr.split(',')))
-
-
-def str_tuple(argstr):
- return tuple(argstr.split(','))
-
-
-def get_checkpoint_path(folder, it=None):
- if it is not None:
- return os.path.join(folder, '%d.pt' % it), it
- all_iters = list(map(lambda x: int(os.path.basename(x[:-3])), glob(os.path.join(folder, '*.pt'))))
- all_iters.sort()
- return os.path.join(folder, '%d.pt' % all_iters[-1]), all_iters[-1]
-
-
-def load_config(config_path):
- with open(config_path, 'r') as f:
- config = EasyDict(yaml.safe_load(f))
- config_name = os.path.basename(config_path)[:os.path.basename(config_path).rfind('.')]
- return config, config_name
-
-
-def extract_weights(weights: OrderedDict, prefix):
- extracted = OrderedDict()
- for k, v in weights.items():
- if k.startswith(prefix):
- extracted.update({
- k[len(prefix):]: v
- })
- return extracted
-
-
-def current_milli_time():
- return round(time.time() * 1000)
diff --git a/spaces/lvwerra/license-static/index.html b/spaces/lvwerra/license-static/index.html
deleted file mode 100644
index 9c6700613d3e8c5b03513d80fc14c0becb6175a6..0000000000000000000000000000000000000000
--- a/spaces/lvwerra/license-static/index.html
+++ /dev/null
@@ -1,1900 +0,0 @@
-
-
-
-
-
-
-
-
-
- BigScience RAIL License v1.0
- dated May 19, 2022
-
- Download as .txt ,
- .docx ,
- or
- .html
-
-
- This is a license (the “License”) between you (“You”) and the
- participants of BigScience (“Licensor”). Whereas the Apache 2.0 license was
- applicable to resources used to develop the Model, the
- licensing conditions have been modified for the access and distribution of the Model. This has been done to further BigScience’s aims of
- promoting not just open-access to its artifacts, but also a responsible use of these artifacts. Therefore,
- this Responsible AI License (RAIL)[1] aims
- at having an open and permissive character while striving for responsible use
- of the Model.
-
-
-
- Section I: PREAMBLE
-
- BigScience is a collaborative open innovation project aimed at the responsible
- development and use of large multilingual datasets and Large Language Models (“LLM”), as well as, the
- documentation of best practices and tools stemming from this collaborative effort. Further, BigScience
- participants wish to promote collaboration and sharing of research artifacts - including the Model - for the benefit of society, pursuant to this
- License.
-
- The development and use of LLMs, and broadly artificial intelligence
- (“AI”), does not come without
- concerns. The world has witnessed how just a few companies/institutions are able to develop LLMs, and
- moreover, how Natural Language Processing techniques might, in some instances, become a risk for the public
- in general. Concerns might come in many forms, from racial discrimination to the treatment of sensitive
- information.
-
- BigScience believes in the intersection between open and responsible AI
- development, thus, this License aims to strike a balance between both in order to
- enable responsible open-science for large language models and future NLP
- techniques.
- This License governs the use of the BigScience BLOOM models (and their derivatives) and is informed by both the BigScience Ethical Charter and the model cards associated with the BigScience BLOOM models.
- BigScience has set forth its Ethical Charter representing the values of its
- community. Although the BigScience community does not aim to impose its values on potential users of
- this Model, it is
- determined to take tangible steps towards protecting the community from
- inappropriate uses of the work being developed by BigScience.
- Furthermore, the model cards for the BigScience BLOOM models will inform the user
- about the limitations of the Model, and thus
- serves as the basis of some of the use-based restrictions in this License (See Part II).
-
-
- NOW THEREFORE, You and Licensor agree as follows:
-
-
- 1. Definitions
-
-
-
-
-
- Section II: INTELLECTUAL PROPERTY
- RIGHTS
- Both copyright and patent grants apply to the Model, Derivatives of the Model and
- Complementary Material. The Model and Derivatives of the Model are subject to additional terms as described in Section
- III.
- 2. Grant of Copyright License. Subject to the terms and
- conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
- no-charge, royalty-free, irrevocable copyright license to reproduce, prepare,
- publicly display, publicly
- perform, sublicense, and distribute the Complementary
- Material, the Model, and Derivatives of the Model.
- 3. Grant of Patent License. Subject to the terms and
- conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive,
- no-charge, royalty-free, irrevocable (except as stated in this
- paragraph) patent license to make, have made, use, offer to sell, sell,
- import, and otherwise transfer the Model and the Complementary Material, where such license applies only to
- those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s)
- alone or by combination of their Contribution(s) with the Model to which such Contribution(s) was submitted.
- If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
- alleging that the Model and/or Complementary Material or a Contribution incorporated within the Model and/or
- Complementary Material constitutes direct or contributory patent infringement, then any patent licenses
- granted to You under this License for the Model and/or Work shall terminate as of the date such litigation
- is filed.
-
- Section III: CONDITIONS OF USAGE, DISTRIBUTION AND
- REDISTRIBUTION
-
- 4. Distribution and Redistribution. You may host for Third Party remote access purposes (e.g.
- software-as-a-service), reproduce and distribute copies of the Model or Derivatives of the Model thereof in
- any medium, with or without modifications, provided that You meet the following conditions:
-
-
- You may add Your own copyright statement to Your modifications and may provide
- additional or different license terms and conditions - respecting paragraph 4.a. - for use, reproduction, or Distribution of Your modifications,
- or for any such Derivatives of the Model as a whole, provided Your use, reproduction, and Distribution of
- the Model otherwise complies with the conditions stated in this License.
- 5. Use-based restrictions. The restrictions set forth in Attachment A are considered
- Use-based restrictions. Therefore You cannot use the Model and the
- Derivatives of the Model for the specified restricted uses. You may use the Model subject to this License, including only for lawful purposes and in
- accordance with the License. Use may include
- creating any content with, finetuning, updating, running, training, evaluating and/or reparametrizing the
- Model. You shall require all of Your users who use the
- Model or a Derivative of the Model to comply with the terms of this paragraph (paragraph 5).
- 6. The Output You Generate. Except as set forth
- herein, Licensor claims no rights in the Output You generate using the Model. You are accountable for the
- Output you generate and its subsequent uses. No use of the output can contravene any provision as stated in the License.
-
- Section IV: OTHER PROVISIONS
- 7. Updates and Runtime Restrictions. To the maximum extent
- permitted by law, Licensor reserves the right to restrict (remotely or otherwise) usage of the Model in
- violation of this License, update the Model through electronic means, or modify the Output of the Model
- based on updates. You shall undertake reasonable efforts to use the latest version of the Model.
- 8. Trademarks and related. Nothing in this License permits You to make use of Licensors’ trademarks, trade
- names, logos or to otherwise suggest endorsement or misrepresent the relationship between the parties; and
- any rights not expressly granted herein are reserved by the Licensors.
- 9. Disclaimer of Warranty. Unless
- required by applicable law or agreed to in writing, Licensor provides the Model and the Complementary Material (and each
- Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
- ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE,
- NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for
- determining the appropriateness of using or redistributing the Model, Derivatives of the Model, and the
- Complementary Material and assume any risks
- associated with Your exercise of permissions under this License.
- 10. Limitation of Liability. In no
- event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless
- required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall
- any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or
- consequential damages of any character arising as a result of this License or out of the use or inability to
- use the Model and the Complementary Material (including but not limited to damages for loss of goodwill, work stoppage, computer
- failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has
- been advised of the possibility of such damages.
- 11. Accepting Warranty or Additional Liability. While redistributing the Model, Derivatives of the Model and the Complementary Material thereof, You may choose to offer, and charge
- a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights
- consistent with this License. However, in accepting such obligations, You may act only on Your own behalf
- and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify,
- defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such
- Contributor by reason of your accepting any such warranty or additional liability.
- 12. If any provision of this License is held to be
- invalid, illegal or unenforceable, the remaining provisions shall be unaffected thereby and remain valid as
- if such provision had not been set forth herein.
- END OF TERMS AND CONDITIONS
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
- Attachment A
- Use Restrictions
- You agree not to use the Model or Derivatives of the Model:
-
-
-
-
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/lyf/faster-whisper-webui/src/source.py b/spaces/lyf/faster-whisper-webui/src/source.py
deleted file mode 100644
index e304e278bfae8ef289c999fc76311ce01b547991..0000000000000000000000000000000000000000
--- a/spaces/lyf/faster-whisper-webui/src/source.py
+++ /dev/null
@@ -1,80 +0,0 @@
-# Gradio seems to truncate files without keeping the extension, so we need to truncate the file prefix ourself
-import os
-import pathlib
-from typing import List
-import zipfile
-
-import ffmpeg
-from more_itertools import unzip
-
-from src.download import ExceededMaximumDuration, download_url
-
-MAX_FILE_PREFIX_LENGTH = 17
-
-class AudioSource:
- def __init__(self, source_path, source_name = None, audio_duration = None):
- self.source_path = source_path
- self.source_name = source_name
- self._audio_duration = audio_duration
-
- # Load source name if not provided
- if (self.source_name is None):
- file_path = pathlib.Path(self.source_path)
- self.source_name = file_path.name
-
- def get_audio_duration(self):
- if self._audio_duration is None:
- self._audio_duration = float(ffmpeg.probe(self.source_path)["format"]["duration"])
-
- return self._audio_duration
-
- def get_full_name(self):
- return self.source_name
-
- def get_short_name(self, max_length: int = MAX_FILE_PREFIX_LENGTH):
- file_path = pathlib.Path(self.source_name)
- short_name = file_path.stem[:max_length] + file_path.suffix
-
- return short_name
-
- def __str__(self) -> str:
- return self.source_path
-
-class AudioSourceCollection:
- def __init__(self, sources: List[AudioSource]):
- self.sources = sources
-
- def __iter__(self):
- return iter(self.sources)
-
-def get_audio_source_collection(urlData: str, multipleFiles: List, microphoneData: str, input_audio_max_duration: float = -1) -> List[AudioSource]:
- output: List[AudioSource] = []
-
- if urlData:
- # Download from YouTube. This could also be a playlist or a channel.
- output.extend([ AudioSource(x) for x in download_url(urlData, input_audio_max_duration, playlistItems=None) ])
- else:
- # Add input files
- if (multipleFiles is not None):
- output.extend([ AudioSource(x.name) for x in multipleFiles ])
- if (microphoneData is not None):
- output.append(AudioSource(microphoneData))
-
- total_duration = 0
-
- # Calculate total audio length. We do this even if input_audio_max_duration
- # is disabled to ensure that all the audio files are valid.
- for source in output:
- audioDuration = ffmpeg.probe(source.source_path)["format"]["duration"]
- total_duration += float(audioDuration)
-
- # Save audio duration
- source._audio_duration = float(audioDuration)
-
- # Ensure the total duration of the audio is not too long
- if input_audio_max_duration > 0:
- if float(total_duration) > input_audio_max_duration:
- raise ExceededMaximumDuration(videoDuration=total_duration, maxDuration=input_audio_max_duration, message="Video(s) is too long")
-
- # Return a list of audio sources
- return output
\ No newline at end of file
diff --git a/spaces/m3hrdadfi/gpt2-persian-qa/meta.py b/spaces/m3hrdadfi/gpt2-persian-qa/meta.py
deleted file mode 100644
index 5324bb9e466bd7cca43449e26cf1153345ec99d6..0000000000000000000000000000000000000000
--- a/spaces/m3hrdadfi/gpt2-persian-qa/meta.py
+++ /dev/null
@@ -1,9 +0,0 @@
-HEADER_INFO = """
-# GPT2 QA - Persian
-""".strip()
-SIDEBAR_INFO = """
-# Configuration
-""".strip()
-C_PROMPT_BOX = "متن خود را وارد کنید ..."
-Q_PROMPT_BOX = "پرسش خود را مطرح کنید ..."
-A_PROMPT_BOX = "وارد نشده."
diff --git a/spaces/ma-xu/LIVE/thrust/thrust/detail/tuple_meta_transform.h b/spaces/ma-xu/LIVE/thrust/thrust/detail/tuple_meta_transform.h
deleted file mode 100644
index 4aca1a91bb6a6932e357670475ef9c2d7149ffe5..0000000000000000000000000000000000000000
--- a/spaces/ma-xu/LIVE/thrust/thrust/detail/tuple_meta_transform.h
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright 2008-2013 NVIDIA Corporation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include
-
-namespace thrust
-{
-
-namespace detail
-{
-
-template class UnaryMetaFunction,
- unsigned int sz = thrust::tuple_size::value>
- struct tuple_meta_transform;
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef null_type type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type
- > type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type
- > type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type
- > type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type
- > type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type
- > type;
-};
-
-template class UnaryMetaFunction>
- struct tuple_meta_transform
-{
- typedef thrust::tuple<
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction::type>::type,
- typename UnaryMetaFunction 
-