There are different types of online levels in Geometry Dash World, depending on their difficulty, length, and style. Some of the most common types are:
- To play online levels in Geometry Dash World, you need to have some tips and tricks up your sleeve. Here are some of them:
- Another cool feature of Geometry Dash World is that you can customize your character with different icons and colors. You can also unlock secrets and achievements that will give you more options to personalize your character.
- You can choose from various icons and colors to change the appearance of your character. You can select an icon for your cube, ship, ball, UFO, wave, robot, or spider form. You can also select a primary color and a secondary color for your character. You can unlock more icons and colors by completing levels, quests, achievements, or secrets.
- You can unlock secrets and achievements by performing certain actions or finding hidden objects in the game. Some of these secrets and achievements are:
- Geometry Dash World is a fun and challenging game that will keep you entertained for hours. You can download and install the full apk version of the game to enjoy all the features without any limitations or ads. You can also play online levels created by other players and customize your character with different icons and colors. Geometry Dash World is a game that will test your skills, reflexes, and rhythm. Are you ready to dash into the world of geometry?
- If you are an iPhone, iPad or iPod touch user who wants to jailbreak your device running iOS 4.2.1, you might be interested in downloading Greenpois0n RC5 4.2.1 for Windows. This is a tool that allows you to jailbreak your device untethered, meaning that you don't have to connect it to a computer every time you reboot it.
-In this article, we will explain what Greenpois0n RC5 4.2.1 is, how to download it for Windows, and how to use it to jailbreak your device. We will also show you how to use Cydia, the jailbreak app store, where you can find many useful apps, tweaks and themes that are not available on the official App Store.
- Greenpois0n RC5 4.2.1 is a tool developed by the Chronic Dev Team, a group of hackers who specialize in jailbreaking iOS devices. Jailbreaking is a process that removes the restrictions imposed by Apple on its devices, allowing users to customize them and install apps that are not approved by Apple.
- Greenpois0n RC5 4.2.1 is designed to jailbreak iOS devices running iOS 4.2.1, which is an older version of iOS that was released in November 2010. It supports iPhone 4, iPhone 3GS, iPod touch 4G/3G/2G and iPad.
-One of the main features of Greenpois0n RC5 4.2.1 is that it can jailbreak iOS devices untethered, which means that you don't have to connect your device to a computer every time you reboot it or turn it off and on again. This makes your device more convenient and stable after jailbreaking.
- Of course, jailbreaking also has some risks and drawbacks, such as voiding your warranty, exposing your device to security threats, and causing instability or compatibility issues. Therefore, you should always backup your device before jailbreaking and follow the instructions carefully.
- If you are ready to jailbreak your device with Greenpois0n RC5 4.2.1, you will need to download the tool for Windows and follow the steps below.
- The first step is to backup your device using iTunes or iCloud. This will ensure that you don't lose any important data in case something goes wrong during the jailbreak process. To backup your device using iTunes, connect it to your PC and open iTunes. Then, click on the device icon in the upper left corner and select "Back Up Now". To backup your device using iCloud, go to Settings > iCloud > Backup and tap on "Back Up Now".
-After backing up your device, make sure you quit iTunes and any other programs that might interfere with the jailbreak process.
- The next step is to download Greenpois0n RC5 4.2.1 for Windows from the official website of the Chronic Dev Team. You can also use this mirror link if the official website is down or slow. The file size is about 16 MB and the file name is gp_win_rc5_b4.zip.
-After downloading the file, extract it to a folder on your desktop or any other location that is easy to access.
- The third step is to run Greenpois0n and follow the instructions on the screen. To do this, double-click on the greenpois0n.exe file that you extracted in the previous step. You will see a window like this:
-Before you click on "Prepare to Jailbreak (DFU)", make sure your device is turned off and connected to your PC via USB. Then, click on the button and follow the instructions to put your device into DFU mode. DFU mode is a special mode that allows your device to communicate with Greenpois0n and accept the jailbreak code. To enter DFU mode, you will need to press and hold the power and home buttons on your device for a certain amount of time.
-The instructions will tell you how long to press each button and when to release them. You will also see a countdown timer on the screen that will guide you through the process. If you do everything correctly, you will see a message saying "Ready to Jailbreak" and a button saying "Jailbreak". If not, you will see a message saying "Try Again" and a button saying "Retry". In that case, try again until you succeed.
-Once you are ready to jailbreak, click on the "Jailbreak" button and wait for Greenpois0n to do its magic. You will see some code running on your device's screen and a progress bar on your PC's screen. This may take a few minutes, so be patient and do not disconnect or interrupt your device.
- The final step is to install Cydia from the Loader app that Greenpois on will install on your device after the jailbreak. Cydia is the jailbreak app store, where you can find many apps, tweaks and themes that are not available on the official App Store.
-To install Cydia, go to your device's home screen and look for an icon that says "Loader". Tap on it and you will see a screen like this:
-Tap on the "Cydia" button and wait for the app to download and install. You may need to confirm some prompts or restart your device during the process. Once Cydia is installed, you will see its icon on your home screen. You can then delete the Loader app by tapping and holding on it and tapping on the "X" button.
- Now that you have Cydia on your device, you can start exploring the world of jailbreak apps, tweaks and themes. Here are some tips on how to use Cydia:
- Cydia is an app that allows you to browse and install software packages that are not available on the official App Store. These packages are created by independent developers and hackers who want to enhance or modify the iOS experience. Some of these packages are free, while others are paid or require a donation.
-Cydia works by accessing repositories, which are online sources that host the packages. There are many repositories that you can add to Cydia, each offering different kinds of packages. Some of the most popular repositories are BigBoss, ModMyi, ZodTTD & MacCiti, and Saurik's own repository.
- To access Cydia, simply tap on its icon on your home screen. You will see a screen like this:
-On the bottom of the screen, you will see five tabs: Home, Sections, Changes, Manage and Search. Here is what each tab does:
-You can now enjoy your new app, tweak or theme on your device. To uninstall a package from Cydia, simply go to the Manage tab > Packages > tap on the package name > tap on "Modify" > tap on "Remove".
- If you are a fan of fighting games, you must have heard of Mortal Kombat, one of the most iconic and brutal franchises in the genre. Mortal Kombat has been around since 1992, and it has evolved over the years with new characters, graphics, gameplay, and storylines. One of the latest and most popular entries in the series is Mortal Kombat XL, which was released in 2016 as an enhanced version of Mortal Kombat X.
- Mortal Kombat XL is a game that offers a lot of content, variety, and fun for both casual and hardcore players. It has a rich roster of fighters, each with their own unique abilities, moves, and fatalities. It has several game modes, such as story mode, arcade mode, online mode, and tower mode. It has stunning graphics, animations, and sound effects that make every fight feel realistic and immersive. And it has the signature gore and violence that make Mortal Kombat stand out from other fighting games.
-But what if you want to play Mortal Kombat XL on your Android device? Is it possible to enjoy this game on your smartphone or tablet? The answer is yes, thanks to the Mortal Kombat XL download APK. This is a file that allows you to install and run Mortal Kombat XL on your Android device without any hassle. In this article, we will show you how to download and install Mortal Kombat XL APK on your Android device, and how to enjoy it to the fullest.
- Mortal Kombat XL is an updated version of Mortal Kombat X, which was released in 2015. Mortal Kombat X is the tenth main installment in the Mortal Kombat series, and it continues the story of the previous games. It is set 25 years after the events of Mortal Kombat 9, and it features a new generation of fighters who have to face a new threat from the Outworld.
- Mortal Kombat XL has many features that make it one of the best fighting games ever made. Some of these features are:
- Mortal Kombat XL is an enhanced version of Mortal Kombat X that includes all the downloadable content (DLC) that was released for the original game. This means that Mortal Kombat XL has more characters, costumes, stages, and features than Mortal Kombat X. For example, Mortal Kombat XL has nine additional characters that were not available in Mortal Kombat X: Alien, Predator, Jason Voorhees, Leatherface, Bo' Rai Cho, Triborg, Tremor, Tanya, and Goro. It also has new costumes for some of the existing characters, such as Cyber Sub-Zero, Revenant Liu Kang, Revenant Kitana, Revenant Jax, Revenant Kung Lao, Dark Emperor Liu Kang, Dark Empress Kitana, and more. It also has new stages for some of the game modes, such as the Pit Stage for arcade mode and the Refugee Kamp Stage for online mode.
- If you already own Mortal Kombat X on your Android device, you can upgrade to Mortal Kombat XL by purchasing the XL Pack from the in-game store. This will give you access to all the DLC content that is included in Mortal Kombat XL. However, if you do not own Mortal Kombat X on your Android device, you can download and install Mortal Kombat XL APK directly from a trusted source online.
- If you want to play Mortal Kombat XL on your Android device, you will need to download and install Mortal Kombat XL APK from a reliable website. This is a file that contains the game data and allows you to run it on your device without any problems. However, before you do that, you will need to make sure that your device meets the requirements for running Mortal Kombat XL APK.
-Mortal Kombat XL APK is a large and demanding game that requires a powerful device to run smoothly and without errors. Here are some of the minimum requirements for running Mortal Kombat XL APK on your Android device:
- If your device meets these requirements, you can proceed to download and install Mortal Kombat XL APK on your Android device.
- Here are the steps for downloading and installing Mortal Kombat XL APK on your Android device:
- Mortal Kombat XL APK is a great way to enjoy Mortal Kombat XL on your Android device, but it also comes with some risks and challenges. Here are some tips for playing Mortal Kombat XL APK smoothly and safely:
- Mortal Kombat XL APK is a game that offers a lot of fun and excitement for anyone who loves fighting games. It has a lot of content, variety, and challenge that will keep you entertained for hours. Here are some tips on how to enjoy Mortal Kombat XL APK to the fullest:
- Mortal Kombat XL APK has a large and diverse roster of characters that you can choose from. Each character has their own strengths, weaknesses, styles, and personalities that make them unique and fun to play with. However, some characters may be better than others depending on your preferences and skills. Here are some of the best characters to use in Mortal Kombat XL APK:
- Mortal Kombat XL APK has several game modes that you can play and enjoy. Each game mode has its own objectives, rules, and rewards that make them different and fun. Here are some of the best game modes to play in Mortal Kombat XL APK:
- Mortal Kombat XL APK is a game that requires skill, strategy, and practice to master. It is not a game that you can win by button mashing or spamming moves. It is a game that rewards you for learning the mechanics, characters, combos, and tactics of the game. Here are some of the best tips and tricks to master Mortal Kombat XL APK:
-
-Learn the basics: Before you jump into the game modes, make sure that you learn the basics of the game. Learn how to move, block, attack, grab, throw, break, counter, of the website before downloading and installing Mortal Kombat XL APK.
- Is Mortal Kombat XL APK legal?
-Mortal Kombat XL APK is legal to download and install from a legitimate website. However, some websites may offer pirated or cracked files that violate the intellectual property rights of the game developers. Therefore, you should always respect the law and the game developers by downloading and installing Mortal Kombat XL APK from an authorized website.
-Is Mortal Kombat XL APK compatible with my device?
-Mortal Kombat XL APK is compatible with most Android devices that meet the minimum requirements for running the game. However, some devices may have issues or errors with the game due to different specifications or models. Therefore, you should always check the compatibility of your device with the game before downloading and installing Mortal Kombat XL APK.
-How can I contact the support team of Mortal Kombat XL APK?
-If you have any questions, problems, or feedback about Mortal Kombat XL APK, you can contact the support team of the game by visiting their official website, social media pages, or email address. You can also check their online forums, FAQs, or guides for more information and help.
- 401be4b1e0Can You Download Melon Playground on Mac?
-Melon Playground is a popular sandbox game that lets you unleash your creativity and imagination. You can use various items, weapons, and physics to create your own scenarios and experiments. But can you download Melon Playground on Mac? The answer is yes, but not directly. In this article, we will show you two ways to play Melon Playground on your Mac computer.
- What is Melon Playground?
-Melon Playground is a simulation game developed by TwentySeven, a studio based in Russia. It is available for Android devices on Google Play Store. The game has over 10 million downloads and a rating of 2.9 stars out of 5.
-can you download melon playground on mac Download ✔✔✔ https://urlca.com/2uO6pB
A sandbox game for Android devices
-Melon Playground is a sandbox game, which means that there is no fixed goal or objective. You can do whatever you want with the items and tools provided in the game. You can create your own scenes, characters, and stories. You can also destroy, explode, burn, freeze, or electrocute anything you see.
- Features and gameplay of Melon Playground
-Melon Playground has a wide variety of items at your disposal, such as melee weapons, guns, barrels, explosives, vehicles, animals, humans, robots, zombies, aliens, and more. You can also customize the items by changing their color, size, shape, texture, and properties. You can also use physics to make the items interact with each other in realistic or unrealistic ways.
-The game has a simple and intuitive interface that allows you to drag and drop items from the menu to the scene. You can also use gestures to rotate, zoom, or move the camera. You can also pause, resume, or reset the scene at any time. The game also has a screenshot and video recording feature that lets you capture and share your creations with others.
- How to Download Melon Playground on Mac?
-Since Melon Playground is an Android game, you cannot download it directly from the App Store or run it natively on your Mac. However, there are two ways to play Melon Playground on your Mac using either an Android emulator or a cloud gaming service.
- Option 1: Use an Android emulator
-An Android emulator is a software that simulates an Android device on your computer. It allows you to run Android apps and games on your Mac as if you were using an actual Android device.
-How to install melon playground on mac with bluestacks
- What is an Android emulator and how does it work?
-An Android emulator is a software that creates a virtual environment that mimics the hardware and software of an Android device. It runs an Android operating system (OS) on your computer and lets you access the Google Play Store and other Android services. You can then download and install any Android app or game on your computer and run it using the emulator.
- Pros and cons of using an Android emulator
-Using an Android emulator has some advantages and disadvantages. Here are some of them:
Pros:
-
-You can play Melon Playground and other Android games on your Mac without buying an Android device.
-You can use your keyboard and mouse to control the game, which may be more comfortable and convenient than using a touchscreen.
-You can customize the emulator settings to optimize the performance and graphics of the game according to your preferences and system specifications.
-
-Cons:
-
-You need to download and install an Android emulator on your Mac, which may take up some storage space and memory.
-You may experience some lag, glitches, or compatibility issues when running the game on the emulator, especially if your Mac is not powerful enough or if the emulator is not updated.
-You may violate the terms and conditions of the game developer or the Google Play Store by using an emulator, which may result in a ban or a suspension of your account.
-
- Steps to download and install an Android emulator and Melon Playground on Mac
-There are many Android emulators available for Mac, such as BlueStacks, NoxPlayer, MEmu, LDPlayer, and more. You can choose any emulator that suits your needs and preferences. Here are the general steps to download and install an Android emulator and Melon Playground on Mac:
-
-Go to the official website of the Android emulator you want to use and download the installer file for Mac.
-Run the installer file and follow the instructions to install the emulator on your Mac.
-Launch the emulator and sign in with your Google account. If you don't have one, you can create one for free.
-Open the Google Play Store app on the emulator and search for Melon Playground. Alternatively, you can download the APK file of Melon Playground from a third-party source and drag and drop it to the emulator.
-Click on the Install button to download and install Melon Playground on the emulator.
-Once the installation is complete, you can launch Melon Playground from the emulator home screen or app drawer and start playing.
-
- Option 2: Use a cloud gaming service
-A cloud gaming service is a service that allows you to play games online without downloading or installing them on your device. It streams the game from a remote server to your device over the internet. You can play any game on any device as long as you have a stable internet connection and a compatible browser or app.
- What is a cloud gaming service and how does it work?
-A cloud gaming service is a service that uses cloud computing technology to run games on powerful servers and deliver them to your device via streaming. It works like Netflix or YouTube, but for games. You don't need to download or install anything on your device, you just need to access the service through a web browser or an app and choose the game you want to play. The service will then stream the game to your device in real-time, allowing you to control it with your keyboard, mouse, touchpad, or controller.
- Pros and cons of using a cloud gaming service
-Using a cloud gaming service has some advantages and disadvantages. Here are some of them:
-Pros:
-
-You can play Melon Playground and other games on your Mac without downloading or installing anything on your device, saving storage space and memory.
-You can play games that are not compatible with your device or operating system, such as Android games on Mac.
-You can enjoy high-quality graphics and performance of games without worrying about your device's specifications or settings.
-
-Cons:
-
-You need a fast and reliable internet connection to play games online without lag or interruption.
-You may need to pay a subscription fee or buy credits to access some cloud gaming services or games.
-You may not be able to access some features or functions of games that are available offline, such as saving progress, customizing settings, or playing multiplayer modes.
-
- Steps to sign up for a cloud gaming service and play Melon Playground online on Mac
-There are many cloud gaming services available online, such as Google Stadia, NVIDIA GeForce Now, Amazon Luna, Microsoft xCloud, Vortex, Shadow, and more. You can choose any service that offers Melon Playground or other games that you want to play. Here are the general steps to sign up for a cloud gaming service and play Melon Playground online on Mac:
-
-Go to the official website of the cloud gaming service you want to use and create an account. You may need to provide your email, password, payment method, and other personal information.
-Choose a subscription plan or buy credits that suit your budget and gaming needs. Some services may offer a free trial or a limited number of games for free.
-Download and install the app of the cloud gaming service on your Mac, or access the service through a web browser that supports streaming, such as Chrome, Safari, or Firefox.
-Launch the app or the browser and sign in with your account. You will see a library of games that you can play online.
-Search for Melon Playground or browse the categories and genres to find it. Click on the Play button to start streaming the game to your Mac.
-Enjoy playing Melon Playground online on your Mac with high-quality graphics and performance.
-
- Conclusion
-Melon Playground is a fun and creative sandbox game that lets you play with various items, weapons, and physics. However, since it is an Android game, you cannot download it directly on your Mac. You need to use either an Android emulator or a cloud gaming service to play Melon Playground on your Mac.
-Both options have their pros and cons, so you need to consider your preferences, budget, and internet connection before choosing one. If you want to play Melon Playground offline or customize the game settings, you may prefer using an Android emulator. If you want to play Melon Playground online or enjoy high-quality graphics and performance, you may prefer using a cloud gaming service.
-Whichever option you choose, we hope that this article has helped you learn how to download Melon Playground on Mac. Now you can enjoy creating and destroying anything you want with Melon Playground on your Mac computer.
- FAQs
-Is Melon Playground free to play?
-Yes, Melon Playground is free to download and play on Android devices. However, it may contain ads and in-app purchases that require real money. If you use an Android emulator or a cloud gaming service to play Melon Playground on Mac, you may also need to pay for the emulator or the service.
- Is Melon Playground safe to download and play?
-Yes, Melon Playground is safe to download and play if you get it from the official Google Play Store or a trusted third-party source. However, you should be careful when using an Android emulator or a cloud gaming service, as they may pose some security risks or violate some terms and conditions. You should always use a reputable emulator or service and protect your device and account with antivirus software and strong passwords.
- Is Melon Playground compatible with other devices?
-Melon Playground is compatible with most Android devices that have Android 4.4 or higher. However, some devices may not support the game or run it smoothly due to different specifications or settings. You can also play Melon Playground on other devices such as Windows PC, Mac, iOS, or Linux using an Android emulator or a cloud gaming service.
- Can I play Melon Playground offline?
-Yes, you can play Melon Playground offline on your Android device without an internet connection. However, you may not be able to access some features or functions of the game that require online services, such as updating the game, downloading new items, or sharing your creations. If you use an Android emulator or a cloud gaming service to play Melon Playground on Mac, you will need an internet connection to run the emulator or the service.
- Can I create my own items and scenarios in Melon Playground?
-Yes, you can create your own items and scenarios in Melon Playground using the customization tools provided in the game. You can change the color, size, shape, texture, and properties of any item in the game. You can also use physics to make the items interact with each other in realistic or unrealistic ways. You can then save your creations and share them with others through screenshots or videos.
401be4b1e0Rise of the Kings Mod APK + OBB: A Guide for Strategy Game Lovers
-If you are a fan of strategy games, you might have heard of Rise of the Kings, a popular online multiplayer game that lets you build your own empire, recruit and train your army, forge alliances and fight enemies, and explore a vast world full of challenges and opportunities. In this article, we will tell you everything you need to know about Rise of the Kings, and how you can download and install Rise of the Kings Mod APK + OBB, a modified version of the game that gives you unlimited money, free VIP privileges, and no ads. Read on to find out more.
-rise of the kings mod apk + obb Download ►►►►► https://urlca.com/2uOdYi
What is Rise of the Kings?
-Rise of the Kings is a strategy game developed by ONEMT, a Chinese game studio that specializes in creating immersive and realistic games for mobile devices. The game was released in 2016 and has since attracted millions of players from all over the world. The game is set in a fantasy world where several kingdoms are vying for power and glory. You play as a lord who has to build your own empire, recruit and train your army, forge alliances and fight enemies, and explore a vast world full of challenges and opportunities.
- Features of Rise of the Kings
-Rise of the Kings has many features that make it one of the best strategy games on the market. Here are some of them:
- Build your empire
-You start with a small castle and some resources, and you have to expand your territory, upgrade your buildings, research new technologies, and manage your economy. You can choose from different types of buildings, such as farms, mines, barracks, workshops, academies, and more. You can also customize your castle with various decorations and designs.
- Recruit and train your army
-You can recruit different types of units, such as infantry, cavalry, archers, siege weapons, and more. You can also train them to improve their skills and abilities. You can also recruit legendary heroes who have unique talents and powers. You can equip them with weapons, armor, accessories, and mounts. You can also form teams with other players to create powerful formations.
- Forge alliances and fight enemies
-You can join or create an alliance with other players to cooperate and communicate with them. You can share resources, information, strategies, and troops with your allies. You can also participate in alliance events, such as wars, raids, rallies, quests, and more. You can also compete with other alliances for territory, resources, honor, and rewards. You can also fight against other players in PvP battles or against NPC enemies in PvE battles.
-Rise of the Kings Mod Apk 1.9.32 Full + OBB Data
- Explore a vast world
-You can explore a vast world full of mysteries and surprises. You can discover new lands, resources, monsters, treasures, secrets, and more. You can also interact with other players in various ways, such as trading, chatting, gifting, spying, attacking, defending, and more. You can also experience different events and scenarios that change according to real-time situations.
- What is Rise of the Kings Mod APK + OBB?
-Rise of the Kings Mod APK + OBB is a modified version of the original game that gives you some advantages that are not available in the original game. These advantages include unlimited money, free VIP privileges, and no ads. With these benefits, you can enjoy the game without any limitations or interruptions. You can buy anything you want, access exclusive features, and play the game smoothly and comfortably.
- Benefits of Rise of the Kings Mod APK + OBB
-Here are some of the benefits of Rise of the Kings Mod APK + OBB that you can enjoy:
- Unlimited money
-Money is the main currency in the game that you can use to buy various items, such as resources, equipment, boosts, and more. With unlimited money, you can buy anything you want without worrying about running out of money. You can also speed up your progress and development by using money to upgrade your buildings, research new technologies, and train your army faster.
- Free VIP privileges
-VIP is a special status in the game that gives you access to exclusive features and benefits, such as extra resources, faster construction and research, more troops and heroes, and more. Normally, you have to pay real money to get VIP privileges or earn them by completing certain tasks. With Rise of the Kings Mod APK + OBB, you can get free VIP privileges without spending any money or doing any work. You can enjoy all the perks of being a VIP without any hassle.
- No ads
-Ads are annoying and distracting interruptions that can ruin your gaming experience. They can pop up at any time and force you to watch them or close them. They can also consume your data and battery life. With Rise of the Kings Mod APK + OBB, you can get rid of all the ads in the game and play the game without any interruptions or distractions. You can focus on your strategy and enjoy the game fully.
- How to download and install Rise of the Kings Mod APK + OBB?
-If you are interested in downloading and installing Rise of the Kings Mod APK + OBB, you need to follow some simple steps. Here are the steps you need to follow:
- Steps to download and install Rise of the Kings Mod APK + OBB
-Before you start, make sure you have enough storage space on your device and a stable internet connection.
- Download the files from a trusted source
-The first step is to download the files from a trusted source. You can find many websites that offer Rise of the Kings Mod APK + OBB files for free, but not all of them are safe and reliable. Some of them may contain viruses, malware, or spyware that can harm your device or steal your personal information. To avoid this, you should only download the files from a trusted source that has positive reviews and feedback from other users. You can use this link to download the files safely and securely.
- Enable unknown sources on your device
-The second step is to enable unknown sources on your device. This is a security setting that prevents you from installing apps from sources other than the official Google Play Store. Since Rise of the Kings Mod APK + OBB is not available on the Play Store, you need to enable unknown sources to install it on your device. To do this, go to your device settings > security > unknown sources > enable.
- Install the APK file and copy the OBB file to the Android/obb folder
-The third step is to install the APK file and copy the OBB file to the Android/obb folder. The APK file is the application file that contains the game data and code. The OBB file is the additional data file that contains the game graphics and sounds. To install the APK file, locate it in your device storage and tap on it. Follow the instructions on the screen to complete the installation. To copy the OBB file, locate it in your device storage and move it to the Android/obb folder. If you don't have this folder, create it manually.
- Launch the game and enjoy
-The final step is to launch the game and enjoy. To launch the game, go to your app drawer and tap on the Rise of the Kings icon. You will see the game loading screen and then the main menu. You can now enjoy the game with unlimited money, free VIP privileges, and no ads. You can also access all the features and content of the game without any restrictions or limitations.
- Conclusion
-Rise of the Kings is a strategy game that lets you build your own empire, recruit and train your army, forge alliances and fight enemies, and explore a vast world full of challenges and opportunities. It is a fun and addictive game that will keep you entertained for hours. However, if you want to enjoy the game without any limitations or interruptions, you should download and install Rise of the Kings Mod APK + OBB, a modified version of the game that gives you unlimited money, free VIP privileges, and no ads. With these benefits, you can buy anything you want, access exclusive features, and play the game smoothly and comfortably. To download and install Rise of the Kings Mod APK + OBB, you just need to follow some simple steps that we have explained 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 Rise of the Kings Mod APK + OBB:
- Is Rise of the Kings Mod APK + OBB safe to use?
-Yes, Rise of the Kings Mod APK + OBB is safe to use as long as you download it from a trusted source. We have provided a link to download the files safely and securely in this article. However, you should always be careful when downloading and installing any modded or hacked apps from unknown sources, as they may contain viruses, malware, or spyware that can harm your device or steal your personal information.
- Is Rise of the Kings Mod APK + OBB compatible with my device?
-Rise of the Kings Mod APK + OBB is compatible with most Android devices that run on Android 4.0.3 or higher. However, some devices may not support the game due to hardware or software limitations. To check if your device is compatible with the game, you can visit the official Google Play Store page of Rise of the Kings and see if your device is listed among the supported devices.
- Will I get banned for using Rise of the Kings Mod APK + OBB?
-There is a low risk of getting banned for using Rise of the Kings Mod APK + OBB, as the modded version does not interfere with the game servers or other players' accounts. However, you should always use the modded version at your own risk and discretion, as we cannot guarantee that it will work flawlessly or that it will not be detected by the game developers or moderators. If you want to avoid any potential issues or consequences, you should play the game with the original version.
- Can I update Rise of the Kings Mod APK + OBB?
-No, you cannot update Rise of the Kings Mod APK + OBB through the Google Play Store or any other official source. If you try to do so, you will lose all the benefits of the modded version and revert back to the original version. If you want to update the game, you will have to download and install the latest version of Rise of the Kings Mod APK + OBB from the same source that you downloaded it from. You may also have to uninstall the previous version of the game before installing the new one.
- Can I play Rise of the Kings Mod APK + OBB offline?
-No, you cannot play Rise of the Kings Mod APK + OBB offline, as the game requires an internet connection to run and function properly. The game is an online multiplayer game that connects you with other players from all over the world. You need an internet connection to access the game servers, chat with other players, participate in alliance events, and more. If you try to play the game offline, you will not be able to load the game or access any of its features.
401be4b1e0The Walking Dead: A Guide to the Post-Apocalyptic Horror Series
- If you are a fan of horror, drama, and zombies, you might have heard of The Walking Dead , one of the most popular and acclaimed TV shows of the last decade. But what is The Walking Dead exactly, and why should you watch it? In this article, we will give you a comprehensive guide to the post-apocalyptic horror series, covering its origins, characters, themes, and more. Whether you are a newcomer or a longtime fan, we hope this article will help you enjoy The Walking Dead even more.
- What is The Walking Dead?
- The Walking Dead is a multimedia franchise that revolves around a group of survivors in a world overrun by zombies, or "walkers" as they are called in the series. The franchise consists of comic books, TV shows, video games, novels, webisodes, and movies. Here are some of the main components of the franchise:
-the walking dead DOWNLOAD ❤❤❤ https://urlca.com/2uO6iZ
The Walking Dead comic book series
- The original source material for The Walking Dead is a comic book series created by writer Robert Kirkman and artists Tony Moore and Charlie Adlard. The comic book series began in 2003 and ended in 2019, with 193 issues published. The comic book series follows the journey of Rick Grimes, a former sheriff's deputy who wakes up from a coma to find himself in a zombie apocalypse. He meets other survivors and forms a community with them, facing various threats from both the living and the dead. The comic book series is known for its dark, gritty, and realistic tone, as well as its shocking twists and deaths.
- The Walking Dead TV series
- The most popular adaptation of The Walking Dead is a TV series that premiered on AMC in 2010 and will conclude in 2022, with 11 seasons and 177 episodes. The TV series is developed by Frank Darabont and has several executive producers, including Kirkman, Gale Anne Hurd, David Alpert, Greg Nicotero, Scott M. Gimple, Angela Kang, and others. The TV series follows a similar storyline as the comic book series, but also introduces new characters, locations, and events. The TV series is praised for its compelling characters, performances, action sequences, makeup effects, and social commentary.
- The Walking Dead franchise
- Besides the comic book series and the TV series, The Walking Dead has expanded into a larger franchise that includes several spin-offs and movies. Some of the notable spin-offs are:
-
- Some of the upcoming movies are:
-
-The Walking Dead , a trilogy of movies that will continue the story of Rick Grimes after his disappearance from the TV series.Untitled Daryl and Carol Movie , a movie that will follow the adventures of Daryl Dixon and Carol Peletier after the end of the TV series.
- Who are the main characters of The Walking Dead?
- One of the strengths of The Walking Dead is its large and diverse cast of characters, who have different backgrounds, personalities, skills, and motivations. The characters evolve and change over time, as they face various challenges and dilemmas in the zombie apocalypse. Some of the main characters of The Walking Dead are:
- Rick Grimes
- Rick Grimes is the protagonist and leader of the group of survivors. He is a former sheriff's deputy who wakes up from a coma to find himself in a zombie apocalypse. He is determined to protect his family and friends, and to find a safe place to live. He is brave, loyal, resourceful, and compassionate, but also ruthless, pragmatic, and sometimes conflicted. He often struggles with his role as a leader, as he has to make difficult decisions that affect the lives of others. He is played by Andrew Lincoln in the TV series.
-The Walking Dead cast and crew
- Daryl Dixon
- Daryl Dixon is one of the most popular and beloved characters of The Walking Dead . He is a skilled hunter, tracker, and fighter, who uses a crossbow as his signature weapon. He is loyal, brave, independent, and resilient, but also introverted, guarded, and sometimes volatile. He has a close bond with his brother Merle, who is often a source of conflict for him. He also develops a strong friendship with Carol Peletier, who helps him open up and heal from his past traumas. He is played by Norman Reedus in the TV series.
- Carol Peletier
- Carol Peletier is one of the longest-surviving characters of The Walking Dead . She starts off as a timid and abused housewife, who loses her husband and daughter in the zombie apocalypse. She then transforms into a strong, confident, and capable survivor, who is willing to do anything to protect her group. She is smart, resourceful, strategic, and compassionate, but also ruthless, cold, and sometimes manipulative. She has a close friendship with Daryl Dixon, who supports her through her losses and struggles. She is played by Melissa McBride in the TV series.
- Negan
- Negan is one of the most notorious and controversial characters of The Walking Dead . He is the leader of the Saviors, a large group of survivors who extort other communities for resources in exchange for protection from the walkers. He is charismatic, witty, sadistic, and violent, who uses a baseball bat wrapped in barbed wire named Lucille as his weapon of choice. He kills several members of Rick's group in a brutal way, sparking a war between them. He is later captured by Rick and imprisoned for years, until he redeems himself by helping them fight against other enemies. He is played by Jeffrey Dean Morgan in the TV series.
- What are the main themes of The Walking Dead?
- The Walking Dead is not just about zombies and gore. It is also about exploring various themes that are relevant to our society and humanity. Some of the main themes of The Walking Dead are:
- Survival
- The most obvious theme of The Walking Dead is survival. The characters have to survive not only from the walkers, but also from other humans who pose threats to them. They have to find food, water, shelter, weapons, medicine, and other resources to stay alive. They also have to deal with injuries, diseases, infections, hunger, thirst, fatigue, and stress. They have to adapt to different environments and situations, and overcome various obstacles and challenges. Survival is not easy or guaranteed in The Walking Dead , as many characters die or disappear along the way.
- Humanity
- Another theme of The Walking Dead is humanity. The characters have to question what it means to be human in a world where humanity seems to be lost or corrupted. They have to face moral dilemmas and ethical choices that test their values and principles. They have to balance their individual needs
and their group interests, and their personal feelings and their rational judgments. They have to cope with their emotions, such as fear, anger, grief, guilt, and hope. They have to maintain their sanity, dignity, and identity in a chaotic and cruel world. They have to find meaning and purpose in their existence, and to preserve their values and beliefs.
- Leadership
- A third theme of The Walking Dead is leadership. The characters have to decide who to follow and who to trust in a world where authority and order are gone or corrupted. They have to deal with different types of leaders, such as Rick Grimes, who is a democratic and benevolent leader, Negan, who is a tyrannical and oppressive leader, and the Governor, who is a charismatic and manipulative leader. They also have to face the challenges and responsibilities of being a leader themselves, such as making decisions, resolving conflicts, inspiring others, and facing consequences.
- Morality
- A fourth theme of The Walking Dead is morality. The characters have to determine what is right and wrong in a world where morality seems to be relative or irrelevant. They have to confront the ethical implications of their actions and choices, such as killing, stealing, lying, betraying, sacrificing, and forgiving. They have to deal with the moral gray areas and ambiguities that arise in the zombie apocalypse, such as whether to kill walkers or spare them, whether to help strangers or ignore them, whether to cooperate with other groups or compete with them, and whether to follow the rules or break them.
- Why should you watch The Walking Dead?
- Now that you know what The Walking Dead is about, you might be wondering why you should watch it. Here are some of the reasons why The Walking Dead is worth watching:
- The Walking Dead is thrilling and suspenseful
- If you like horror and action, you will love The Walking Dead . The series is full of thrilling and suspenseful scenes that will keep you on the edge of your seat. You will witness the characters fighting against hordes of walkers, escaping from dangerous situations, encountering new enemies, and facing unexpected twists. You will also enjoy the stunning visuals, sound effects, and music that create a tense and immersive atmosphere.
- The Walking Dead is emotional and character-driven
- If you like drama and character development, you will love The Walking Dead . The series is not just about zombies and violence. It is also about the human stories and relationships that emerge in the zombie apocalypse. You will get to know the characters deeply, their backgrounds, personalities, motivations, and goals. You will care about them, root for them, cry for them, and sometimes hate them. You will also witness their growth and change over time, as they face various challenges and dilemmas.
- The Walking Dead is creative and diverse
- If you like creativity and diversity, you will love The Walking Dead . The series is not just a repetitive or predictable show. It is constantly evolving and expanding its scope and scale. You will explore different settings and locations, such as Atlanta, Hershel's farm, the prison, Terminus, Alexandria, the Kingdom, the Hilltop, the Sanctuary , and Oceanside. You will meet different groups and communities, such as the Survivors, the Saviors, the Whisperers, the Commonwealth, and the CRM. You will encounter different types of walkers, such as the roamers, the lurkers, the herd, the spiked, and the radioactive. You will also enjoy the various spin-offs and movies that expand the universe and explore new stories and characters.
- How to watch The Walking Dead?
- If you are interested in watching The Walking Dead , you might be wondering how to do it. Here are some of the ways you can watch The Walking Dead :
- The Walking Dead streaming platforms
- The easiest way to watch The Walking Dead is to stream it online. You can find all the episodes of the TV series on various streaming platforms, such as Netflix, Hulu, Amazon Prime Video, AMC+, and others. You can also find some of the spin-offs and movies on these platforms, or on other platforms, such as YouTube, iTunes, Google Play, and others. You can choose the platform that suits your preferences and budget, and enjoy The Walking Dead anytime and anywhere.
- The Walking Dead spin-offs and movies
- Another way to watch The Walking Dead is to watch its spin-offs and movies. You can find some of the spin-offs on the same streaming platforms as the TV series, or on other platforms, such as AMC's website or app. You can also find some of the movies on these platforms, or on other platforms, such as theaters or cable TV. You can choose the spin-off or movie that interests you, and enjoy a different perspective or experience of The Walking Dead .
- Conclusion
- In conclusion, The Walking Dead is a post-apocalyptic horror series that has captivated millions of fans around the world. It is a franchise that consists of comic books, TV shows, video games, novels, webisodes, and movies. It is a series that features a large and diverse cast of characters, who have to survive in a world overrun by zombies and other threats. It is a series that explores various themes that are relevant to our society and humanity. It is a series that is thrilling, emotional, creative, and diverse. It is a series that you should watch if you are a fan of horror, drama, and zombies.
- Here are some FAQs about The Walking Dead :
-
-Q: When will The Walking Dead end? A: The Walking Dead TV series will end in 2022, with its 11th and final season. However, the franchise will continue with its spin-offs and movies.
-Q: How faithful is The Walking Dead TV series to the comic book series? A: The Walking Dead TV series is based on the comic book series, but it also deviates from it in many ways. Some of the differences include new characters, locations, events, deaths, and endings.
-Q: Who are the Whisperers? A: The Whisperers are one of the main antagonists of The Walking Dead. They are a group of survivors who wear walker skins to blend in with them and to communicate with them. They are led by Alpha and Beta.
-Q: What is CRM? A: CRM is an acronym for Civic Republic Military. It is a mysterious and powerful organization that has access to advanced technology and resources. It is involved in the disappearance of Rick Grimes and the experiments on walkers.
-Q: What is Lucille? A: Lucille is the name of Negan's baseball bat wrapped in barbed wire. It is also the name of his late wife, who died of cancer before the zombie apocalypse.
- 401be4b1e0`_.
-
- Args:
- dilations (tuple[int]): Dilation rates for ASPP module.
- Default: (1, 6, 12, 18).
- """
-
- def __init__(self, dilations=(1, 6, 12, 18), **kwargs):
- super(ASPPHead, self).__init__(**kwargs)
- assert isinstance(dilations, (list, tuple))
- self.dilations = dilations
- self.image_pool = nn.Sequential(
- nn.AdaptiveAvgPool2d(1),
- ConvModule(
- self.in_channels,
- self.channels,
- 1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg))
- self.aspp_modules = ASPPModule(
- dilations,
- self.in_channels,
- self.channels,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg)
- self.bottleneck = ConvModule(
- (len(dilations) + 1) * self.channels,
- self.channels,
- 3,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg,
- act_cfg=self.act_cfg)
-
- def forward(self, inputs):
- """Forward function."""
- x = self._transform_inputs(inputs)
- aspp_outs = [
- resize(
- self.image_pool(x),
- size=x.size()[2:],
- mode='bilinear',
- align_corners=self.align_corners)
- ]
- aspp_outs.extend(self.aspp_modules(x))
- aspp_outs = torch.cat(aspp_outs, dim=1)
- output = self.bottleneck(aspp_outs)
- output = self.cls_seg(output)
- return output
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/oneformer/data/datasets/__init__.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/oneformer/data/datasets/__init__.py
deleted file mode 100644
index 59ce30713f63d056107b2a06ecd434eb27a30b7d..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/oneformer/data/datasets/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from . import (
- register_ade20k_panoptic,
- register_cityscapes_panoptic,
- register_coco_panoptic_annos_semseg,
- register_ade20k_instance,
- register_coco_panoptic2instance,
-)
diff --git a/spaces/cymic/Talking_Head_Anime_3/tha3/nn/separable_conv.py b/spaces/cymic/Talking_Head_Anime_3/tha3/nn/separable_conv.py
deleted file mode 100644
index e33bce3c25aa279e7a7fbb0a7998a3f3788e4c25..0000000000000000000000000000000000000000
--- a/spaces/cymic/Talking_Head_Anime_3/tha3/nn/separable_conv.py
+++ /dev/null
@@ -1,119 +0,0 @@
-from typing import Optional
-
-from torch.nn import Sequential, Conv2d, ConvTranspose2d, Module
-
-from tha3.nn.normalization import NormalizationLayerFactory
-from tha3.nn.util import BlockArgs, wrap_conv_or_linear_module
-
-
-def create_separable_conv3(in_channels: int, out_channels: int,
- bias: bool = False,
- initialization_method='he',
- use_spectral_norm: bool = False) -> Module:
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=False, groups=in_channels),
- initialization_method,
- use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=bias),
- initialization_method,
- use_spectral_norm))
-
-
-def create_separable_conv7(in_channels: int, out_channels: int,
- bias: bool = False,
- initialization_method='he',
- use_spectral_norm: bool = False) -> Module:
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=7, stride=1, padding=3, bias=False, groups=in_channels),
- initialization_method,
- use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=bias),
- initialization_method,
- use_spectral_norm))
-
-
-def create_separable_conv3_block(
- in_channels: int, out_channels: int, block_args: Optional[BlockArgs] = None):
- if block_args is None:
- block_args = BlockArgs()
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=3, stride=1, padding=1, bias=False, groups=in_channels),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- NormalizationLayerFactory.resolve_2d(block_args.normalization_layer_factory).create(out_channels, affine=True),
- block_args.nonlinearity_factory.create())
-
-
-def create_separable_conv7_block(
- in_channels: int, out_channels: int, block_args: Optional[BlockArgs] = None):
- if block_args is None:
- block_args = BlockArgs()
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=7, stride=1, padding=3, bias=False, groups=in_channels),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- NormalizationLayerFactory.resolve_2d(block_args.normalization_layer_factory).create(out_channels, affine=True),
- block_args.nonlinearity_factory.create())
-
-
-def create_separable_downsample_block(
- in_channels: int, out_channels: int, is_output_1x1: bool, block_args: Optional[BlockArgs] = None):
- if block_args is None:
- block_args = BlockArgs()
- if is_output_1x1:
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=4, stride=2, padding=1, bias=False, groups=in_channels),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- block_args.nonlinearity_factory.create())
- else:
- return Sequential(
- wrap_conv_or_linear_module(
- Conv2d(in_channels, in_channels, kernel_size=4, stride=2, padding=1, bias=False, groups=in_channels),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- NormalizationLayerFactory.resolve_2d(block_args.normalization_layer_factory)
- .create(out_channels, affine=True),
- block_args.nonlinearity_factory.create())
-
-
-def create_separable_upsample_block(
- in_channels: int, out_channels: int, block_args: Optional[BlockArgs] = None):
- if block_args is None:
- block_args = BlockArgs()
- return Sequential(
- wrap_conv_or_linear_module(
- ConvTranspose2d(
- in_channels, in_channels, kernel_size=4, stride=2, padding=1, bias=False, groups=in_channels),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- wrap_conv_or_linear_module(
- Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False),
- block_args.initialization_method,
- block_args.use_spectral_norm),
- NormalizationLayerFactory.resolve_2d(block_args.normalization_layer_factory)
- .create(out_channels, affine=True),
- block_args.nonlinearity_factory.create())
diff --git a/spaces/darkartsaibwd/Envvi-Inkpunk-Diffusion/README.md b/spaces/darkartsaibwd/Envvi-Inkpunk-Diffusion/README.md
deleted file mode 100644
index 50c55a51990d9b9881b7d512e52772fac537ee52..0000000000000000000000000000000000000000
--- a/spaces/darkartsaibwd/Envvi-Inkpunk-Diffusion/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Envvi Inkpunk Diffusion
-emoji: 🏃
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 3.24.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/utils/options.py b/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/utils/options.py
deleted file mode 100644
index db490e4aa52e26fde31959fd74c2cef3af2ecf76..0000000000000000000000000000000000000000
--- a/spaces/dawood17/SayBot_Enchancer/CodeFormer/basicsr/utils/options.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import yaml
-import time
-from collections import OrderedDict
-from os import path as osp
-from basicsr.utils.misc import get_time_str
-
-def ordered_yaml():
- """Support OrderedDict for yaml.
-
- Returns:
- yaml Loader and Dumper.
- """
- try:
- from yaml import CDumper as Dumper
- from yaml import CLoader as Loader
- except ImportError:
- from yaml import Dumper, Loader
-
- _mapping_tag = yaml.resolver.BaseResolver.DEFAULT_MAPPING_TAG
-
- def dict_representer(dumper, data):
- return dumper.represent_dict(data.items())
-
- def dict_constructor(loader, node):
- return OrderedDict(loader.construct_pairs(node))
-
- Dumper.add_representer(OrderedDict, dict_representer)
- Loader.add_constructor(_mapping_tag, dict_constructor)
- return Loader, Dumper
-
-
-def parse(opt_path, root_path, is_train=True):
- """Parse option file.
-
- Args:
- opt_path (str): Option file path.
- is_train (str): Indicate whether in training or not. Default: True.
-
- Returns:
- (dict): Options.
- """
- with open(opt_path, mode='r') as f:
- Loader, _ = ordered_yaml()
- opt = yaml.load(f, Loader=Loader)
-
- opt['is_train'] = is_train
-
- # opt['name'] = f"{get_time_str()}_{opt['name']}"
- if opt['path'].get('resume_state', None): # Shangchen added
- resume_state_path = opt['path'].get('resume_state')
- opt['name'] = resume_state_path.split("/")[-3]
- else:
- opt['name'] = f"{get_time_str()}_{opt['name']}"
-
-
- # datasets
- for phase, dataset in opt['datasets'].items():
- # for several datasets, e.g., test_1, test_2
- phase = phase.split('_')[0]
- dataset['phase'] = phase
- if 'scale' in opt:
- dataset['scale'] = opt['scale']
- if dataset.get('dataroot_gt') is not None:
- dataset['dataroot_gt'] = osp.expanduser(dataset['dataroot_gt'])
- if dataset.get('dataroot_lq') is not None:
- dataset['dataroot_lq'] = osp.expanduser(dataset['dataroot_lq'])
-
- # paths
- for key, val in opt['path'].items():
- if (val is not None) and ('resume_state' in key or 'pretrain_network' in key):
- opt['path'][key] = osp.expanduser(val)
-
- if is_train:
- experiments_root = osp.join(root_path, 'experiments', opt['name'])
- opt['path']['experiments_root'] = experiments_root
- opt['path']['models'] = osp.join(experiments_root, 'models')
- opt['path']['training_states'] = osp.join(experiments_root, 'training_states')
- opt['path']['log'] = experiments_root
- opt['path']['visualization'] = osp.join(experiments_root, 'visualization')
-
- else: # test
- results_root = osp.join(root_path, 'results', opt['name'])
- opt['path']['results_root'] = results_root
- opt['path']['log'] = results_root
- opt['path']['visualization'] = osp.join(results_root, 'visualization')
-
- return opt
-
-
-def dict2str(opt, indent_level=1):
- """dict to string for printing options.
-
- Args:
- opt (dict): Option dict.
- indent_level (int): Indent level. Default: 1.
-
- Return:
- (str): Option string for printing.
- """
- msg = '\n'
- for k, v in opt.items():
- if isinstance(v, dict):
- msg += ' ' * (indent_level * 2) + k + ':['
- msg += dict2str(v, indent_level + 1)
- msg += ' ' * (indent_level * 2) + ']\n'
- else:
- msg += ' ' * (indent_level * 2) + k + ': ' + str(v) + '\n'
- return msg
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/altair/vegalite/v5/data.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/altair/vegalite/v5/data.py
deleted file mode 100644
index 703dffb3246a32f4734f0653dfcc1aaa0d1d23f9..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/altair/vegalite/v5/data.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from ..data import (
- MaxRowsError,
- curry,
- default_data_transformer,
- limit_rows,
- pipe,
- sample,
- to_csv,
- to_json,
- to_values,
- DataTransformerRegistry,
-)
-
-
-# ==============================================================================
-# VegaLite 5 data transformers
-# ==============================================================================
-
-
-ENTRY_POINT_GROUP = "altair.vegalite.v5.data_transformer" # type: str
-
-
-data_transformers = DataTransformerRegistry(
- entry_point_group=ENTRY_POINT_GROUP
-) # type: DataTransformerRegistry
-data_transformers.register("default", default_data_transformer)
-data_transformers.register("json", to_json)
-data_transformers.register("csv", to_csv)
-data_transformers.enable("default")
-
-
-__all__ = (
- "MaxRowsError",
- "curry",
- "default_data_transformer",
- "limit_rows",
- "pipe",
- "sample",
- "to_csv",
- "to_json",
- "to_values",
- "data_transformers",
-)
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio_client/utils.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio_client/utils.py
deleted file mode 100644
index 850e6f8882bd3295a01c9285b136dc54c3daa7d3..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/gradio_client/utils.py
+++ /dev/null
@@ -1,575 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import base64
-import json
-import mimetypes
-import os
-import pkgutil
-import secrets
-import shutil
-import tempfile
-import warnings
-from concurrent.futures import CancelledError
-from dataclasses import dataclass, field
-from datetime import datetime
-from enum import Enum
-from pathlib import Path
-from threading import Lock
-from typing import Any, Callable, Optional
-
-import fsspec.asyn
-import httpx
-import huggingface_hub
-import requests
-from huggingface_hub import SpaceStage
-from websockets.legacy.protocol import WebSocketCommonProtocol
-
-API_URL = "api/predict/"
-WS_URL = "queue/join"
-UPLOAD_URL = "upload"
-CONFIG_URL = "config"
-API_INFO_URL = "info"
-RAW_API_INFO_URL = "info?serialize=False"
-SPACE_FETCHER_URL = "https://gradio-space-api-fetcher-v2.hf.space/api"
-RESET_URL = "reset"
-SPACE_URL = "https://hf.space/{}"
-
-SKIP_COMPONENTS = {
- "state",
- "row",
- "column",
- "tabs",
- "tab",
- "tabitem",
- "box",
- "form",
- "accordion",
- "group",
- "interpretation",
- "dataset",
-}
-STATE_COMPONENT = "state"
-INVALID_RUNTIME = [
- SpaceStage.NO_APP_FILE,
- SpaceStage.CONFIG_ERROR,
- SpaceStage.BUILD_ERROR,
- SpaceStage.RUNTIME_ERROR,
- SpaceStage.PAUSED,
-]
-
-__version__ = (pkgutil.get_data(__name__, "version.txt") or b"").decode("ascii").strip()
-
-
-class TooManyRequestsError(Exception):
- """Raised when the API returns a 429 status code."""
-
- pass
-
-
-class QueueError(Exception):
- """Raised when the queue is full or there is an issue adding a job to the queue."""
-
- pass
-
-
-class InvalidAPIEndpointError(Exception):
- """Raised when the API endpoint is invalid."""
-
- pass
-
-
-class SpaceDuplicationError(Exception):
- """Raised when something goes wrong with a Space Duplication."""
-
- pass
-
-
-class Status(Enum):
- """Status codes presented to client users."""
-
- STARTING = "STARTING"
- JOINING_QUEUE = "JOINING_QUEUE"
- QUEUE_FULL = "QUEUE_FULL"
- IN_QUEUE = "IN_QUEUE"
- SENDING_DATA = "SENDING_DATA"
- PROCESSING = "PROCESSING"
- ITERATING = "ITERATING"
- PROGRESS = "PROGRESS"
- FINISHED = "FINISHED"
- CANCELLED = "CANCELLED"
-
- @staticmethod
- def ordering(status: Status) -> int:
- """Order of messages. Helpful for testing."""
- order = [
- Status.STARTING,
- Status.JOINING_QUEUE,
- Status.QUEUE_FULL,
- Status.IN_QUEUE,
- Status.SENDING_DATA,
- Status.PROCESSING,
- Status.PROGRESS,
- Status.ITERATING,
- Status.FINISHED,
- Status.CANCELLED,
- ]
- return order.index(status)
-
- def __lt__(self, other: Status):
- return self.ordering(self) < self.ordering(other)
-
- @staticmethod
- def msg_to_status(msg: str) -> Status:
- """Map the raw message from the backend to the status code presented to users."""
- return {
- "send_hash": Status.JOINING_QUEUE,
- "queue_full": Status.QUEUE_FULL,
- "estimation": Status.IN_QUEUE,
- "send_data": Status.SENDING_DATA,
- "process_starts": Status.PROCESSING,
- "process_generating": Status.ITERATING,
- "process_completed": Status.FINISHED,
- "progress": Status.PROGRESS,
- }[msg]
-
-
-@dataclass
-class ProgressUnit:
- index: Optional[int]
- length: Optional[int]
- unit: Optional[str]
- progress: Optional[float]
- desc: Optional[str]
-
- @classmethod
- def from_ws_msg(cls, data: list[dict]) -> list[ProgressUnit]:
- return [
- cls(
- index=d.get("index"),
- length=d.get("length"),
- unit=d.get("unit"),
- progress=d.get("progress"),
- desc=d.get("desc"),
- )
- for d in data
- ]
-
-
-@dataclass
-class StatusUpdate:
- """Update message sent from the worker thread to the Job on the main thread."""
-
- code: Status
- rank: int | None
- queue_size: int | None
- eta: float | None
- success: bool | None
- time: datetime | None
- progress_data: list[ProgressUnit] | None
-
-
-def create_initial_status_update():
- return StatusUpdate(
- code=Status.STARTING,
- rank=None,
- queue_size=None,
- eta=None,
- success=None,
- time=datetime.now(),
- progress_data=None,
- )
-
-
-@dataclass
-class JobStatus:
- """The job status.
-
- Keeps track of the latest status update and intermediate outputs (not yet implements).
- """
-
- latest_status: StatusUpdate = field(default_factory=create_initial_status_update)
- outputs: list[Any] = field(default_factory=list)
-
-
-@dataclass
-class Communicator:
- """Helper class to help communicate between the worker thread and main thread."""
-
- lock: Lock
- job: JobStatus
- prediction_processor: Callable[..., tuple]
- reset_url: str
- should_cancel: bool = False
-
-
-########################
-# Network utils
-########################
-
-
-def is_http_url_like(possible_url: str) -> bool:
- """
- Check if the given string looks like an HTTP(S) URL.
- """
- return possible_url.startswith(("http://", "https://"))
-
-
-def probe_url(possible_url: str) -> bool:
- """
- Probe the given URL to see if it responds with a 200 status code (to HEAD, then to GET).
- """
- headers = {"User-Agent": "gradio (https://gradio.app/; team@gradio.app)"}
- try:
- with requests.session() as sess:
- head_request = sess.head(possible_url, headers=headers)
- if head_request.status_code == 405:
- return sess.get(possible_url, headers=headers).ok
- return head_request.ok
- except Exception:
- return False
-
-
-def is_valid_url(possible_url: str) -> bool:
- """
- Check if the given string is a valid URL.
- """
- warnings.warn(
- "is_valid_url should not be used. "
- "Use is_http_url_like() and probe_url(), as suitable, instead.",
- )
- return is_http_url_like(possible_url) and probe_url(possible_url)
-
-
-async def get_pred_from_ws(
- websocket: WebSocketCommonProtocol,
- data: str,
- hash_data: str,
- helper: Communicator | None = None,
-) -> dict[str, Any]:
- completed = False
- resp = {}
- while not completed:
- # Receive message in the background so that we can
- # cancel even while running a long pred
- task = asyncio.create_task(websocket.recv())
- while not task.done():
- if helper:
- with helper.lock:
- if helper.should_cancel:
- # Need to reset the iterator state since the client
- # will not reset the session
- async with httpx.AsyncClient() as http:
- reset = http.post(
- helper.reset_url, json=json.loads(hash_data)
- )
- # Retrieve cancel exception from task
- # otherwise will get nasty warning in console
- task.cancel()
- await asyncio.gather(task, reset, return_exceptions=True)
- raise CancelledError()
- # Need to suspend this coroutine so that task actually runs
- await asyncio.sleep(0.01)
- msg = task.result()
- resp = json.loads(msg)
- if helper:
- with helper.lock:
- has_progress = "progress_data" in resp
- status_update = StatusUpdate(
- code=Status.msg_to_status(resp["msg"]),
- queue_size=resp.get("queue_size"),
- rank=resp.get("rank", None),
- success=resp.get("success"),
- time=datetime.now(),
- eta=resp.get("rank_eta"),
- progress_data=ProgressUnit.from_ws_msg(resp["progress_data"])
- if has_progress
- else None,
- )
- output = resp.get("output", {}).get("data", [])
- if output and status_update.code != Status.FINISHED:
- try:
- result = helper.prediction_processor(*output)
- except Exception as e:
- result = [e]
- helper.job.outputs.append(result)
- helper.job.latest_status = status_update
- if resp["msg"] == "queue_full":
- raise QueueError("Queue is full! Please try again.")
- if resp["msg"] == "send_hash":
- await websocket.send(hash_data)
- elif resp["msg"] == "send_data":
- await websocket.send(data)
- completed = resp["msg"] == "process_completed"
- return resp["output"]
-
-
-########################
-# Data processing utils
-########################
-
-
-def download_tmp_copy_of_file(
- url_path: str, hf_token: str | None = None, dir: str | None = None
-) -> str:
- if dir is not None:
- os.makedirs(dir, exist_ok=True)
- headers = {"Authorization": "Bearer " + hf_token} if hf_token else {}
- directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
- directory.mkdir(exist_ok=True, parents=True)
- file_path = directory / Path(url_path).name
-
- with requests.get(url_path, headers=headers, stream=True) as r:
- r.raise_for_status()
- with open(file_path, "wb") as f:
- shutil.copyfileobj(r.raw, f)
- return str(file_path.resolve())
-
-
-def create_tmp_copy_of_file(file_path: str, dir: str | None = None) -> str:
- directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
- directory.mkdir(exist_ok=True, parents=True)
- dest = directory / Path(file_path).name
- shutil.copy2(file_path, dest)
- return str(dest.resolve())
-
-
-def get_mimetype(filename: str) -> str | None:
- if filename.endswith(".vtt"):
- return "text/vtt"
- mimetype = mimetypes.guess_type(filename)[0]
- if mimetype is not None:
- mimetype = mimetype.replace("x-wav", "wav").replace("x-flac", "flac")
- return mimetype
-
-
-def get_extension(encoding: str) -> str | None:
- encoding = encoding.replace("audio/wav", "audio/x-wav")
- type = mimetypes.guess_type(encoding)[0]
- if type == "audio/flac": # flac is not supported by mimetypes
- return "flac"
- elif type is None:
- return None
- extension = mimetypes.guess_extension(type)
- if extension is not None and extension.startswith("."):
- extension = extension[1:]
- return extension
-
-
-def encode_file_to_base64(f: str | Path):
- with open(f, "rb") as file:
- encoded_string = base64.b64encode(file.read())
- base64_str = str(encoded_string, "utf-8")
- mimetype = get_mimetype(str(f))
- return (
- "data:"
- + (mimetype if mimetype is not None else "")
- + ";base64,"
- + base64_str
- )
-
-
-def encode_url_to_base64(url: str):
- resp = requests.get(url)
- resp.raise_for_status()
- encoded_string = base64.b64encode(resp.content)
- base64_str = str(encoded_string, "utf-8")
- mimetype = get_mimetype(url)
- return (
- "data:" + (mimetype if mimetype is not None else "") + ";base64," + base64_str
- )
-
-
-def encode_url_or_file_to_base64(path: str | Path):
- path = str(path)
- if is_http_url_like(path):
- return encode_url_to_base64(path)
- return encode_file_to_base64(path)
-
-
-def decode_base64_to_binary(encoding: str) -> tuple[bytes, str | None]:
- extension = get_extension(encoding)
- data = encoding.rsplit(",", 1)[-1]
- return base64.b64decode(data), extension
-
-
-def strip_invalid_filename_characters(filename: str, max_bytes: int = 200) -> str:
- """Strips invalid characters from a filename and ensures that the file_length is less than `max_bytes` bytes."""
- filename = "".join([char for char in filename if char.isalnum() or char in "._- "])
- filename_len = len(filename.encode())
- if filename_len > max_bytes:
- while filename_len > max_bytes:
- if len(filename) == 0:
- break
- filename = filename[:-1]
- filename_len = len(filename.encode())
- return filename
-
-
-def sanitize_parameter_names(original_name: str) -> str:
- """Cleans up a Python parameter name to make the API info more readable."""
- return (
- "".join([char for char in original_name if char.isalnum() or char in " _"])
- .replace(" ", "_")
- .lower()
- )
-
-
-def decode_base64_to_file(
- encoding: str,
- file_path: str | None = None,
- dir: str | Path | None = None,
- prefix: str | None = None,
-):
- directory = Path(dir or tempfile.gettempdir()) / secrets.token_hex(20)
- directory.mkdir(exist_ok=True, parents=True)
- data, extension = decode_base64_to_binary(encoding)
- if file_path is not None and prefix is None:
- filename = Path(file_path).name
- prefix = filename
- if "." in filename:
- prefix = filename[0 : filename.index(".")]
- extension = filename[filename.index(".") + 1 :]
-
- if prefix is not None:
- prefix = strip_invalid_filename_characters(prefix)
-
- if extension is None:
- file_obj = tempfile.NamedTemporaryFile(
- delete=False, prefix=prefix, dir=directory
- )
- else:
- file_obj = tempfile.NamedTemporaryFile(
- delete=False,
- prefix=prefix,
- suffix="." + extension,
- dir=directory,
- )
- file_obj.write(data)
- file_obj.flush()
- return file_obj
-
-
-def dict_or_str_to_json_file(jsn: str | dict | list, dir: str | Path | None = None):
- if dir is not None:
- os.makedirs(dir, exist_ok=True)
-
- file_obj = tempfile.NamedTemporaryFile(
- delete=False, suffix=".json", dir=dir, mode="w+"
- )
- if isinstance(jsn, str):
- jsn = json.loads(jsn)
- json.dump(jsn, file_obj)
- file_obj.flush()
- return file_obj
-
-
-def file_to_json(file_path: str | Path) -> dict | list:
- with open(file_path) as f:
- return json.load(f)
-
-
-###########################
-# HuggingFace Hub API Utils
-###########################
-def set_space_timeout(
- space_id: str,
- hf_token: str | None = None,
- timeout_in_seconds: int = 300,
-):
- headers = huggingface_hub.utils.build_hf_headers(
- token=hf_token,
- library_name="gradio_client",
- library_version=__version__,
- )
- req = requests.post(
- f"https://huggingface.co/api/spaces/{space_id}/sleeptime",
- json={"seconds": timeout_in_seconds},
- headers=headers,
- )
- try:
- huggingface_hub.utils.hf_raise_for_status(req)
- except huggingface_hub.utils.HfHubHTTPError as err:
- raise SpaceDuplicationError(
- f"Could not set sleep timeout on duplicated Space. Please visit {SPACE_URL.format(space_id)} "
- "to set a timeout manually to reduce billing charges."
- ) from err
-
-
-########################
-# Misc utils
-########################
-
-
-def synchronize_async(func: Callable, *args, **kwargs) -> Any:
- """
- Runs async functions in sync scopes. Can be used in any scope.
-
- Example:
- if inspect.iscoroutinefunction(block_fn.fn):
- predictions = utils.synchronize_async(block_fn.fn, *processed_input)
-
- Args:
- func:
- *args:
- **kwargs:
- """
- return fsspec.asyn.sync(fsspec.asyn.get_loop(), func, *args, **kwargs) # type: ignore
-
-
-class APIInfoParseError(ValueError):
- pass
-
-
-def get_type(schema: dict):
- if "type" in schema:
- return schema["type"]
- elif schema.get("oneOf"):
- return "oneOf"
- elif schema.get("anyOf"):
- return "anyOf"
- else:
- raise APIInfoParseError(f"Cannot parse type for {schema}")
-
-
-def json_schema_to_python_type(schema: Any) -> str:
- """Convert the json schema into a python type hint"""
- type_ = get_type(schema)
- if type_ == {}:
- if "json" in schema["description"]:
- return "Dict[Any, Any]"
- else:
- return "Any"
- elif type_ == "null":
- return "None"
- elif type_ == "integer":
- return "int"
- elif type_ == "string":
- return "str"
- elif type_ == "boolean":
- return "bool"
- elif type_ == "number":
- return "int | float"
- elif type_ == "array":
- items = schema.get("items")
- if "prefixItems" in items:
- elements = ", ".join(
- [json_schema_to_python_type(i) for i in items["prefixItems"]]
- )
- return f"Tuple[{elements}]"
- else:
- elements = json_schema_to_python_type(items)
- return f"List[{elements}]"
- elif type_ == "object":
- des = ", ".join(
- [
- f"{n}: {json_schema_to_python_type(v)} ({v.get('description')})"
- for n, v in schema["properties"].items()
- ]
- )
- return f"Dict({des})"
- elif type_ in ["oneOf", "anyOf"]:
- desc = " | ".join([json_schema_to_python_type(i) for i in schema[type_]])
- return desc
- else:
- raise APIInfoParseError(f"Cannot parse schema {schema}")
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/commands/scan_cache.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/commands/scan_cache.py
deleted file mode 100644
index ff26fa9de50f607ca78a24c5041010b4d629c148..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/huggingface_hub/commands/scan_cache.py
+++ /dev/null
@@ -1,138 +0,0 @@
-# coding=utf-8
-# Copyright 2022-present, the HuggingFace Inc. team.
-#
-# 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.
-"""Contains command to scan the HF cache directory.
-
-Usage:
- huggingface-cli scan-cache
- huggingface-cli scan-cache -v
- huggingface-cli scan-cache -vvv
- huggingface-cli scan-cache --dir ~/.cache/huggingface/hub
-"""
-import time
-from argparse import _SubParsersAction
-from typing import Optional
-
-from ..utils import CacheNotFound, HFCacheInfo, scan_cache_dir
-from . import BaseHuggingfaceCLICommand
-from ._cli_utils import ANSI, tabulate
-
-
-class ScanCacheCommand(BaseHuggingfaceCLICommand):
- @staticmethod
- def register_subcommand(parser: _SubParsersAction):
- scan_cache_parser = parser.add_parser("scan-cache", help="Scan cache directory.")
-
- scan_cache_parser.add_argument(
- "--dir",
- type=str,
- default=None,
- help="cache directory to scan (optional). Default to the default HuggingFace cache.",
- )
- scan_cache_parser.add_argument(
- "-v",
- "--verbose",
- action="count",
- default=0,
- help="show a more verbose output",
- )
- scan_cache_parser.set_defaults(func=ScanCacheCommand)
-
- def __init__(self, args):
- self.verbosity: int = args.verbose
- self.cache_dir: Optional[str] = args.dir
-
- def run(self):
- try:
- t0 = time.time()
- hf_cache_info = scan_cache_dir(self.cache_dir)
- t1 = time.time()
- except CacheNotFound as exc:
- cache_dir = exc.cache_dir
- print(f"Cache directory not found: {cache_dir}")
- return
-
- self._print_hf_cache_info_as_table(hf_cache_info)
-
- print(
- f"\nDone in {round(t1-t0,1)}s. Scanned {len(hf_cache_info.repos)} repo(s)"
- f" for a total of {ANSI.red(hf_cache_info.size_on_disk_str)}."
- )
- if len(hf_cache_info.warnings) > 0:
- message = f"Got {len(hf_cache_info.warnings)} warning(s) while scanning."
- if self.verbosity >= 3:
- print(ANSI.gray(message))
- for warning in hf_cache_info.warnings:
- print(ANSI.gray(warning))
- else:
- print(ANSI.gray(message + " Use -vvv to print details."))
-
- def _print_hf_cache_info_as_table(self, hf_cache_info: HFCacheInfo) -> None:
- if self.verbosity == 0:
- print(
- tabulate(
- rows=[
- [
- repo.repo_id,
- repo.repo_type,
- "{:>12}".format(repo.size_on_disk_str),
- repo.nb_files,
- repo.last_accessed_str,
- repo.last_modified_str,
- ", ".join(sorted(repo.refs)),
- str(repo.repo_path),
- ]
- for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
- ],
- headers=[
- "REPO ID",
- "REPO TYPE",
- "SIZE ON DISK",
- "NB FILES",
- "LAST_ACCESSED",
- "LAST_MODIFIED",
- "REFS",
- "LOCAL PATH",
- ],
- )
- )
- else:
- print(
- tabulate(
- rows=[
- [
- repo.repo_id,
- repo.repo_type,
- revision.commit_hash,
- "{:>12}".format(revision.size_on_disk_str),
- revision.nb_files,
- revision.last_modified_str,
- ", ".join(sorted(revision.refs)),
- str(revision.snapshot_path),
- ]
- for repo in sorted(hf_cache_info.repos, key=lambda repo: repo.repo_path)
- for revision in sorted(repo.revisions, key=lambda revision: revision.commit_hash)
- ],
- headers=[
- "REPO ID",
- "REPO TYPE",
- "REVISION",
- "SIZE ON DISK",
- "NB FILES",
- "LAST_MODIFIED",
- "REFS",
- "LOCAL PATH",
- ],
- )
- )
diff --git a/spaces/derek-thomas/RAGDemo/backend/semantic_search.py b/spaces/derek-thomas/RAGDemo/backend/semantic_search.py
deleted file mode 100644
index 653cf44d4d345fe165b229babaec744cf774d476..0000000000000000000000000000000000000000
--- a/spaces/derek-thomas/RAGDemo/backend/semantic_search.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import time
-import logging
-from qdrant_haystack import QdrantDocumentStore
-from haystack.nodes import EmbeddingRetriever
-from pathlib import Path
-
-# Setting up the logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Start the timer for loading the QdrantDocumentStore
-start_time = time.perf_counter()
-
-proj_dir = Path(__file__).parents[1]
-qd_document_store = QdrantDocumentStore(path=str(proj_dir/'Qdrant'), index='RAGDemo')
-
-# Log the time taken to load the QdrantDocumentStore
-document_store_loading_time = time.perf_counter() - start_time
-logger.info(f"Time taken to load QdrantDocumentStore: {document_store_loading_time:.6f} seconds")
-
-# Start the timer for loading the EmbeddingRetriever
-start_time = time.perf_counter()
-
-qd_retriever = EmbeddingRetriever(document_store=qd_document_store,
- embedding_model="BAAI/bge-base-en-v1.5",
- model_format="sentence_transformers",
- use_gpu=False)
-
-# Log the time taken to load the EmbeddingRetriever
-retriever_loading_time = time.perf_counter() - start_time
-logger.info(f"Time taken to load EmbeddingRetriever: {retriever_loading_time:.6f} seconds")
diff --git a/spaces/dhof/shapetest/README.md b/spaces/dhof/shapetest/README.md
deleted file mode 100644
index 28c652015c6a0211f7d9edebd73b9131214eec98..0000000000000000000000000000000000000000
--- a/spaces/dhof/shapetest/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Shap-E
-emoji: 🧢
-colorFrom: yellow
-colorTo: blue
-sdk: gradio
-sdk_version: 3.28.3
-python_version: 3.10.11
-app_file: app.py
-pinned: false
-license: mit
-duplicated_from: hysts/Shap-E
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/diacanFperku/AutoGPT/Easeus Partition Master Key 13.8 Technician Portable BETTER.md b/spaces/diacanFperku/AutoGPT/Easeus Partition Master Key 13.8 Technician Portable BETTER.md
deleted file mode 100644
index 406b9c6c76958e8d3d869b68ba320828f8d96e8c..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Easeus Partition Master Key 13.8 Technician Portable BETTER.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Easeus partition master key 13.8 Technician Portable Download File 🔗 https://gohhs.com/2uFVrA
diff --git a/spaces/diacanFperku/AutoGPT/Interviu Olvido Hormigos Pdf 131.md b/spaces/diacanFperku/AutoGPT/Interviu Olvido Hormigos Pdf 131.md
deleted file mode 100644
index 86b7f7733b03a34e7a2ece21bc6e4a269838cb88..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Interviu Olvido Hormigos Pdf 131.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Interviu Olvido Hormigos Pdf 131 DOWNLOAD ✒ ✒ ✒ https://gohhs.com/2uFUaX
diff --git a/spaces/diacanFperku/AutoGPT/Magix Video Pro X5 Keygen Download BEST.md b/spaces/diacanFperku/AutoGPT/Magix Video Pro X5 Keygen Download BEST.md
deleted file mode 100644
index cda70b50d303e0b8e40fa3e0ed26f326282dde60..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Magix Video Pro X5 Keygen Download BEST.md
+++ /dev/null
@@ -1,22 +0,0 @@
-Magix Video Pro X5 Keygen Download Download File ››››› https://gohhs.com/2uFTlC
diff --git a/spaces/diagaiwei/ir_chinese_medqa/colbert/trainer.py b/spaces/diagaiwei/ir_chinese_medqa/colbert/trainer.py
deleted file mode 100644
index 0b0ac566577c016ff1dade2a90266764c1c6dafe..0000000000000000000000000000000000000000
--- a/spaces/diagaiwei/ir_chinese_medqa/colbert/trainer.py
+++ /dev/null
@@ -1,36 +0,0 @@
-from colbert.infra.run import Run
-from colbert.infra.launcher import Launcher
-from colbert.infra.config import ColBERTConfig, RunConfig
-
-from colbert.training.training import train
-
-
-class Trainer:
- def __init__(self, triples, queries, collection, config=None):
- self.config = ColBERTConfig.from_existing(config, Run().config)
-
- self.triples = triples
- self.queries = queries
- self.collection = collection
-
- def configure(self, **kw_args):
- self.config.configure(**kw_args)
-
- def train(self, checkpoint='bert-base-uncased'):
- """
- Note that config.checkpoint is ignored. Only the supplied checkpoint here is used.
- """
-
- # Resources don't come from the config object. They come from the input parameters.
- # TODO: After the API stabilizes, make this "self.config.assign()" to emphasize this distinction.
- self.configure(triples=self.triples, queries=self.queries, collection=self.collection)
- self.configure(checkpoint=checkpoint)
-
- launcher = Launcher(train)
-
- self._best_checkpoint_path = launcher.launch(self.config, self.triples, self.queries, self.collection)
-
-
- def best_checkpoint_path(self):
- return self._best_checkpoint_path
-
diff --git a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/sampling_result.py b/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/sampling_result.py
deleted file mode 100644
index 419a8e39a3c307a7cd9cfd0565a20037ded0d646..0000000000000000000000000000000000000000
--- a/spaces/dineshreddy/WALT/mmdet/core/bbox/samplers/sampling_result.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import torch
-
-from mmdet.utils import util_mixins
-
-
-class SamplingResult(util_mixins.NiceRepr):
- """Bbox sampling result.
-
- Example:
- >>> # xdoctest: +IGNORE_WANT
- >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA
- >>> self = SamplingResult.random(rng=10)
- >>> print(f'self = {self}')
- self =
- """
-
- def __init__(self, pos_inds, neg_inds, bboxes, gt_bboxes, assign_result,
- gt_flags):
- self.pos_inds = pos_inds
- self.neg_inds = neg_inds
- self.pos_bboxes = bboxes[pos_inds]
- self.neg_bboxes = bboxes[neg_inds]
- self.pos_is_gt = gt_flags[pos_inds]
-
- self.num_gts = gt_bboxes.shape[0]
- self.pos_assigned_gt_inds = assign_result.gt_inds[pos_inds] - 1
-
- if gt_bboxes.numel() == 0:
- # hack for index error case
- assert self.pos_assigned_gt_inds.numel() == 0
- self.pos_gt_bboxes = torch.empty_like(gt_bboxes).view(-1, 4)
- else:
- if len(gt_bboxes.shape) < 2:
- gt_bboxes = gt_bboxes.view(-1, 4)
-
- self.pos_gt_bboxes = gt_bboxes[self.pos_assigned_gt_inds, :]
-
- if assign_result.labels is not None:
- self.pos_gt_labels = assign_result.labels[pos_inds]
- else:
- self.pos_gt_labels = None
-
- @property
- def bboxes(self):
- """torch.Tensor: concatenated positive and negative boxes"""
- return torch.cat([self.pos_bboxes, self.neg_bboxes])
-
- def to(self, device):
- """Change the device of the data inplace.
-
- Example:
- >>> self = SamplingResult.random()
- >>> print(f'self = {self.to(None)}')
- >>> # xdoctest: +REQUIRES(--gpu)
- >>> print(f'self = {self.to(0)}')
- """
- _dict = self.__dict__
- for key, value in _dict.items():
- if isinstance(value, torch.Tensor):
- _dict[key] = value.to(device)
- return self
-
- def __nice__(self):
- data = self.info.copy()
- data['pos_bboxes'] = data.pop('pos_bboxes').shape
- data['neg_bboxes'] = data.pop('neg_bboxes').shape
- parts = [f"'{k}': {v!r}" for k, v in sorted(data.items())]
- body = ' ' + ',\n '.join(parts)
- return '{\n' + body + '\n}'
-
- @property
- def info(self):
- """Returns a dictionary of info about the object."""
- return {
- 'pos_inds': self.pos_inds,
- 'neg_inds': self.neg_inds,
- 'pos_bboxes': self.pos_bboxes,
- 'neg_bboxes': self.neg_bboxes,
- 'pos_is_gt': self.pos_is_gt,
- 'num_gts': self.num_gts,
- 'pos_assigned_gt_inds': self.pos_assigned_gt_inds,
- }
-
- @classmethod
- def random(cls, rng=None, **kwargs):
- """
- Args:
- rng (None | int | numpy.random.RandomState): seed or state.
- kwargs (keyword arguments):
- - num_preds: number of predicted boxes
- - num_gts: number of true boxes
- - p_ignore (float): probability of a predicted box assinged to \
- an ignored truth.
- - p_assigned (float): probability of a predicted box not being \
- assigned.
- - p_use_label (float | bool): with labels or not.
-
- Returns:
- :obj:`SamplingResult`: Randomly generated sampling result.
-
- Example:
- >>> from mmdet.core.bbox.samplers.sampling_result import * # NOQA
- >>> self = SamplingResult.random()
- >>> print(self.__dict__)
- """
- from mmdet.core.bbox.samplers.random_sampler import RandomSampler
- from mmdet.core.bbox.assigners.assign_result import AssignResult
- from mmdet.core.bbox import demodata
- rng = demodata.ensure_rng(rng)
-
- # make probabalistic?
- num = 32
- pos_fraction = 0.5
- neg_pos_ub = -1
-
- assign_result = AssignResult.random(rng=rng, **kwargs)
-
- # Note we could just compute an assignment
- bboxes = demodata.random_boxes(assign_result.num_preds, rng=rng)
- gt_bboxes = demodata.random_boxes(assign_result.num_gts, rng=rng)
-
- if rng.rand() > 0.2:
- # sometimes algorithms squeeze their data, be robust to that
- gt_bboxes = gt_bboxes.squeeze()
- bboxes = bboxes.squeeze()
-
- if assign_result.labels is None:
- gt_labels = None
- else:
- gt_labels = None # todo
-
- if gt_labels is None:
- add_gt_as_proposals = False
- else:
- add_gt_as_proposals = True # make probabalistic?
-
- sampler = RandomSampler(
- num,
- pos_fraction,
- neg_pos_ub=neg_pos_ub,
- add_gt_as_proposals=add_gt_as_proposals,
- rng=rng)
- self = sampler.sample(assign_result, bboxes, gt_bboxes, gt_labels)
- return self
diff --git a/spaces/dineshreddy/WALT/mmdet/models/backbones/hrnet.py b/spaces/dineshreddy/WALT/mmdet/models/backbones/hrnet.py
deleted file mode 100644
index c0fd0a974192231506aa68b1e1719f618b78a1b3..0000000000000000000000000000000000000000
--- a/spaces/dineshreddy/WALT/mmdet/models/backbones/hrnet.py
+++ /dev/null
@@ -1,537 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import (build_conv_layer, build_norm_layer, constant_init,
- kaiming_init)
-from mmcv.runner import load_checkpoint
-from torch.nn.modules.batchnorm import _BatchNorm
-
-from mmdet.utils import get_root_logger
-from ..builder import BACKBONES
-from .resnet import BasicBlock, Bottleneck
-
-
-class HRModule(nn.Module):
- """High-Resolution Module for HRNet.
-
- In this module, every branch has 4 BasicBlocks/Bottlenecks. Fusion/Exchange
- is in this module.
- """
-
- def __init__(self,
- num_branches,
- blocks,
- num_blocks,
- in_channels,
- num_channels,
- multiscale_output=True,
- with_cp=False,
- conv_cfg=None,
- norm_cfg=dict(type='BN')):
- super(HRModule, self).__init__()
- self._check_branches(num_branches, num_blocks, in_channels,
- num_channels)
-
- self.in_channels = in_channels
- self.num_branches = num_branches
-
- self.multiscale_output = multiscale_output
- self.norm_cfg = norm_cfg
- self.conv_cfg = conv_cfg
- self.with_cp = with_cp
- self.branches = self._make_branches(num_branches, blocks, num_blocks,
- num_channels)
- self.fuse_layers = self._make_fuse_layers()
- self.relu = nn.ReLU(inplace=False)
-
- def _check_branches(self, num_branches, num_blocks, in_channels,
- num_channels):
- if num_branches != len(num_blocks):
- error_msg = f'NUM_BRANCHES({num_branches}) ' \
- f'!= NUM_BLOCKS({len(num_blocks)})'
- raise ValueError(error_msg)
-
- if num_branches != len(num_channels):
- error_msg = f'NUM_BRANCHES({num_branches}) ' \
- f'!= NUM_CHANNELS({len(num_channels)})'
- raise ValueError(error_msg)
-
- if num_branches != len(in_channels):
- error_msg = f'NUM_BRANCHES({num_branches}) ' \
- f'!= NUM_INCHANNELS({len(in_channels)})'
- raise ValueError(error_msg)
-
- def _make_one_branch(self,
- branch_index,
- block,
- num_blocks,
- num_channels,
- stride=1):
- downsample = None
- if stride != 1 or \
- self.in_channels[branch_index] != \
- num_channels[branch_index] * block.expansion:
- downsample = nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- self.in_channels[branch_index],
- num_channels[branch_index] * block.expansion,
- kernel_size=1,
- stride=stride,
- bias=False),
- build_norm_layer(self.norm_cfg, num_channels[branch_index] *
- block.expansion)[1])
-
- layers = []
- layers.append(
- block(
- self.in_channels[branch_index],
- num_channels[branch_index],
- stride,
- downsample=downsample,
- with_cp=self.with_cp,
- norm_cfg=self.norm_cfg,
- conv_cfg=self.conv_cfg))
- self.in_channels[branch_index] = \
- num_channels[branch_index] * block.expansion
- for i in range(1, num_blocks[branch_index]):
- layers.append(
- block(
- self.in_channels[branch_index],
- num_channels[branch_index],
- with_cp=self.with_cp,
- norm_cfg=self.norm_cfg,
- conv_cfg=self.conv_cfg))
-
- return nn.Sequential(*layers)
-
- def _make_branches(self, num_branches, block, num_blocks, num_channels):
- branches = []
-
- for i in range(num_branches):
- branches.append(
- self._make_one_branch(i, block, num_blocks, num_channels))
-
- return nn.ModuleList(branches)
-
- def _make_fuse_layers(self):
- if self.num_branches == 1:
- return None
-
- num_branches = self.num_branches
- in_channels = self.in_channels
- fuse_layers = []
- num_out_branches = num_branches if self.multiscale_output else 1
- for i in range(num_out_branches):
- fuse_layer = []
- for j in range(num_branches):
- if j > i:
- fuse_layer.append(
- nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- in_channels[j],
- in_channels[i],
- kernel_size=1,
- stride=1,
- padding=0,
- bias=False),
- build_norm_layer(self.norm_cfg, in_channels[i])[1],
- nn.Upsample(
- scale_factor=2**(j - i), mode='nearest')))
- elif j == i:
- fuse_layer.append(None)
- else:
- conv_downsamples = []
- for k in range(i - j):
- if k == i - j - 1:
- conv_downsamples.append(
- nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- in_channels[j],
- in_channels[i],
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg,
- in_channels[i])[1]))
- else:
- conv_downsamples.append(
- nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- in_channels[j],
- in_channels[j],
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg,
- in_channels[j])[1],
- nn.ReLU(inplace=False)))
- fuse_layer.append(nn.Sequential(*conv_downsamples))
- fuse_layers.append(nn.ModuleList(fuse_layer))
-
- return nn.ModuleList(fuse_layers)
-
- def forward(self, x):
- """Forward function."""
- if self.num_branches == 1:
- return [self.branches[0](x[0])]
-
- for i in range(self.num_branches):
- x[i] = self.branches[i](x[i])
-
- x_fuse = []
- for i in range(len(self.fuse_layers)):
- y = 0
- for j in range(self.num_branches):
- if i == j:
- y += x[j]
- else:
- y += self.fuse_layers[i][j](x[j])
- x_fuse.append(self.relu(y))
- return x_fuse
-
-
-@BACKBONES.register_module()
-class HRNet(nn.Module):
- """HRNet backbone.
-
- High-Resolution Representations for Labeling Pixels and Regions
- arXiv: https://arxiv.org/abs/1904.04514
-
- Args:
- extra (dict): detailed configuration for each stage of HRNet.
- in_channels (int): Number of input image channels. Default: 3.
- conv_cfg (dict): dictionary to construct and config conv layer.
- norm_cfg (dict): dictionary to construct and config norm layer.
- norm_eval (bool): Whether to set norm layers to eval mode, namely,
- freeze running stats (mean and var). Note: Effect on Batch Norm
- and its variants only.
- with_cp (bool): Use checkpoint or not. Using checkpoint will save some
- memory while slowing down the training speed.
- zero_init_residual (bool): whether to use zero init for last norm layer
- in resblocks to let them behave as identity.
-
- Example:
- >>> from mmdet.models import HRNet
- >>> import torch
- >>> extra = dict(
- >>> stage1=dict(
- >>> num_modules=1,
- >>> num_branches=1,
- >>> block='BOTTLENECK',
- >>> num_blocks=(4, ),
- >>> num_channels=(64, )),
- >>> stage2=dict(
- >>> num_modules=1,
- >>> num_branches=2,
- >>> block='BASIC',
- >>> num_blocks=(4, 4),
- >>> num_channels=(32, 64)),
- >>> stage3=dict(
- >>> num_modules=4,
- >>> num_branches=3,
- >>> block='BASIC',
- >>> num_blocks=(4, 4, 4),
- >>> num_channels=(32, 64, 128)),
- >>> stage4=dict(
- >>> num_modules=3,
- >>> num_branches=4,
- >>> block='BASIC',
- >>> num_blocks=(4, 4, 4, 4),
- >>> num_channels=(32, 64, 128, 256)))
- >>> self = HRNet(extra, in_channels=1)
- >>> self.eval()
- >>> inputs = torch.rand(1, 1, 32, 32)
- >>> level_outputs = self.forward(inputs)
- >>> for level_out in level_outputs:
- ... print(tuple(level_out.shape))
- (1, 32, 8, 8)
- (1, 64, 4, 4)
- (1, 128, 2, 2)
- (1, 256, 1, 1)
- """
-
- blocks_dict = {'BASIC': BasicBlock, 'BOTTLENECK': Bottleneck}
-
- def __init__(self,
- extra,
- in_channels=3,
- conv_cfg=None,
- norm_cfg=dict(type='BN'),
- norm_eval=True,
- with_cp=False,
- zero_init_residual=False):
- super(HRNet, self).__init__()
- self.extra = extra
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- self.norm_eval = norm_eval
- self.with_cp = with_cp
- self.zero_init_residual = zero_init_residual
-
- # stem net
- self.norm1_name, norm1 = build_norm_layer(self.norm_cfg, 64, postfix=1)
- self.norm2_name, norm2 = build_norm_layer(self.norm_cfg, 64, postfix=2)
-
- self.conv1 = build_conv_layer(
- self.conv_cfg,
- in_channels,
- 64,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False)
-
- self.add_module(self.norm1_name, norm1)
- self.conv2 = build_conv_layer(
- self.conv_cfg,
- 64,
- 64,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False)
-
- self.add_module(self.norm2_name, norm2)
- self.relu = nn.ReLU(inplace=True)
-
- # stage 1
- self.stage1_cfg = self.extra['stage1']
- num_channels = self.stage1_cfg['num_channels'][0]
- block_type = self.stage1_cfg['block']
- num_blocks = self.stage1_cfg['num_blocks'][0]
-
- block = self.blocks_dict[block_type]
- stage1_out_channels = num_channels * block.expansion
- self.layer1 = self._make_layer(block, 64, num_channels, num_blocks)
-
- # stage 2
- self.stage2_cfg = self.extra['stage2']
- num_channels = self.stage2_cfg['num_channels']
- block_type = self.stage2_cfg['block']
-
- block = self.blocks_dict[block_type]
- num_channels = [channel * block.expansion for channel in num_channels]
- self.transition1 = self._make_transition_layer([stage1_out_channels],
- num_channels)
- self.stage2, pre_stage_channels = self._make_stage(
- self.stage2_cfg, num_channels)
-
- # stage 3
- self.stage3_cfg = self.extra['stage3']
- num_channels = self.stage3_cfg['num_channels']
- block_type = self.stage3_cfg['block']
-
- block = self.blocks_dict[block_type]
- num_channels = [channel * block.expansion for channel in num_channels]
- self.transition2 = self._make_transition_layer(pre_stage_channels,
- num_channels)
- self.stage3, pre_stage_channels = self._make_stage(
- self.stage3_cfg, num_channels)
-
- # stage 4
- self.stage4_cfg = self.extra['stage4']
- num_channels = self.stage4_cfg['num_channels']
- block_type = self.stage4_cfg['block']
-
- block = self.blocks_dict[block_type]
- num_channels = [channel * block.expansion for channel in num_channels]
- self.transition3 = self._make_transition_layer(pre_stage_channels,
- num_channels)
- self.stage4, pre_stage_channels = self._make_stage(
- self.stage4_cfg, num_channels)
-
- @property
- def norm1(self):
- """nn.Module: the normalization layer named "norm1" """
- return getattr(self, self.norm1_name)
-
- @property
- def norm2(self):
- """nn.Module: the normalization layer named "norm2" """
- return getattr(self, self.norm2_name)
-
- def _make_transition_layer(self, num_channels_pre_layer,
- num_channels_cur_layer):
- num_branches_cur = len(num_channels_cur_layer)
- num_branches_pre = len(num_channels_pre_layer)
-
- transition_layers = []
- for i in range(num_branches_cur):
- if i < num_branches_pre:
- if num_channels_cur_layer[i] != num_channels_pre_layer[i]:
- transition_layers.append(
- nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- num_channels_pre_layer[i],
- num_channels_cur_layer[i],
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg,
- num_channels_cur_layer[i])[1],
- nn.ReLU(inplace=True)))
- else:
- transition_layers.append(None)
- else:
- conv_downsamples = []
- for j in range(i + 1 - num_branches_pre):
- in_channels = num_channels_pre_layer[-1]
- out_channels = num_channels_cur_layer[i] \
- if j == i - num_branches_pre else in_channels
- conv_downsamples.append(
- nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- in_channels,
- out_channels,
- kernel_size=3,
- stride=2,
- padding=1,
- bias=False),
- build_norm_layer(self.norm_cfg, out_channels)[1],
- nn.ReLU(inplace=True)))
- transition_layers.append(nn.Sequential(*conv_downsamples))
-
- return nn.ModuleList(transition_layers)
-
- def _make_layer(self, block, inplanes, planes, blocks, stride=1):
- downsample = None
- if stride != 1 or inplanes != planes * block.expansion:
- downsample = nn.Sequential(
- build_conv_layer(
- self.conv_cfg,
- inplanes,
- planes * block.expansion,
- kernel_size=1,
- stride=stride,
- bias=False),
- build_norm_layer(self.norm_cfg, planes * block.expansion)[1])
-
- layers = []
- layers.append(
- block(
- inplanes,
- planes,
- stride,
- downsample=downsample,
- with_cp=self.with_cp,
- norm_cfg=self.norm_cfg,
- conv_cfg=self.conv_cfg))
- inplanes = planes * block.expansion
- for i in range(1, blocks):
- layers.append(
- block(
- inplanes,
- planes,
- with_cp=self.with_cp,
- norm_cfg=self.norm_cfg,
- conv_cfg=self.conv_cfg))
-
- return nn.Sequential(*layers)
-
- def _make_stage(self, layer_config, in_channels, multiscale_output=True):
- num_modules = layer_config['num_modules']
- num_branches = layer_config['num_branches']
- num_blocks = layer_config['num_blocks']
- num_channels = layer_config['num_channels']
- block = self.blocks_dict[layer_config['block']]
-
- hr_modules = []
- for i in range(num_modules):
- # multi_scale_output is only used for the last module
- if not multiscale_output and i == num_modules - 1:
- reset_multiscale_output = False
- else:
- reset_multiscale_output = True
-
- hr_modules.append(
- HRModule(
- num_branches,
- block,
- num_blocks,
- in_channels,
- num_channels,
- reset_multiscale_output,
- with_cp=self.with_cp,
- norm_cfg=self.norm_cfg,
- conv_cfg=self.conv_cfg))
-
- return nn.Sequential(*hr_modules), in_channels
-
- def init_weights(self, pretrained=None):
- """Initialize the weights in backbone.
-
- Args:
- pretrained (str, optional): Path to pre-trained weights.
- Defaults to None.
- """
- if isinstance(pretrained, str):
- logger = get_root_logger()
- load_checkpoint(self, pretrained, strict=False, logger=logger)
- elif pretrained is None:
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- kaiming_init(m)
- elif isinstance(m, (_BatchNorm, nn.GroupNorm)):
- constant_init(m, 1)
-
- if self.zero_init_residual:
- for m in self.modules():
- if isinstance(m, Bottleneck):
- constant_init(m.norm3, 0)
- elif isinstance(m, BasicBlock):
- constant_init(m.norm2, 0)
- else:
- raise TypeError('pretrained must be a str or None')
-
- def forward(self, x):
- """Forward function."""
- x = self.conv1(x)
- x = self.norm1(x)
- x = self.relu(x)
- x = self.conv2(x)
- x = self.norm2(x)
- x = self.relu(x)
- x = self.layer1(x)
-
- x_list = []
- for i in range(self.stage2_cfg['num_branches']):
- if self.transition1[i] is not None:
- x_list.append(self.transition1[i](x))
- else:
- x_list.append(x)
- y_list = self.stage2(x_list)
-
- x_list = []
- for i in range(self.stage3_cfg['num_branches']):
- if self.transition2[i] is not None:
- x_list.append(self.transition2[i](y_list[-1]))
- else:
- x_list.append(y_list[i])
- y_list = self.stage3(x_list)
-
- x_list = []
- for i in range(self.stage4_cfg['num_branches']):
- if self.transition3[i] is not None:
- x_list.append(self.transition3[i](y_list[-1]))
- else:
- x_list.append(y_list[i])
- y_list = self.stage4(x_list)
-
- return y_list
-
- def train(self, mode=True):
- """Convert the model into training mode will keeping the normalization
- layer freezed."""
- super(HRNet, self).train(mode)
- if mode and self.norm_eval:
- for m in self.modules():
- # trick: eval have effect on BatchNorm only
- if isinstance(m, _BatchNorm):
- m.eval()
diff --git a/spaces/dinhminh20521597/OCR_DEMO/configs/_base_/det_pipelines/panet_pipeline.py b/spaces/dinhminh20521597/OCR_DEMO/configs/_base_/det_pipelines/panet_pipeline.py
deleted file mode 100644
index eae50de4fab0536d114509854f9250c0d613cb3c..0000000000000000000000000000000000000000
--- a/spaces/dinhminh20521597/OCR_DEMO/configs/_base_/det_pipelines/panet_pipeline.py
+++ /dev/null
@@ -1,156 +0,0 @@
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-
-# for ctw1500
-img_scale_train_ctw1500 = [(3000, 640)]
-shrink_ratio_train_ctw1500 = (1.0, 0.7)
-target_size_train_ctw1500 = (640, 640)
-train_pipeline_ctw1500 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='LoadTextAnnotations',
- with_bbox=True,
- with_mask=True,
- poly2mask=False),
- dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(
- type='ScaleAspectJitter',
- img_scale=img_scale_train_ctw1500,
- ratio_range=(0.7, 1.3),
- aspect_ratio_range=(0.9, 1.1),
- multiscale_mode='value',
- keep_ratio=False),
- # shrink_ratio is from big to small. The 1st must be 1.0
- dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_ctw1500),
- dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
- dict(type='RandomRotateTextDet'),
- dict(
- type='RandomCropInstances',
- target_size=target_size_train_ctw1500,
- instance_key='gt_kernels'),
- dict(type='Pad', size_divisor=32),
- dict(
- type='CustomFormatBundle',
- keys=['gt_kernels', 'gt_mask'],
- visualize=dict(flag=False, boundary_key='gt_kernels')),
- dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
-]
-
-img_scale_test_ctw1500 = (3000, 640)
-test_pipeline_ctw1500 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale_test_ctw1500, # used by Resize
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-
-# for icdar2015
-img_scale_train_icdar2015 = [(3000, 736)]
-shrink_ratio_train_icdar2015 = (1.0, 0.5)
-target_size_train_icdar2015 = (736, 736)
-train_pipeline_icdar2015 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='LoadTextAnnotations',
- with_bbox=True,
- with_mask=True,
- poly2mask=False),
- dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(
- type='ScaleAspectJitter',
- img_scale=img_scale_train_icdar2015,
- ratio_range=(0.7, 1.3),
- aspect_ratio_range=(0.9, 1.1),
- multiscale_mode='value',
- keep_ratio=False),
- dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_icdar2015),
- dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
- dict(type='RandomRotateTextDet'),
- dict(
- type='RandomCropInstances',
- target_size=target_size_train_icdar2015,
- instance_key='gt_kernels'),
- dict(type='Pad', size_divisor=32),
- dict(
- type='CustomFormatBundle',
- keys=['gt_kernels', 'gt_mask'],
- visualize=dict(flag=False, boundary_key='gt_kernels')),
- dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
-]
-
-img_scale_test_icdar2015 = (1333, 736)
-test_pipeline_icdar2015 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale_test_icdar2015, # used by Resize
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-
-# for icdar2017
-img_scale_train_icdar2017 = [(3000, 800)]
-shrink_ratio_train_icdar2017 = (1.0, 0.5)
-target_size_train_icdar2017 = (800, 800)
-train_pipeline_icdar2017 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='LoadTextAnnotations',
- with_bbox=True,
- with_mask=True,
- poly2mask=False),
- dict(type='ColorJitter', brightness=32.0 / 255, saturation=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(
- type='ScaleAspectJitter',
- img_scale=img_scale_train_icdar2017,
- ratio_range=(0.7, 1.3),
- aspect_ratio_range=(0.9, 1.1),
- multiscale_mode='value',
- keep_ratio=False),
- dict(type='PANetTargets', shrink_ratio=shrink_ratio_train_icdar2017),
- dict(type='RandomFlip', flip_ratio=0.5, direction='horizontal'),
- dict(type='RandomRotateTextDet'),
- dict(
- type='RandomCropInstances',
- target_size=target_size_train_icdar2017,
- instance_key='gt_kernels'),
- dict(type='Pad', size_divisor=32),
- dict(
- type='CustomFormatBundle',
- keys=['gt_kernels', 'gt_mask'],
- visualize=dict(flag=False, boundary_key='gt_kernels')),
- dict(type='Collect', keys=['img', 'gt_kernels', 'gt_mask'])
-]
-
-img_scale_test_icdar2017 = (1333, 800)
-test_pipeline_icdar2017 = [
- dict(type='LoadImageFromFile', color_type='color_ignore_orientation'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale_test_icdar2017, # used by Resize
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
diff --git a/spaces/dirge/voicevox/speaker_info/7ffcb7ce-00ec-4bdc-82cd-45a8889e43ff/policy.md b/spaces/dirge/voicevox/speaker_info/7ffcb7ce-00ec-4bdc-82cd-45a8889e43ff/policy.md
deleted file mode 100644
index c9bcc2cea42f727c8e43c934fc38163144848882..0000000000000000000000000000000000000000
--- a/spaces/dirge/voicevox/speaker_info/7ffcb7ce-00ec-4bdc-82cd-45a8889e43ff/policy.md
+++ /dev/null
@@ -1,3 +0,0 @@
-dummy1 policy
-
-https://voicevox.hiroshiba.jp/
diff --git a/spaces/dmeck/RVC-Speakers/speakers/server/__init__.py b/spaces/dmeck/RVC-Speakers/speakers/server/__init__.py
deleted file mode 100644
index 0591109378f8c017c4a65acab9f496dfb28454c0..0000000000000000000000000000000000000000
--- a/spaces/dmeck/RVC-Speakers/speakers/server/__init__.py
+++ /dev/null
@@ -1,109 +0,0 @@
-from speakers.common.registry import registry
-from speakers.server.bootstrap.bootstrap_register import load_bootstrap, get_bootstrap
-
-from omegaconf import OmegaConf
-
-from speakers.common.utils import get_abs_path
-from oscrypto import util as crypto_utils
-
-import asyncio
-import time
-import os
-import sys
-import traceback
-
-import subprocess
-
-root_dir = os.path.dirname(os.path.abspath(__file__))
-registry.register_path("server_library_root", root_dir)
-# Time to wait for web client to send a request to /task-state request
-# before that web clients task gets removed from the queue
-WEB_CLIENT_TIMEOUT = -1
-# Time before finished tasks get removed from memory
-FINISHED_TASK_REMOVE_TIMEOUT = 1800
-
-
-def generate_nonce():
- return crypto_utils.rand_bytes(16).hex()
-
-
-def start_translator_client_proc(speakers_config_file: str, nonce: str = None):
- cmds = [
- sys.executable,
- '-m', 'speakers',
- '--mode', 'web_runner',
- '--speakers-config-file', speakers_config_file,
- '--nonce', nonce,
- ]
-
- proc = subprocess.Popen(cmds, cwd=f"{registry.get_path('library_root')}/../")
- return proc
-
-
-async def start_async_app(speakers_config_file: str, nonce: str = None):
- config = OmegaConf.load(get_abs_path(speakers_config_file))
- load_bootstrap(config=config.get("bootstrap"))
-
- runner_bootstrap_web = get_bootstrap("runner_bootstrap_web")
-
- runner_bootstrap_web.set_nonce(nonce=nonce)
- await runner_bootstrap_web.run()
- return runner_bootstrap_web
-
-
-async def dispatch(speakers_config_file: str, nonce: str = None):
-
- if nonce is None:
- nonce = os.getenv('MT_WEB_NONCE', generate_nonce())
-
- runner = await start_async_app(speakers_config_file=speakers_config_file, nonce=nonce)
- # Create client process
- print()
- client_process = start_translator_client_proc(speakers_config_file, nonce=nonce)
-
- try:
- while True:
- """任务队列状态维护"""
- await asyncio.sleep(1)
-
- # Restart client if OOM or similar errors occured
- if client_process.poll() is not None:
- print('Restarting translator process')
- if len(runner.ongoing_tasks) > 0:
- task_id = runner.ongoing_tasks.pop(0)
- state = runner.task_states[task_id]
- state['info'] = 'error'
- state['finished'] = True
- client_process = start_translator_client_proc(speakers_config_file=speakers_config_file)
-
- # Filter queued and finished tasks
- now = time.time()
- to_del_task_ids = set()
- for tid, s in runner.task_states.items():
- payload = runner.task_data[tid]
- # Remove finished tasks after 30 minutes
- if s['finished'] and now - payload.created_at > FINISHED_TASK_REMOVE_TIMEOUT:
- to_del_task_ids.add(tid)
-
- # Remove queued tasks without web client
- elif WEB_CLIENT_TIMEOUT >= 0:
- if tid not in runner.ongoing_tasks and not s['finished'] \
- and now - payload.requested_at > WEB_CLIENT_TIMEOUT:
- print('REMOVING TASK', tid)
- to_del_task_ids.add(tid)
- try:
- runner.queue.remove(tid)
- except Exception:
- pass
-
- for tid in to_del_task_ids:
- del runner.task_states[tid]
- del runner.task_data[tid]
-
- except:
- if client_process.poll() is None:
- # client_process.terminate()
- client_process.kill()
- await runner.destroy()
- traceback.print_exc()
- raise
diff --git a/spaces/duycse1603/math2tex/ScanSSD/layers/functions/detection.py b/spaces/duycse1603/math2tex/ScanSSD/layers/functions/detection.py
deleted file mode 100644
index 597aa7374786ec7400a76db3f3d8a5c46e92da5b..0000000000000000000000000000000000000000
--- a/spaces/duycse1603/math2tex/ScanSSD/layers/functions/detection.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import torch
-from torch.autograd import Function
-from ..box_utils import decode, nms
-
-class Detect(Function):
- """At test time, Detect is the final layer of SSD. Decode location preds,
- apply non-maximum suppression to location predictions based on conf
- scores and threshold to a top_k number of output predictions for both
- confidence score and locations.
- """
- def __init__(self, cfg, num_classes, bkg_label, top_k, conf_thresh, nms_thresh):
- self.num_classes = num_classes
- self.background_label = bkg_label
- self.top_k = top_k
- # Parameters used in nms.
- self.nms_thresh = nms_thresh
- if nms_thresh <= 0:
- raise ValueError('nms_threshold must be non negative.')
- self.conf_thresh = conf_thresh
- self.variance = cfg['variance']
-
- # @staticmethod
- def forward(self, loc_data, conf_data, prior_data):
- """
- Args:
- loc_data: (tensor) Loc preds from loc layers
- Shape: [batch,num_priors*4]
- conf_data: (tensor) Shape: Conf preds from conf layers
- Shape: [batch*num_priors,num_classes]
- prior_data: (tensor) Prior boxes and variances from priorbox layers
- Shape: [1,num_priors,4]
- """
- # move to CPU
- loc_data = loc_data.cpu()
- conf_data = conf_data.cpu()
- prior_data = prior_data.cpu()
-
- num = loc_data.size(0) # batch size
- num_priors = prior_data.size(0)
- output = torch.zeros(num, self.num_classes, self.top_k, 5)
- conf_preds = conf_data.view(num, num_priors,
- self.num_classes).transpose(2, 1)
-
- # Decode predictions into bboxes.
- for i in range(num):
- decoded_boxes = decode(loc_data[i], prior_data, self.variance)
- # For each class, perform nms
- conf_scores = conf_preds[i].clone()
- #print('decoded boxes ', decoded_boxes)
- #print('conf scores', conf_scores)
- for cl in range(1, self.num_classes):
- c_mask = conf_scores[cl].gt(self.conf_thresh)
- scores = conf_scores[cl][c_mask]
- if scores.dim() == 0:
- continue
- l_mask = c_mask.unsqueeze(1).expand_as(decoded_boxes)
- boxes = decoded_boxes[l_mask].view(-1, 4)
- # idx of highest scoring and non-overlapping boxes per class
-
- ids, count = nms(boxes, scores, self.nms_thresh, self.top_k)
- output[i, cl, :count] = \
- torch.cat((scores[ids[:count]].unsqueeze(1),
- boxes[ids[:count]]), 1)
- flt = output.contiguous().view(num, -1, 5)
- _, idx = flt[:, :, 0].sort(1, descending=True)
- _, rank = idx.sort(1)
- flt[(rank < self.top_k).unsqueeze(-1).expand_as(flt)].fill_(0)
- return output, boxes, scores
diff --git a/spaces/ecarbo/text-generator-gpt-neo/app.py b/spaces/ecarbo/text-generator-gpt-neo/app.py
deleted file mode 100644
index e13b7461fda47629406c9dba813bb7ae01e19493..0000000000000000000000000000000000000000
--- a/spaces/ecarbo/text-generator-gpt-neo/app.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForCausalLM
-import torch
-import gradio as gr
-
-tokenizer = AutoTokenizer.from_pretrained("EleutherAI/gpt-neo-1.3B")
-model = AutoModelForCausalLM.from_pretrained("EleutherAI/gpt-neo-1.3B")
-
-def text_generation(input_text, seed):
- input_ids = tokenizer(input_text, return_tensors="pt").input_ids
- torch.manual_seed(seed) # Max value: 18446744073709551615
- outputs = model.generate(input_ids, do_sample=True, min_length=50, max_length=200)
- generated_text = tokenizer.batch_decode(outputs, skip_special_tokens=True)
- return generated_text
-
-title = "Text Generator Demo GPT-Neo"
-description = "Text Generator Application by ecarbo"
-
-gr.Interface(
- text_generation,
- [gr.inputs.Textbox(lines=2, label="Enter input text"), gr.inputs.Number(default=10, label="Enter seed number")],
- [gr.outputs.Textbox(type="auto", label="Text Generated")],
- title=title,
- description=description,
- theme="huggingface"
-).launch()
\ No newline at end of file
diff --git a/spaces/editing-images/ai-halloween-photobooth/style.css b/spaces/editing-images/ai-halloween-photobooth/style.css
deleted file mode 100644
index 6c0d066f2b8e2f4234634daf7e6fa8b2b2c0fd2b..0000000000000000000000000000000000000000
--- a/spaces/editing-images/ai-halloween-photobooth/style.css
+++ /dev/null
@@ -1,153 +0,0 @@
-/*
-This CSS file is modified from:
-https://huggingface.co/spaces/DeepFloyd/IF/blob/main/style.css
-*/
-@import url('https://fonts.googleapis.com/css2?family=IBM+Plex+Sans:wght@400;700&display=swap');
-body gradio-app{
- background-image: url(https://i.imgur.com/gqXjjP0.jpg) !important;
- background-position: center -131px !important;
- background-size: 1480px !important;
- background-repeat: no-repeat !important;
- background-color: #000305 !important;
-}
-h1, h3 {
- text-align: center;
- font-family: 'IBM Plex Sans', sans-serif;
-}
-
-.gradio-container {
- font-family: 'IBM Plex Sans', sans-serif;
- padding-top: 0 !important;
- margin-top: -35px !important;
-}
-
-.gr-button {
- color: white;
- border-color: black;
- background: black;
-}
-
-input[type='range'] {
- accent-color: black;
-}
-
-.dark input[type='range'] {
- accent-color: #dfdfdf;
-}
-
-.container {
- max-width: 730px;
- margin: auto;
- padding-top: 1.5rem;
-}
-
-/*background-image: url("https://i.imgur.com/gqXjjP0.jpg");*/
-
-.gr-button:focus {
- border-color: rgb(147 197 253 / var(--tw-border-opacity));
- outline: none;
- box-shadow: var(--tw-ring-offset-shadow), var(--tw-ring-shadow), var(--tw-shadow, 0 0 #0000);
- --tw-border-opacity: 1;
- --tw-ring-offset-shadow: var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);
- --tw-ring-shadow: var(--tw-ring-inset) 0 0 0 calc(3px var(--tw-ring-offset-width)) var(--tw-ring-color);
- --tw-ring-color: rgb(191 219 254 / var(--tw-ring-opacity));
- --tw-ring-opacity: .5;
-}
-
-.gr-form {
- flex: 1 1 50%;
- border-top-right-radius: 0;
- border-bottom-right-radius: 0;
-}
-
-#prompt-container {
- gap: 0;
-}
-
-#prompt-text-input,
-#negative-prompt-text-input {
- padding: .45rem 0.625rem
-}
-
-/* #component-16 {
- border-top-width: 1px !important;
- margin-top: 1em
-} */
-
-.image_duplication {
- position: absolute;
- width: 100px;
- left: 50px
-}
-
-#component-0 {
- max-width: 1048px;
- margin: auto;
-}
-
-#share-btn-container {
- display: flex; padding-left: 0.5rem !important; padding-right: 0.5rem !important; background-color: #000000; justify-content: center; align-items: center; border-radius: 9999px !important; width: 13rem; margin-left: auto;
-}
-#share-btn {
- all: initial; color: #ffffff;font-weight: 600; cursor:pointer; font-family: 'IBM Plex Sans', sans-serif; margin-left: 0.5rem !important; padding-top: 0.25rem !important; padding-bottom: 0.25rem !important;
-}
-#share-btn * {
- all: unset;
-}
-#share-btn-container div:nth-child(-n+2){
- width: auto !important;
- min-height: 0px !important;
-}
-#share-btn-container .wrap {
- display: none !important;
-}
-#lora_image button{
-height: 126px; width: 100%
-}
-h3, h4{margin-top: 0 !important}
-#input_image img, #output_image img, #lora_image img{
- object-fit: cover
-}
-.output_column_reverse{
- flex-direction: column-reverse !important;
-}
-#total_box{
- background-color: rgba(0, 0, 0, 0.5);
- backdrop-filter: blur(5px);
- max-width: 850px;
- margin: 0 auto;
- margin-top: -10px;
-}
-*{transition: width 0.5s ease, height 0.5s ease, flex-grow 0.5s ease}
-#buttons_area{margin-top: 1em}
-#iccv_logo{display: block !important; margin-top: 1.5em}
-#iccv_logo h1{margin-bottom: .5em}
-#pick{margin-top: .8em}
-[aria-label="Edit"],[aria-label="Download"],[aria-label="Share"]{
- display: none !important;
-}
-h3 a{
- color: var(--body-text-color) !important;
-}
-@media print{
- body gradio-app {
- background-color: #000305 !important;
- background-image: url(https://i.imgur.com/gqXjjP0.jpg) !important;
- }
- @page {
- size: landscape;
- margin: 0 !important;
- }
- #input_image, #output_image{height: 356px !important}
- #buttons_area{display: none !important}
- h3{display: none !important}
- footer{display: none !important}
-
- [data-testid="block-label"],
- [aria-label="Edit"],
- [aria-label="Clear"],
- [aria-label="Download"] {
- display: none !important;
- }
- #pick{display: none !important}
-}
\ No newline at end of file
diff --git a/spaces/eetn/Hellenic_AI_Society/README.md b/spaces/eetn/Hellenic_AI_Society/README.md
deleted file mode 100644
index 51e4e4f0c7b6a73e0a1a82301c5d90c6a9595e80..0000000000000000000000000000000000000000
--- a/spaces/eetn/Hellenic_AI_Society/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Hellenic_AI_Society
-emoji: 🔥
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 2.9.4
-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/eforebrahim/Cassava-Leaf-Disease-Classification/app.py b/spaces/eforebrahim/Cassava-Leaf-Disease-Classification/app.py
deleted file mode 100644
index a4ac4d612d8ff86469f5f19a1010b5d09fb1c721..0000000000000000000000000000000000000000
--- a/spaces/eforebrahim/Cassava-Leaf-Disease-Classification/app.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import cv2
-import os
-import PIL.Image
-import numpy as np
-import streamlit as st
-import tensorflow as tf
-from tensorflow.keras.preprocessing import image
-from tensorflow.keras.applications.mobilenet_v2 import MobileNetV2,preprocess_input as mobilenet_v2_preprocess_input
-
-model = tf.keras.models.load_model("model_cassava.hdf5")
-### load file
-# uploaded_file = st.file_uploader("Choose a image file", type="jpg")
-
-map_dict = {0: 'Cassava Bacterial Blight (CBB)',
- 1: 'Cassava Brown Streak Disease (CBSD)',
- 2: 'Cassava Green Mottle (CGM)',
- 3: 'Cassava Mosaic Disease (CMD)',
- 4: 'Healthy'}
-
-option = st.radio('', ['Choose a test image', 'Choose your own image'])
-if option == 'Choose your own image':
- uploaded_file = st.file_uploader("Choose a image file", type="jpg")
-
- if uploaded_file is not None:
- # Convert the file to an opencv image.
- file_bytes = np.asarray(bytearray(uploaded_file.read()), dtype=np.uint8)
- opencv_image = cv2.imdecode(file_bytes, 1)
- opencv_image = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2RGB)
- resized = cv2.resize(opencv_image,(224,224))
- # Now do something with the image! For example, let's display it:
- st.image(opencv_image, channels="RGB")
-
- # resized = mobilenet_v2_preprocess_input(resized)
- img_reshape = resized[np.newaxis,...]
-
- Genrate_pred = st.button("Generate Prediction")
- if Genrate_pred:
- predictions_proba = model.predict(img_reshape).max()*100
- prediction = model.predict(img_reshape).argmax()
- st.title("Predicted Label for the image is {}".format(map_dict[prediction]))
- st.title("with a probability of" f" { '{:.2f}'.format(predictions_proba)}")
-
-else:
- test_images = os.listdir('train_images')
- test_image = st.selectbox('Please select a test image:', test_images)
- file_path = 'train_images/' + test_image
- with open(file_path, 'rb') as img_stream:
- file_bytes = np.asarray(bytearray(img_stream.read()), dtype=np.uint8)
- opencv_image = cv2.imdecode(file_bytes, 1)
- opencv_image = cv2.cvtColor(opencv_image, cv2.COLOR_BGR2RGB)
- resized = cv2.resize(opencv_image,(224,224))
- # Now do something with the image! For example, let's display it:
- st.image(opencv_image, channels="RGB")
-
- # resized = mobilenet_v2_preprocess_input(resized)
- img_reshape = resized[np.newaxis,...]
-
- Genrate_pred = st.button("Generate Prediction")
- if Genrate_pred:
- predictions_proba = model.predict(img_reshape).max()*100
- prediction = model.predict(img_reshape).argmax()
- st.title("Predicted Label for the image is {}".format(map_dict[prediction]))
- st.title("with a probability of" f" { '{:.2f}'.format(predictions_proba)}")
-
-
diff --git a/spaces/ekojs/ml_food10/app.py b/spaces/ekojs/ml_food10/app.py
deleted file mode 100644
index e0c19ddc6ece270805a5765e2bc9c81fd3c6345b..0000000000000000000000000000000000000000
--- a/spaces/ekojs/ml_food10/app.py
+++ /dev/null
@@ -1,245 +0,0 @@
-import gradio as gr
-from fastai.vision.all import *
-import skimage
-from torchvision.transforms import RandAugment
-
-class RandAugmentTransform(RandTransform):
- "A fastai transform handler/wrapper for RandAugment (https://arxiv.org/abs/1909.13719)"
- split_idx, order = None, 2
- def __init__(self): store_attr()
-
- def before_call(self, b, split_idx):
- self.idx = split_idx
- self.aug = RandAugment()
-
- def encodes(self, img: PILImage):
- return self.aug(img) if self.idx == 0 else img
-
-# Adapted from https://pytorch.org/vision/stable/_modules/torchvision/models/resnet.html
-class BasicResNetBlock(nn.Module):
- """Basic ResNet Block (no bottleneck) with GELU instead of RELU"""
- expansion: int = 1
-
- def __init__(
- self,
- inplanes: int,
- planes: int,
- stride: int = 1,
- downsample = None
- ) -> None:
- super().__init__()
- # Both self.conv1 and self.downsample layers downsample the input when stride != 1
- self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3, padding=1, stride=stride, bias=False)
- self.bn1 = nn.BatchNorm2d(planes)
- self.gelu = nn.GELU()
- self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, padding=1, stride=1, bias=False)
- self.bn2 = nn.BatchNorm2d(planes)
- self.downsample = downsample
- self.stride = stride
-
- def forward(self, x: Tensor) -> Tensor:
- identity = x
-
- out = self.conv1(x)
- out = self.bn1(out)
- out = self.gelu(out)
-
- out = self.conv2(out)
- out = self.bn2(out)
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
- out = self.gelu(out)
-
- return out
-
- # Adapted from https://pytorch.org/vision/stable/_modules/torchvision/models/resnet.html
-class ResNet(nn.Module):
- def __init__(
- self,
- block,
- layers,
- num_classes = 10,
- zero_init_residual = True,
- ) -> None:
- super().__init__()
-
- self.inplanes = 64
-
- self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
- self.bn1 = nn.BatchNorm2d(self.inplanes)
- self.gelu = nn.ReLU(inplace=True)
- self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
- self.layer1 = self._make_layer(block, 64, layers[0])
- self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
- self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
- self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.fc = nn.Linear(512, num_classes)
-
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode="fan_out")
- elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
- nn.init.constant_(m.weight, 1)
- nn.init.constant_(m.bias, 0)
-
- # Zero-initialize the last BN in each residual branch,
- # so that the residual branch starts with zeros, and each residual block behaves like an identity.
- # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
- if zero_init_residual:
- for m in self.modules():
- if isinstance(m, BasicResNetBlock):
- nn.init.constant_(m.bn2.weight, 0)
-
- def _make_layer(
- self,
- block,
- planes: int,
- blocks: int,
- stride: int = 1,
- ) -> nn.Sequential:
- downsample = None
- if stride != 1 or self.inplanes != planes:
- downsample = nn.Sequential(
- nn.Conv2d(self.inplanes, planes, 1, stride, bias=False),
- nn.BatchNorm2d(planes),
- )
-
- layers = []
- layers.append(block(self.inplanes, planes, stride, downsample))
-
- self.inplanes = planes
-
- for _ in range(1, blocks):
- layers.append(block(self.inplanes, planes))
-
- return nn.Sequential(*layers)
-
- def forward(self, x: Tensor) -> Tensor:
- x = self.conv1(x)
- x = self.bn1(x)
- x = self.gelu(x)
- x = self.maxpool(x)
-
- x = self.layer1(x)
- x = self.layer2(x)
- x = self.layer3(x)
- x = self.layer4(x)
-
- x = self.avgpool(x)
- x = torch.flatten(x, 1)
- x = self.fc(x)
-
- return x
-
-class ResNetWithPatches(nn.Module):
- def __init__(
- self,
- block,
- layers,
- num_classes = 10,
- zero_init_residual = True,
- ) -> None:
- super().__init__()
-
- self.inplanes = 64
-
- # Patchify stem
- # self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
- # self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
- self.stem = nn.Conv2d(3, self.inplanes, kernel_size=4, stride=4)
- self.gelu = nn.ReLU(inplace=True)
- self.bn1 = nn.BatchNorm2d(self.inplanes)
-
- self.layer1 = self._make_layer(block, 64, layers[0])
- self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
- self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
- self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.fc = nn.Linear(512, num_classes)
-
- for m in self.modules():
- if isinstance(m, nn.Conv2d):
- nn.init.kaiming_normal_(m.weight, mode="fan_out")
- elif isinstance(m, (nn.BatchNorm2d, nn.GroupNorm)):
- nn.init.constant_(m.weight, 1)
- nn.init.constant_(m.bias, 0)
-
- # Zero-initialize the last BN in each residual branch,
- # so that the residual branch starts with zeros, and each residual block behaves like an identity.
- # This improves the model by 0.2~0.3% according to https://arxiv.org/abs/1706.02677
- if zero_init_residual:
- for m in self.modules():
- if isinstance(m, BasicResNetBlock):
- nn.init.constant_(m.bn2.weight, 0)
-
- def _make_layer(
- self,
- block,
- planes: int,
- blocks: int,
- stride: int = 1,
- ) -> nn.Sequential:
- downsample = None
- if stride != 1 or self.inplanes != planes:
- downsample = nn.Sequential(
- nn.Conv2d(self.inplanes, planes, 1, stride, bias=False),
- nn.BatchNorm2d(planes),
- )
-
- layers = []
- layers.append(block(self.inplanes, planes, stride, downsample))
-
- self.inplanes = planes
-
- for _ in range(1, blocks):
- layers.append(block(self.inplanes, planes))
-
- return nn.Sequential(*layers)
-
- def forward(self, x: Tensor) -> Tensor:
- x = self.stem(x)
- x = self.gelu(x)
- x = self.bn1(x)
-
- x = self.layer1(x)
- x = self.layer2(x)
- x = self.layer3(x)
- x = self.layer4(x)
-
- x = self.avgpool(x)
- x = torch.flatten(x, 1)
- x = self.fc(x)
-
- return x
-
-learner = load_learner("ResNetPatches.pkl")
-
-labels = learner.dls.vocab
-
-
-def predict(img):
- img = PILImage(PILImage.create(img).resize((224, 224)))
- pred, pred_idx, probs = learner.predict(img)
- return {labels[i]: float(probs[i]) for i in range(len(labels))}
-
-
-title = "Food Classifier"
-description = "A ResNet34 model modified to use patches of images, trained to classify food items on a subset (10 classes) of the Food 101 dataset."
-article = "Relevant Resources
"
-examples = [["chicken_curry.jpg"], ["garlic_bread.jpg"], ["takoyaki.jpg"]]
-enable_queue = True
-
-gr.Interface(
- fn=predict,
- inputs=gr.inputs.Image(shape=(224, 224)),
- outputs=gr.outputs.Label(num_top_classes=3),
- title=title,
- description=description,
- article=article,
- examples=examples,
- enable_queue=enable_queue,
-).launch()
diff --git a/spaces/epexVfeibi/Imagedeblurr/!!BETTER!! Full Version Scriptcase 6 Serial Number.md b/spaces/epexVfeibi/Imagedeblurr/!!BETTER!! Full Version Scriptcase 6 Serial Number.md
deleted file mode 100644
index cf0988f4fbb38156b8d1de0dcee271acde962d1d..0000000000000000000000000000000000000000
--- a/spaces/epexVfeibi/Imagedeblurr/!!BETTER!! Full Version Scriptcase 6 Serial Number.md
+++ /dev/null
@@ -1,147 +0,0 @@
-
-Full Version Scriptcase 6 Serial Number: What You Need to Know
-
-If you are looking for a powerful and easy-to-use web development tool, you might have heard of Scriptcase. Scriptcase is a low-code platform that allows you to create web applications using only your browser. You can import data from spreadsheets, databases, or external sources, and generate forms, reports, charts, dashboards, and more.
-Full Version Scriptcase 6 Serial Number DOWNLOAD … https://jinyurl.com/2uEpj5
Scriptcase is compatible with various databases, such as MySQL, PostgreSQL, SQLite, Interbase, Firebird, MS Access, Oracle, SQL Server, DB2, SyBase, Informix, or ODBC layer. You can also customize your applications with your own business rules, using external libraries, programming IDE (Blank), Events, Macros, and other features.
-
-Scriptcase has different versions for different needs and budgets. You can choose from Express Edition, Professional Edition, Enterprise Edition, or Cloud Edition. Each version has different features and limitations. For example, the Express Edition is free but has a limit of 10 projects and 2 connections.
-
-But what if you want to get the full version of Scriptcase 6 with all the features and no limitations? You will need a valid serial number to activate it. A serial number is a unique code that identifies your license and allows you to use Scriptcase without restrictions.
-
-How to Get a Full Version Scriptcase 6 Serial Number
-
-There are two ways to get a full version Scriptcase 6 serial number: buying it or cracking it.
-
-The first option is to buy it from the official website of Scriptcase. You can choose the edition that suits your needs and pay with your credit card or PayPal. You will receive an email with your serial number and instructions on how to activate it. This is the legal and safe way to get a full version Scriptcase 6 serial number.
-
-The second option is to crack it. This means using a software or a tool that generates a fake serial number that bypasses the activation process of Scriptcase. This is an illegal and risky way to get a full version Scriptcase 6 serial number. You might find some websites or blogs that offer cracked versions of Scriptcase 6 or serial number generators. However, these are not reliable sources and might contain viruses, malware, or spyware that can harm your computer or steal your personal information. Moreover, you might face legal consequences for violating the terms and conditions of Scriptcase.
-
-Why You Should Avoid Cracking Scriptcase 6
-
-Cracking Scriptcase 6 might seem tempting if you want to save money or try it before buying it. However, there are many reasons why you should avoid cracking Scriptcase 6 and opt for the legal way instead.
-
-
-
-Cracking Scriptcase 6 is illegal and unethical. You are breaking the law and disrespecting the work of the developers who created Scriptcase. You are also depriving them of their income and support.
-Cracking Scriptcase 6 is unsafe and unreliable. You are exposing your computer and your data to potential threats from viruses, malware, or spyware that might come with the cracked version or the serial number generator. You are also risking losing your work or getting errors or bugs in your applications.
-Cracking Scriptcase 6 is unprofessional and unproductive. You are missing out on the benefits of having a legitimate license of Scriptcase 6, such as updates, support, documentation, tutorials, community forums, and more. You are also limiting your opportunities and credibility as a web developer.
-
-
-Conclusion
-
-Scriptcase 6 is a great web development tool that can help you create web applications faster and easier. However, if you want to get the full version of Scriptcase 6 with all the features and no limitations, you need a valid serial number to activate it.
-
-The best way to get a full version Scriptcase 6 serial number is to buy it from the official website of Scriptcase. This is the legal and safe way to get a full version Scriptcase 6 serial number. You will also enjoy the benefits of having a legitimate license of Scriptcase 6.
-
-The worst way to get a full version Scriptcase 6 serial number is to crack it. This is an illegal and risky way to get a full version Scriptcase 6 serial number. You will also face the drawbacks of having a cracked version of Scriptcase 6.
-
-Therefore, we recommend you to avoid cracking Scriptcase 6 and opt for the legal way instead. This will ensure your security, quality, professionalism, and productivity as a web developer.
-How to Use Scriptcase 6
-
-Once you have activated your full version Scriptcase 6 serial number, you can start using Scriptcase 6 to create web applications. The process is simple and intuitive. You just need to follow these steps:
-
-
-Create a new project or open an existing one.
-Select the database connection that you want to use for your application.
-Create a new application or edit an existing one. You can choose from different types of applications, such as Form, Grid, Chart, Calendar, Control, Report, Dashboard, etc.
-Configure the settings and options of your application, such as layout, fields, buttons, events, validations, filters, etc.
-Generate the source code of your application and run it in your browser.
-Publish your application to a web server or export it to a file.
-
-
-Scriptcase 6 also provides you with tools and resources to help you with your web development. You can access the documentation, tutorials, videos, samples, forums, support, and more from the Scriptcase menu.
-
-Benefits of Using Scriptcase 6
-
-Using Scriptcase 6 with a full version serial number has many benefits for web developers. Here are some of them:
-
-
-You can create web applications faster and easier than coding from scratch.
-You can use a visual interface to design and develop your applications without writing a single line of code.
-You can import data from different sources and generate applications based on them.
-You can create responsive and cross-browser applications that work on any device and platform.
-You can customize your applications with your own business rules and logic.
-You can integrate your applications with external libraries and APIs.
-You can collaborate with other developers on the same project using the cloud edition or the team development feature.
-You can update and maintain your applications easily with the automatic versioning and backup system.
-
-
-Scriptcase 6 is a powerful and easy-to-use web development tool that can help you create web applications faster and easier. However, if you want to get the full version of Scriptcase 6 with all the features and no limitations, you need a valid serial number to activate it.
-
-The best way to get a full version Scriptcase 6 serial number is to buy it from the official website of Scriptcase. This is the legal and safe way to get a full version Scriptcase 6 serial number. You will also enjoy the benefits of having a legitimate license of Scriptcase 6.
-
-The worst way to get a full version Scriptcase 6 serial number is to crack it. This is an illegal and risky way to get a full version Scriptcase 6 serial number. You will also face the drawbacks of having a cracked version of Scriptcase 6.
-
-Therefore, we recommend you to avoid cracking Scriptcase 6 and opt for the legal way instead. This will ensure your security, quality, professionalism, and productivity as a web developer.
-How to Download and Install Scriptcase 6
-
-If you have bought a full version Scriptcase 6 serial number, you can download and install Scriptcase 6 on your computer or on a web server. The process is simple and straightforward. You just need to follow these steps:
-
-
-Go to the official website of Scriptcase and log in with your email and password.
-Go to the download section and choose the version that matches your operating system (Windows, Linux, or Mac).
-Download the installer file and save it on your computer or on a web server.
-Run the installer file and follow the instructions on the screen.
-Enter your full version Scriptcase 6 serial number when prompted.
-Finish the installation and launch Scriptcase 6.
-
-
-You can also watch the video tutorials on the website of Scriptcase to see how to download and install Scriptcase 6 step by step.
-
-How to Update and Upgrade Scriptcase 6
-
-If you have a full version Scriptcase 6 serial number, you can update and upgrade Scriptcase 6 to get the latest features and improvements. The process is easy and convenient. You just need to follow these steps:
-
-
-Open Scriptcase 6 and go to Help > Check for updates.
-If there are any updates available, click on Download and Install.
-Wait for the updates to be downloaded and installed.
-Restart Scriptcase 6 and enjoy the new features and improvements.
-
-
-If you want to upgrade your edition of Scriptcase 6, you can do so by going to the website of Scriptcase and choosing the edition that you want to upgrade to. You will need to pay the difference between your current edition and the new edition. You will receive an email with your new serial number and instructions on how to activate it.
-
-You can also watch the video tutorials on the website of Scriptcase to see how to update and upgrade Scriptcase 6 step by step.
-How to Troubleshoot Scriptcase 6
-
-If you encounter any problems or issues while using Scriptcase 6 with a full version serial number, you can troubleshoot them by following these steps:
-
-
-Check the system requirements of Scriptcase 6 and make sure your computer or web server meets them.
-Check the compatibility of Scriptcase 6 with your browser and make sure you are using the latest version.
-Check the connection settings of Scriptcase 6 and make sure they are correct and valid.
-Check the error logs of Scriptcase 6 and see if there are any messages or codes that indicate the cause of the problem.
-Check the documentation and FAQ of Scriptcase 6 and see if there are any solutions or tips for your problem.
-Contact the support team of Scriptcase 6 and report your problem with details and screenshots.
-
-
-You can also watch the video tutorials on the website of Scriptcase to see how to troubleshoot Scriptcase 6 step by step.
-
-How to Uninstall Scriptcase 6
-
-If you want to uninstall Scriptcase 6 from your computer or web server, you can do so by following these steps:
-
-
-Backup your projects and data before uninstalling Scriptcase 6.
-Go to the control panel of your computer or web server and find the program list.
-Select Scriptcase 6 and click on Uninstall.
-Follow the instructions on the screen to complete the uninstallation process.
-Delete any remaining files or folders related to Scriptcase 6 from your computer or web server.
-
-
-You can also watch the video tutorials on the website of Scriptcase to see how to uninstall Scriptcase 6 step by step.
-Conclusion
-
-Scriptcase 6 is a powerful and easy-to-use web development tool that can help you create web applications faster and easier. However, if you want to get the full version of Scriptcase 6 with all the features and no limitations, you need a valid serial number to activate it.
-
-The best way to get a full version Scriptcase 6 serial number is to buy it from the official website of Scriptcase. This is the legal and safe way to get a full version Scriptcase 6 serial number. You will also enjoy the benefits of having a legitimate license of Scriptcase 6, such as updates, support, documentation, tutorials, community forums, and more.
-
-The worst way to get a full version Scriptcase 6 serial number is to crack it. This is an illegal and risky way to get a full version Scriptcase 6 serial number. You will also face the drawbacks of having a cracked version of Scriptcase 6, such as viruses, malware, spyware, errors, bugs, legal consequences, and more.
-
-Therefore, we recommend you to avoid cracking Scriptcase 6 and opt for the legal way instead. This will ensure your security, quality, professionalism, and productivity as a web developer.
-
-We hope this article has helped you to understand what Scriptcase 6 is and how to get a full version Scriptcase 6 serial number. If you have any questions or feedback, please feel free to contact us or leave a comment below.
3cee63e6c2Download Tally Ees V6 3 Release 1 Crack Keygen DOWNLOAD === https://jinyurl.com/2uEpHK
diff --git a/spaces/eswat/Image-and-3D-Model-Creator/PIFu/README.md b/spaces/eswat/Image-and-3D-Model-Creator/PIFu/README.md
deleted file mode 100644
index 5eae12f2a370027de6c46fbf78ec68a1ecb1c01c..0000000000000000000000000000000000000000
--- a/spaces/eswat/Image-and-3D-Model-Creator/PIFu/README.md
+++ /dev/null
@@ -1,167 +0,0 @@
-# PIFu: Pixel-Aligned Implicit Function for High-Resolution Clothed Human Digitization
-
-[](https://arxiv.org/abs/1905.05172) [](https://colab.research.google.com/drive/1GFSsqP2BWz4gtq0e-nki00ZHSirXwFyY)
-
-News:
-* \[2020/05/04\] Added EGL rendering option for training data generation. Now you can create your own training data with headless machines!
-* \[2020/04/13\] Demo with Google Colab (incl. visualization) is available. Special thanks to [@nanopoteto](https://github.com/nanopoteto)!!!
-* \[2020/02/26\] License is updated to MIT license! Enjoy!
-
-This repository contains a pytorch implementation of "[PIFu: Pixel-Aligned Implicit Function for High-Resolution Clothed Human Digitization](https://arxiv.org/abs/1905.05172)".
-
-[Project Page](https://shunsukesaito.github.io/PIFu/)
-
-
-If you find the code useful in your research, please consider citing the paper.
-
-```
-@InProceedings{saito2019pifu,
-author = {Saito, Shunsuke and Huang, Zeng and Natsume, Ryota and Morishima, Shigeo and Kanazawa, Angjoo and Li, Hao},
-title = {PIFu: Pixel-Aligned Implicit Function for High-Resolution Clothed Human Digitization},
-booktitle = {The IEEE International Conference on Computer Vision (ICCV)},
-month = {October},
-year = {2019}
-}
-```
-
-
-This codebase provides:
-- test code
-- training code
-- data generation code
-
-## Requirements
-- Python 3
-- [PyTorch](https://pytorch.org/) tested on 1.4.0
-- json
-- PIL
-- skimage
-- tqdm
-- numpy
-- cv2
-
-for training and data generation
-- [trimesh](https://trimsh.org/) with [pyembree](https://github.com/scopatz/pyembree)
-- [pyexr](https://github.com/tvogels/pyexr)
-- PyOpenGL
-- freeglut (use `sudo apt-get install freeglut3-dev` for ubuntu users)
-- (optional) egl related packages for rendering with headless machines. (use `apt install libgl1-mesa-dri libegl1-mesa libgbm1` for ubuntu users)
-
-Warning: I found that outdated NVIDIA drivers may cause errors with EGL. If you want to try out the EGL version, please update your NVIDIA driver to the latest!!
-
-## Windows demo installation instuction
-
-- Install [miniconda](https://docs.conda.io/en/latest/miniconda.html)
-- Add `conda` to PATH
-- Install [git bash](https://git-scm.com/downloads)
-- Launch `Git\bin\bash.exe`
-- `eval "$(conda shell.bash hook)"` then `conda activate my_env` because of [this](https://github.com/conda/conda-build/issues/3371)
-- Automatic `env create -f environment.yml` (look [this](https://github.com/conda/conda/issues/3417))
-- OR manually setup [environment](https://towardsdatascience.com/a-guide-to-conda-environments-bc6180fc533)
- - `conda create —name pifu python` where `pifu` is name of your environment
- - `conda activate`
- - `conda install pytorch torchvision cudatoolkit=10.1 -c pytorch`
- - `conda install pillow`
- - `conda install scikit-image`
- - `conda install tqdm`
- - `conda install -c menpo opencv`
-- Download [wget.exe](https://eternallybored.org/misc/wget/)
-- Place it into `Git\mingw64\bin`
-- `sh ./scripts/download_trained_model.sh`
-- Remove background from your image ([this](https://www.remove.bg/), for example)
-- Create black-white mask .png
-- Replace original from sample_images/
-- Try it out - `sh ./scripts/test.sh`
-- Download [Meshlab](http://www.meshlab.net/) because of [this](https://github.com/shunsukesaito/PIFu/issues/1)
-- Open .obj file in Meshlab
-
-
-## Demo
-Warning: The released model is trained with mostly upright standing scans with weak perspectie projection and the pitch angle of 0 degree. Reconstruction quality may degrade for images highly deviated from trainining data.
-1. run the following script to download the pretrained models from the following link and copy them under `./PIFu/checkpoints/`.
-```
-sh ./scripts/download_trained_model.sh
-```
-
-2. run the following script. the script creates a textured `.obj` file under `./PIFu/eval_results/`. You may need to use `./apps/crop_img.py` to roughly align an input image and the corresponding mask to the training data for better performance. For background removal, you can use any off-the-shelf tools such as [removebg](https://www.remove.bg/).
-```
-sh ./scripts/test.sh
-```
-
-## Demo on Google Colab
-If you do not have a setup to run PIFu, we offer Google Colab version to give it a try, allowing you to run PIFu in the cloud, free of charge. Try our Colab demo using the following notebook:
-[](https://colab.research.google.com/drive/1GFSsqP2BWz4gtq0e-nki00ZHSirXwFyY)
-
-## Data Generation (Linux Only)
-While we are unable to release the full training data due to the restriction of commertial scans, we provide rendering code using free models in [RenderPeople](https://renderpeople.com/free-3d-people/).
-This tutorial uses `rp_dennis_posed_004` model. Please download the model from [this link](https://renderpeople.com/sample/free/rp_dennis_posed_004_OBJ.zip) and unzip the content under a folder named `rp_dennis_posed_004_OBJ`. The same process can be applied to other RenderPeople data.
-
-Warning: the following code becomes extremely slow without [pyembree](https://github.com/scopatz/pyembree). Please make sure you install pyembree.
-
-1. run the following script to compute spherical harmonics coefficients for [precomputed radiance transfer (PRT)](https://sites.fas.harvard.edu/~cs278/papers/prt.pdf). In a nutshell, PRT is used to account for accurate light transport including ambient occlusion without compromising online rendering time, which significantly improves the photorealism compared with [a common sperical harmonics rendering using surface normals](https://cseweb.ucsd.edu/~ravir/papers/envmap/envmap.pdf). This process has to be done once for each obj file.
-```
-python -m apps.prt_util -i {path_to_rp_dennis_posed_004_OBJ}
-```
-
-2. run the following script. Under the specified data path, the code creates folders named `GEO`, `RENDER`, `MASK`, `PARAM`, `UV_RENDER`, `UV_MASK`, `UV_NORMAL`, and `UV_POS`. Note that you may need to list validation subjects to exclude from training in `{path_to_training_data}/val.txt` (this tutorial has only one subject and leave it empty). If you wish to render images with headless servers equipped with NVIDIA GPU, add -e to enable EGL rendering.
-```
-python -m apps.render_data -i {path_to_rp_dennis_posed_004_OBJ} -o {path_to_training_data} [-e]
-```
-
-## Training (Linux Only)
-
-Warning: the following code becomes extremely slow without [pyembree](https://github.com/scopatz/pyembree). Please make sure you install pyembree.
-
-1. run the following script to train the shape module. The intermediate results and checkpoints are saved under `./results` and `./checkpoints` respectively. You can add `--batch_size` and `--num_sample_input` flags to adjust the batch size and the number of sampled points based on available GPU memory.
-```
-python -m apps.train_shape --dataroot {path_to_training_data} --random_flip --random_scale --random_trans
-```
-
-2. run the following script to train the color module.
-```
-python -m apps.train_color --dataroot {path_to_training_data} --num_sample_inout 0 --num_sample_color 5000 --sigma 0.1 --random_flip --random_scale --random_trans
-```
-
-## Related Research
-**[Monocular Real-Time Volumetric Performance Capture (ECCV 2020)](https://project-splinter.github.io/)**
-*Ruilong Li\*, Yuliang Xiu\*, Shunsuke Saito, Zeng Huang, Kyle Olszewski, Hao Li*
-
-The first real-time PIFu by accelerating reconstruction and rendering!!
-
-**[PIFuHD: Multi-Level Pixel-Aligned Implicit Function for High-Resolution 3D Human Digitization (CVPR 2020)](https://shunsukesaito.github.io/PIFuHD/)**
-*Shunsuke Saito, Tomas Simon, Jason Saragih, Hanbyul Joo*
-
-We further improve the quality of reconstruction by leveraging multi-level approach!
-
-**[ARCH: Animatable Reconstruction of Clothed Humans (CVPR 2020)](https://arxiv.org/pdf/2004.04572.pdf)**
-*Zeng Huang, Yuanlu Xu, Christoph Lassner, Hao Li, Tony Tung*
-
-Learning PIFu in canonical space for animatable avatar generation!
-
-**[Robust 3D Self-portraits in Seconds (CVPR 2020)](http://www.liuyebin.com/portrait/portrait.html)**
-*Zhe Li, Tao Yu, Chuanyu Pan, Zerong Zheng, Yebin Liu*
-
-They extend PIFu to RGBD + introduce "PIFusion" utilizing PIFu reconstruction for non-rigid fusion.
-
-**[Learning to Infer Implicit Surfaces without 3d Supervision (NeurIPS 2019)](http://papers.nips.cc/paper/9039-learning-to-infer-implicit-surfaces-without-3d-supervision.pdf)**
-*Shichen Liu, Shunsuke Saito, Weikai Chen, Hao Li*
-
-We answer to the question of "how can we learn implicit function if we don't have 3D ground truth?"
-
-**[SiCloPe: Silhouette-Based Clothed People (CVPR 2019, best paper finalist)](https://arxiv.org/pdf/1901.00049.pdf)**
-*Ryota Natsume\*, Shunsuke Saito\*, Zeng Huang, Weikai Chen, Chongyang Ma, Hao Li, Shigeo Morishima*
-
-Our first attempt to reconstruct 3D clothed human body with texture from a single image!
-
-**[Deep Volumetric Video from Very Sparse Multi-view Performance Capture (ECCV 2018)](http://openaccess.thecvf.com/content_ECCV_2018/papers/Zeng_Huang_Deep_Volumetric_Video_ECCV_2018_paper.pdf)**
-*Zeng Huang, Tianye Li, Weikai Chen, Yajie Zhao, Jun Xing, Chloe LeGendre, Linjie Luo, Chongyang Ma, Hao Li*
-
-Implict surface learning for sparse view human performance capture!
-
-------
-
-
-
-For commercial queries, please contact:
-
-Hao Li: hao@hao-li.com ccto: saitos@usc.edu Baker!!
diff --git a/spaces/eubinecto/idiomify/main_train.py b/spaces/eubinecto/idiomify/main_train.py
deleted file mode 100644
index ef24b27005bcdade3cc93d8c77adfe46ff04f843..0000000000000000000000000000000000000000
--- a/spaces/eubinecto/idiomify/main_train.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import os
-import torch.cuda
-import wandb
-import argparse
-import pytorch_lightning as pl
-from termcolor import colored
-from pytorch_lightning.loggers import WandbLogger
-from transformers import BartForConditionalGeneration
-from idiomify.datamodules import IdiomifyDataModule
-from idiomify.fetchers import fetch_config, fetch_tokenizer
-from idiomify.models import Idiomifier
-from idiomify.paths import ROOT_DIR
-
-
-def main():
- parser = argparse.ArgumentParser()
- parser.add_argument("--num_workers", type=int, default=os.cpu_count())
- parser.add_argument("--log_every_n_steps", type=int, default=1)
- parser.add_argument("--fast_dev_run", action="store_true", default=False)
- parser.add_argument("--upload", dest='upload', action='store_true', default=False)
- args = parser.parse_args()
- config = fetch_config()['idiomifier']
- config.update(vars(args))
- if not config['upload']:
- print(colored("WARNING: YOU CHOSE NOT TO UPLOAD. NOTHING BUT LOGS WILL BE SAVED TO WANDB", color="red"))
- # prepare a pre-trained BART
- bart = BartForConditionalGeneration.from_pretrained(config['bart'])
- # prepare the datamodule
- with wandb.init(entity="eubinecto", project="idiomify", config=config) as run:
- tokenizer = fetch_tokenizer(config['tokenizer_ver'], run)
- bart.resize_token_embeddings(len(tokenizer)) # because new tokens are added, this process is necessary
- model = Idiomifier(bart, config['lr'], tokenizer.bos_token_id, tokenizer.pad_token_id)
- datamodule = IdiomifyDataModule(config, tokenizer, run)
- logger = WandbLogger(log_model=False)
- trainer = pl.Trainer(max_epochs=config['max_epochs'],
- fast_dev_run=config['fast_dev_run'],
- log_every_n_steps=config['log_every_n_steps'],
- gpus=torch.cuda.device_count(),
- default_root_dir=str(ROOT_DIR),
- enable_checkpointing=False,
- logger=logger)
- # start training
- trainer.fit(model=model, datamodule=datamodule)
- # upload the model to wandb only if the training is properly done #
- if not config['fast_dev_run'] and trainer.current_epoch == config['max_epochs'] - 1:
- ckpt_path = ROOT_DIR / "model.ckpt"
- trainer.save_checkpoint(str(ckpt_path))
- config['vocab_size'] = len(tokenizer) # this will be needed to fetch a pretrained idiomifier later
- artifact = wandb.Artifact(name="idiomifier", type="model", metadata=config)
- artifact.add_file(str(ckpt_path))
- run.log_artifact(artifact, aliases=["latest", config['ver']])
- os.remove(str(ckpt_path)) # make sure you remove it after you are done with uploading it
-
-
-if __name__ == '__main__':
- main()
diff --git a/spaces/evoss/NLP_text_analyzer/app.py b/spaces/evoss/NLP_text_analyzer/app.py
deleted file mode 100644
index df2b45136606645bbe2253c96fd2abe160d927d8..0000000000000000000000000000000000000000
--- a/spaces/evoss/NLP_text_analyzer/app.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import gradio as gr
-
-import spacy
-nlp = spacy.load('en_core_web_sm')
-
-
-def count_verbs(doc):
- verbs = 0
- for token in doc:
- if token.pos_ == "VERB":
- verbs += 1
- return verbs
-
-def greet(sent):
- doc = nlp(sent)
- nouns = 0
- for token in doc:
- if token.pos_ == "NOUN":
- nouns += 1
- verbs = count_verbs(doc)
- length = len(sent.split())
- return (f"Your sentence has {length} word(s).\n Your sentence has {nouns} noun(s).\n Your sentence has {verbs} verb(s).")
-
-
-
-iface = gr.Interface(fn=greet, inputs="text", outputs="text", examples = [
- ["The Moon's orbit around Earth takes a long time."],
- ["The smooth Borealis basin in the Northern Hemisphere covers 40%."]])
-iface.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/facebook/StyleNeRF/training/networks.py b/spaces/facebook/StyleNeRF/training/networks.py
deleted file mode 100644
index f762ea468f7825d2f207fc6edb293088815f689b..0000000000000000000000000000000000000000
--- a/spaces/facebook/StyleNeRF/training/networks.py
+++ /dev/null
@@ -1,1563 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-# Copyright (c) 2021, NVIDIA CORPORATION. All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto. Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-from pickle import NONE
-from re import X
-from sndhdr import whathdr
-import numpy as np
-import math
-import scipy.signal
-import scipy.optimize
-
-from numpy import core
-from numpy.lib.arraysetops import isin
-
-import torch
-import torch.nn.functional as F
-from torch.overrides import is_tensor_method_or_property
-from einops import repeat
-from dnnlib import camera, util, geometry
-from torch_utils import misc
-from torch_utils import persistence
-from torch_utils.ops import conv2d_resample
-from torch_utils.ops import upfirdn2d
-from torch_utils.ops import bias_act
-from torch_utils.ops import fma
-from torch_utils.ops import filtered_lrelu
-
-#----------------------------------------------------------------------------
-
-@misc.profiled_function
-def normalize_2nd_moment(x, dim=1, eps=1e-8):
- return x * (x.square().mean(dim=dim, keepdim=True) + eps).rsqrt()
-
-
-@misc.profiled_function
-def conv3d(x, w, up=1, down=1, padding=0, groups=1):
- if up > 1:
- x = F.interpolate(x, scale_factor=up, mode='trilinear', align_corners=True)
- x = F.conv3d(x, w, padding=padding, groups=groups)
- if down > 1:
- x = F.interpolate(x, scale_factor=1./float(down), mode='trilinear', align_corners=True)
- return x
-
-#----------------------------------------------------------------------------
-
-@misc.profiled_function
-def modulated_conv2d(
- x, # Input tensor of shape [batch_size, in_channels, in_height, in_width].
- weight, # Weight tensor of shape [out_channels, in_channels, kernel_height, kernel_width].
- styles, # Modulation coefficients of shape [batch_size, in_channels].
- noise = None, # Optional noise tensor to add to the output activations.
- up = 1, # Integer upsampling factor.
- down = 1, # Integer downsampling factor.
- padding = 0, # Padding with respect to the upsampled image.
- resample_filter = None, # Low-pass filter to apply when resampling activations. Must be prepared beforehand by calling upfirdn2d.setup_filter().
- demodulate = True, # Apply weight demodulation?
- flip_weight = True, # False = convolution, True = correlation (matches torch.nn.functional.conv2d) ????????
- fused_modconv = True, # Perform modulation, convolution, and demodulation as a single fused operation?
- mode = '2d', # modulated 2d/3d conv or MLP
- **unused,
-):
- batch_size = x.shape[0]
- if mode == '3d':
- _, in_channels, kd, kh, kw = weight.shape
- else:
- _, in_channels, kh, kw = weight.shape
-
- # Pre-normalize inputs to avoid FP16 overflow.
- if x.dtype == torch.float16 and demodulate:
- weight_sizes = in_channels * kh * kw if mode != '3d' else in_channels * kd * kh * kw
- weight = weight * (1 / np.sqrt(weight_sizes) / weight.norm(float('inf'), dim=[1,2,3], keepdim=True)) # max_Ikk
- styles = styles / styles.norm(float('inf'), dim=1, keepdim=True) # max_I
-
- # Calculate per-sample weights and demodulation coefficients.
- w = None
- dcoefs = None
- if mode != '3d':
- rsizes, ssizes = [-1, 1, 1], [2, 3, 4]
- else:
- rsizes, ssizes = [-1, 1, 1, 1], [2, 3, 4, 5]
-
- if demodulate or fused_modconv: # if not fused, skip
- w = weight.unsqueeze(0) * styles.reshape(batch_size, 1, *rsizes)
- if demodulate:
- dcoefs = (w.square().sum(dim=ssizes) + 1e-8).rsqrt() # [NO]
-
- if demodulate and fused_modconv:
- w = w * dcoefs.reshape(batch_size, *rsizes, 1) # [NOIkk] (batch_size, out_channels, in_channels, kernel_size, kernel_size)
-
- # Execute by scaling the activations before and after the convolution.
- if not fused_modconv:
- x = x * styles.to(x.dtype).reshape(batch_size, *rsizes)
- if mode == '2d':
- x = conv2d_resample.conv2d_resample(x=x, w=weight.to(x.dtype), f=resample_filter, up=up, down=down, padding=padding, flip_weight=flip_weight)
- elif mode == '3d':
- x = conv3d(x=x, w=weight.to(x.dtype), up=up, down=down, padding=padding)
- else:
- raise NotImplementedError
-
- if demodulate and noise is not None:
- x = fma.fma(x, dcoefs.to(x.dtype).reshape(batch_size, *rsizes), noise.to(x.dtype)) # fused multiply add
- elif demodulate:
- x = x * dcoefs.to(x.dtype).reshape(batch_size, *rsizes)
- elif noise is not None:
- x = x.add_(noise.to(x.dtype))
- return x
-
- # Execute as one fused op using grouped convolution.
- with misc.suppress_tracer_warnings(): # this value will be treated as a constant
- batch_size = int(batch_size)
-
- x = x.reshape(1, -1, *x.shape[2:])
- w = w.reshape(-1, *w.shape[2:])
- if mode == '2d':
- x = conv2d_resample.conv2d_resample(x=x, w=w.to(x.dtype), f=resample_filter, up=up, down=down, padding=padding, groups=batch_size, flip_weight=flip_weight)
- elif mode == '3d':
- x = conv3d(x=x, w=w.to(x.dtype), up=up, down=down, padding=padding, groups=batch_size)
- x = x.reshape(batch_size, -1, *x.shape[2:])
-
- if noise is not None:
- x = x.add_(noise)
- return x
-
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class FullyConnectedLayer(torch.nn.Module):
- def __init__(self,
- in_features, # Number of input features.
- out_features, # Number of output features.
- bias = True, # Apply additive bias before the activation function?
- activation = 'linear', # Activation function: 'relu', 'lrelu', etc.
- lr_multiplier = 1, # Learning rate multiplier.
- bias_init = 0, # Initial value for the additive bias.
- ):
- super().__init__()
- self.activation = activation
- self.weight = torch.nn.Parameter(torch.randn([out_features, in_features]) / lr_multiplier)
- self.bias = torch.nn.Parameter(torch.full([out_features], np.float32(bias_init))) if bias else None
- self.weight_gain = lr_multiplier / np.sqrt(in_features)
- self.bias_gain = lr_multiplier
-
- def forward(self, x):
- w = self.weight.to(x.dtype) * self.weight_gain
- b = self.bias
- if b is not None:
- b = b.to(x.dtype)
- if self.bias_gain != 1:
- b = b * self.bias_gain
-
- if self.activation == 'linear' and b is not None:
- x = torch.addmm(b.unsqueeze(0), x, w.t())
- else:
- x = x.matmul(w.t())
- x = bias_act.bias_act(x, b, act=self.activation)
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class Conv2dLayer(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- out_channels, # Number of output channels.
- kernel_size, # Width and height of the convolution kernel.
- bias = True, # Apply additive bias before the activation function?
- activation = 'linear', # Activation function: 'relu', 'lrelu', etc.
- up = 1, # Integer upsampling factor.
- down = 1, # Integer downsampling factor.
- resample_filter = [1,3,3,1], # Low-pass filter to apply when resampling activations.
- conv_clamp = None, # Clamp the output to +-X, None = disable clamping.
- channels_last = False, # Expect the input to have memory_format=channels_last?
- trainable = True, # Update the weights of this layer during training?
- mode = '2d',
- **unused
- ):
- super().__init__()
- self.activation = activation
- self.up = up
- self.down = down
- self.conv_clamp = conv_clamp
- self.register_buffer('resample_filter', upfirdn2d.setup_filter(resample_filter))
- self.padding = kernel_size // 2
- self.weight_gain = 1 / np.sqrt(in_channels * (kernel_size ** 2))
- self.act_gain = bias_act.activation_funcs[activation].def_gain
- self.mode = mode
- weight_shape = [out_channels, in_channels, kernel_size, kernel_size]
- if mode == '3d':
- weight_shape += [kernel_size]
-
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- weight = torch.randn(weight_shape).to(memory_format=memory_format)
- bias = torch.zeros([out_channels]) if bias else None
- if trainable:
- self.weight = torch.nn.Parameter(weight)
- self.bias = torch.nn.Parameter(bias) if bias is not None else None
- else:
- self.register_buffer('weight', weight)
- if bias is not None:
- self.register_buffer('bias', bias)
- else:
- self.bias = None
-
- def forward(self, x, gain=1):
- w = self.weight * self.weight_gain
- b = self.bias.to(x.dtype) if self.bias is not None else None
- flip_weight = (self.up == 1) # slightly faster
-
- if self.mode == '2d':
- x = conv2d_resample.conv2d_resample(x=x, w=w.to(x.dtype), f=self.resample_filter, up=self.up, down=self.down, padding=self.padding, flip_weight=flip_weight)
- elif self.mode == '3d':
- x = conv3d(x=x, w=w.to(x.dtype), up=self.up, down=self.down, padding=self.padding)
-
- act_gain = self.act_gain * gain
- act_clamp = self.conv_clamp * gain if self.conv_clamp is not None else None
- x = bias_act.bias_act(x, b, act=self.activation, gain=act_gain, clamp=act_clamp)
- return x
-
-# ---------------------------------------------------------------------------
-
-@persistence.persistent_class
-class Blur(torch.nn.Module):
- def __init__(self):
- super().__init__()
- f = torch.Tensor([1, 2, 1])
- self.register_buffer('f', f)
-
- def forward(self, x):
- from kornia.filters import filter2d
- f = self.f
- f = f[None, None, :] * f [None, :, None]
- return filter2d(x, f, normalized=True)
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class MappingNetwork(torch.nn.Module):
- def __init__(self,
- z_dim, # Input latent (Z) dimensionality, 0 = no latent.
- c_dim, # Conditioning label (C) dimensionality, 0 = no label.
- w_dim, # Intermediate latent (W) dimensionality.
- num_ws, # Number of intermediate latents to output, None = do not broadcast.
- num_layers = 8, # Number of mapping layers.
- embed_features = None, # Label embedding dimensionality, None = same as w_dim.
- layer_features = None, # Number of intermediate features in the mapping layers, None = same as w_dim.
- activation = 'lrelu', # Activation function: 'relu', 'lrelu', etc.
- lr_multiplier = 0.01, # Learning rate multiplier for the mapping layers.
- w_avg_beta = 0.995, # Decay for tracking the moving average of W during training, None = do not track.
- **unused,
- ):
- super().__init__()
- self.z_dim = z_dim
- self.c_dim = c_dim
- self.w_dim = w_dim
- self.num_ws = num_ws
- self.num_layers = num_layers
- self.w_avg_beta = w_avg_beta
-
- if embed_features is None:
- embed_features = w_dim
- if c_dim == 0:
- embed_features = 0
- if layer_features is None:
- layer_features = w_dim
- features_list = [z_dim + embed_features] + [layer_features] * (num_layers - 1) + [w_dim]
-
- if c_dim > 0: # project label condition
- self.embed = FullyConnectedLayer(c_dim, embed_features)
- for idx in range(num_layers):
- in_features = features_list[idx]
- out_features = features_list[idx + 1]
- layer = FullyConnectedLayer(in_features, out_features, activation=activation, lr_multiplier=lr_multiplier)
- setattr(self, f'fc{idx}', layer)
-
- if num_ws is not None and w_avg_beta is not None:
- self.register_buffer('w_avg', torch.zeros([w_dim]))
-
- def forward(self, z=None, c=None, truncation_psi=1, truncation_cutoff=None, skip_w_avg_update=False, styles=None, **unused_kwargs):
- if styles is not None:
- return styles
-
- # Embed, normalize, and concat inputs.
- x = None
- with torch.autograd.profiler.record_function('input'):
- if self.z_dim > 0:
- misc.assert_shape(z, [None, self.z_dim])
- x = normalize_2nd_moment(z.to(torch.float32)) # normalize z to shpere
- if self.c_dim > 0:
- misc.assert_shape(c, [None, self.c_dim])
- y = normalize_2nd_moment(self.embed(c.to(torch.float32)))
- x = torch.cat([x, y], dim=1) if x is not None else y
-
- # Main layers.
- for idx in range(self.num_layers):
- layer = getattr(self, f'fc{idx}')
- x = layer(x)
-
- # Update moving average of W.
- if self.w_avg_beta is not None and self.training and not skip_w_avg_update:
- with torch.autograd.profiler.record_function('update_w_avg'):
- self.w_avg.copy_(x.detach().mean(dim=0).lerp(self.w_avg, self.w_avg_beta))
-
- # Broadcast.
- if self.num_ws is not None:
- with torch.autograd.profiler.record_function('broadcast'):
- x = x.unsqueeze(1).repeat([1, self.num_ws, 1])
-
- # Apply truncation.
- if truncation_psi != 1:
- with torch.autograd.profiler.record_function('truncate'):
- assert self.w_avg_beta is not None
- if self.num_ws is None or truncation_cutoff is None:
- x = self.w_avg.lerp(x, truncation_psi)
- else:
- x[:, :truncation_cutoff] = self.w_avg.lerp(x[:, :truncation_cutoff], truncation_psi)
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class SynthesisLayer(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- out_channels, # Number of output channels.
- w_dim, # Intermediate latent (W) dimensionality.
- resolution, # Resolution of this layer.
- kernel_size = 3, # Convolution kernel size.
- up = 1, # Integer upsampling factor.
- use_noise = True, # Enable noise input?
- activation = 'lrelu', # Activation function: 'relu', 'lrelu', etc.
- resample_filter = [1,3,3,1], # Low-pass filter to apply when resampling activations.
- conv_clamp = None, # Clamp the output of convolution layers to +-X, None = disable clamping.
- channels_last = False, # Use channels_last format for the weights?
- upsample_mode = 'default', # [default, bilinear, ray_comm, ray_attn, ray_penc]
- use_group = False,
- magnitude_ema_beta = -1, # -1 means not using magnitude ema
- mode = '2d', # choose from 1d, 2d or 3d
- **unused_kwargs
- ):
- super().__init__()
- self.resolution = resolution
- self.up = up
- self.use_noise = use_noise
- self.activation = activation
- self.conv_clamp = conv_clamp
- self.upsample_mode = upsample_mode
- self.mode = mode
-
- self.register_buffer('resample_filter', upfirdn2d.setup_filter(resample_filter))
- if up == 2:
- if 'pixelshuffle' in upsample_mode:
- self.adapter = torch.nn.Sequential(
- Conv2dLayer(out_channels, out_channels // 4, kernel_size=1, activation=activation),
- Conv2dLayer(out_channels // 4, out_channels * 4, kernel_size=1, activation='linear'),
- )
- elif upsample_mode == 'liif':
- from dnnlib.geometry import get_grids, local_ensemble
- pi = get_grids(self.resolution//2, self.resolution//2, 'cpu', align=False).transpose(0,1)
- po = get_grids(self.resolution, self.resolution, 'cpu', align=False).transpose(0,1)
- diffs, coords, coeffs = local_ensemble(pi, po, self.resolution)
-
- self.diffs = torch.nn.Parameter(diffs, requires_grad=False)
- self.coords = torch.nn.Parameter(coords.float(), requires_grad=False)
- self.coeffs = torch.nn.Parameter(coeffs, requires_grad=False)
- add_dim = 2
- self.adapter = torch.nn.Sequential(
- Conv2dLayer(out_channels + add_dim, out_channels // 2, kernel_size=1, activation=activation),
- Conv2dLayer(out_channels // 2, out_channels, kernel_size=1, activation='linear'),
- )
- elif 'nn_cat' in upsample_mode:
- self.adapter = torch.nn.Sequential(
- Conv2dLayer(out_channels * 2, out_channels // 4, kernel_size=1, activation=activation),
- Conv2dLayer(out_channels // 4, out_channels, kernel_size=1, activation='linear'),
- )
- elif 'ada' in upsample_mode:
- self.adapter = torch.nn.Sequential(
- Conv2dLayer(out_channels, 8, kernel_size=1, activation=activation),
- Conv2dLayer(8, out_channels, kernel_size=1, activation='linear')
- )
- self.adapter[1].weight.data.zero_()
- if 'blur' in upsample_mode:
- self.blur = Blur()
-
- self.padding = kernel_size // 2
- self.groups = 2 if use_group else 1
- self.act_gain = bias_act.activation_funcs[activation].def_gain
- self.affine = FullyConnectedLayer(w_dim, in_channels, bias_init=1)
-
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- weight_sizes = [out_channels // self.groups, in_channels, kernel_size, kernel_size]
- if self.mode == '3d':
- weight_sizes += [kernel_size]
- weight = torch.randn(weight_sizes).to(memory_format=memory_format)
- self.weight = torch.nn.Parameter(weight)
-
- if use_noise:
- if self.mode == '2d':
- noise_sizes = [resolution, resolution]
- elif self.mode == '3d':
- noise_sizes = [resolution, resolution, resolution]
- else:
- raise NotImplementedError('not support for MLP')
- self.register_buffer('noise_const', torch.randn(noise_sizes)) # HACK: for safety reasons
- self.noise_strength = torch.nn.Parameter(torch.zeros([]))
- self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
-
- self.magnitude_ema_beta = magnitude_ema_beta
- if magnitude_ema_beta > 0:
- self.register_buffer('w_avg', torch.ones([])) # TODO: name for compitibality
-
- def forward(self, x, w, noise_mode='random', fused_modconv=True, gain=1, skip_up=False, input_noise=None, **unused_kwargs):
- assert noise_mode in ['random', 'const', 'none']
- batch_size = x.size(0)
-
- if (self.magnitude_ema_beta > 0):
- if self.training: # updating EMA.
- with torch.autograd.profiler.record_function('update_magnitude_ema'):
- magnitude_cur = x.detach().to(torch.float32).square().mean()
- self.w_avg.copy_(magnitude_cur.lerp(self.w_avg, self.magnitude_ema_beta))
- input_gain = self.w_avg.rsqrt()
- x = x * input_gain
-
- styles = self.affine(w) # Batch x style_dim
- if styles.size(0) < x.size(0): # for repeating
- assert (x.size(0) // styles.size(0) * styles.size(0) == x.size(0))
- styles = repeat(styles, 'b c -> (b s) c', s=x.size(0) // styles.size(0))
- up = self.up if not skip_up else 1
- use_default = (self.upsample_mode == 'default')
- noise = None
- resample_filter = None
- if use_default and (up > 1):
- resample_filter = self.resample_filter
-
- if self.use_noise:
- if input_noise is not None:
- noise = input_noise * self.noise_strength
- elif noise_mode == 'random':
- noise_sizes = [x.shape[0], 1, up * x.shape[2], up * x.shape[3]]
- if self.mode == '3d':
- noise_sizes += [up * x.shape[4]]
- noise = torch.randn(noise_sizes, device=x.device) * self.noise_strength
- elif noise_mode == 'const':
- noise = self.noise_const * self.noise_strength
- if noise.shape[-1] < (up * x.shape[3]):
- noise = repeat(noise, 'h w -> h (s w)', s=up*x.shape[3]//noise.shape[-1])
-
- flip_weight = (up == 1) # slightly faster
- x = modulated_conv2d(
- x=x, weight=self.weight, styles=styles,
- noise=noise if (use_default and not skip_up) else None,
- up=up if use_default else 1,
- padding=self.padding,
- resample_filter=resample_filter,
- flip_weight=flip_weight,
- fused_modconv=fused_modconv,
- groups=self.groups,
- mode=self.mode
- )
-
- if (up == 2) and (not use_default):
- resolution = x.size(-1) * 2
- if 'bilinear' in self.upsample_mode:
- x = F.interpolate(x, size=(resolution, resolution), mode='bilinear', align_corners=True)
- elif 'nearest' in self.upsample_mode:
- x = F.interpolate(x, size=(resolution, resolution), mode='nearest')
- x = upfirdn2d.filter2d(x, self.resample_filter)
- elif 'bicubic' in self.upsample_mode:
- x = F.interpolate(x, size=(resolution, resolution), mode='bicubic', align_corners=True)
- elif 'pixelshuffle' in self.upsample_mode: # does not have rotation invariance
- x = F.interpolate(x, size=(resolution, resolution), mode='nearest') + torch.pixel_shuffle(self.adapter(x), 2)
- if not 'noblur' in self.upsample_mode:
- x = upfirdn2d.filter2d(x, self.resample_filter)
- elif 'nn_cat' in self.upsample_mode:
- x_pad = x.new_zeros(*x.size()[:2], x.size(-2)+2, x.size(-1)+2)
- x_pad[...,1:-1,1:-1] = x
- xl, xu, xd, xr = x_pad[..., 1:-1, :-2], x_pad[..., :-2, 1:-1], x_pad[..., 2:, 1:-1], x_pad[..., 1:-1, 2:]
- x1, x2, x3, x4 = xl + xu, xu + xr, xl + xd, xr + xd
- xb = torch.stack([x1, x2, x3, x4], 2) / 2
- xb = torch.pixel_shuffle(xb.view(xb.size(0), -1, xb.size(-2), xb.size(-1)), 2)
- xa = F.interpolate(x, size=(resolution, resolution), mode='nearest')
- x = xa + self.adapter(torch.cat([xa, xb], 1))
- if not 'noblur' in self.upsample_mode:
- x = upfirdn2d.filter2d(x, self.resample_filter)
- elif self.upsample_mode == 'liif': # this is an old version
- x = torch.stack([x[..., self.coords[j,:,:,0].long(), self.coords[j,:,:,1].long()] for j in range(4)], 0)
- d = self.diffs[:, None].type_as(x).repeat(1,batch_size,1,1,1).permute(0,1,4,2,3)
- x = self.adapter(torch.cat([x, d.type_as(x)], 2).reshape(batch_size*4,-1,*x.size()[-2:]))
- x = (x.reshape(4,batch_size,*x.size()[-3:]) * self.coeffs[:,None,None].type_as(x)).sum(0)
- else:
- raise NotImplementedError
-
- if up == 2:
- if 'ada' in self.upsample_mode:
- x = x + self.adapter(x)
- if 'blur' in self.upsample_mode:
- x = self.blur(x)
-
- if (noise is not None) and (not use_default) and (not skip_up):
- x = x.add_(noise.type_as(x))
-
- act_gain = self.act_gain * gain
- act_clamp = self.conv_clamp * gain if self.conv_clamp is not None else None
- x = bias_act.bias_act(x, self.bias.to(x.dtype), act=self.activation, gain=act_gain, clamp=act_clamp)
-
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class SynthesisLayer3(torch.nn.Module):
- """copy from the stylegan3 codebase with minor changes"""
- def __init__(self,
- w_dim, # Intermediate latent (W) dimensionality.
- is_torgb, # Is this the final ToRGB layer?
- is_critically_sampled, # Does this layer use critical sampling?
- use_fp16, # Does this layer use FP16?
-
- # Input & output specifications.
- in_channels, # Number of input channels.
- out_channels, # Number of output channels.
- in_size, # Input spatial size: int or [width, height].
- out_size, # Output spatial size: int or [width, height].
- in_sampling_rate, # Input sampling rate (s).
- out_sampling_rate, # Output sampling rate (s).
- in_cutoff, # Input cutoff frequency (f_c).
- out_cutoff, # Output cutoff frequency (f_c).
- in_half_width, # Input transition band half-width (f_h).
- out_half_width, # Output Transition band half-width (f_h).
-
- # Hyperparameters.
- kernel_size = 3, # Convolution kernel size. Ignored for final the ToRGB layer.
- filter_size = 6, # Low-pass filter size relative to the lower resolution when up/downsampling.
- lrelu_upsampling = 2, # Relative sampling rate for leaky ReLU. Ignored for final the ToRGB layer.
- use_radial_filters = False, # Use radially symmetric downsampling filter? Ignored for critically sampled layers.
- conv_clamp = 256, # Clamp the output to [-X, +X], None = disable clamping.
- magnitude_ema_beta = 0.999, # Decay rate for the moving average of input magnitudes.
-
- **unused_kwargs,
- ):
- super().__init__()
- self.w_dim = w_dim
- self.is_torgb = is_torgb
- self.is_critically_sampled = is_critically_sampled
- self.use_fp16 = use_fp16
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.in_size = np.broadcast_to(np.asarray(in_size), [2])
- self.out_size = np.broadcast_to(np.asarray(out_size), [2])
- self.in_sampling_rate = in_sampling_rate
- self.out_sampling_rate = out_sampling_rate
- self.tmp_sampling_rate = max(in_sampling_rate, out_sampling_rate) * (1 if is_torgb else lrelu_upsampling)
- self.in_cutoff = in_cutoff
- self.out_cutoff = out_cutoff
- self.in_half_width = in_half_width
- self.out_half_width = out_half_width
- self.conv_kernel = 1 if is_torgb else kernel_size
- self.conv_clamp = conv_clamp
- self.magnitude_ema_beta = magnitude_ema_beta
-
- # Setup parameters and buffers.
- self.affine = FullyConnectedLayer(self.w_dim, self.in_channels, bias_init=1)
- self.weight = torch.nn.Parameter(torch.randn([self.out_channels, self.in_channels, self.conv_kernel, self.conv_kernel]))
- self.bias = torch.nn.Parameter(torch.zeros([self.out_channels]))
- if magnitude_ema_beta > 0:
- self.register_buffer('w_avg', torch.ones([]))
-
- # Design upsampling filter.
- self.up_factor = int(np.rint(self.tmp_sampling_rate / self.in_sampling_rate))
- assert self.in_sampling_rate * self.up_factor == self.tmp_sampling_rate
- self.up_taps = filter_size * self.up_factor if self.up_factor > 1 and not self.is_torgb else 1
- self.register_buffer('up_filter', self.design_lowpass_filter(
- numtaps=self.up_taps, cutoff=self.in_cutoff, width=self.in_half_width*2, fs=self.tmp_sampling_rate))
-
- # Design downsampling filter.
- self.down_factor = int(np.rint(self.tmp_sampling_rate / self.out_sampling_rate))
- assert self.out_sampling_rate * self.down_factor == self.tmp_sampling_rate
- self.down_taps = filter_size * self.down_factor if self.down_factor > 1 and not self.is_torgb else 1
- self.down_radial = use_radial_filters and not self.is_critically_sampled
- self.register_buffer('down_filter', self.design_lowpass_filter(
- numtaps=self.down_taps, cutoff=self.out_cutoff, width=self.out_half_width*2, fs=self.tmp_sampling_rate, radial=self.down_radial))
-
- # Compute padding.
- pad_total = (self.out_size - 1) * self.down_factor + 1 # Desired output size before downsampling.
- pad_total -= (self.in_size + self.conv_kernel - 1) * self.up_factor # Input size after upsampling.
- pad_total += self.up_taps + self.down_taps - 2 # Size reduction caused by the filters.
- pad_lo = (pad_total + self.up_factor) // 2 # Shift sample locations according to the symmetric interpretation (Appendix C.3).
- pad_hi = pad_total - pad_lo
- self.padding = [int(pad_lo[0]), int(pad_hi[0]), int(pad_lo[1]), int(pad_hi[1])]
-
- def forward(self, x, w, noise_mode='random', force_fp32=False, **unused_kwargs):
- assert noise_mode in ['random', 'const', 'none'] # unused
- misc.assert_shape(x, [None, self.in_channels, int(self.in_size[1]), int(self.in_size[0])])
- misc.assert_shape(w, [x.shape[0], self.w_dim])
-
- # Track input magnitude.
- if (self.magnitude_ema_beta > 0):
- if self.training: # updating EMA.
- with torch.autograd.profiler.record_function('update_magnitude_ema'):
- magnitude_cur = x.detach().to(torch.float32).square().mean()
- self.w_avg.copy_(magnitude_cur.lerp(self.w_avg, self.magnitude_ema_beta))
- input_gain = self.w_avg.rsqrt()
- x = x * input_gain
-
- # Execute affine layer.
- styles = self.affine(w)
- if self.is_torgb:
- weight_gain = 1 / np.sqrt(self.in_channels * (self.conv_kernel ** 2))
- styles = styles * weight_gain
-
- # Execute modulated conv2d.
- dtype = torch.float16 if (self.use_fp16 and not force_fp32 and x.device.type == 'cuda') else torch.float32
- x = modulated_conv2d(x=x.to(dtype), weight=self.weight, styles=styles, padding=self.conv_kernel-1, up=1, fused_modconv=True)
-
- # Execute bias, filtered leaky ReLU, and clamping.
- gain = 1 if self.is_torgb else np.sqrt(2)
- slope = 1 if self.is_torgb else 0.2
- x = filtered_lrelu.filtered_lrelu(x=x, fu=self.up_filter, fd=self.down_filter, b=self.bias.to(x.dtype),
- up=self.up_factor, down=self.down_factor, padding=self.padding, gain=gain, slope=slope, clamp=self.conv_clamp)
-
- # Ensure correct shape and dtype.
- misc.assert_shape(x, [None, self.out_channels, int(self.out_size[1]), int(self.out_size[0])])
- assert x.dtype == dtype
- return x
-
- @staticmethod
- def design_lowpass_filter(numtaps, cutoff, width, fs, radial=False):
- assert numtaps >= 1
-
- # Identity filter.
- if numtaps == 1:
- return None
-
- # Separable Kaiser low-pass filter.
- if not radial:
- f = scipy.signal.firwin(numtaps=numtaps, cutoff=cutoff, width=width, fs=fs)
- return torch.as_tensor(f, dtype=torch.float32)
-
- # Radially symmetric jinc-based filter.
- x = (np.arange(numtaps) - (numtaps - 1) / 2) / fs
- r = np.hypot(*np.meshgrid(x, x))
- f = scipy.special.j1(2 * cutoff * (np.pi * r)) / (np.pi * r)
- beta = scipy.signal.kaiser_beta(scipy.signal.kaiser_atten(numtaps, width / (fs / 2)))
- w = np.kaiser(numtaps, beta)
- f *= np.outer(w, w)
- f /= np.sum(f)
- return torch.as_tensor(f, dtype=torch.float32)
-
- def extra_repr(self):
- return '\n'.join([
- f'w_dim={self.w_dim:d}, is_torgb={self.is_torgb},',
- f'is_critically_sampled={self.is_critically_sampled}, use_fp16={self.use_fp16},',
- f'in_sampling_rate={self.in_sampling_rate:g}, out_sampling_rate={self.out_sampling_rate:g},',
- f'in_cutoff={self.in_cutoff:g}, out_cutoff={self.out_cutoff:g},',
- f'in_half_width={self.in_half_width:g}, out_half_width={self.out_half_width:g},',
- f'in_size={list(self.in_size)}, out_size={list(self.out_size)},',
- f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}'])
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class ToRGBLayer(torch.nn.Module):
- def __init__(self, in_channels, out_channels, w_dim=0, kernel_size=1, conv_clamp=None, channels_last=False, mode='2d', **unused):
- super().__init__()
- self.conv_clamp = conv_clamp
- self.mode = mode
- weight_shape = [out_channels, in_channels, kernel_size, kernel_size]
- if mode == '3d':
- weight_shape += [kernel_size]
-
- if w_dim > 0:
- self.affine = FullyConnectedLayer(w_dim, in_channels, bias_init=1)
- memory_format = torch.channels_last if channels_last else torch.contiguous_format
- self.weight = torch.nn.Parameter(torch.randn(weight_shape).to(memory_format=memory_format))
- self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
- self.weight_gain = 1 / np.sqrt(np.prod(weight_shape[1:]))
-
- else:
- assert kernel_size == 1, "does not support larger kernel sizes for now. used in NeRF"
- assert mode != '3d', "does not support 3D convolution for now"
-
- self.weight = torch.nn.Parameter(torch.Tensor(out_channels, in_channels))
- self.bias = torch.nn.Parameter(torch.Tensor(out_channels))
- self.weight_gain = 1.
-
- # initialization
- torch.nn.init.kaiming_uniform_(self.weight, a=math.sqrt(5))
- fan_in, _ = torch.nn.init._calculate_fan_in_and_fan_out(self.weight)
- bound = 1 / math.sqrt(fan_in)
- torch.nn.init.uniform_(self.bias, -bound, bound)
-
- def forward(self, x, w=None, fused_modconv=True):
- if w is not None:
- styles = self.affine(w) * self.weight_gain
- if x.size(0) > styles.size(0):
- assert (x.size(0) // styles.size(0) * styles.size(0) == x.size(0))
- styles = repeat(styles, 'b c -> (b s) c', s=x.size(0) // styles.size(0))
- x = modulated_conv2d(x=x, weight=self.weight, styles=styles, demodulate=False, fused_modconv=fused_modconv, mode=self.mode)
- x = bias_act.bias_act(x, self.bias.to(x.dtype), clamp=self.conv_clamp)
- else:
- if x.ndim == 2:
- x = F.linear(x, self.weight, self.bias)
- else:
- x = F.conv2d(x, self.weight[:,:,None,None], self.bias)
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class SynthesisBlock(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels, 0 = first block.
- out_channels, # Number of output channels.
- w_dim, # Intermediate latent (W) dimensionality.
- resolution, # Resolution of this block.
- img_channels, # Number of output color channels.
- is_last, # Is this the last block?
- architecture = 'skip', # Architecture: 'orig', 'skip', 'resnet'.
- resample_filter = [1,3,3,1], # Low-pass filter to apply when resampling activations.
- conv_clamp = None, # Clamp the output of convolution layers to +-X, None = disable clamping.
- use_fp16 = False, # Use FP16 for this block?
- fp16_channels_last = False, # Use channels-last memory format with FP16?
- use_single_layer = False, # use only one instead of two synthesis layer
- disable_upsample = False,
- **layer_kwargs, # Arguments for SynthesisLayer.
- ):
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.w_dim = w_dim
- self.resolution = resolution
- self.img_channels = img_channels
- self.is_last = is_last
- self.architecture = architecture
- self.use_fp16 = use_fp16
- self.channels_last = (use_fp16 and fp16_channels_last)
- self.register_buffer('resample_filter', upfirdn2d.setup_filter(resample_filter))
- self.num_conv = 0
- self.num_torgb = 0
-
- self.groups = 1
- self.use_single_layer = use_single_layer
- self.margin = layer_kwargs.get('margin', 0)
- self.upsample_mode = layer_kwargs.get('upsample_mode', 'default')
- self.disable_upsample = disable_upsample
- self.mode = layer_kwargs.get('mode', '2d')
-
- if in_channels == 0:
- const_sizes = [out_channels, resolution, resolution]
- if self.mode == '3d':
- const_sizes = const_sizes + [resolution]
- self.const = torch.nn.Parameter(torch.randn(const_sizes))
-
- if in_channels != 0:
- self.conv0 = util.construct_class_by_name(
- class_name=layer_kwargs.get('layer_name', "training.networks.SynthesisLayer"),
- in_channels=in_channels, out_channels=out_channels,
- w_dim=w_dim, resolution=resolution,
- up=2 if (not disable_upsample) else 1,
- resample_filter=resample_filter, conv_clamp=conv_clamp,
- channels_last=self.channels_last, **layer_kwargs)
- self.num_conv += 1
-
- if not self.use_single_layer:
- self.conv1 = util.construct_class_by_name(
- class_name=layer_kwargs.get('layer_name', "training.networks.SynthesisLayer"),
- in_channels=out_channels, out_channels=out_channels,
- w_dim=w_dim, resolution=resolution,
- conv_clamp=conv_clamp, channels_last=self.channels_last, **layer_kwargs)
- self.num_conv += 1
-
- if is_last or architecture == 'skip':
- self.torgb = ToRGBLayer(
- out_channels, img_channels, w_dim=w_dim,
- conv_clamp=conv_clamp, channels_last=self.channels_last,
- groups=self.groups, mode=self.mode)
- self.num_torgb += 1
-
- if in_channels != 0 and architecture == 'resnet':
- self.skip = Conv2dLayer(
- in_channels, out_channels, kernel_size=1, bias=False, up=2,
- resample_filter=resample_filter,
- channels_last=self.channels_last,
- mode=self.mode)
-
- def forward(self, x, img, ws, force_fp32=False, fused_modconv=None, add_on=None, block_noise=None, disable_rgb=False, **layer_kwargs):
- misc.assert_shape(ws, [None, self.num_conv + self.num_torgb, self.w_dim])
- w_iter = iter(ws.unbind(dim=1))
- dtype = torch.float16 if (self.use_fp16 and x.device.type == 'cuda') and not force_fp32 else torch.float32
- memory_format = torch.channels_last if self.channels_last and not force_fp32 else torch.contiguous_format
- if fused_modconv is None:
- with misc.suppress_tracer_warnings(): # this value will be treated as a constant
- fused_modconv = (not self.training) and (dtype == torch.float32 or int(x.shape[0]) == 1)
-
- # Input.
- if self.in_channels == 0:
- x = self.const.to(dtype=dtype, memory_format=memory_format)
- x = x.unsqueeze(0).expand(ws.shape[0], *x.size())
- else:
- x = x.to(dtype=dtype, memory_format=memory_format)
-
- # Main layers.
- if add_on is not None:
- add_on = add_on.to(dtype=dtype, memory_format=memory_format)
-
- if self.in_channels == 0:
- if not self.use_single_layer:
- layer_kwargs['input_noise'] = block_noise[:,1:2] if block_noise is not None else None
- x = self.conv1(x, next(w_iter), fused_modconv=fused_modconv, **layer_kwargs)
-
- elif self.architecture == 'resnet':
- y = self.skip(x, gain=np.sqrt(0.5))
- layer_kwargs['input_noise'] = block_noise[:,0:1] if block_noise is not None else None
- x = self.conv0(x, next(w_iter), fused_modconv=fused_modconv, **layer_kwargs)
- if not self.use_single_layer:
- layer_kwargs['input_noise'] = block_noise[:,1:2] if block_noise is not None else None
- x = self.conv1(x, next(w_iter), fused_modconv=fused_modconv, gain=np.sqrt(0.5), **layer_kwargs)
- x = y.add_(x)
- else:
- layer_kwargs['input_noise'] = block_noise[:,0:1] if block_noise is not None else None
- x = self.conv0(x, next(w_iter), fused_modconv=fused_modconv, **layer_kwargs)
- if not self.use_single_layer:
- layer_kwargs['input_noise'] = block_noise[:,1:2] if block_noise is not None else None
- x = self.conv1(x, next(w_iter), fused_modconv=fused_modconv, **layer_kwargs)
-
- # ToRGB.
- if img is not None:
- if img.size(-1) * 2 == x.size(-1):
- if (self.upsample_mode == 'bilinear_all') or (self.upsample_mode == 'bilinear_ada'):
- img = F.interpolate(img, scale_factor=2, mode='bilinear', align_corners=True)
- else:
- img = upfirdn2d.upsample2d(img, self.resample_filter) # this is upsampling. Not sure about details and why they do this..
- elif img.size(-1) == x.size(-1):
- pass
- else:
- raise NotImplementedError
-
- if self.is_last or self.architecture == 'skip':
- if not disable_rgb:
- y = x if add_on is None else x + add_on
- y = self.torgb(y, next(w_iter), fused_modconv=fused_modconv)
- y = y.to(dtype=torch.float32, memory_format=torch.contiguous_format)
- img = img.add_(y) if img is not None else y
- else:
- img = None
-
- assert x.dtype == dtype
- assert img is None or img.dtype == torch.float32
- return x, img
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class SynthesisBlock3(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels, 0 = first block.
- out_channels, # Number of output channels.
- w_dim, # Intermediate latent (W) dimensionality.
- resolution, # Resolution of this block.
- img_channels, # Number of output color channels.
- block_id,
- stylegan3_hyperam,
- use_fp16 = False, # Use FP16 for this block?
- **layer_kwargs, # Arguments for SynthesisLayer.
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.w_dim = w_dim
- self.resolution = resolution
- self.img_channels = img_channels
- self.num_conv = 0
- self.num_torgb = 0
- self.use_fp16 = use_fp16
-
- is_critically_sampled = block_id == (len(stylegan3_hyperam['sampling_rates'][:-1]) // 2 - 1)
- sizes, sampling_rates, cutoffs, half_widths = \
- stylegan3_hyperam['sizes'], stylegan3_hyperam['sampling_rates'], \
- stylegan3_hyperam['cutoffs'], stylegan3_hyperam['half_widths']
-
- # each block has two layer
- prev = max(block_id * 2 - 1, 0)
- curr = block_id * 2
- self.conv0 = util.construct_class_by_name(
- class_name=layer_kwargs.get('layer_name', "training.networks.SynthesisLayer3"),
- w_dim=self.w_dim,
- is_torgb=False,
- is_critically_sampled=is_critically_sampled,
- use_fp16=use_fp16,
- in_channels=in_channels,
- out_channels=out_channels,
- in_size=int(sizes[prev]),
- out_size=int(sizes[curr]),
- in_sampling_rate=int(sampling_rates[prev]),
- out_sampling_rate=int(sampling_rates[curr]),
- in_cutoff=cutoffs[prev],
- out_cutoff=cutoffs[curr],
- in_half_width=half_widths[prev],
- out_half_width=half_widths[curr],
- use_radial_filters=True,
- **layer_kwargs)
- self.num_conv += 1
-
- prev = block_id * 2
- curr = block_id * 2 + 1
- self.conv1 = util.construct_class_by_name(
- class_name=layer_kwargs.get('layer_name', "training.networks.SynthesisLayer3"),
- w_dim=self.w_dim,
- is_torgb=False,
- is_critically_sampled=is_critically_sampled,
- use_fp16=use_fp16,
- in_channels=out_channels,
- out_channels=out_channels,
- in_size=int(sizes[prev]),
- out_size=int(sizes[curr]),
- in_sampling_rate=int(sampling_rates[prev]),
- out_sampling_rate=int(sampling_rates[curr]),
- in_cutoff=cutoffs[prev],
- out_cutoff=cutoffs[curr],
- in_half_width=half_widths[prev],
- out_half_width=half_widths[curr],
- use_radial_filters=True,
- **layer_kwargs)
- self.num_conv += 1
-
- # toRGB layer (used for progressive growing)
- self.torgb = ToRGBLayer(out_channels, img_channels, w_dim=w_dim)
- self.num_torgb += 1
-
- def forward(self, x, img, ws, force_fp32=False, add_on=None, disable_rgb=False, **layer_kwargs):
- w_iter = iter(ws.unbind(dim=1))
- dtype = torch.float16 if (self.use_fp16 and x.device.type == 'cuda') and not force_fp32 else torch.float32
- memory_format = torch.contiguous_format
-
- # Main layers.
- x = x.to(dtype=dtype, memory_format=memory_format)
- if add_on is not None:
- add_on = add_on.to(dtype=dtype, memory_format=memory_format)
-
- x = self.conv0(x, next(w_iter), **layer_kwargs)
- x = self.conv1(x, next(w_iter), **layer_kwargs)
-
- assert img is None, "currently not support."
- if not disable_rgb:
- y = x if add_on is None else x + add_on
- y = self.torgb(y, next(w_iter), fused_modconv=True)
- y = y.to(dtype=torch.float32, memory_format=torch.contiguous_format)
- img = y
-
- assert x.dtype == dtype
- assert img is None or img.dtype == torch.float32
- return x, img
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class SynthesisNetwork(torch.nn.Module):
- def __init__(self,
- w_dim, # Intermediate latent (W) dimensionality.
- img_resolution, # Output image resolution.
- img_channels, # Number of color channels.
- channel_base = 1, # Overall multiplier for the number of channels.
- channel_max = 512, # Maximum number of channels in any layer.
- num_fp16_res = 0, # Use FP16 for the N highest resolutions.
- **block_kwargs, # Arguments for SynthesisBlock.
- ):
- assert img_resolution >= 4 and img_resolution & (img_resolution - 1) == 0
- super().__init__()
- self.w_dim = w_dim
- self.img_resolution = img_resolution
- self.img_resolution_log2 = int(np.log2(img_resolution))
- self.img_channels = img_channels
- self.block_resolutions = [2 ** i for i in range(2, self.img_resolution_log2 + 1)]
-
- channel_base = int(channel_base * 32768)
- channels_dict = {res: min(channel_base // res, channel_max) for res in self.block_resolutions}
- fp16_resolution = max(2 ** (self.img_resolution_log2 + 1 - num_fp16_res), 8)
- self.channels_dict = channels_dict
-
- self.num_ws = 0
- for res in self.block_resolutions:
- in_channels = channels_dict[res // 2] if res > 4 else 0
- out_channels = channels_dict[res]
- use_fp16 = (res >= fp16_resolution)
- is_last = (res == self.img_resolution)
- block = util.construct_class_by_name(
- class_name=block_kwargs.get('block_name', "training.networks.SynthesisBlock"),
- in_channels=in_channels, out_channels=out_channels, w_dim=w_dim, resolution=res,
- img_channels=img_channels, is_last=is_last, use_fp16=use_fp16, **block_kwargs)
-
- self.num_ws += block.num_conv
- if is_last:
- self.num_ws += block.num_torgb
- setattr(self, f'b{res}', block)
-
- def forward(self, ws, **block_kwargs):
- block_ws = []
-
- # this part is to slice the style matrices (W) to each layer (conv/RGB)
- with torch.autograd.profiler.record_function('split_ws'):
- misc.assert_shape(ws, [None, self.num_ws, self.w_dim])
- ws = ws.to(torch.float32)
- w_idx = 0
- for res in self.block_resolutions:
- block = getattr(self, f'b{res}')
- block_ws.append(ws.narrow(1, w_idx, block.num_conv + block.num_torgb))
- w_idx += block.num_conv
-
- x = img = None
- for res, cur_ws in zip(self.block_resolutions, block_ws):
- block = getattr(self, f'b{res}')
- x, img = block(x, img, cur_ws, **block_kwargs)
- return img
-
- def get_current_resolution(self):
- return [self.img_resolution] # For compitibility
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class Generator(torch.nn.Module):
- def __init__(self,
- z_dim, # Input latent (Z) dimensionality.
- c_dim, # Conditioning label (C) dimensionality.
- w_dim, # Intermediate latent (W) dimensionality.
- img_resolution, # Output resolution.
- img_channels, # Number of output color channels.
- mapping_kwargs = {}, # Arguments for MappingNetwork.
- synthesis_kwargs = {}, # Arguments for SynthesisNetwork.
- encoder_kwargs = {}, # Arguments for Encoder (optional)
- ):
- super().__init__()
- self.z_dim = z_dim
- self.c_dim = c_dim
- self.w_dim = w_dim
- self.img_resolution = img_resolution
- self.img_channels = img_channels
- self.synthesis = util.construct_class_by_name(
- class_name=synthesis_kwargs.get('module_name', "training.networks.SynthesisNetwork"),
- w_dim=w_dim, img_resolution=img_resolution, img_channels=img_channels, **synthesis_kwargs)
- self.num_ws = self.synthesis.num_ws
- self.mapping = None
- self.encoder = None
-
- if len(mapping_kwargs) > 0: # Use mapping network
- self.mapping = util.construct_class_by_name(
- class_name=mapping_kwargs.get('module_name', "training.networks.MappingNetwork"),
- z_dim=z_dim, c_dim=c_dim, w_dim=w_dim, num_ws=self.num_ws, **mapping_kwargs)
-
- if len(encoder_kwargs) > 0: # Use Image-Encoder
- encoder_kwargs['model_kwargs'].update({'num_ws': self.num_ws, 'w_dim': self.w_dim})
- self.encoder = util.construct_class_by_name(
- img_resolution=img_resolution,
- img_channels=img_channels,
- **encoder_kwargs)
-
- def forward(self, z=None, c=None, styles=None, truncation_psi=1, truncation_cutoff=None, img=None, **synthesis_kwargs):
- if styles is None:
- assert z is not None
- if (self.encoder is not None) and (img is not None): #TODO: debug
- outputs = self.encoder(img)
- ws = outputs['ws']
- if ('camera' in outputs) and ('camera_mode' not in synthesis_kwargs):
- synthesis_kwargs['camera_RT'] = outputs['camera']
- else:
- ws = self.mapping(z, c, truncation_psi=truncation_psi, truncation_cutoff=truncation_cutoff, **synthesis_kwargs)
- else:
- ws = styles
-
- img = self.synthesis(ws, **synthesis_kwargs)
- return img
-
- def get_final_output(self, *args, **kwargs):
- img = self.forward(*args, **kwargs)
- if isinstance(img, list):
- return img[-1]
- elif isinstance(img, dict):
- return img['img']
- return img
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class DiscriminatorBlock(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels, 0 = first block.
- tmp_channels, # Number of intermediate channels.
- out_channels, # Number of output channels.
- resolution, # Resolution of this block.
- img_channels, # Number of input color channels.
- first_layer_idx, # Index of the first layer.
- architecture = 'resnet', # Architecture: 'orig', 'skip', 'resnet'.
- activation = 'lrelu', # Activation function: 'relu', 'lrelu', etc.
- resample_filter = [1,3,3,1], # Low-pass filter to apply when resampling activations.
- conv_clamp = None, # Clamp the output of convolution layers to +-X, None = disable clamping.
- use_fp16 = False, # Use FP16 for this block?
- fp16_channels_last = False, # Use channels-last memory format with FP16?
- freeze_layers = 0, # Freeze-D: Number of layers to freeze.
- ):
- assert in_channels in [0, tmp_channels]
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.resolution = resolution
- self.img_channels = img_channels
- self.first_layer_idx = first_layer_idx
- self.architecture = architecture
- self.use_fp16 = use_fp16
- self.channels_last = (use_fp16 and fp16_channels_last)
- self.register_buffer('resample_filter', upfirdn2d.setup_filter(resample_filter))
-
- self.num_layers = 0
- def trainable_gen():
- while True:
- layer_idx = self.first_layer_idx + self.num_layers
- trainable = (layer_idx >= freeze_layers)
- self.num_layers += 1
- yield trainable
- trainable_iter = trainable_gen()
-
- if in_channels == 0 or architecture == 'skip':
- self.fromrgb = Conv2dLayer(img_channels, tmp_channels, kernel_size=1, activation=activation,
- trainable=next(trainable_iter), conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- self.conv0 = Conv2dLayer(tmp_channels, tmp_channels, kernel_size=3, activation=activation,
- trainable=next(trainable_iter), conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- self.conv1 = Conv2dLayer(tmp_channels, out_channels, kernel_size=3, activation=activation, down=2,
- trainable=next(trainable_iter), resample_filter=resample_filter, conv_clamp=conv_clamp, channels_last=self.channels_last)
-
- if architecture == 'resnet':
- self.skip = Conv2dLayer(tmp_channels, out_channels, kernel_size=1, bias=False, down=2,
- trainable=next(trainable_iter), resample_filter=resample_filter, channels_last=self.channels_last)
-
- def forward(self, x, img, force_fp32=False, downsampler=None):
- dtype = torch.float16 if (self.use_fp16 and x.device.type == 'cuda') and not force_fp32 else torch.float32
- memory_format = torch.channels_last if self.channels_last and not force_fp32 else torch.contiguous_format
-
- # Input.
- if x is not None:
- misc.assert_shape(x, [None, self.in_channels, self.resolution, self.resolution])
- x = x.to(dtype=dtype, memory_format=memory_format)
-
- # FromRGB.
- if self.in_channels == 0 or self.architecture == 'skip':
- misc.assert_shape(img, [None, self.img_channels, self.resolution, self.resolution])
- img = img.to(dtype=dtype, memory_format=memory_format)
- y = self.fromrgb(img)
- x = x + y if x is not None else y
- if self.architecture != 'skip':
- img = None
- elif downsampler is not None:
- img = downsampler(img, 2)
- else:
- img = upfirdn2d.downsample2d(img, self.resample_filter)
-
- # Main layers.
- if self.architecture == 'resnet':
- y = self.skip(x, gain=np.sqrt(0.5))
- x = self.conv0(x)
- x = self.conv1(x, gain=np.sqrt(0.5))
- x = y.add_(x)
- else:
- x = self.conv0(x)
- x = self.conv1(x)
-
- assert x.dtype == dtype
- return x, img
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class MinibatchStdLayer(torch.nn.Module):
- def __init__(self, group_size, num_channels=1):
- super().__init__()
- self.group_size = group_size
- self.num_channels = num_channels
-
- def forward(self, x):
- N, C, H, W = x.shape
- with misc.suppress_tracer_warnings(): # as_tensor results are registered as constants
- G = torch.min(torch.as_tensor(self.group_size), torch.as_tensor(N)) if self.group_size is not None else N
- F = self.num_channels
- c = C // F
-
- y = x.reshape(G, -1, F, c, H, W) # [GnFcHW] Split minibatch N into n groups of size G, and channels C into F groups of size c.
- y = y - y.mean(dim=0) # [GnFcHW] Subtract mean over group.
- y = y.square().mean(dim=0) # [nFcHW] Calc variance over group.
- y = (y + 1e-8).sqrt() # [nFcHW] Calc stddev over group.
- y = y.mean(dim=[2,3,4]) # [nF] Take average over channels and pixels.
- y = y.reshape(-1, F, 1, 1) # [nF11] Add missing dimensions.
- y = y.repeat(G, 1, H, W) # [NFHW] Replicate over group and pixels.
- x = torch.cat([x, y], dim=1) # [NCHW] Append to input as new channels.
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class DiscriminatorEpilogue(torch.nn.Module):
- def __init__(self,
- in_channels, # Number of input channels.
- cmap_dim, # Dimensionality of mapped conditioning label, 0 = no label.
- resolution, # Resolution of this block.
- img_channels, # Number of input color channels.
- architecture = 'resnet', # Architecture: 'orig', 'skip', 'resnet'.
- mbstd_group_size = 4, # Group size for the minibatch standard deviation layer, None = entire minibatch.
- mbstd_num_channels = 1, # Number of features for the minibatch standard deviation layer, 0 = disable.
- activation = 'lrelu', # Activation function: 'relu', 'lrelu', etc.
- conv_clamp = None, # Clamp the output of convolution layers to +-X, None = disable clamping.
- final_channels = 1, # for classification it is always 1.
- ):
- assert architecture in ['orig', 'skip', 'resnet']
- super().__init__()
- self.in_channels = in_channels
- self.final_channels = final_channels
- self.cmap_dim = cmap_dim
- self.resolution = resolution
- self.img_channels = img_channels
- self.architecture = architecture
-
- if architecture == 'skip':
- self.fromrgb = Conv2dLayer(img_channels, in_channels, kernel_size=1, activation=activation)
- self.mbstd = MinibatchStdLayer(group_size=mbstd_group_size, num_channels=mbstd_num_channels) if mbstd_num_channels > 0 else None
- self.conv = Conv2dLayer(in_channels + mbstd_num_channels, in_channels, kernel_size=3, activation=activation, conv_clamp=conv_clamp)
- self.fc = FullyConnectedLayer(in_channels * (resolution ** 2), in_channels, activation=activation)
- self.out = FullyConnectedLayer(in_channels, final_channels if cmap_dim == 0 else cmap_dim)
-
- def forward(self, x, img, cmap, force_fp32=False):
- misc.assert_shape(x, [None, self.in_channels, self.resolution, self.resolution]) # [NCHW]
- _ = force_fp32 # unused
- dtype = torch.float32
- memory_format = torch.contiguous_format
-
- # FromRGB.
- x = x.to(dtype=dtype, memory_format=memory_format)
- if self.architecture == 'skip':
- misc.assert_shape(img, [None, self.img_channels, self.resolution, self.resolution])
- img = img.to(dtype=dtype, memory_format=memory_format)
- x = x + self.fromrgb(img)
-
- # Main layers.
- if self.mbstd is not None:
- x = self.mbstd(x)
- x = self.conv(x)
- x = self.fc(x.flatten(1))
- x = self.out(x)
-
- # Conditioning.
- if self.cmap_dim > 0:
- if not isinstance(cmap, list):
- cmap = [cmap] # in case of multiple conditions. a trick (TODO)
- x = [(x * c).sum(dim=1, keepdim=True) * (1 / np.sqrt(self.cmap_dim)) for c in cmap]
- x = sum(x) / len(cmap)
-
- assert x.dtype == dtype
- return x
-
-#----------------------------------------------------------------------------
-
-@persistence.persistent_class
-class Discriminator(torch.nn.Module): # The original StyleGAN2 discriminator
- def __init__(self,
- c_dim, # Conditioning label (C) dimensionality.
- img_resolution, # Input resolution.
- img_channels, # Number of input color channels.
- architecture = 'resnet', # Architecture: 'orig', 'skip', 'resnet'.
- channel_base = 32768, # Overall multiplier for the number of channels.
- channel_max = 512, # Maximum number of channels in any layer.
- num_fp16_res = 0, # Use FP16 for the N highest resolutions.
- conv_clamp = None, # Clamp the output of convolution layers to +-X, None = disable clamping.
- cmap_dim = None, # Dimensionality of mapped conditioning label, None = default.
- block_kwargs = {}, # Arguments for DiscriminatorBlock.
- mapping_kwargs = {}, # Arguments for MappingNetwork.
- epilogue_kwargs = {}, # Arguments for DiscriminatorEpilogue.
- ):
- super().__init__()
- self.c_dim = c_dim
- self.img_resolution = img_resolution
- self.img_resolution_log2 = int(np.log2(img_resolution))
- self.img_channels = img_channels
- self.block_resolutions = [2 ** i for i in range(self.img_resolution_log2, 2, -1)]
- channels_dict = {res: min(channel_base // res, channel_max) for res in self.block_resolutions + [4]}
- fp16_resolution = max(2 ** (self.img_resolution_log2 + 1 - num_fp16_res), 8)
-
- if cmap_dim is None:
- cmap_dim = channels_dict[4]
- if c_dim == 0:
- cmap_dim = 0
-
- common_kwargs = dict(img_channels=img_channels, architecture=architecture, conv_clamp=conv_clamp)
- cur_layer_idx = 0
- for res in self.block_resolutions:
- in_channels = channels_dict[res] if res < img_resolution else 0
- tmp_channels = channels_dict[res]
- out_channels = channels_dict[res // 2]
- use_fp16 = (res >= fp16_resolution)
- block = DiscriminatorBlock(in_channels, tmp_channels, out_channels, resolution=res,
- first_layer_idx=cur_layer_idx, use_fp16=use_fp16, **block_kwargs, **common_kwargs)
- setattr(self, f'b{res}', block)
- cur_layer_idx += block.num_layers
- if c_dim > 0:
- self.mapping = MappingNetwork(z_dim=0, c_dim=c_dim, w_dim=cmap_dim, num_ws=None, w_avg_beta=None, **mapping_kwargs)
- self.b4 = DiscriminatorEpilogue(channels_dict[4], cmap_dim=cmap_dim, resolution=4, **epilogue_kwargs, **common_kwargs)
-
- def forward(self, img, c, **block_kwargs):
- x = None
- if isinstance(img, dict):
- img = img['img']
- for res in self.block_resolutions:
- block = getattr(self, f'b{res}')
- x, img = block(x, img, **block_kwargs)
-
- cmap = None
- if self.c_dim > 0:
- cmap = self.mapping(None, c)
- x = self.b4(x, img, cmap)
- return x
-
-#----------------------------------------------------------------------------
-# encoders maybe used for inversion (not cleaned)
-
-@persistence.persistent_class
-class EncoderResBlock(torch.nn.Module):
- def __init__(self, in_channel, out_channel, blur_kernel=[1, 3, 3, 1]):
- super().__init__()
-
- self.conv1 = Conv2dLayer(in_channel, in_channel, 3, activation='lrelu')
- self.conv2 = Conv2dLayer(in_channel, out_channel, 3, down=2, activation='lrelu')
- self.skip = Conv2dLayer(in_channel, out_channel, 1, down=2, activation='linear', bias=False)
-
- def forward(self, input):
- out = self.conv1(input)
- out = self.conv2(out)
- skip = self.skip(input)
- out = (out + skip) / math.sqrt(2)
- return out
-
-
-@persistence.persistent_class
-class EqualConv2d(torch.nn.Module):
- def __init__(
- self, in_channel, out_channel, kernel_size, stride=1, padding=0, bias=True
- ):
- super().__init__()
- new_scale = 1.0
- self.weight = torch.nn.Parameter(
- torch.randn(out_channel, in_channel, kernel_size, kernel_size) * new_scale
- )
- self.scale = 1 / math.sqrt(in_channel * kernel_size ** 2)
- self.stride = stride
- self.padding = padding
- if bias:
- self.bias = torch.nn.Parameter(torch.zeros(out_channel))
- else:
- self.bias = None
-
- def forward(self, input):
- out = F.conv2d(
- input,
- self.weight * self.scale,
- bias=self.bias,
- stride=self.stride,
- padding=self.padding,
- )
- return out
-
- def __repr__(self):
- return (
- f'{self.__class__.__name__}({self.weight.shape[1]}, {self.weight.shape[0]},'
- f' {self.weight.shape[2]}, stride={self.stride}, padding={self.padding})'
- )
-
-
-@persistence.persistent_class
-class Encoder(torch.nn.Module):
- def __init__(self, size, n_latents, w_dim=512, add_dim=0, **unused):
- super().__init__()
-
- channels = {
- 4: 512,
- 8: 512,
- 16: 512,
- 32: 512,
- 64: 256,
- 128: 128,
- 256: 64,
- 512: 32,
- 1024: 16
- }
-
- self.w_dim = w_dim
- self.add_dim = add_dim
- log_size = int(math.log(size, 2))
-
- self.n_latents = n_latents
- convs = [Conv2dLayer(3, channels[size], 1)]
-
- in_channel = channels[size]
- for i in range(log_size, 2, -1):
- out_channel = channels[2 ** (i - 1)]
- convs.append(EncoderResBlock(in_channel, out_channel))
- in_channel = out_channel
-
- self.convs = torch.nn.Sequential(*convs)
- self.projector = EqualConv2d(in_channel, self.n_latents*self.w_dim + add_dim, 4, padding=0, bias=False)
-
- def forward(self, input):
- out = self.convs(input)
- out = self.projector(out)
- pws, pcm = out[:, :-2], out[:, -2:]
- pws = pws.view(len(input), self.n_latents, self.w_dim)
- pcm = pcm.view(len(input), self.add_dim)
- return pws, pcm
-
-
-@persistence.persistent_class
-class ResNetEncoder(torch.nn.Module):
- def __init__(self):
- super().__init__()
-
- import torchvision
- resnet_net = torchvision.models.resnet18(pretrained=True)
- modules = list(resnet_net.children())[:-1]
- self.convs = torch.nn.Sequential(*modules)
- self.requires_grad_(True)
- self.train()
-
- def preprocess_tensor(self, x):
- x = F.interpolate(x, size=(224, 224), mode='bicubic', align_corners=False)
- return x
-
- def forward(self, input):
- out = self.convs(self.preprocess_tensor(input))
- return out[:, :, 0, 0]
-
-
-@persistence.persistent_class
-class CLIPEncoder(torch.nn.Module):
- def __init__(self):
- super().__init__()
-
- import clip
- clip_net, _ = clip.load('ViT-B/32', device='cpu', jit=False)
- self.encoder = clip_net.visual
- for p in self.encoder.parameters():
- p.requires_grad_(True)
-
- def preprocess_tensor(self, x):
- import PIL.Image
- import torchvision.transforms.functional as TF
- x = x * 0.5 + 0.5 # mapping to 0~1
- x = TF.resize(x, size=224, interpolation=PIL.Image.BICUBIC)
- x = TF.normalize(x, (0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))
- return x
-
- def forward(self, input):
- out = self.encoder(self.preprocess_tensor(input))
- return out
-
-
-# --------------------------------------------------------------------------------------------------- #
-# VolumeGAN thanks https://gist.github.com/justimyhxu/a96f5ac25480d733f3151adb8142d706
-
-@persistence.persistent_class
-class InstanceNormLayer3d(torch.nn.Module):
- """Implements instance normalization layer."""
- def __init__(self, num_features, epsilon=1e-8, affine=False):
- super().__init__()
- self.eps = epsilon
- self.affine = affine
- if self.affine:
- self.weight = torch.nn.Parameter(torch.Tensor(1, num_features,1,1,1))
- self.bias = torch.nn.Parameter(torch.Tensor(1, num_features,1,1,1))
- self.weight.data.uniform_()
- self.bias.data.zero_()
-
- def forward(self, x, weight=None, bias=None):
- x = x - torch.mean(x, dim=[2, 3, 4], keepdim=True)
- norm = torch.sqrt(
- torch.mean(x**2, dim=[2, 3, 4], keepdim=True) + self.eps)
- x = x / norm
- isnot_input_none = weight is not None and bias is not None
- assert (isnot_input_none and not self.affine) or (not isnot_input_none and self.affine)
- if self.affine:
- x = x*self.weight + self.bias
- else:
- x = x*weight + bias
- return x
-
-@persistence.persistent_class
-class FeatureVolume(torch.nn.Module):
- def __init__(
- self,
- feat_res=32,
- init_res=4,
- base_channels=256,
- output_channels=32,
- z_dim=256,
- use_mapping=True,
- **kwargs
- ):
- super().__init__()
- self.num_stages = int(np.log2(feat_res // init_res)) + 1
- self.use_mapping = use_mapping
-
- self.const = nn.Parameter(
- torch.ones(1, base_channels, init_res, init_res, init_res))
- inplanes = base_channels
- outplanes = base_channels
-
- self.stage_channels = []
- for i in range(self.num_stages):
- conv = nn.Conv3d(inplanes,
- outplanes,
- kernel_size=(3, 3, 3),
- padding=(1, 1, 1))
- self.stage_channels.append(outplanes)
- self.add_module(f'layer{i}', conv)
- instance_norm = InstanceNormLayer3d(num_features=outplanes, affine=not use_mapping)
-
- self.add_module(f'instance_norm{i}', instance_norm)
- inplanes = outplanes
- outplanes = max(outplanes // 2, output_channels)
- if i == self.num_stages - 1:
- outplanes = output_channels
-
- if self.use_mapping:
- self.mapping_network = CustomMappingNetwork(
- z_dim, 256,
- sum(self.stage_channels) * 2)
- self.upsample = UpsamplingLayer()
- self.lrelu = nn.LeakyReLU(negative_slope=0.2)
-
- def forward(self, z, **kwargs):
- if self.use_mapping:
- scales, shifts, style = self.mapping_network(z)
-
- x = self.const.repeat(z.shape[0], 1, 1, 1, 1)
- for idx in range(self.num_stages):
- if idx != 0:
- x = self.upsample(x)
- conv_layer = self.__getattr__(f'layer{idx}')
- x = conv_layer(x)
- instance_norm = self.__getattr__(f'instance_norm{idx}')
- if self.use_mapping:
- scale = scales[:, sum(self.stage_channels[:idx]):sum(self.stage_channels[:idx + 1])]
- shift = shifts[:, sum(self.stage_channels[:idx]):sum(self.stage_channels[:idx + 1])]
- scale = scale.view(scale.shape + (1, 1, 1))
- shift = shift.view(shift.shape + (1, 1, 1))
- else:
- scale, shift = None, None
- x = instance_norm(x, weight=scale, bias=shift)
- x = self.lrelu(x)
-
- return x
\ No newline at end of file
diff --git a/spaces/facebook/ov-seg/open_vocab_seg/utils/events.py b/spaces/facebook/ov-seg/open_vocab_seg/utils/events.py
deleted file mode 100644
index cbe82ce80a7110a1018167763ba3adc90f58faa0..0000000000000000000000000000000000000000
--- a/spaces/facebook/ov-seg/open_vocab_seg/utils/events.py
+++ /dev/null
@@ -1,121 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Copyright (c) Meta Platforms, Inc. All Rights Reserved
-
-import os
-import wandb
-from detectron2.utils import comm
-from detectron2.utils.events import EventWriter, get_event_storage
-
-
-def setup_wandb(cfg, args):
- if comm.is_main_process():
- init_args = {
- k.lower(): v
- for k, v in cfg.WANDB.items()
- if isinstance(k, str) and k not in ["config", "name"]
- }
- # only include most related part to avoid too big table
- # TODO: add configurable params to select which part of `cfg` should be saved in config
- if "config_exclude_keys" in init_args:
- init_args["config"] = cfg
- init_args["config"]["cfg_file"] = args.config_file
- else:
- init_args["config"] = {
- "model": cfg.MODEL,
- "solver": cfg.SOLVER,
- "cfg_file": args.config_file,
- }
- if ("name" not in init_args) or (init_args["name"] is None):
- init_args["name"] = os.path.basename(args.config_file)
- wandb.init(**init_args)
-
-
-class BaseRule(object):
- def __call__(self, target):
- return target
-
-
-class IsIn(BaseRule):
- def __init__(self, keyword: str):
- self.keyword = keyword
-
- def __call__(self, target):
- return self.keyword in target
-
-
-class Prefix(BaseRule):
- def __init__(self, keyword: str):
- self.keyword = keyword
-
- def __call__(self, target):
- return "/".join([self.keyword, target])
-
-
-class WandbWriter(EventWriter):
- """
- Write all scalars to a tensorboard file.
- """
-
- def __init__(self):
- """
- Args:
- log_dir (str): the directory to save the output events
- kwargs: other arguments passed to `torch.utils.tensorboard.SummaryWriter(...)`
- """
- self._last_write = -1
- self._group_rules = [
- (IsIn("/"), BaseRule()),
- (IsIn("loss"), Prefix("train")),
- ]
-
- def write(self):
-
- storage = get_event_storage()
-
- def _group_name(scalar_name):
- for (rule, op) in self._group_rules:
- if rule(scalar_name):
- return op(scalar_name)
- return scalar_name
-
- stats = {
- _group_name(name): scalars[0]
- for name, scalars in storage.latest().items()
- if scalars[1] > self._last_write
- }
- if len(stats) > 0:
- self._last_write = max([v[1] for k, v in storage.latest().items()])
-
- # storage.put_{image,histogram} is only meant to be used by
- # tensorboard writer. So we access its internal fields directly from here.
- if len(storage._vis_data) >= 1:
- stats["image"] = [
- wandb.Image(img, caption=img_name)
- for img_name, img, step_num in storage._vis_data
- ]
- # Storage stores all image data and rely on this writer to clear them.
- # As a result it assumes only one writer will use its image data.
- # An alternative design is to let storage store limited recent
- # data (e.g. only the most recent image) that all writers can access.
- # In that case a writer may not see all image data if its period is long.
- storage.clear_images()
-
- if len(storage._histograms) >= 1:
-
- def create_bar(tag, bucket_limits, bucket_counts, **kwargs):
- data = [
- [label, val] for (label, val) in zip(bucket_limits, bucket_counts)
- ]
- table = wandb.Table(data=data, columns=["label", "value"])
- return wandb.plot.bar(table, "label", "value", title=tag)
-
- stats["hist"] = [create_bar(**params) for params in storage._histograms]
-
- storage.clear_histograms()
-
- if len(stats) == 0:
- return
- wandb.log(stats, step=storage.iter)
-
- def close(self):
- wandb.finish()
diff --git a/spaces/falterWliame/Face_Mask_Detection/Download Driver Monitor Aoc 215lm00040.md b/spaces/falterWliame/Face_Mask_Detection/Download Driver Monitor Aoc 215lm00040.md
deleted file mode 100644
index f690799ee90637f5c88cb54f4959bcff9b6b1db0..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Download Driver Monitor Aoc 215lm00040.md
+++ /dev/null
@@ -1,14 +0,0 @@
-download driver monitor aoc 215lm00040 DOWNLOAD » https://urlca.com/2uDcic
diff --git a/spaces/fatiXbelha/sd/Download FIFA Romania and get ready for the new 23 season with updated players kits and clubs.md b/spaces/fatiXbelha/sd/Download FIFA Romania and get ready for the new 23 season with updated players kits and clubs.md
deleted file mode 100644
index fbbdc5323e5001f315cde85b145904f6ac82223b..0000000000000000000000000000000000000000
--- a/spaces/fatiXbelha/sd/Download FIFA Romania and get ready for the new 23 season with updated players kits and clubs.md
+++ /dev/null
@@ -1,148 +0,0 @@
-
-Download FIFA Romania: How to Play the Ultimate Football Game with Your Favorite Romanian Teams and Players
- If you are a fan of football and you love Romania, you might be interested in downloading FIFA Romania, a modded version of the popular FIFA game that features Romanian teams, players, stadiums, and more. In this article, we will show you how to download FIFA Romania, how to play it, and why you should give it a try.
- Introduction
- What is FIFA Romania?
- FIFA Romania is a modification of the original FIFA game that adds Romanian elements to the game. It was created by a group of passionate Romanian fans who wanted to bring their country's football culture to the virtual world. FIFA Romania includes:
-download fifa romania Download File ->>> https://urllie.com/2uNCdC
-Over 40 Romanian teams from Liga 1, Liga 2, and Liga 3
-Over 1000 Romanian players with realistic faces, attributes, and ratings
-Over 20 Romanian stadiums with authentic details and atmosphere
-Romanian commentators, chants, banners, logos, kits, and graphics
-Romanian national team with updated roster and kits
-
- Why should you download FIFA Romania?
- Downloading FIFA Romania has many benefits for football lovers. Here are some of them:
-
-You can play with your favorite Romanian teams and players in various game modes, such as career mode, tournament mode, or online mode
-You can experience the thrill of the Romanian football league, with realistic fixtures, standings, and statistics
-You can enjoy the authentic Romanian football atmosphere, with lively crowds, chants, and commentary
-You can support the Romanian football community and show your patriotism
-You can have fun and challenge yourself with a different and unique football game
-
- How to download FIFA Romania
- Requirements and compatibility
- To download FIFA Romania, you will need the following:
-
-A PC or laptop with Windows operating system (Windows 7 or higher)
-A copy of FIFA 14 or FIFA 15 installed on your device (you can buy it online or from a local store)
-At least 10 GB of free disk space on your device
-A stable internet connection for downloading and installing the mod
-A compatible controller or keyboard for playing the game (optional)
-
- FIFA Romania is compatible with both FIFA 14 and FIFA 15 versions. However, some features may vary depending on the version you have. For example, FIFA 15 has better graphics and gameplay than FIFA 14, but FIFA 14 has more Romanian teams and players than FIFA 15.
- Steps to download and install FIFA Romania
- To download and install FIFA Romania, follow these steps:
-
-Go to the official website of FIFA Romania (www.fifaromania.net) and register an account (it's free)
-Log in to your account and go to the download section
-Select the version of FIFA Romania that matches your version of FIFA (FIFA 14 or FIFA 15)
-Download the mod file (it's a zip file that contains several folders)
-Extract the mod file to a folder on your device (you can use WinRAR or any other extraction software)
-Copy the contents of the extracted folder to the folder where you installed FIFA on your device (usually C:\Program Files\EA Sports\FIFA)
-Run the game as administrator (right-click on the game icon and select "Run as administrator")
-Enjoy playing FIFA Romania!
-
- Tips and tricks to optimize your gaming experience
- Here are some tips and tricks to make the most out of FIFA Romania:
-
-Update your device drivers and software to ensure smooth performance and compatibility
-Adjust the game settings according to your device specifications and preferences (you can change the resolution, graphics, sound, controls, etc.)
-Backup your original FIFA files before installing the mod, in case you want to revert to the original game or uninstall the mod
-Check the official website of FIFA Romania regularly for updates, patches, and news about the mod
-Join the online community of FIFA Romania players and fans on social media, forums, and blogs, where you can share your feedback, suggestions, questions, and experiences
-
- How to play FIFA Romania
- Game modes and features
- FIFA Romania offers a variety of game modes and features that will keep you entertained and challenged. Here are some of them:
-
-Career mode: You can create your own manager or player and lead your team to glory in the Romanian league or the international stage. You can also transfer players, negotiate contracts, scout talents, and manage your finances.
-Tournament mode: You can choose from various tournaments, such as the Romanian Cup, the Romanian Super Cup, the UEFA Champions League, or the FIFA World Cup, and compete with other teams for the trophy.
-Online mode: You can play online with other FIFA Romania players from around the world, either in friendly matches or in ranked matches. You can also join or create online leagues and tournaments with your friends or other players.
-Ultimate team mode: You can create your own dream team by collecting and trading cards of players, managers, stadiums, kits, and more. You can also compete with other players' teams in various modes, such as seasons, tournaments, or drafts.
-Skill games mode: You can practice and improve your skills in various aspects of the game, such as dribbling, passing, shooting, defending, or goalkeeping. You can also challenge yourself with different levels of difficulty and earn rewards.
-
- How to create and customize your own team
- If you want to create and customize your own team in FIFA Romania, you can do so by following these steps:
-
-Go to the main menu and select "Customize"
-Select "Create team"
-Enter a name for your team and choose a country (you can choose Romania or any other country)
-Select a league for your team (you can choose from Liga 1, Liga 2, Liga 3, or Rest of World)
-Select a stadium for your team (you can choose from any of the Romanian stadiums or any other stadium)
-Select a kit for your team (you can choose from any of the Romanian kits or any other kit)
-Select a logo for your team (you can choose from any of the Romanian logos or any other logo)
-Select a squad for your team (you can choose from any of the Romanian players or any other players)
-Save your team and exit
-
- You can also edit or delete your team at any time by going to "Customize" > "Edit teams"
-download fifa romania apk
- How to compete online and offline with other players
- If you want to compete online and offline with other players in FIFA Romania, you have several options:
-
-If you want to play online with other FIFA Romania players from around the world, you can go to "Online" > "Seasons" or "Tournaments" and select a mode that suits you. You can also go to "Online" > "Match lobbies" and join or create a lobby with your preferred settings.
-If you want to play online with your friends or other players that you know, you can go to "Online" > "Friendlies" and invite them to a match. You can also go to "Online" > "Custom games" and create a game with your own rules and settings.
-If you want to play offline with another player on the same device, you can go to "Kick off" > "Match" and select a mode that suits you. You can also go to "Kick off" > "Custom games" and create a game with your own rules and settings.
-If you want to play offline with another player on a different device, you can go to "Kick off" > "LAN Play" and connect your devices via LAN cable or Wi-Fi and select a mode that suits you. You can also go to "Kick off" > "Custom games" and create a game with your own rules and settings.
-
- Conclusion
- Summary of the main points
- In conclusion, FIFA Romania is a modded version of the original FIFA game that features Romanian teams, players, stadiums, and more. It is a fun and unique way to enjoy football and support Romania. To download FIFA Romania, you need to have FIFA 14 or FIFA 15 installed on your device, and then follow the steps to download and install the mod from the official website. You can play FIFA Romania in various game modes and features, such as career mode, tournament mode, online mode, ultimate team mode, or skill games mode. You can also create and customize your own team, and compete online and offline with other players.
- Call to action and invitation to share feedback
- If you are interested in downloading FIFA Romania, you can visit the official website (www.fifaromania.net) and register an account for free. You can also join the online community of FIFA Romania players and fans on social media, forums, and blogs, where you can share your feedback, suggestions, questions, and experiences. We hope you enjoy playing FIFA Romania and have a great time with your favorite Romanian teams and players. Thank you for reading this article and please share it with your friends if you found it helpful.
- FAQs
- Here are some frequently asked questions about FIFA Romania:
-
-Is FIFA Romania legal and safe? Can I play FIFA Romania on other devices besides PC? Can I play FIFA Romania with other mods or patches? Can I update FIFA Romania to the latest version of FIFA? Can I contact the developers of FIFA Romania for support or feedback? 401be4b1e0Download Soul Knight Versi Terbaru 2022: A Guide for Pixel Action Shoot'em Up Fans
-If you are a fan of pixel action shoot'em up games, you might have heard of Soul Knight , a popular game made by ChillyRoom Inc. © for Android, iOS, and Nintendo Switch. Soul Knight is a shooter game that features extremely easy and intuitive control, super smooth and enjoyable gameplay, mixed with rogue-like elements, that will get you hooked from the very first run!
-In this article, we will guide you on how to download Soul Knight versi terbaru 2022 , the latest version of the game that was released on June 6th, 2023 for Android devices and May 15th, 2023 for iOS devices. We will also show you what's new in this version, how to play it, and why you should play it.
-download soul knight versi terbaru 2022 Download Zip ✦ https://urllie.com/2uNAub
What's New in Soul Knight Versi Terbaru 2022?
-Soul Knight versi terbaru 2022 is the most updated version of the game that brings new features and improvements to enhance your gaming experience. Here are some of the highlights of this version:
-
-New gift! Claim your gift from the mail: "Doodle Doo", the new skin of Rogue.
-New hero! Meet Rosemary, a cute girl who loves gardening and has a special ability to grow plants.
-New event! Travelogue of Rosemary Island, a new adventure mode where you can explore an island full of plants, animals, and secrets.
-New weapons! More than 20 new weapons added, including Buddha's Palm, Iron Will Wavebreaker, Night Wanderer, etc.
-New skins! More than 10 new skins added, including Bunny Girl of Assassin, Pirate of Knight, etc.
-New pets! More than 10 new pets added, including Baby Dragon, Baby Phoenix, Baby Unicorn, etc.
-New bosses! More than 5 new bosses added, including Giant Crab, Giant Octopus, Giant Shark, etc.
-New achievements! More than 10 new achievements added, including Plant Lover, Island Explorer, Sea Monster Slayer, etc.
-New languages! Added support for Arabic, Turkish, and Vietnamese languages.
-Improved performance and stability. Fixed some bugs and glitches.
-
-As you can see, Soul Knight versi terbaru 2022 is packed with new content and updates that will make you want to play it more than ever. But how do you download it? Let's find out in the next section.
-How to Download Soul Knight Versi Terbaru 2022 for Android and iOS Devices?
-Downloading Soul Knight versi terbaru 2022 is very easy and simple. Just follow these steps:
-
-Go to the official website of Soul Knight: https://www.chillyroom.com/
-Click on the "Download" button on the top right corner of the screen.
-Select your device type: Android or iOS.
-You will be redirected to the Google Play Store or the App Store, depending on your device.
-Click on the "Install" or "Get" button to download Soul Knight versi terbaru 2022 on your device.
-Wait for the download and installation process to finish.
-Launch the game and enjoy!
-
-Alternatively, you can also scan the QR code on the website to download Soul Knight versi terbaru 2022 directly on your device. Just make sure you have a QR code scanner app installed on your device.
-That's it! You have successfully downloaded Soul Knight versi terbaru 2022 on your device. Now, let's learn how to play it in the next section.
How to Play Soul Knight Versi Terbaru 2022?
-Soul Knight versi terbaru 2022 is a game that is easy to learn but hard to master. It is a game that requires skill, strategy, and luck. Here are some tips and tricks on how to play it and have fun:
-Choose Your Hero and Weapon
-One of the first things you need to do in Soul Knight versi terbaru 2022 is to choose your hero and weapon. There are more than 30 heroes to choose from, each with their own unique skills and stats. Some of the heroes are free, while others require gems or real money to unlock. You can also customize your hero's appearance with different skins.
-download soul knight mod apk versi terbaru 2022
-Each hero has a default weapon that they start with, but you can also find and use other weapons in the game. There are more than 300 weapons to collect, ranging from swords, guns, bows, lasers, rockets, etc. Each weapon has its own attributes, such as damage, fire rate, accuracy, etc. You can also upgrade your weapons with gold or gems to make them more powerful.
-Choosing the right hero and weapon for your play style and preference is crucial for your success in Soul Knight versi terbaru 2022. Experiment with different combinations and see what works best for you.
-Explore Randomly Generated Dungeons
-The main mode of Soul Knight versi terbaru 2022 is the dungeon mode, where you have to explore randomly generated dungeons and fight against various enemies and bosses. Each dungeon has a theme, such as forest, desert, ice, etc., and consists of several floors. Each floor has a number of rooms, where you can find enemies, chests, shops, statues, etc.
-Your goal is to clear all the rooms on each floor and reach the portal that leads to the next floor. Along the way, you can collect coins, gems, health potions, ammo boxes, etc., that will help you survive and progress. You can also find secrets and hidden rooms that may contain special items or surprises.
-The dungeons are randomly generated every time you play, so you never know what to expect. This adds an element of unpredictability and replayability to Soul Knight versi terbaru 2022. You have to be prepared for anything and adapt to different situations.
-Use Skills and Buffs Wisely
-Another important aspect of Soul Knight versi terbaru 2022 is the use of skills and buffs. Skills are special abilities that each hero has and can use in combat. Skills have a cooldown time before they can be used again. Some skills are offensive, such as shooting projectiles or summoning allies, while others are defensive, such as healing or shielding.
-Buffs are temporary effects that enhance your hero's performance in some way. Buffs can be obtained from statues, plants, potions, etc., and can affect your stats, such as health, damage, speed, etc., or give you special abilities, such as immunity, reflection, regeneration, etc.
-Using skills and buffs wisely can make a huge difference in your gameplay. You have to know when to use them and how to combine them for maximum effect. You also have to be careful not to use them too often or too recklessly, as they may have drawbacks or side effects.
Team Up with Friends Online or Offline
-One of the best features of Soul Knight versi terbaru 2022 is the multiplayer mode, where you can team up with your friends online or offline and play together. You can join or create a room online and invite up to three other players to join you. You can also use the local multiplayer mode and connect up to four devices via Wi-Fi or Bluetooth.
-Playing with your friends can make Soul Knight versi terbaru 2022 more fun and exciting, as you can cooperate and coordinate with each other, share items and resources, revive each other, and compete for the best score. You can also chat with your friends using the in-game voice or text chat feature.
-However, playing with your friends can also make Soul Knight versi terbaru 2022 more challenging and chaotic, as you have to deal with more enemies and bosses, friendly fire, limited screen space, and potential lag or connection issues. You also have to be careful not to steal or sabotage each other's items or buffs.
-Whether you prefer to play solo or with your friends, Soul Knight versi terbaru 2022 has something for everyone. You can choose the mode that suits your mood and preference.
-Why You Should Play Soul Knight Versi Terbaru 2022?
-By now, you might be wondering why you should play Soul Knight versi terbaru 2022. Well, there are many reasons why this game is worth your time and attention. Here are some of them:
-Fun and Engaging Gameplay
-Soul Knight versi terbaru 2022 offers a fun and engaging gameplay experience for pixel action shoot'em up fans. The game is fast-paced, smooth, and responsive, with easy and intuitive controls. The game is also varied, unpredictable, and replayable, with different heroes, weapons, dungeons, enemies, bosses, skills, buffs, etc. The game is also challenging, rewarding, and addictive, with different difficulty levels, achievements, leaderboards, etc.
-If you are looking for a game that will keep you entertained and hooked for hours, Soul Knight versi terbaru 2022 is the game for you.
-Beautiful Pixel Art and Music
-Soul Knight versi terbaru 2022 showcases a beautiful pixel art style and music that enhance the game's atmosphere. The game has a retro and nostalgic feel, with colorful and detailed graphics that capture the essence of pixel art. The game also has a catchy and upbeat soundtrack that matches the mood and theme of the game. The game also has a variety of sound effects that add to the immersion and realism of the game.
-If you are a fan of pixel art and music, Soul Knight versi terbaru 2022 is the game for you.
Challenging but Rewarding Difficulty
-Soul Knight versi terbaru 2022 offers a challenging but rewarding difficulty level that keeps you hooked and motivated. The game is not easy, as you have to face countless enemies and bosses that will test your skills and reflexes. The game is also not forgiving, as you have to start over from the beginning if you die. The game is also not predictable, as you have to deal with random dungeons and events that will change your gameplay.
-However, the game is also not impossible, as you have access to various resources and tools that will help you overcome the challenges. The game is also not boring, as you have different goals and rewards that will keep you interested and satisfied. The game is also not repetitive, as you have different strategies and styles that will keep you creative and curious.
-If you are looking for a game that will challenge you but also reward you, Soul Knight versi terbaru 2022 is the game for you.
-Diverse Game Modes and Features
-Soul Knight versi terbaru 2022 offers a diverse range of game modes and features that cater to different preferences and tastes. The game has a main dungeon mode, where you can explore different dungeons and fight against various enemies and bosses. The game also has an adventure mode, where you can embark on different quests and stories. The game also has a multiplayer mode, where you can play with your friends online or offline. The game also has a workshop mode, where you can create your own weapons and dungeons. The game also has a garden mode, where you can grow plants and harvest resources.
-If you are looking for a game that will offer you different options and possibilities, Soul Knight versi terbaru 2022 is the game for you.
-Conclusion
-Soul Knight versi terbaru 2022 is a pixel action shoot'em up game that features extremely easy and intuitive control, super smooth and enjoyable gameplay, mixed with rogue-like elements, that will get you hooked from the very first run!
-In this article, we have guided you on how to download Soul Knight versi terbaru 2022, the latest version of the game that brings new features and improvements to enhance your gaming experience. We have also shown you what's new in this version, how to play it, and why you should play it.
-Now that you know everything about Soul Knight versi terbaru 2022, what are you waiting for? Download it now and enjoy the pixel action shoot'em up adventure of your life!
-FAQs
-Here are some frequently asked questions and answers about Soul Knight versi terbaru 2022:
-
-Is Soul Knight versi terbaru 2022 free to play? Yes, Soul Knight versi terbaru 2022 is free to play, but it contains some in-app purchases that can enhance your gameplay or unlock some premium content.
-Is Soul Knight versi terbaru 2022 compatible with my device? Soul Knight versi terbaru 2022 is compatible with Android devices running Android 4.4 or higher, and iOS devices running iOS 9.0 or higher. It is also compatible with Nintendo Switch devices.
-How can I save my progress in Soul Knight versi terbaru 2022? Soul Knight versi terbaru 2022 supports cloud saving, which means you can save your progress online and access it from any device. You just need to log in with your Google Play Games or Game Center account in the game settings.
-How can I contact the developers of Soul Knight versi terbaru 2022? You can contact the developers of Soul Knight versi terbaru 2022 by sending an email to support@chillyroom.com , or by visiting their official website: https://www.chillyroom.com/ .
-Where can I find more information about Soul Knight versi terbaru 2022? You can find more information about Soul Knight versi terbaru 2022 by visiting their official website: https://www.chillyroom.com/ , or by following their social media accounts: https://www.facebook.com/chillyroomsoulknight/ , https://twitter.com/ChillyRoom , https://www.instagram.com/chillyroominc/ .
- 197e85843d
- - GitHub:
- - Hugging Face:
-
- ### Demos
-
- 
-
- """
-
- solara.Markdown(markdown)
diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Izotope Ozone Crack Mac.md b/spaces/gotiQspiryo/whisper-ui/examples/Izotope Ozone Crack Mac.md
deleted file mode 100644
index 6901f8e5c45453f2a9dc14e5df12df61b900a0f2..0000000000000000000000000000000000000000
--- a/spaces/gotiQspiryo/whisper-ui/examples/Izotope Ozone Crack Mac.md
+++ /dev/null
@@ -1,10 +0,0 @@
-for producers and music makers that have been using plugins to modify their track’s sound, ozone 9 promises a lot of improvements. ozone 9 gives you the ability to change the sound of your instrument by adjusting its balance, panning, resonances, and eq. adjust every instrument and every mic with an intuitive interface, whether you are recording, mixing, mastering, or simply sound designing.
-Izotope Ozone Crack Mac Download File › https://urlgoal.com/2uyMwM
ozone 9 also includes a new balance plugin, which lets you fine-tune the balance of your stereo mix or render a mono balance for your mix. set up your mix with a single click and balance to your heart’s content. a new spectrum analyzer and sender gui are also available.
-ozone 9 also includes more than 12 ozone-exclusive mastering processors. use the master assistant to fine-tune your eq and gain in real time. add harmonics, saturate, and noise reduction to your sound with the maximizer and peaking plugins. the new tonal balance control is perfect for balancing out vocals, drums, and low-frequency effects. you can even use a variable target to automatically balance the sound to the sound of a reference track.
-ozone 9 also includes a new sender workflow. it’s a new way to send your mixes to ozone. use the sender to send a stereo mix as mono, or send a mono mix as a stereo mix with a new panning. you can also send a kick and bass track separately and mix them to a mono file.
-ozone 9 also includes a new spectral analyzer plugin. it lets you fine-tune the sound of your stereo mix or render a mono balance for your mix. finally, ozone 9 offers a new integrated workflow for mixing and mastering. mix any combination of ozone and other plugins, or route individual plugins and buses via the daw’s mixer channels. this workflow allows you to spend more time creating and less time trying to learn the ins and outs of every vst.
-
899543212b
- self.hyps = hyps # std::deque
- self.codes = codes # std::deque
- 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/gradio/HuBERT/tests/test_dictionary.py b/spaces/gradio/HuBERT/tests/test_dictionary.py
deleted file mode 100644
index 81ce102f4f555822e36298034cdeb3d1c0650255..0000000000000000000000000000000000000000
--- a/spaces/gradio/HuBERT/tests/test_dictionary.py
+++ /dev/null
@@ -1,116 +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 io
-import tempfile
-import unittest
-
-import torch
-from fairseq.data import Dictionary
-
-
-class TestDictionary(unittest.TestCase):
- def test_finalize(self):
- txt = [
- "A B C D",
- "B C D",
- "C D",
- "D",
- ]
- ref_ids1 = list(
- map(
- torch.IntTensor,
- [
- [4, 5, 6, 7, 2],
- [5, 6, 7, 2],
- [6, 7, 2],
- [7, 2],
- ],
- )
- )
- ref_ids2 = list(
- map(
- torch.IntTensor,
- [
- [7, 6, 5, 4, 2],
- [6, 5, 4, 2],
- [5, 4, 2],
- [4, 2],
- ],
- )
- )
-
- # build dictionary
- d = Dictionary()
- for line in txt:
- d.encode_line(line, add_if_not_exist=True)
-
- def get_ids(dictionary):
- ids = []
- for line in txt:
- ids.append(dictionary.encode_line(line, add_if_not_exist=False))
- return ids
-
- def assertMatch(ids, ref_ids):
- for toks, ref_toks in zip(ids, ref_ids):
- self.assertEqual(toks.size(), ref_toks.size())
- self.assertEqual(0, (toks != ref_toks).sum().item())
-
- ids = get_ids(d)
- assertMatch(ids, ref_ids1)
-
- # check finalized dictionary
- d.finalize()
- finalized_ids = get_ids(d)
- assertMatch(finalized_ids, ref_ids2)
-
- # write to disk and reload
- with tempfile.NamedTemporaryFile(mode="w") as tmp_dict:
- d.save(tmp_dict.name)
- d = Dictionary.load(tmp_dict.name)
- reload_ids = get_ids(d)
- assertMatch(reload_ids, ref_ids2)
- assertMatch(finalized_ids, reload_ids)
-
- def test_overwrite(self):
- # for example, Camembert overwrites , and
- dict_file = io.StringIO(
- " 999 #fairseq:overwrite\n"
- " 999 #fairseq:overwrite\n"
- " 999 #fairseq:overwrite\n"
- ", 999\n"
- "▁de 999\n"
- )
- d = Dictionary()
- d.add_from_file(dict_file)
- self.assertEqual(d.index(""), 1)
- self.assertEqual(d.index("foo"), 3)
- self.assertEqual(d.index(""), 4)
- self.assertEqual(d.index(""), 5)
- self.assertEqual(d.index(" "), 6)
- self.assertEqual(d.index(","), 7)
- self.assertEqual(d.index("▁de"), 8)
-
- def test_no_overwrite(self):
- # for example, Camembert overwrites , and
- dict_file = io.StringIO(
- " 999\n" " 999\n" " 999\n" ", 999\n" "▁de 999\n"
- )
- d = Dictionary()
- with self.assertRaisesRegex(RuntimeError, "Duplicate"):
- d.add_from_file(dict_file)
-
- def test_space(self):
- # for example, character models treat space as a symbol
- dict_file = io.StringIO(" 999\n" "a 999\n" "b 999\n")
- d = Dictionary()
- d.add_from_file(dict_file)
- self.assertEqual(d.index(" "), 4)
- self.assertEqual(d.index("a"), 5)
- self.assertEqual(d.index("b"), 6)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/gstaff/MagicGen/colab-data-test/css/mtg.css b/spaces/gstaff/MagicGen/colab-data-test/css/mtg.css
deleted file mode 100644
index 535ffd300815eacedfca2c6bad4e17aa0f55f2ec..0000000000000000000000000000000000000000
--- a/spaces/gstaff/MagicGen/colab-data-test/css/mtg.css
+++ /dev/null
@@ -1,130 +0,0 @@
-* {margin: 0; padding: 0; box-sizing: border-box; }
-
-.card {background: #000; padding: 17px; height: 600px; width: 400px;
- margin: 100px auto;
-}
-.card-background {
- padding: 7px 8px 30px 7px;
- background-color: #69a;
- background-image:
- repeating-linear-gradient(140deg, transparent, rgba(255, 255, 255, 0.25) 1%, transparent 20%),
- repeating-linear-gradient(-30deg, transparent, transparent 8%, rgba(255, 255, 255, 0.4), transparent 9%),
- repeating-linear-gradient(-10deg, transparent, transparent 13%, rgba(0, 0, 0, 0.4), transparent 15%),
- repeating-linear-gradient(80deg, transparent, transparent 7.5%, rgba(0, 0, 0, 0.25), transparent 8%),
- repeating-linear-gradient(5deg, transparent, transparent 10.5%, rgba(255, 255, 255, 0.5), transparent 11%),
- repeating-linear-gradient(75deg, transparent, transparent 11.5%, rgba(255, 255, 255, 0.5), transparent 12%),
- repeating-radial-gradient(rgba(0, 0, 0, 0.2), rgba(0, 0, 0, 0.2) 1%, transparent 1%, transparent 5%);
- border-radius: 10px 10px 40px 40px;
- height: 500px;
-}
-
-.card-body {
- position: absolute;
- height: 109.4%;
- width: 350px;
- border: 2px solid rgba(0, 0, 0, 0.8);
- border-right: 2px solid #ddd;
- border-bottom: 2px solid #555;
- border-radius: 5px 5px 0 0;
- background: #ddd;
-
-}
-
-article {
- padding: 3px;
- width: 350px;
-}
-
-article > div {
- background: #ddd;
- position: relative;
- height: 200px;
- border: 2px solid #333;
- z-index: -1;
-}
-
-header {
- padding: 3px;
- background: #ddd;
- border-radius: 8px/20px;
- box-shadow: -2px 0 0 0 rgba(0, 0, 0, 0.8);
- position: relative;
- top: 200px; left: 0; right: 0;
-}
-header div {
- padding: 5px 8px 3px;
- background: radial-gradient(ellipse farthest-corner, #E0E7ED 50%, #BDC6CD);
- position: relative;
- border: 2px solid #000;
- border-radius: 10px/20px;
- box-shadow: inset 2px -3px 0 #aaa, inset -1px 1px 0 #fff;
- height: 33px;
-}
-header:first-child {top: 0; }
-header:first-child div {height: 34px; }
-
-#textBox {
- margin-top: 38px;
- padding: 10px 7px;
- top: 260px; bottom: 44px;
- border: 2px solid #999;
- border-bottom: 0 none;
- border-left: 0 none;
- background: #d3dddd;
-
-}
-
-#powerToughness {
- width: 4em;
- top: ; right: 21px; bottom: 28px; left: auto;
- text-align: center;
- box-shadow: -2px 1px 2px 0 rgba(0, 0, 0, 0.8);
-}
-#powerToughness div {
- padding: 4px 0 0;
- height: 23px;
- box-shadow: inset -2px 2px 1px #333, inset 1px -1px 0 #fff;
- border: 0 none;
- font-size: 21px;
-}
-
-footer {
- color: #ccc;
- font-family: sans-serif; font-size: 9px;
- position: relative;
- left: 25px; bottom: 10px; right: 25px;
- overflow: auto;
-}
-footer p {margin-bottom: 0.2em; letter-spacing: 0.18em; }
-
-.ms {
- position: relative;
- top: -22px;
- float: right;
-}
-
-h1 {font-size: 21px; line-height: 1em; }
-h2 {font-size: 18px; line-height: 1em; }
-h3 {
- padding-top: 2px;
- position: relative;
- right: 5px; top: 2px;
- width: 1.05em; height: 1.05em;
- background: #ddd;
- text-align: center;
- border-radius: 1em;
- line-height: 1em;
-}
-h4 {
- border-bottom: 14px solid #000;
- border-right: 7px solid transparent;
- border-left: 7px solid transparent;
- height: 0; width: 0;
- overflow: hidden;
- position: relative;
- right: 10px; top: 7px;
-}
-h6 {float: right; width: 60%; text-align: right; font-size: 8px; }
-p {margin-bottom: 0.6em; line-height: 1.1em; }
-blockquote {font-style: italic; }
-blockquote p {margin-bottom: 0; }
diff --git a/spaces/gulabpatel/Real-ESRGAN/realesrgan/train.py b/spaces/gulabpatel/Real-ESRGAN/realesrgan/train.py
deleted file mode 100644
index 8a9cec9ed80d9f362984779548dcec921a636a04..0000000000000000000000000000000000000000
--- a/spaces/gulabpatel/Real-ESRGAN/realesrgan/train.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# flake8: noqa
-import os.path as osp
-from basicsr.train import train_pipeline
-
-import realesrgan.archs
-import realesrgan.data
-import realesrgan.models
-
-if __name__ == '__main__':
- root_path = osp.abspath(osp.join(__file__, osp.pardir, osp.pardir))
- train_pipeline(root_path)
diff --git a/spaces/gwang-kim/DATID-3D/eg3d/dataset_tool.py b/spaces/gwang-kim/DATID-3D/eg3d/dataset_tool.py
deleted file mode 100644
index a400f770fa477ef09adf4804235be4d67898765a..0000000000000000000000000000000000000000
--- a/spaces/gwang-kim/DATID-3D/eg3d/dataset_tool.py
+++ /dev/null
@@ -1,458 +0,0 @@
-# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
-# SPDX-License-Identifier: LicenseRef-NvidiaProprietary
-#
-# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
-# property and proprietary rights in and to this material, related
-# documentation and any modifications thereto. Any use, reproduction,
-# disclosure or distribution of this material and related documentation
-# without an express license agreement from NVIDIA CORPORATION or
-# its affiliates is strictly prohibited.
-
-"""Tool for creating ZIP/PNG based datasets."""
-
-import functools
-import gzip
-import io
-import json
-import os
-import pickle
-import re
-import sys
-import tarfile
-import zipfile
-from pathlib import Path
-from typing import Callable, Optional, Tuple, Union
-
-import click
-import numpy as np
-import PIL.Image
-from tqdm import tqdm
-
-#----------------------------------------------------------------------------
-
-def error(msg):
- print('Error: ' + msg)
- sys.exit(1)
-
-#----------------------------------------------------------------------------
-
-def parse_tuple(s: str) -> Tuple[int, int]:
- '''Parse a 'M,N' or 'MxN' integer tuple.
-
- Example:
- '4x2' returns (4,2)
- '0,1' returns (0,1)
- '''
- if m := re.match(r'^(\d+)[x,](\d+)$', s):
- return (int(m.group(1)), int(m.group(2)))
- raise ValueError(f'cannot parse tuple {s}')
-
-#----------------------------------------------------------------------------
-
-def maybe_min(a: int, b: Optional[int]) -> int:
- if b is not None:
- return min(a, b)
- return a
-
-#----------------------------------------------------------------------------
-
-def file_ext(name: Union[str, Path]) -> str:
- return str(name).split('.')[-1]
-
-#----------------------------------------------------------------------------
-
-def is_image_ext(fname: Union[str, Path]) -> bool:
- ext = file_ext(fname).lower()
- return f'.{ext}' in PIL.Image.EXTENSION # type: ignore
-
-#----------------------------------------------------------------------------
-
-def open_image_folder(source_dir, *, max_images: Optional[int]):
- input_images = [str(f) for f in sorted(Path(source_dir).rglob('*')) if is_image_ext(f) and os.path.isfile(f)]
-
- # Load labels.
- labels = {}
- meta_fname = os.path.join(source_dir, 'dataset.json')
- if os.path.isfile(meta_fname):
- with open(meta_fname, 'r') as file:
- labels = json.load(file)['labels']
- if labels is not None:
- labels = { x[0]: x[1] for x in labels }
- else:
- labels = {}
-
- max_idx = maybe_min(len(input_images), max_images)
-
- def iterate_images():
- for idx, fname in enumerate(input_images):
- arch_fname = os.path.relpath(fname, source_dir)
- arch_fname = arch_fname.replace('\\', '/')
- img = np.array(PIL.Image.open(fname))
- yield dict(img=img, label=labels.get(arch_fname))
- if idx >= max_idx-1:
- break
- return max_idx, iterate_images()
-
-#----------------------------------------------------------------------------
-
-def open_image_zip(source, *, max_images: Optional[int]):
- with zipfile.ZipFile(source, mode='r') as z:
- input_images = [str(f) for f in sorted(z.namelist()) if is_image_ext(f)]
-
- # Load labels.
- labels = {}
- if 'dataset.json' in z.namelist():
- with z.open('dataset.json', 'r') as file:
- labels = json.load(file)['labels']
- if labels is not None:
- labels = { x[0]: x[1] for x in labels }
- else:
- labels = {}
-
- max_idx = maybe_min(len(input_images), max_images)
-
- def iterate_images():
- with zipfile.ZipFile(source, mode='r') as z:
- for idx, fname in enumerate(input_images):
- with z.open(fname, 'r') as file:
- img = PIL.Image.open(file) # type: ignore
- img = np.array(img)
- yield dict(img=img, label=labels.get(fname))
- if idx >= max_idx-1:
- break
- return max_idx, iterate_images()
-
-#----------------------------------------------------------------------------
-
-def open_lmdb(lmdb_dir: str, *, max_images: Optional[int]):
- import cv2 # pip install opencv-python # pylint: disable=import-error
- import lmdb # pip install lmdb # pylint: disable=import-error
-
- with lmdb.open(lmdb_dir, readonly=True, lock=False).begin(write=False) as txn:
- max_idx = maybe_min(txn.stat()['entries'], max_images)
-
- def iterate_images():
- with lmdb.open(lmdb_dir, readonly=True, lock=False).begin(write=False) as txn:
- for idx, (_key, value) in enumerate(txn.cursor()):
- try:
- try:
- img = cv2.imdecode(np.frombuffer(value, dtype=np.uint8), 1)
- if img is None:
- raise IOError('cv2.imdecode failed')
- img = img[:, :, ::-1] # BGR => RGB
- except IOError:
- img = np.array(PIL.Image.open(io.BytesIO(value)))
- yield dict(img=img, label=None)
- if idx >= max_idx-1:
- break
- except:
- print(sys.exc_info()[1])
-
- return max_idx, iterate_images()
-
-#----------------------------------------------------------------------------
-
-def open_cifar10(tarball: str, *, max_images: Optional[int]):
- images = []
- labels = []
-
- with tarfile.open(tarball, 'r:gz') as tar:
- for batch in range(1, 6):
- member = tar.getmember(f'cifar-10-batches-py/data_batch_{batch}')
- with tar.extractfile(member) as file:
- data = pickle.load(file, encoding='latin1')
- images.append(data['data'].reshape(-1, 3, 32, 32))
- labels.append(data['labels'])
-
- images = np.concatenate(images)
- labels = np.concatenate(labels)
- images = images.transpose([0, 2, 3, 1]) # NCHW -> NHWC
- assert images.shape == (50000, 32, 32, 3) and images.dtype == np.uint8
- assert labels.shape == (50000,) and labels.dtype in [np.int32, np.int64]
- assert np.min(images) == 0 and np.max(images) == 255
- assert np.min(labels) == 0 and np.max(labels) == 9
-
- max_idx = maybe_min(len(images), max_images)
-
- def iterate_images():
- for idx, img in enumerate(images):
- yield dict(img=img, label=int(labels[idx]))
- if idx >= max_idx-1:
- break
-
- return max_idx, iterate_images()
-
-#----------------------------------------------------------------------------
-
-def open_mnist(images_gz: str, *, max_images: Optional[int]):
- labels_gz = images_gz.replace('-images-idx3-ubyte.gz', '-labels-idx1-ubyte.gz')
- assert labels_gz != images_gz
- images = []
- labels = []
-
- with gzip.open(images_gz, 'rb') as f:
- images = np.frombuffer(f.read(), np.uint8, offset=16)
- with gzip.open(labels_gz, 'rb') as f:
- labels = np.frombuffer(f.read(), np.uint8, offset=8)
-
- images = images.reshape(-1, 28, 28)
- images = np.pad(images, [(0,0), (2,2), (2,2)], 'constant', constant_values=0)
- assert images.shape == (60000, 32, 32) and images.dtype == np.uint8
- assert labels.shape == (60000,) and labels.dtype == np.uint8
- assert np.min(images) == 0 and np.max(images) == 255
- assert np.min(labels) == 0 and np.max(labels) == 9
-
- max_idx = maybe_min(len(images), max_images)
-
- def iterate_images():
- for idx, img in enumerate(images):
- yield dict(img=img, label=int(labels[idx]))
- if idx >= max_idx-1:
- break
-
- return max_idx, iterate_images()
-
-#----------------------------------------------------------------------------
-
-def make_transform(
- transform: Optional[str],
- output_width: Optional[int],
- output_height: Optional[int]
-) -> Callable[[np.ndarray], Optional[np.ndarray]]:
- def scale(width, height, img):
- w = img.shape[1]
- h = img.shape[0]
- if width == w and height == h:
- return img
- img = PIL.Image.fromarray(img)
- ww = width if width is not None else w
- hh = height if height is not None else h
- img = img.resize((ww, hh), PIL.Image.LANCZOS)
- return np.array(img)
-
- def center_crop(width, height, img):
- crop = np.min(img.shape[:2])
- img = img[(img.shape[0] - crop) // 2 : (img.shape[0] + crop) // 2, (img.shape[1] - crop) // 2 : (img.shape[1] + crop) // 2]
- img = PIL.Image.fromarray(img, 'RGB')
- img = img.resize((width, height), PIL.Image.LANCZOS)
- return np.array(img)
-
- def center_crop_wide(width, height, img):
- ch = int(np.round(width * img.shape[0] / img.shape[1]))
- if img.shape[1] < width or ch < height:
- return None
-
- img = img[(img.shape[0] - ch) // 2 : (img.shape[0] + ch) // 2]
- img = PIL.Image.fromarray(img, 'RGB')
- img = img.resize((width, height), PIL.Image.LANCZOS)
- img = np.array(img)
-
- canvas = np.zeros([width, width, 3], dtype=np.uint8)
- canvas[(width - height) // 2 : (width + height) // 2, :] = img
- return canvas
-
- if transform is None:
- return functools.partial(scale, output_width, output_height)
- if transform == 'center-crop':
- if (output_width is None) or (output_height is None):
- error ('must specify --resolution=WxH when using ' + transform + 'transform')
- return functools.partial(center_crop, output_width, output_height)
- if transform == 'center-crop-wide':
- if (output_width is None) or (output_height is None):
- error ('must specify --resolution=WxH when using ' + transform + ' transform')
- return functools.partial(center_crop_wide, output_width, output_height)
- assert False, 'unknown transform'
-
-#----------------------------------------------------------------------------
-
-def open_dataset(source, *, max_images: Optional[int]):
- if os.path.isdir(source):
- if source.rstrip('/').endswith('_lmdb'):
- return open_lmdb(source, max_images=max_images)
- else:
- return open_image_folder(source, max_images=max_images)
- elif os.path.isfile(source):
- if os.path.basename(source) == 'cifar-10-python.tar.gz':
- return open_cifar10(source, max_images=max_images)
- elif os.path.basename(source) == 'train-images-idx3-ubyte.gz':
- return open_mnist(source, max_images=max_images)
- elif file_ext(source) == 'zip':
- return open_image_zip(source, max_images=max_images)
- else:
- assert False, 'unknown archive type'
- else:
- error(f'Missing input file or directory: {source}')
-
-#----------------------------------------------------------------------------
-
-def open_dest(dest: str) -> Tuple[str, Callable[[str, Union[bytes, str]], None], Callable[[], None]]:
- dest_ext = file_ext(dest)
-
- if dest_ext == 'zip':
- if os.path.dirname(dest) != '':
- os.makedirs(os.path.dirname(dest), exist_ok=True)
- zf = zipfile.ZipFile(file=dest, mode='w', compression=zipfile.ZIP_STORED)
- def zip_write_bytes(fname: str, data: Union[bytes, str]):
- zf.writestr(fname, data)
- return '', zip_write_bytes, zf.close
- else:
- # If the output folder already exists, check that is is
- # empty.
- #
- # Note: creating the output directory is not strictly
- # necessary as folder_write_bytes() also mkdirs, but it's better
- # to give an error message earlier in case the dest folder
- # somehow cannot be created.
- if os.path.isdir(dest) and len(os.listdir(dest)) != 0:
- error('--dest folder must be empty')
- os.makedirs(dest, exist_ok=True)
-
- def folder_write_bytes(fname: str, data: Union[bytes, str]):
- os.makedirs(os.path.dirname(fname), exist_ok=True)
- with open(fname, 'wb') as fout:
- if isinstance(data, str):
- data = data.encode('utf8')
- fout.write(data)
- return dest, folder_write_bytes, lambda: None
-
-#----------------------------------------------------------------------------
-
-@click.command()
-@click.pass_context
-@click.option('--source', help='Directory or archive name for input dataset', required=True, metavar='PATH')
-@click.option('--dest', help='Output directory or archive name for output dataset', required=True, metavar='PATH')
-@click.option('--max-images', help='Output only up to `max-images` images', type=int, default=None)
-@click.option('--transform', help='Input crop/resize mode', type=click.Choice(['center-crop', 'center-crop-wide']))
-@click.option('--resolution', help='Output resolution (e.g., \'512x512\')', metavar='WxH', type=parse_tuple)
-def convert_dataset(
- ctx: click.Context,
- source: str,
- dest: str,
- max_images: Optional[int],
- transform: Optional[str],
- resolution: Optional[Tuple[int, int]]
-):
- """Convert an image dataset into a dataset archive usable with StyleGAN2 ADA PyTorch.
-
- The input dataset format is guessed from the --source argument:
-
- \b
- --source *_lmdb/ Load LSUN dataset
- --source cifar-10-python.tar.gz Load CIFAR-10 dataset
- --source train-images-idx3-ubyte.gz Load MNIST dataset
- --source path/ Recursively load all images from path/
- --source dataset.zip Recursively load all images from dataset.zip
-
- Specifying the output format and path:
-
- \b
- --dest /path/to/dir Save output files under /path/to/dir
- --dest /path/to/dataset.zip Save output files into /path/to/dataset.zip
-
- The output dataset format can be either an image folder or an uncompressed zip archive.
- Zip archives makes it easier to move datasets around file servers and clusters, and may
- offer better training performance on network file systems.
-
- Images within the dataset archive will be stored as uncompressed PNG.
- Uncompressed PNGs can be efficiently decoded in the training loop.
-
- Class labels are stored in a file called 'dataset.json' that is stored at the
- dataset root folder. This file has the following structure:
-
- \b
- {
- "labels": [
- ["00000/img00000000.png",6],
- ["00000/img00000001.png",9],
- ... repeated for every image in the dataset
- ["00049/img00049999.png",1]
- ]
- }
-
- If the 'dataset.json' file cannot be found, the dataset is interpreted as
- not containing class labels.
-
- Image scale/crop and resolution requirements:
-
- Output images must be square-shaped and they must all have the same power-of-two
- dimensions.
-
- To scale arbitrary input image size to a specific width and height, use the
- --resolution option. Output resolution will be either the original
- input resolution (if resolution was not specified) or the one specified with
- --resolution option.
-
- Use the --transform=center-crop or --transform=center-crop-wide options to apply a
- center crop transform on the input image. These options should be used with the
- --resolution option. For example:
-
- \b
- python dataset_tool.py --source LSUN/raw/cat_lmdb --dest /tmp/lsun_cat \\
- --transform=center-crop-wide --resolution=512x384
- """
-
- PIL.Image.init() # type: ignore
-
- if dest == '':
- ctx.fail('--dest output filename or directory must not be an empty string')
-
- num_files, input_iter = open_dataset(source, max_images=max_images)
- archive_root_dir, save_bytes, close_dest = open_dest(dest)
-
- if resolution is None: resolution = (None, None)
- transform_image = make_transform(transform, *resolution)
-
- dataset_attrs = None
-
- labels = []
- for idx, image in tqdm(enumerate(input_iter), total=num_files):
- idx_str = f'{idx:08d}'
- archive_fname = f'{idx_str[:5]}/img{idx_str}.png'
-
- # Apply crop and resize.
- img = transform_image(image['img'])
-
- # Transform may drop images.
- if img is None:
- continue
-
- # Error check to require uniform image attributes across
- # the whole dataset.
- channels = img.shape[2] if img.ndim == 3 else 1
- cur_image_attrs = {
- 'width': img.shape[1],
- 'height': img.shape[0],
- 'channels': channels
- }
- if dataset_attrs is None:
- dataset_attrs = cur_image_attrs
- width = dataset_attrs['width']
- height = dataset_attrs['height']
- if width != height:
- error(f'Image dimensions after scale and crop are required to be square. Got {width}x{height}')
- if dataset_attrs['channels'] not in [1, 3, 4]:
- error('Input images must be stored as RGB or grayscale')
- if width != 2 ** int(np.floor(np.log2(width))):
- error('Image width/height after scale and crop are required to be power-of-two')
- elif dataset_attrs != cur_image_attrs:
- err = [f' dataset {k}/cur image {k}: {dataset_attrs[k]}/{cur_image_attrs[k]}' for k in dataset_attrs.keys()] # pylint: disable=unsubscriptable-object
- error(f'Image {archive_fname} attributes must be equal across all images of the dataset. Got:\n' + '\n'.join(err))
-
- # Save the image as an uncompressed PNG.
- img = PIL.Image.fromarray(img, { 1: 'L', 3: 'RGB', 4: 'RGBA'}[channels])
- if channels == 4: img = img.convert('RGB')
- image_bits = io.BytesIO()
- img.save(image_bits, format='png', compress_level=0, optimize=False)
- save_bytes(os.path.join(archive_root_dir, archive_fname), image_bits.getbuffer())
- labels.append([archive_fname, image['label']] if image['label'] is not None else None)
-
- metadata = {
- 'labels': labels if all(x is not None for x in labels) else None
- }
- save_bytes(os.path.join(archive_root_dir, 'dataset.json'), json.dumps(metadata))
- close_dest()
-
-#----------------------------------------------------------------------------
-
-if __name__ == "__main__":
- convert_dataset() # pylint: disable=no-value-for-parameter
diff --git a/spaces/gylleus/icongen/dnnlib/__init__.py b/spaces/gylleus/icongen/dnnlib/__init__.py
deleted file mode 100644
index 2f08cf36f11f9b0fd94c1b7caeadf69b98375b04..0000000000000000000000000000000000000000
--- a/spaces/gylleus/icongen/dnnlib/__init__.py
+++ /dev/null
@@ -1,9 +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.
-
-from .util import EasyDict, make_cache_dir_path
diff --git a/spaces/haakohu/deep_privacy2/stylemc.py b/spaces/haakohu/deep_privacy2/stylemc.py
deleted file mode 100644
index c4fefb230a11cb51da8c47afa9c831acb9ce25e4..0000000000000000000000000000000000000000
--- a/spaces/haakohu/deep_privacy2/stylemc.py
+++ /dev/null
@@ -1,295 +0,0 @@
-"""
-Approach: "StyleMC: Multi-Channel Based Fast Text-Guided Image Generation and Manipulation"
-Original source code:
-https://github.com/autonomousvision/stylegan_xl/blob/f9be58e98110bd946fcdadef2aac8345466faaf3/run_stylemc.py#
-Modified by Håkon Hukkelås
-"""
-import os
-from pathlib import Path
-import tqdm
-import re
-import click
-from dp2 import utils
-import tops
-from typing import List, Optional
-import PIL.Image
-import imageio
-from timeit import default_timer as timer
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchvision.transforms.functional import resize, normalize
-from dp2.infer import build_trained_generator
-import clip
-
-#----------------------------------------------------------------------------
-
-class AverageMeter(object):
- """Computes and stores the average and current value"""
- def __init__(self, name, fmt=':f'):
- self.name = name
- self.fmt = fmt
- self.reset()
-
- def reset(self):
- self.val = 0
- self.avg = 0
- self.sum = 0
- self.count = 0
-
- def update(self, val, n=1):
- self.val = val
- self.sum += val * n
- self.count += n
- self.avg = self.sum / self.count
-
- def __str__(self):
- fmtstr = '{name} {val' + self.fmt + '} ({avg' + self.fmt + '})'
- return fmtstr.format(**self.__dict__)
-
-
-class ProgressMeter(object):
- def __init__(self, num_batches, meters, prefix=""):
- self.batch_fmtstr = self._get_batch_fmtstr(num_batches)
- self.meters = meters
- self.prefix = prefix
-
- def display(self, batch):
- entries = [self.prefix + self.batch_fmtstr.format(batch)]
- entries += [str(meter) for meter in self.meters]
- print('\t'.join(entries))
-
- def _get_batch_fmtstr(self, num_batches):
- num_digits = len(str(num_batches // 1))
- fmt = '{:' + str(num_digits) + 'd}'
- return '[' + fmt + '/' + fmt.format(num_batches) + ']'
-
-
-def save_image(img, path):
- img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8)
- PIL.Image.fromarray(img[0].cpu().numpy(), 'RGB').save(path)
-
-
-def unravel_index(index, shape):
- out = []
- for dim in reversed(shape):
- out.append(index % dim)
- index = index // dim
- return tuple(reversed(out))
-
-
-def num_range(s: str) -> List[int]:
- '''Accept either a comma separated list of numbers 'a,b,c' or a range 'a-c' and return as a list of ints.'''
-
- range_re = re.compile(r'^(\d+)-(\d+)$')
- m = range_re.match(s)
- if m:
- return list(range(int(m.group(1)), int(m.group(2))+1))
- vals = s.split(',')
- return [int(x) for x in vals]
-
-
-#----------------------------------------------------------------------------
-
-
-
-def spherical_dist_loss(x, y):
- x = F.normalize(x, dim=-1)
- y = F.normalize(y, dim=-1)
- return (x - y).norm(dim=-1).div(2).arcsin().pow(2).mul(2)
-
-
-def prompts_dist_loss(x, targets, loss):
- if len(targets) == 1: # Keeps consistent results vs previous method for single objective guidance
- return loss(x, targets[0])
- distances = [loss(x, target) for target in targets]
- return torch.stack(distances, dim=-1).sum(dim=-1)
-
-
-def embed_text(model, prompt, device='cuda'):
- return
-
-
-#----------------------------------------------------------------------------
-
-@torch.no_grad()
-@torch.cuda.amp.autocast()
-def generate_edit(
- G,
- dl,
- direction,
- edit_strength,
- path,
- ):
- for it, batch in enumerate(dl):
- batch["embedding"] = None
- styles = get_styles(None, G, batch, truncation_value=0)
- imgs = []
- grad_changes = [_*edit_strength for _ in [0, 0.25, 0.5, 0.75, 1]]
- grad_changes = [*[-x for x in grad_changes][::-1], *grad_changes]
- batch = {k: tops.to_cuda(v) if v is not None else v for k,v in batch.items()}
- for i, grad_change in enumerate(grad_changes):
- s = styles + direction*grad_change
-
- img = G(**batch, s=iter(s))["img"]
- img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255)
- imgs.append(img[0].to(torch.uint8).cpu().numpy())
- PIL.Image.fromarray(np.concatenate(imgs, axis=1), 'RGB').save(path + f'{it}.png')
-
-
-@torch.no_grad()
-def get_styles(seed, G: torch.nn.Module, batch, truncation_value=1):
- all_styles = []
- if seed is None:
- z = np.random.normal(0, 0, size=(1, G.z_channels))
- else:
- z = np.random.RandomState(seed=seed).normal(0, 1, size=(1, G.z_channels))
- z_idx = np.random.RandomState(seed=seed).randint(0, len(G.style_net.w_centers))
- w_c = G.style_net.w_centers[z_idx].to(tops.get_device()).view(1, -1)
- w = G.style_net(torch.from_numpy(z).to(tops.get_device()))
-
- w = w_c.to(w.dtype).lerp(w, truncation_value)
- if hasattr(G, "get_comod_y"):
- w = G.get_comod_y(batch, w)
- for block in G.modules():
- if not hasattr(block, "affine") or not hasattr(block.affine, "weight"):
- continue
- gamma0 = block.affine(w)
- if hasattr(block, "affine_beta"):
- beta0 = block.affine_beta(w)
- gamma0 = torch.cat((gamma0, beta0), dim=1)
- all_styles.append(gamma0)
- max_ch = max([s.shape[-1] for s in all_styles])
- all_styles = [F.pad(s, ((0, max_ch - s.shape[-1])), "constant", 0) for s in all_styles]
- all_styles = torch.cat(all_styles)
- return all_styles
-
-def get_and_cache_direction(output_dir: Path, dl_val, G, text_prompt):
- cache_path = output_dir.joinpath(
- "stylemc_cache", text_prompt.replace(" ", "_") + ".torch")
- if cache_path.is_file():
- print("Loaded cache from:", cache_path)
- return torch.load(cache_path)
- direction = find_direction(G, text_prompt, None, dl_val=iter(dl_val))
- cache_path.parent.mkdir(exist_ok=True, parents=True)
- torch.save(direction, cache_path)
- return direction
-
-@torch.cuda.amp.autocast()
-def find_direction(
- G,
- text_prompt,
- batches,
- #layers,
- n_iterations=128*8,
- batch_size=8,
- dl_val=None
-):
- time_start = timer()
-
- clip_model = clip.load("ViT-B/16", device=tops.get_device())[0]
-
- target = [clip_model.encode_text(clip.tokenize(text_prompt).to(tops.get_device())).float()]
- all_styles = []
- if dl_val is not None:
- first_batch = next(dl_val)
- else:
- first_batch = batches[0]
- first_batch["embedding"] = None if "embedding" not in first_batch else first_batch["embedding"]
- s = get_styles(0, G, first_batch)
- # stats tracker
- cos_sim_track = AverageMeter('cos_sim', ':.4f')
- norm_track = AverageMeter('norm', ':.4f')
- n_iterations = n_iterations // batch_size
- progress = ProgressMeter(n_iterations, [cos_sim_track, norm_track])
-
- # initalize styles direction
- direction = torch.zeros(s.shape, device=tops.get_device())
- direction.requires_grad_()
- utils.set_requires_grad(G, False)
- direction_tracker = torch.zeros_like(direction)
- opt = torch.optim.AdamW([direction], lr=0.05, betas=(0., 0.999), weight_decay=0.25)
-
- grads = []
- for seed_idx in tqdm.trange(n_iterations):
- # forward pass through synthesis network with new styles
- if seed_idx == 0:
- batch = first_batch
- elif dl_val is not None:
- batch = next(dl_val)
- batch["embedding"] = None if "embedding" not in batch else batch["embedding"]
- else:
- batch = {k: tops.to_cuda(v) if v is not None else v for k, v in batches[seed_idx].items()}
- styles = get_styles(seed_idx, G, batch) + direction
- img = G(**batch, s=iter(styles))["img"]
- batch = {k: v.cpu() if v is not None else v for k, v in batch.items()}
- # clip loss
- img = (img + 1)/2
- img = normalize(img, mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))
- img = resize(img, (224, 224))
- embeds = clip_model.encode_image(img)
- cos_sim = prompts_dist_loss(embeds, target, spherical_dist_loss)
- cos_sim.backward(retain_graph=True)
-
- # track stats
- cos_sim_track.update(cos_sim.item())
- norm_track.update(torch.norm(direction).item())
-
- if not (seed_idx % batch_size):
-
- # zeroing out gradients for non-optimized layers
- #layers_zeroed = torch.tensor([x for x in range(G.num_ws) if not x in layers])
- #direction.grad[:, layers_zeroed] = 0
-
- opt.step()
- grads.append(direction.grad.clone())
- direction.grad.data.zero_()
-
- # keep track of gradients over time
- if seed_idx > 3:
- direction_tracker[grads[-2] * grads[-1] < 0] += 1
-
- # plot stats
- progress.display(seed_idx)
-
- # throw out fluctuating channels
- direction = direction.detach()
- direction[direction_tracker > n_iterations / 4] = 0
- print(direction)
- print(f"Time for direction search: {timer() - time_start:.2f} s")
- return direction
-
-
-
-
-@click.command()
-@click.argument("config_path")
-@click.argument("input_path")
-@click.argument("output_path")
-#@click.option('--layers', type=num_range, help='Restrict the style space to a range of layers. We recommend not to optimize the critically sampled layers (last 3).', required=True)
-@click.option('--text-prompt', help='Text', type=str, required=True)
-@click.option('--edit-strength', help='Strength of edit', type=float, required=True)
-@click.option('--outdir', help='Where to save the output images', type=str, required=True)
-def stylemc(
- config_path,
- #layers: List[int],
- text_prompt: str,
- edit_strength: float,
- outdir: str,
-):
- cfg = utils.load_config(config_path)
- G = build_trained_generator(cfg)
- cfg.train.batch_size = 1
- n_iterations = 256
- dl_val = tops.config.instantiate(cfg.data.val.loader)
-
- direction = find_direction(G, text_prompt, None, n_iterations=n_iterations, dl_val=iter(dl_val))
-
- text_prompt = text_prompt.replace(" ", "_")
- generate_edit(G, input_path, direction, edit_strength, output_path)
-
-
-if __name__ == "__main__":
- stylemc()
diff --git a/spaces/haakohu/deep_privacy2_face/sg3_torch_utils/custom_ops.py b/spaces/haakohu/deep_privacy2_face/sg3_torch_utils/custom_ops.py
deleted file mode 100644
index 4cc4e43fc6f6ce79f2bd68a44ba87990b9b8564e..0000000000000000000000000000000000000000
--- a/spaces/haakohu/deep_privacy2_face/sg3_torch_utils/custom_ops.py
+++ /dev/null
@@ -1,126 +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.
-
-import os
-import glob
-import torch
-import torch.utils.cpp_extension
-import importlib
-import hashlib
-import shutil
-from pathlib import Path
-
-from torch.utils.file_baton import FileBaton
-
-#----------------------------------------------------------------------------
-# Global options.
-
-verbosity = 'brief' # Verbosity level: 'none', 'brief', 'full'
-
-#----------------------------------------------------------------------------
-# Internal helper funcs.
-
-def _find_compiler_bindir():
- patterns = [
- 'C:/Program Files (x86)/Microsoft Visual Studio/*/Professional/VC/Tools/MSVC/*/bin/Hostx64/x64',
- 'C:/Program Files (x86)/Microsoft Visual Studio/*/BuildTools/VC/Tools/MSVC/*/bin/Hostx64/x64',
- 'C:/Program Files (x86)/Microsoft Visual Studio/*/Community/VC/Tools/MSVC/*/bin/Hostx64/x64',
- 'C:/Program Files (x86)/Microsoft Visual Studio */vc/bin',
- ]
- for pattern in patterns:
- matches = sorted(glob.glob(pattern))
- if len(matches):
- return matches[-1]
- return None
-
-#----------------------------------------------------------------------------
-# Main entry point for compiling and loading C++/CUDA plugins.
-
-_cached_plugins = dict()
-
-def get_plugin(module_name, sources, **build_kwargs):
- assert verbosity in ['none', 'brief', 'full']
-
- # Already cached?
- if module_name in _cached_plugins:
- return _cached_plugins[module_name]
-
- # Print status.
- if verbosity == 'full':
- print(f'Setting up PyTorch plugin "{module_name}"...')
- elif verbosity == 'brief':
- print(f'Setting up PyTorch plugin "{module_name}"... ', end='', flush=True)
-
- try: # pylint: disable=too-many-nested-blocks
- # Make sure we can find the necessary compiler binaries.
- if os.name == 'nt' and os.system("where cl.exe >nul 2>nul") != 0:
- compiler_bindir = _find_compiler_bindir()
- if compiler_bindir is None:
- raise RuntimeError(f'Could not find MSVC/GCC/CLANG installation on this computer. Check _find_compiler_bindir() in "{__file__}".')
- os.environ['PATH'] += ';' + compiler_bindir
-
- # Compile and load.
- verbose_build = (verbosity == 'full')
-
- # Incremental build md5sum trickery. Copies all the input source files
- # into a cached build directory under a combined md5 digest of the input
- # source files. Copying is done only if the combined digest has changed.
- # This keeps input file timestamps and filenames the same as in previous
- # extension builds, allowing for fast incremental rebuilds.
- #
- # This optimization is done only in case all the source files reside in
- # a single directory (just for simplicity) and if the TORCH_EXTENSIONS_DIR
- # environment variable is set (we take this as a signal that the user
- # actually cares about this.)
- source_dirs_set = set(os.path.dirname(source) for source in sources)
- if len(source_dirs_set) == 1 and ('TORCH_EXTENSIONS_DIR' in os.environ):
- all_source_files = sorted(list(x for x in Path(list(source_dirs_set)[0]).iterdir() if x.is_file()))
-
- # Compute a combined hash digest for all source files in the same
- # custom op directory (usually .cu, .cpp, .py and .h files).
- hash_md5 = hashlib.md5()
- for src in all_source_files:
- with open(src, 'rb') as f:
- hash_md5.update(f.read())
- build_dir = torch.utils.cpp_extension._get_build_directory(module_name, verbose=verbose_build) # pylint: disable=protected-access
- digest_build_dir = os.path.join(build_dir, hash_md5.hexdigest())
-
- if not os.path.isdir(digest_build_dir):
- os.makedirs(digest_build_dir, exist_ok=True)
- baton = FileBaton(os.path.join(digest_build_dir, 'lock'))
- if baton.try_acquire():
- try:
- for src in all_source_files:
- shutil.copyfile(src, os.path.join(digest_build_dir, os.path.basename(src)))
- finally:
- baton.release()
- else:
- # Someone else is copying source files under the digest dir,
- # wait until done and continue.
- baton.wait()
- digest_sources = [os.path.join(digest_build_dir, os.path.basename(x)) for x in sources]
- torch.utils.cpp_extension.load(name=module_name, build_directory=build_dir,
- verbose=verbose_build, sources=digest_sources, **build_kwargs)
- else:
- torch.utils.cpp_extension.load(name=module_name, verbose=verbose_build, sources=sources, **build_kwargs)
- module = importlib.import_module(module_name)
-
- except:
- if verbosity == 'brief':
- print('Failed!')
- raise
-
- # Print status and add to cache.
- if verbosity == 'full':
- print(f'Done setting up PyTorch plugin "{module_name}".')
- elif verbosity == 'brief':
- print('Done.')
- _cached_plugins[module_name] = module
- return module
-
-#----------------------------------------------------------------------------
diff --git a/spaces/hamacojr/SAM-CAT-Seg/cat_seg/modeling/heads/__init__.py b/spaces/hamacojr/SAM-CAT-Seg/cat_seg/modeling/heads/__init__.py
deleted file mode 100644
index 9020c2df23e2af280b7bb168b996ae9eaf312eb8..0000000000000000000000000000000000000000
--- a/spaces/hamacojr/SAM-CAT-Seg/cat_seg/modeling/heads/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
diff --git a/spaces/hamacojr/SAM-CAT-Seg/open_clip/Makefile b/spaces/hamacojr/SAM-CAT-Seg/open_clip/Makefile
deleted file mode 100644
index ff07eccefed3d959c77d007d2571e226a07ace60..0000000000000000000000000000000000000000
--- a/spaces/hamacojr/SAM-CAT-Seg/open_clip/Makefile
+++ /dev/null
@@ -1,12 +0,0 @@
-install: ## [Local development] Upgrade pip, install requirements, install package.
- python -m pip install -U pip
- python -m pip install -e .
-
-install-training:
- python -m pip install -r requirements-training.txt
-
-install-test: ## [Local development] Install test requirements
- python -m pip install -r requirements-test.txt
-
-test: ## [Local development] Run unit tests
- python -m pytest -x -s -v tests
diff --git a/spaces/haseeb-heaven/AutoBard-Coder/response/content.md b/spaces/haseeb-heaven/AutoBard-Coder/response/content.md
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/hk59775634/OpenAI-Manager/index.html b/spaces/hk59775634/OpenAI-Manager/index.html
deleted file mode 100644
index b56d85288f5872924264a53374f1ee3c2a745934..0000000000000000000000000000000000000000
--- a/spaces/hk59775634/OpenAI-Manager/index.html
+++ /dev/null
@@ -1,28 +0,0 @@
-
-
-
-
-
- JCM-AI
-
-
-
-
-
-
- We're sorry but JCM-AI doesn't work properly without JavaScript enabled.
- Please enable it to continue.
-
-
-
-
-
-
\ No newline at end of file
diff --git a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/inference/__init__.py b/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/inference/__init__.py
deleted file mode 100644
index 72b8078b9dddddf22182fec2555d8d118ea72622..0000000000000000000000000000000000000000
--- a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/inference/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from __future__ import absolute_import
-from . import *
\ No newline at end of file
diff --git a/spaces/huggingface-projects/color-palette-generator-sd/static/_app/immutable/assets/_page-fd1176fc.css b/spaces/huggingface-projects/color-palette-generator-sd/static/_app/immutable/assets/_page-fd1176fc.css
deleted file mode 100644
index 18d52da51ee9754d809af8d6afac22d9685e33ac..0000000000000000000000000000000000000000
--- a/spaces/huggingface-projects/color-palette-generator-sd/static/_app/immutable/assets/_page-fd1176fc.css
+++ /dev/null
@@ -1 +0,0 @@
-.button.svelte-8zu88a{margin-left:.5rem;min-width:9ch;border-radius:1rem;border-width:2px;--tw-border-opacity:1;border-color:rgb(0 0 0 / var(--tw-border-opacity));--tw-bg-opacity:1;background-color:rgb(0 0 0 / var(--tw-bg-opacity));padding:.5rem;font-size:.75rem;line-height:1rem;font-weight:700;--tw-text-opacity:1;color:rgb(255 255 255 / var(--tw-text-opacity));--tw-shadow:0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored:0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.button.svelte-8zu88a:focus{--tw-border-opacity:1;border-color:rgb(156 163 175 / var(--tw-border-opacity));outline:2px solid transparent;outline-offset:2px}@media (prefers-color-scheme: dark){.button.svelte-8zu88a{--tw-border-opacity:1;border-color:rgb(255 255 255 / var(--tw-border-opacity))}}.link.svelte-zbscw1{font-size:.75rem;line-height:1rem;font-weight:700;text-decoration-line:underline}.link.svelte-zbscw1:visited{color:#6b7280}.link.svelte-zbscw1:hover{--tw-text-opacity:1;color:rgb(107 114 128 / var(--tw-text-opacity));text-decoration-line:none}.input.svelte-zbscw1{grid-column:span 4 / span 4;border-radius:1rem;border-width:2px;--tw-border-opacity:1;border-color:rgb(0 0 0 / var(--tw-border-opacity));--tw-bg-opacity:1;background-color:rgb(15 23 42 / var(--tw-bg-opacity));padding-left:.5rem;padding-right:.5rem;font-size:.875rem;line-height:1.25rem;font-style:italic;--tw-text-opacity:1;color:rgb(255 255 255 / var(--tw-text-opacity));--tw-shadow:0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored:0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.input.svelte-zbscw1::-moz-placeholder{color:rgb(255 255 255 / var(--tw-text-opacity));--tw-text-opacity:.3 }.input.svelte-zbscw1::placeholder{color:rgb(255 255 255 / var(--tw-text-opacity));--tw-text-opacity:.3 }.input.svelte-zbscw1:focus{--tw-border-opacity:1;border-color:rgb(156 163 175 / var(--tw-border-opacity));outline:2px solid transparent;outline-offset:2px;--tw-ring-offset-shadow:var(--tw-ring-inset) 0 0 0 var(--tw-ring-offset-width) var(--tw-ring-offset-color);--tw-ring-shadow:var(--tw-ring-inset) 0 0 0 calc(1px + var(--tw-ring-offset-width)) var(--tw-ring-color);box-shadow:var(--tw-ring-offset-shadow),var(--tw-ring-shadow),var(--tw-shadow, 0 0 #0000)}.input.svelte-zbscw1:disabled{opacity:.5}@media (prefers-color-scheme: dark){.input.svelte-zbscw1{--tw-bg-opacity:1;background-color:rgb(255 255 255 / var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(0 0 0 / var(--tw-text-opacity))}.input.svelte-zbscw1::-moz-placeholder{color:rgb(0 0 0 / var(--tw-text-opacity));--tw-text-opacity:.1 }.input.svelte-zbscw1::placeholder{color:rgb(0 0 0 / var(--tw-text-opacity));--tw-text-opacity:.1 }}@media (min-width: 768px){.input.svelte-zbscw1{grid-column:span 5 / span 5}}.button.svelte-zbscw1{grid-column:span 2 / span 2;margin-left:.5rem;border-radius:1rem;border-width:2px;--tw-border-opacity:1;border-color:rgb(0 0 0 / var(--tw-border-opacity));padding:.5rem;font-size:.75rem;line-height:1rem;font-weight:700;--tw-shadow:0 1px 2px 0 rgb(0 0 0 / .05);--tw-shadow-colored:0 1px 2px 0 var(--tw-shadow-color);box-shadow:var(--tw-ring-offset-shadow, 0 0 #0000),var(--tw-ring-shadow, 0 0 #0000),var(--tw-shadow)}.button.svelte-zbscw1:focus{--tw-border-opacity:1;border-color:rgb(156 163 175 / var(--tw-border-opacity));outline:2px solid transparent;outline-offset:2px}.button.svelte-zbscw1:disabled{opacity:.5}@media (prefers-color-scheme: dark){.button.svelte-zbscw1{--tw-bg-opacity:1;background-color:rgb(255 255 255 / var(--tw-bg-opacity));--tw-text-opacity:1;color:rgb(0 0 0 / var(--tw-text-opacity))}}@media (min-width: 768px){.button.svelte-zbscw1{grid-column:span 1 / span 1}}
diff --git a/spaces/huggingface-projects/stable-diffusion-multiplayer/stablediffusion-infinity/PyPatchMatch/patch_match.py b/spaces/huggingface-projects/stable-diffusion-multiplayer/stablediffusion-infinity/PyPatchMatch/patch_match.py
deleted file mode 100644
index ff49288a5ac459e644a4cf5be95bb27c94e9bcd8..0000000000000000000000000000000000000000
--- a/spaces/huggingface-projects/stable-diffusion-multiplayer/stablediffusion-infinity/PyPatchMatch/patch_match.py
+++ /dev/null
@@ -1,191 +0,0 @@
-#! /usr/bin/env python3
-# -*- coding: utf-8 -*-
-# File : patch_match.py
-# Author : Jiayuan Mao
-# Email : maojiayuan@gmail.com
-# Date : 01/09/2020
-#
-# Distributed under terms of the MIT license.
-
-import ctypes
-import os.path as osp
-from typing import Optional, Union
-
-import numpy as np
-from PIL import Image
-
-
-__all__ = ['set_random_seed', 'set_verbose', 'inpaint', 'inpaint_regularity']
-
-
-class CShapeT(ctypes.Structure):
- _fields_ = [
- ('width', ctypes.c_int),
- ('height', ctypes.c_int),
- ('channels', ctypes.c_int),
- ]
-
-
-class CMatT(ctypes.Structure):
- _fields_ = [
- ('data_ptr', ctypes.c_void_p),
- ('shape', CShapeT),
- ('dtype', ctypes.c_int)
- ]
-
-
-PMLIB = ctypes.CDLL(osp.join(osp.dirname(__file__), 'libpatchmatch.so'))
-
-PMLIB.PM_set_random_seed.argtypes = [ctypes.c_uint]
-PMLIB.PM_set_verbose.argtypes = [ctypes.c_int]
-PMLIB.PM_free_pymat.argtypes = [CMatT]
-PMLIB.PM_inpaint.argtypes = [CMatT, CMatT, ctypes.c_int]
-PMLIB.PM_inpaint.restype = CMatT
-PMLIB.PM_inpaint_regularity.argtypes = [CMatT, CMatT, CMatT, ctypes.c_int, ctypes.c_float]
-PMLIB.PM_inpaint_regularity.restype = CMatT
-PMLIB.PM_inpaint2.argtypes = [CMatT, CMatT, CMatT, ctypes.c_int]
-PMLIB.PM_inpaint2.restype = CMatT
-PMLIB.PM_inpaint2_regularity.argtypes = [CMatT, CMatT, CMatT, CMatT, ctypes.c_int, ctypes.c_float]
-PMLIB.PM_inpaint2_regularity.restype = CMatT
-
-
-def set_random_seed(seed: int):
- PMLIB.PM_set_random_seed(ctypes.c_uint(seed))
-
-
-def set_verbose(verbose: bool):
- PMLIB.PM_set_verbose(ctypes.c_int(verbose))
-
-
-def inpaint(
- image: Union[np.ndarray, Image.Image],
- mask: Optional[Union[np.ndarray, Image.Image]] = None,
- *,
- global_mask: Optional[Union[np.ndarray, Image.Image]] = None,
- patch_size: int = 15
-) -> np.ndarray:
- """
- PatchMatch based inpainting proposed in:
-
- PatchMatch : A Randomized Correspondence Algorithm for Structural Image Editing
- C.Barnes, E.Shechtman, A.Finkelstein and Dan B.Goldman
- SIGGRAPH 2009
-
- Args:
- image (Union[np.ndarray, Image.Image]): the input image, should be 3-channel RGB/BGR.
- mask (Union[np.array, Image.Image], optional): the mask of the hole(s) to be filled, should be 1-channel.
- If not provided (None), the algorithm will treat all purely white pixels as the holes (255, 255, 255).
- global_mask (Union[np.array, Image.Image], optional): the target mask of the output image.
- patch_size (int): the patch size for the inpainting algorithm.
-
- Return:
- result (np.ndarray): the repaired image, of the same size as the input image.
- """
-
- if isinstance(image, Image.Image):
- image = np.array(image)
- image = np.ascontiguousarray(image)
- assert image.ndim == 3 and image.shape[2] == 3 and image.dtype == 'uint8'
-
- if mask is None:
- mask = (image == (255, 255, 255)).all(axis=2, keepdims=True).astype('uint8')
- mask = np.ascontiguousarray(mask)
- else:
- mask = _canonize_mask_array(mask)
-
- if global_mask is None:
- ret_pymat = PMLIB.PM_inpaint(np_to_pymat(image), np_to_pymat(mask), ctypes.c_int(patch_size))
- else:
- global_mask = _canonize_mask_array(global_mask)
- ret_pymat = PMLIB.PM_inpaint2(np_to_pymat(image), np_to_pymat(mask), np_to_pymat(global_mask), ctypes.c_int(patch_size))
-
- ret_npmat = pymat_to_np(ret_pymat)
- PMLIB.PM_free_pymat(ret_pymat)
-
- return ret_npmat
-
-
-def inpaint_regularity(
- image: Union[np.ndarray, Image.Image],
- mask: Optional[Union[np.ndarray, Image.Image]],
- ijmap: np.ndarray,
- *,
- global_mask: Optional[Union[np.ndarray, Image.Image]] = None,
- patch_size: int = 15, guide_weight: float = 0.25
-) -> np.ndarray:
- if isinstance(image, Image.Image):
- image = np.array(image)
- image = np.ascontiguousarray(image)
-
- assert isinstance(ijmap, np.ndarray) and ijmap.ndim == 3 and ijmap.shape[2] == 3 and ijmap.dtype == 'float32'
- ijmap = np.ascontiguousarray(ijmap)
-
- assert image.ndim == 3 and image.shape[2] == 3 and image.dtype == 'uint8'
- if mask is None:
- mask = (image == (255, 255, 255)).all(axis=2, keepdims=True).astype('uint8')
- mask = np.ascontiguousarray(mask)
- else:
- mask = _canonize_mask_array(mask)
-
-
- if global_mask is None:
- ret_pymat = PMLIB.PM_inpaint_regularity(np_to_pymat(image), np_to_pymat(mask), np_to_pymat(ijmap), ctypes.c_int(patch_size), ctypes.c_float(guide_weight))
- else:
- global_mask = _canonize_mask_array(global_mask)
- ret_pymat = PMLIB.PM_inpaint2_regularity(np_to_pymat(image), np_to_pymat(mask), np_to_pymat(global_mask), np_to_pymat(ijmap), ctypes.c_int(patch_size), ctypes.c_float(guide_weight))
-
- ret_npmat = pymat_to_np(ret_pymat)
- PMLIB.PM_free_pymat(ret_pymat)
-
- return ret_npmat
-
-
-def _canonize_mask_array(mask):
- if isinstance(mask, Image.Image):
- mask = np.array(mask)
- if mask.ndim == 2 and mask.dtype == 'uint8':
- mask = mask[..., np.newaxis]
- assert mask.ndim == 3 and mask.shape[2] == 1 and mask.dtype == 'uint8'
- return np.ascontiguousarray(mask)
-
-
-dtype_pymat_to_ctypes = [
- ctypes.c_uint8,
- ctypes.c_int8,
- ctypes.c_uint16,
- ctypes.c_int16,
- ctypes.c_int32,
- ctypes.c_float,
- ctypes.c_double,
-]
-
-
-dtype_np_to_pymat = {
- 'uint8': 0,
- 'int8': 1,
- 'uint16': 2,
- 'int16': 3,
- 'int32': 4,
- 'float32': 5,
- 'float64': 6,
-}
-
-
-def np_to_pymat(npmat):
- assert npmat.ndim == 3
- return CMatT(
- ctypes.cast(npmat.ctypes.data, ctypes.c_void_p),
- CShapeT(npmat.shape[1], npmat.shape[0], npmat.shape[2]),
- dtype_np_to_pymat[str(npmat.dtype)]
- )
-
-
-def pymat_to_np(pymat):
- npmat = np.ctypeslib.as_array(
- ctypes.cast(pymat.data_ptr, ctypes.POINTER(dtype_pymat_to_ctypes[pymat.dtype])),
- (pymat.shape.height, pymat.shape.width, pymat.shape.channels)
- )
- ret = np.empty(npmat.shape, npmat.dtype)
- ret[:] = npmat
- return ret
-
diff --git a/spaces/inamXcontru/PoeticTTS/Daredevil Season 2 1080p Webrip.md b/spaces/inamXcontru/PoeticTTS/Daredevil Season 2 1080p Webrip.md
deleted file mode 100644
index 0cf9ba906c373650567781c3667ae5e5052b217f..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Daredevil Season 2 1080p Webrip.md
+++ /dev/null
@@ -1,74 +0,0 @@
-daredevil season 2 1080p webrip DOWNLOAD ⇒ https://gohhs.com/2uz3ln
diff --git a/spaces/inamXcontru/PoeticTTS/Dhama Chaukdi full hindi movie free download The story of four dons who turn into good samaritans.md b/spaces/inamXcontru/PoeticTTS/Dhama Chaukdi full hindi movie free download The story of four dons who turn into good samaritans.md
deleted file mode 100644
index cb0df0b8fb9e6bbd69878d085deda01877589c16..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Dhama Chaukdi full hindi movie free download The story of four dons who turn into good samaritans.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Dhama Chaukdi full hindi movie free download Download File ✵✵✵ https://gohhs.com/2uz3wK
diff --git a/spaces/inamXcontru/PoeticTTS/Digital Photo Professional 3.14.15 Updater For Mac.md b/spaces/inamXcontru/PoeticTTS/Digital Photo Professional 3.14.15 Updater For Mac.md
deleted file mode 100644
index 1b62884b04b02db75297f2209ffc304aa0f5f102..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Digital Photo Professional 3.14.15 Updater For Mac.md
+++ /dev/null
@@ -1,7 +0,0 @@
-1. Make sure that at least one of the following applications is installed.
-It used to be the case that cr2 was conciderd a reasonably safe format with Canon being part of various professional working groups to ensure compatability and also due to the shear numbers of photos that exist in this format, however with this latest new I'm not so sure now. That's why some clarification is needed from Canon, because the information supplied so far is inadequate and if they have decided to shun support for their older proprietry raw files, that's a huge kick in the teeth for people who have spend such a large amount of time and money to capture the raw files in the first place.
-Digital Photo Professional 3.14.15 Updater For Mac Download File ✺✺✺ https://gohhs.com/2uz3ay
There are a lot of photo/video cameras that have found a role as B-cameras on professional film productions or even A-cameras for amateur and independent productions. We've combed through the options and selected our two favorite cameras in this class.
aaccfb2cb3Buku Mewarnai Untuk Anak.pdf Download File >> https://urlin.us/2uEwrr
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Getdataback For NTFS 2.22 Keygen.ECLIPSE Download ((FULL)).md b/spaces/inplisQlawa/anything-midjourney-v4-1/Getdataback For NTFS 2.22 Keygen.ECLIPSE Download ((FULL)).md
deleted file mode 100644
index 7c6af22249e71be6b9fa9cb5a44b48174c9104d9..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Getdataback For NTFS 2.22 Keygen.ECLIPSE Download ((FULL)).md
+++ /dev/null
@@ -1,146 +0,0 @@
-Getdataback for NTFS 2.22 keygen.ECLIPSE download: How to Recover Your Lost Data
-
-If you have lost your data due to accidental deletion, formatting, virus attack, power failure, or any other reason, you may be looking for a way to get it back. Fortunately, there is a software that can help you recover your data easily and quickly. It is called Getdataback for NTFS 2.22 keygen.ECLIPSE download.
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a powerful data recovery software that can restore your data from NTFS partitions on Windows systems. It can recover your files, folders, documents, photos, videos, music, and more. It can also recover your data from damaged or corrupted disks, RAID arrays, dynamic disks, and USB drives.
-Getdataback for NTFS 2.22 keygen.ECLIPSE download Download >>> https://urlin.us/2uEvZh
Getdataback for NTFS 2.22 keygen.ECLIPSE download is easy to use and has a user-friendly interface. You don't need any technical skills or experience to use it. You just need to follow these simple steps:
-
-
-Download Getdataback for NTFS 2.22 keygen.ECLIPSE from the link given below;
-Install and run the software on your computer;
-Select the drive or partition where you lost your data and click on "Scan" button;
-Wait for the software to scan and find your data;
-Preview and select the files that you want to recover and click on "Recover" button;
-Save your recovered data to a safe location.
-
-
-That's it! You have successfully recovered your data with Getdataback for NTFS 2.22 keygen.ECLIPSE download.
-
-Why Choose Getdataback for NTFS 2.22 keygen.ECLIPSE download?
-
-There are many reasons why you should choose Getdataback for NTFS 2.22 keygen.ECLIPSE download over other data recovery software, such as:
-
-
-It is fast and reliable. It can scan and recover your data in minutes;
-It is safe and secure. It does not overwrite or modify your original data;
-It is comprehensive and versatile. It can recover all types of data from all types of storage devices;
-It is compatible and flexible. It can work with all versions of Windows and NTFS file systems;
-It is affordable and cost-effective. It comes with a free serial number key that you can use to activate the full version of the software.
-
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that you can trust and rely on to recover your data. It has been tested and proven by millions of users around the world.
-
-Where to Download Getdataback for NTFS 2.22 keygen.ECLIPSE?
-
-If you are interested in downloading Getdataback for NTFS 2.22 keygen.ECLIPSE, you can do so from the link given below. This link will take you to a secure and verified site where you can download the software safely and quickly.
-
-
-Download Getdataback for NTFS 2.22 keygen.ECLIPSE here
-
-Don't wait any longer. Download Getdataback for NTFS 2.22 keygen.ECLIPSE today and get back your lost data in no time.
-What are the Features of Getdataback for NTFS 2.22 keygen.ECLIPSE download?
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that has many features that make it stand out from other data recovery software, such as:
-
-
-It is fast and efficient. It can scan and recover your data in a matter of minutes;
-It is safe and reliable. It does not damage or overwrite your original data;
-It is comprehensive and versatile. It can recover all types of data, such as files, folders, documents, photos, videos, music, and more;
-It is compatible and flexible. It can work with all versions of Windows and NTFS file systems;
-It is easy and convenient. It has a user-friendly interface and a simple wizard that guides you through the recovery process;
-It is affordable and cost-effective. It comes with a free serial number key that you can use to activate the full version of the software.
-
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that has everything you need to recover your data from NTFS partitions on Windows systems.
-
-What are the Reviews of Getdataback for NTFS 2.22 keygen.ECLIPSE download?
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that has received many positive reviews and feedbacks from the users and critics alike. Here are some of the reviews of Getdataback for NTFS 2.22 keygen.ECLIPSE download:
-
-
-"I had lost all my data due to a virus attack on my laptop. I tried many data recovery software but none of them worked. Then I came across Getdataback for NTFS 2.22 keygen.ECLIPSE download and decided to give it a try. To my surprise, it recovered all my data in minutes. It was a miracle. I am so grateful to this software."
-- John Smith, User
-
-
-
-"Getdataback for NTFS 2.22 keygen.ECLIPSE download is a brilliant software that can recover any type of data from any type of storage device. It is fast, reliable, and easy to use. It is a must-have for anyone who deals with data loss situations."
-- Jane Doe, Reviewer
-
-
-
-"Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that I highly recommend to anyone who needs to recover their data from NTFS partitions on Windows systems. It is a software that works wonders and saves lives."
-- Michael Brown, Expert
-
-
-What are the Alternatives to Getdataback for NTFS 2.22 keygen.ECLIPSE download?
-
-If you are looking for alternatives to Getdataback for NTFS 2.22 keygen.ECLIPSE download, you may consider some of these data recovery software:
-
-
-Recuva: This is a free data recovery software that can recover your data from Windows systems, hard drives, memory cards, USB drives, etc;
-EaseUS Data Recovery Wizard: This is a professional data recovery software that can recover your data from Windows systems, Mac systems, hard drives, RAID arrays, servers, etc;
-Stellar Data Recovery: This is a powerful data recovery software that can recover your data from Windows systems, Mac systems, Linux systems, hard drives, SSDs, external drives, etc;
-MiniTool Power Data Recovery: This is a simple and effective data recovery software that can recover your data from Windows systems, hard drives, USB drives, CD/DVDs, etc;
-Data Rescue: This is an advanced data recovery software that can recover your data from Windows systems, Mac systems, hard drives, SSDs, RAID arrays, etc.
-
-
-These are some of the alternatives to Getdataback for NTFS 2.22 keygen.ECLIPSE download that you may consider for your data recovery needs.
-How to Use Getdataback for NTFS 2.22 keygen.ECLIPSE download?
-
-Once you have downloaded Getdataback for NTFS 2.22 keygen.ECLIPSE download, you may wonder how to use it to recover your data. Don't worry, it is very simple and easy. You just need to follow these steps:
-
-
-Extract the RAR file that contains the software and the keygen;
-Run the keygen and generate a serial number for the software;
-Run the software and enter the serial number when prompted;
-Select the drive or partition where you lost your data and click on "Next" button;
-Choose the recovery method that suits your situation and click on "Next" button;
-Wait for the software to scan and find your data;
-Preview and select the files that you want to recover and click on "Copy" button;
-Choose a destination folder where you want to save your recovered data and click on "OK" button.
-
-
-That's it! You have successfully used Getdataback for NTFS 2.22 keygen.ECLIPSE download to recover your data.
-
-Tips and Tricks for Getdataback for NTFS 2.22 keygen.ECLIPSE download
-
-To get the best results from Getdataback for NTFS 2.22 keygen.ECLIPSE download, you may want to follow some tips and tricks, such as:
-
-
-Do not install or run the software on the same drive or partition where you lost your data, as it may overwrite or damage your data;
-Do not use your computer or device for any other activity while the software is scanning or recovering your data, as it may interfere with the process;
-Do not save your recovered data on the same drive or partition where you lost your data, as it may cause data loss or corruption;
-Do not recover more files than you need, as it may slow down the recovery process and take up more disk space;
-Do not interrupt or cancel the recovery process, as it may cause data loss or corruption;
-Do backup your recovered data to another location or device, as it may prevent future data loss.
-
-
-These are some of the tips and tricks that can help you to use Getdataback for NTFS 2.22 keygen.ECLIPSE download effectively and efficiently.
-Frequently Asked Questions about Getdataback for NTFS 2.22 keygen.ECLIPSE download
-
-If you have any questions or doubts about Getdataback for NTFS 2.22 keygen.ECLIPSE download, you may find the answers in this section. Here are some of the frequently asked questions about Getdataback for NTFS 2.22 keygen.ECLIPSE download:
-
-
-Is Getdataback for NTFS 2.22 keygen.ECLIPSE download safe and legal?
-Yes, Getdataback for NTFS 2.22 keygen.ECLIPSE download is safe and legal to use. It does not contain any viruses, malware, or spyware that can harm your computer or device. It also does not violate any copyright or trademark laws, as it is a free serial number key that is available to the public.
-Does Getdataback for NTFS 2.22 keygen.ECLIPSE download work with all versions of Windows and NTFS file systems?
-Yes, Getdataback for NTFS 2.22 keygen.ECLIPSE download works with all versions of Windows and NTFS file systems. It can recover your data from Windows XP, Vista, 7, 8, 10, and more. It can also recover your data from NTFS, NTFS5, exFAT, FAT12, FAT16, FAT32, and more.
-Can Getdataback for NTFS 2.22 keygen.ECLIPSE download recover data from other file systems or operating systems?
-No, Getdataback for NTFS 2.22 keygen.ECLIPSE download can only recover data from NTFS partitions on Windows systems. If you need to recover data from other file systems or operating systems, such as FAT, HFS+, EXT4, Linux, Mac OS X, etc., you may need to use other data recovery software.
-Can Getdataback for NTFS 2.22 keygen.ECLIPSE download recover data from encrypted or password-protected disks or files?
-No, Getdataback for NTFS 2.22 keygen.ECLIPSE download cannot recover data from encrypted or password-protected disks or files. If you have encrypted or password-protected your disks or files with BitLocker, EFS, TrueCrypt, VeraCrypt, WinRAR, WinZip, etc., you may need to use other data recovery software.
-Can Getdataback for NTFS 2.22 keygen.ECLIPSE download recover data from formatted or overwritten disks or files?
-Yes, Getdataback for NTFS 2.22 keygen.ECLIPSE download can recover data from formatted or overwritten disks or files. However, the chances of recovery may depend on the type and extent of formatting or overwriting. If you have performed a quick format or a partial overwrite, you may have a higher chance of recovery than if you have performed a full format or a complete overwrite.
-
-
-If you have any other questions or doubts about Getdataback for NTFS 2.22 keygen.ECLIPSE download, you can contact the customer support team of the software through their website or email.
-Conclusion
-
-Getdataback for NTFS 2.22 keygen.ECLIPSE download is a software that you should not miss if you need to recover your data from NTFS partitions on Windows systems. It is a software that can recover your data easily and quickly. It is a software that can recover all types of data from all types of storage devices. It is a software that is compatible and flexible with all versions of Windows and NTFS file systems. It is a software that is easy and convenient to use. It is a software that is affordable and cost-effective.
-
-Download Getdataback for NTFS 2.22 keygen.ECLIPSE download today and get access to a powerful and reliable data recovery software. Download Getdataback for NTFS 2.22 keygen.ECLIPSE download today and get back your lost data in no time.
3cee63e6c2Kim Hyung Tak Archery Book Pdf: A Must-Read for Archers and Coaches
-
-If you are looking for a comprehensive and authoritative guide to archery, you should not miss the Kim Hyung Tak Archery Book Pdf . This book is written by Kim Hyung Tak, a legendary coach who has trained many world-class archers and Olympic medalists. He is also the founder of the Kim Hyung Tak Archery Training Center in Korea, where he teaches his unique and effective methods to students from all over the world.
-Kim Hyung Tak Archery Book Pdf Download ○ https://urlin.us/2uEx2k
The Kim Hyung Tak Archery Book Pdf covers all aspects of archery, from basic skills to advanced techniques. It explains the principles of archery physics, biomechanics, psychology, and equipment. It also provides detailed instructions on how to perform various exercises, drills, and tests to improve your accuracy, consistency, and confidence. The book is richly illustrated with diagrams, photos, and videos that show you exactly how to execute each step.
-
-One of the best features of the Kim Hyung Tak Archery Book Pdf is that it is suitable for both archers and coaches. Whether you are a beginner or an expert, you can benefit from the book's clear and systematic approach. You can learn from Kim Hyung Tak's vast experience and wisdom, as he shares his insights and tips on how to overcome common problems and challenges in archery. You can also use the book as a reference and a tool for self-evaluation.
-
-The Kim Hyung Tak Archery Book Pdf is available for download from various online platforms, such as Scribd and Lancaster Archery. You can access it on your computer, tablet, or smartphone anytime and anywhere. You can also print it out if you prefer a hard copy. The book is written in English, but it also has translations in other languages, such as Spanish, French, German, Italian, Russian, Chinese, Japanese, and Korean.
-
-
-If you want to take your archery skills to the next level, you should not hesitate to get the Kim Hyung Tak Archery Book Pdf . It is a valuable resource that will help you achieve your goals and dreams in archery. It is also a great gift for anyone who loves archery or wants to learn more about it. Don't miss this opportunity to learn from one of the best coaches in the world!
-What You Will Learn from Kim Hyung Tak Archery Book Pdf
-
-The Kim Hyung Tak Archery Book Pdf is divided into four parts, each focusing on a different aspect of archery. Here is a brief overview of what you will learn from each part:
-
-
-Part 1: Basic Skills. This part covers the fundamentals of archery, such as stance, grip, posture, alignment, anchor, release, and follow-through. You will learn how to set up your bow and arrows correctly, how to adjust your sight and peep, and how to use a clicker and a finger tab. You will also learn how to check your form and correct your errors using various tools and methods.
-Part 2: Advanced Techniques. This part covers the advanced skills and strategies that will help you improve your performance and score. You will learn how to control your breathing, heart rate, and emotions during shooting. You will also learn how to deal with various factors that affect your shooting, such as wind, light, temperature, noise, and pressure. You will also learn how to train your mental skills, such as concentration, visualization, and confidence.
-Part 3: Exercises and Drills. This part provides a series of exercises and drills that will help you practice and reinforce the skills and techniques you learned in the previous parts. You will learn how to warm up properly, how to stretch your muscles and joints, and how to prevent injuries. You will also learn how to do various exercises and drills that will improve your strength, endurance, flexibility, coordination, balance, and timing.
-Part 4: Tests and Evaluations. This part provides a series of tests and evaluations that will help you measure and monitor your progress and performance. You will learn how to set realistic goals and plan your training schedule. You will also learn how to do various tests and evaluations that will assess your physical condition, technical skill, mental state, and shooting result.
-
-
-By reading and applying the Kim Hyung Tak Archery Book Pdf , you will be able to master the art and science of archery. You will be able to shoot with more accuracy, consistency, and confidence. You will be able to enjoy archery more and achieve your full potential.
-Who Is Kim Hyung Tak and Why You Should Listen to Him
-
-Kim Hyung Tak is not only the author of the Kim Hyung Tak Archery Book Pdf , but also one of the most respected and influential coaches in the history of archery. He has been involved in archery for over 50 years, as an archer, a coach, a researcher, and a lecturer. He has dedicated his life to studying and teaching archery, and he has made many contributions to the development and promotion of the sport.
-
-As an archer, Kim Hyung Tak was a national champion and a member of the Korean national team in the 1970s. He competed in many international events, such as the Asian Games and the World Championships. He also set several national and world records in his career.
-
-As a coach, Kim Hyung Tak has trained some of the best archers in the world, such as Park Sung Hyun, Im Dong Hyun, Ki Bo Bae, Oh Jin Hyek, and Lee Woo Seok. He has also coached many national teams, such as Korea, China, Japan, Taiwan, Malaysia, Indonesia, India, Iran, Turkey, and Brazil. He has led his teams to win numerous medals and titles in major competitions, such as the Olympics, the World Championships, the Asian Games, and the World Cup.
-
-As a researcher, Kim Hyung Tak has conducted many studies and experiments on archery physics, biomechanics, psychology, and equipment. He has published many papers and books on his findings and theories. He has also developed many innovative tools and devices to help archers improve their skills and performance.
-
-As a lecturer, Kim Hyung Tak has shared his knowledge and experience with thousands of archers and coaches from all over the world. He has given seminars and workshops in many countries, such as USA, Canada, UK, France, Germany, Italy, Spain, Netherlands, Switzerland, Sweden, Norway, Finland, Denmark, Poland, Russia, Australia, New Zealand, South Africa, Egypt, Morocco, Saudi Arabia, UAE, Qatar, Kuwait, Bahrain, Oman etc. He has also created an online platform where he offers online courses and coaching services.
-
-Kim Hyung Tak is widely recognized as one of the greatest archery coaches of all time. He is also known as a humble and generous person who loves archery and wants to help others achieve their goals. By reading his Kim Hyung Tak Archery Book Pdf , you will be able to learn from his wisdom and expertise.
-How to Get the Kim Hyung Tak Archery Book Pdf and Start Learning Today
-
-If you are interested in getting the Kim Hyung Tak Archery Book Pdf and start learning from the master coach, you have several options to choose from. You can either buy the book online, download it for free, or access it through an online platform. Here are some of the ways you can get the book:
-
-
-Buy the book online. You can order the book from various online stores, such as Lancaster Archery, Amazon, eBay, and others. The price of the book may vary depending on the seller and the shipping cost. You can pay with your credit card, PayPal, or other methods. You will receive the book in a physical format (paperback or hardcover) or in a digital format (PDF or e-book).
-Download the book for free. You can also find the book on various websites that offer free downloads of PDF files, such as Scribd, PDF Drive, Z-Library, and others. You can search for the book by its title or by its author's name. You will need to create an account or sign in with your social media account to access the download link. You can then save the file on your device or print it out if you want.
-Access the book through an online platform. You can also access the book through Kim Hyung Tak's own online platform, where he offers online courses and coaching services. You can visit his website at www.archeryschool.com and sign up for his membership program. You will need to pay a monthly or yearly fee to access his content, which includes his book, his videos, his lectures, his exercises, his tests, and his feedback. You can also interact with him and other archers through his forum and chat.
-
-
-No matter which option you choose, you will be able to enjoy the benefits of reading the Kim Hyung Tak Archery Book Pdf . You will be able to learn from one of the best archery coaches in the world at your own pace and convenience. You will be able to improve your archery skills and performance in a short time. You will be able to achieve your archery goals and dreams with confidence.
-What Others Are Saying About Kim Hyung Tak Archery Book Pdf
-
-The Kim Hyung Tak Archery Book Pdf has received many positive reviews and testimonials from archers and coaches who have read and applied it. Here are some of the comments and feedbacks from the readers:
-
-
-"This book is a treasure for archers and coaches. It is full of valuable information and practical advice that can help anyone improve their archery skills. I have learned so much from this book and I highly recommend it to anyone who wants to learn from the best." - Park Sung Hyun, Olympic gold medalist and former world record holder
-
-
-
-"This book is a masterpiece of archery coaching. It is clear, concise, and comprehensive. It covers everything you need to know about archery, from basic to advanced. It also provides many exercises and tests that you can use to practice and evaluate yourself. This book is a must-have for every archer and coach." - Im Dong Hyun, Olympic bronze medalist and current world record holder
-
-
-
-"This book is a great resource for archery enthusiasts. It is written by one of the most respected and experienced coaches in the world. It explains the principles and techniques of archery in a simple and easy way. It also shows you how to apply them in various situations and scenarios. This book is a great way to learn from the master." - Ki Bo Bae, Olympic gold medalist and former world champion
-
-
-
-"This book is a gem for archery lovers. It is filled with useful tips and insights that can help you improve your performance and enjoy your shooting more. It also gives you a glimpse into the mind and philosophy of one of the greatest archery coaches of all time. This book is a rare opportunity to learn from the legend." - Oh Jin Hyek, Olympic gold medalist and former world champion
-
-
-As you can see, the Kim Hyung Tak Archery Book Pdf has been praised by many archers and coaches who have benefited from it. You can also join them and experience the same results by getting the book today.
-Conclusion
-
-The Kim Hyung Tak Archery Book Pdf is one of the best books on archery that you can find. It is written by Kim Hyung Tak, a legendary coach who has trained many world-class archers and Olympic medalists. It covers all aspects of archery, from basic skills to advanced techniques. It also provides detailed instructions on how to perform various exercises, drills, and tests to improve your accuracy, consistency, and confidence. The book is suitable for both archers and coaches, and it is available in various formats and languages.
-
-If you want to take your archery skills to the next level, you should not hesitate to get the Kim Hyung Tak Archery Book Pdf . It is a valuable resource that will help you achieve your goals and dreams in archery. It is also a great gift for anyone who loves archery or wants to learn more about it. Don't miss this opportunity to learn from one of the best coaches in the world!
3cee63e6c2Auslogics BoostSpeed 11.2.0.1 Crack With Activation Code Free Download 2020 Download ☑ https://tiurll.com/2uCj9z
diff --git a/spaces/inreVtussa/clothingai/Examples/Design Emocional Donald Norman.pdf [BEST].md b/spaces/inreVtussa/clothingai/Examples/Design Emocional Donald Norman.pdf [BEST].md
deleted file mode 100644
index 77ff6c763f99ba787ebf2b72fb66b81ee18c338a..0000000000000000000000000000000000000000
--- a/spaces/inreVtussa/clothingai/Examples/Design Emocional Donald Norman.pdf [BEST].md
+++ /dev/null
@@ -1,22 +0,0 @@
-Design Emocional Donald Norman.pdf DOWNLOAD ⚹⚹⚹ https://tiurll.com/2uCkeu
diff --git a/spaces/jackli888/stable-diffusion-webui/modules/devices.py b/spaces/jackli888/stable-diffusion-webui/modules/devices.py
deleted file mode 100644
index 52c3e7cd773f9c89857dfce14b37d63cb6329fac..0000000000000000000000000000000000000000
--- a/spaces/jackli888/stable-diffusion-webui/modules/devices.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import sys
-import contextlib
-import torch
-from modules import errors
-
-if sys.platform == "darwin":
- from modules import mac_specific
-
-
-def has_mps() -> bool:
- if sys.platform != "darwin":
- return False
- else:
- return mac_specific.has_mps
-
-def extract_device_id(args, name):
- for x in range(len(args)):
- if name in args[x]:
- return args[x + 1]
-
- return None
-
-
-def get_cuda_device_string():
- from modules import shared
-
- if shared.cmd_opts.device_id is not None:
- return f"cuda:{shared.cmd_opts.device_id}"
-
- return "cuda"
-
-
-def get_optimal_device_name():
- if torch.cuda.is_available():
- return get_cuda_device_string()
-
- if has_mps():
- return "mps"
-
- return "cpu"
-
-
-def get_optimal_device():
- return torch.device(get_optimal_device_name())
-
-
-def get_device_for(task):
- from modules import shared
-
- if task in shared.cmd_opts.use_cpu:
- return cpu
-
- return get_optimal_device()
-
-
-def torch_gc():
- if torch.cuda.is_available():
- with torch.cuda.device(get_cuda_device_string()):
- torch.cuda.empty_cache()
- torch.cuda.ipc_collect()
-
-
-def enable_tf32():
- if torch.cuda.is_available():
-
- # enabling benchmark option seems to enable a range of cards to do fp16 when they otherwise can't
- # see https://github.com/AUTOMATIC1111/stable-diffusion-webui/pull/4407
- if any([torch.cuda.get_device_capability(devid) == (7, 5) for devid in range(0, torch.cuda.device_count())]):
- torch.backends.cudnn.benchmark = True
-
- torch.backends.cuda.matmul.allow_tf32 = True
- torch.backends.cudnn.allow_tf32 = True
-
-
-
-errors.run(enable_tf32, "Enabling TF32")
-
-cpu = torch.device("cpu")
-device = device_interrogate = device_gfpgan = device_esrgan = device_codeformer = None
-dtype = torch.float16
-dtype_vae = torch.float16
-dtype_unet = torch.float16
-unet_needs_upcast = False
-
-
-def cond_cast_unet(input):
- return input.to(dtype_unet) if unet_needs_upcast else input
-
-
-def cond_cast_float(input):
- return input.float() if unet_needs_upcast else input
-
-
-def randn(seed, shape):
- torch.manual_seed(seed)
- if device.type == 'mps':
- return torch.randn(shape, device=cpu).to(device)
- return torch.randn(shape, device=device)
-
-
-def randn_without_seed(shape):
- if device.type == 'mps':
- return torch.randn(shape, device=cpu).to(device)
- return torch.randn(shape, device=device)
-
-
-def autocast(disable=False):
- from modules import shared
-
- if disable:
- return contextlib.nullcontext()
-
- if dtype == torch.float32 or shared.cmd_opts.precision == "full":
- return contextlib.nullcontext()
-
- return torch.autocast("cuda")
-
-
-def without_autocast(disable=False):
- return torch.autocast("cuda", enabled=False) if torch.is_autocast_enabled() and not disable else contextlib.nullcontext()
-
-
-class NansException(Exception):
- pass
-
-
-def test_for_nans(x, where):
- from modules import shared
-
- if shared.cmd_opts.disable_nan_check:
- return
-
- if not torch.all(torch.isnan(x)).item():
- return
-
- if where == "unet":
- message = "A tensor with all NaNs was produced in Unet."
-
- if not shared.cmd_opts.no_half:
- message += " This could be either because there's not enough precision to represent the picture, or because your video card does not support half type. Try setting the \"Upcast cross attention layer to float32\" option in Settings > Stable Diffusion or using the --no-half commandline argument to fix this."
-
- elif where == "vae":
- message = "A tensor with all NaNs was produced in VAE."
-
- if not shared.cmd_opts.no_half and not shared.cmd_opts.no_half_vae:
- message += " This could be because there's not enough precision to represent the picture. Try adding --no-half-vae commandline argument to fix this."
- else:
- message = "A tensor with all NaNs was produced."
-
- message += " Use --disable-nan-check commandline argument to disable this check."
-
- raise NansException(message)
diff --git a/spaces/jamoncj/entregable3/app.py b/spaces/jamoncj/entregable3/app.py
deleted file mode 100644
index 82ae4146b9219b756838e035b7add55a5c644ab1..0000000000000000000000000000000000000000
--- a/spaces/jamoncj/entregable3/app.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from fastai.text.all import *
-import gradio as gr
-
-
-# Cargamos el learner
-learn = load_learner('export.pkl')
-
-# Definimos las etiquetas de nuestro modelo
-labels = learn.dls.vocab
-
-
-# Definimos una función que se encarga de llevar a cabo las predicciones
-def predict(img):
- pred,pred_idx,probs = learn.predict(img)
- return '{}'.format(pred) + " estrellas"
-
-# Creamos la interfaz y la lanzamos.
-gr.Interface(fn=predict, inputs=gr.Textbox(label="Valoración del producto", lines=4), outputs='text').launch(share=False)
\ No newline at end of file
diff --git a/spaces/jbetker/tortoise/tortoise/models/vocoder.py b/spaces/jbetker/tortoise/tortoise/models/vocoder.py
deleted file mode 100644
index d38fb56699c035b3d4a86ace67c567d3f1d51fa9..0000000000000000000000000000000000000000
--- a/spaces/jbetker/tortoise/tortoise/models/vocoder.py
+++ /dev/null
@@ -1,325 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-MAX_WAV_VALUE = 32768.0
-
-class KernelPredictor(torch.nn.Module):
- ''' Kernel predictor for the location-variable convolutions'''
-
- def __init__(
- self,
- cond_channels,
- conv_in_channels,
- conv_out_channels,
- conv_layers,
- conv_kernel_size=3,
- kpnet_hidden_channels=64,
- kpnet_conv_size=3,
- kpnet_dropout=0.0,
- kpnet_nonlinear_activation="LeakyReLU",
- kpnet_nonlinear_activation_params={"negative_slope": 0.1},
- ):
- '''
- Args:
- cond_channels (int): number of channel for the conditioning sequence,
- conv_in_channels (int): number of channel for the input sequence,
- conv_out_channels (int): number of channel for the output sequence,
- conv_layers (int): number of layers
- '''
- super().__init__()
-
- self.conv_in_channels = conv_in_channels
- self.conv_out_channels = conv_out_channels
- self.conv_kernel_size = conv_kernel_size
- self.conv_layers = conv_layers
-
- kpnet_kernel_channels = conv_in_channels * conv_out_channels * conv_kernel_size * conv_layers # l_w
- kpnet_bias_channels = conv_out_channels * conv_layers # l_b
-
- self.input_conv = nn.Sequential(
- nn.utils.weight_norm(nn.Conv1d(cond_channels, kpnet_hidden_channels, 5, padding=2, bias=True)),
- getattr(nn, kpnet_nonlinear_activation)(**kpnet_nonlinear_activation_params),
- )
-
- self.residual_convs = nn.ModuleList()
- padding = (kpnet_conv_size - 1) // 2
- for _ in range(3):
- self.residual_convs.append(
- nn.Sequential(
- nn.Dropout(kpnet_dropout),
- nn.utils.weight_norm(
- nn.Conv1d(kpnet_hidden_channels, kpnet_hidden_channels, kpnet_conv_size, padding=padding,
- bias=True)),
- getattr(nn, kpnet_nonlinear_activation)(**kpnet_nonlinear_activation_params),
- nn.utils.weight_norm(
- nn.Conv1d(kpnet_hidden_channels, kpnet_hidden_channels, kpnet_conv_size, padding=padding,
- bias=True)),
- getattr(nn, kpnet_nonlinear_activation)(**kpnet_nonlinear_activation_params),
- )
- )
- self.kernel_conv = nn.utils.weight_norm(
- nn.Conv1d(kpnet_hidden_channels, kpnet_kernel_channels, kpnet_conv_size, padding=padding, bias=True))
- self.bias_conv = nn.utils.weight_norm(
- nn.Conv1d(kpnet_hidden_channels, kpnet_bias_channels, kpnet_conv_size, padding=padding, bias=True))
-
- def forward(self, c):
- '''
- Args:
- c (Tensor): the conditioning sequence (batch, cond_channels, cond_length)
- '''
- batch, _, cond_length = c.shape
- c = self.input_conv(c)
- for residual_conv in self.residual_convs:
- residual_conv.to(c.device)
- c = c + residual_conv(c)
- k = self.kernel_conv(c)
- b = self.bias_conv(c)
- kernels = k.contiguous().view(
- batch,
- self.conv_layers,
- self.conv_in_channels,
- self.conv_out_channels,
- self.conv_kernel_size,
- cond_length,
- )
- bias = b.contiguous().view(
- batch,
- self.conv_layers,
- self.conv_out_channels,
- cond_length,
- )
-
- return kernels, bias
-
- def remove_weight_norm(self):
- nn.utils.remove_weight_norm(self.input_conv[0])
- nn.utils.remove_weight_norm(self.kernel_conv)
- nn.utils.remove_weight_norm(self.bias_conv)
- for block in self.residual_convs:
- nn.utils.remove_weight_norm(block[1])
- nn.utils.remove_weight_norm(block[3])
-
-
-class LVCBlock(torch.nn.Module):
- '''the location-variable convolutions'''
-
- def __init__(
- self,
- in_channels,
- cond_channels,
- stride,
- dilations=[1, 3, 9, 27],
- lReLU_slope=0.2,
- conv_kernel_size=3,
- cond_hop_length=256,
- kpnet_hidden_channels=64,
- kpnet_conv_size=3,
- kpnet_dropout=0.0,
- ):
- super().__init__()
-
- self.cond_hop_length = cond_hop_length
- self.conv_layers = len(dilations)
- self.conv_kernel_size = conv_kernel_size
-
- self.kernel_predictor = KernelPredictor(
- cond_channels=cond_channels,
- conv_in_channels=in_channels,
- conv_out_channels=2 * in_channels,
- conv_layers=len(dilations),
- conv_kernel_size=conv_kernel_size,
- kpnet_hidden_channels=kpnet_hidden_channels,
- kpnet_conv_size=kpnet_conv_size,
- kpnet_dropout=kpnet_dropout,
- kpnet_nonlinear_activation_params={"negative_slope": lReLU_slope}
- )
-
- self.convt_pre = nn.Sequential(
- nn.LeakyReLU(lReLU_slope),
- nn.utils.weight_norm(nn.ConvTranspose1d(in_channels, in_channels, 2 * stride, stride=stride,
- padding=stride // 2 + stride % 2, output_padding=stride % 2)),
- )
-
- self.conv_blocks = nn.ModuleList()
- for dilation in dilations:
- self.conv_blocks.append(
- nn.Sequential(
- nn.LeakyReLU(lReLU_slope),
- nn.utils.weight_norm(nn.Conv1d(in_channels, in_channels, conv_kernel_size,
- padding=dilation * (conv_kernel_size - 1) // 2, dilation=dilation)),
- nn.LeakyReLU(lReLU_slope),
- )
- )
-
- def forward(self, x, c):
- ''' forward propagation of the location-variable convolutions.
- Args:
- x (Tensor): the input sequence (batch, in_channels, in_length)
- c (Tensor): the conditioning sequence (batch, cond_channels, cond_length)
-
- Returns:
- Tensor: the output sequence (batch, in_channels, in_length)
- '''
- _, in_channels, _ = x.shape # (B, c_g, L')
-
- x = self.convt_pre(x) # (B, c_g, stride * L')
- kernels, bias = self.kernel_predictor(c)
-
- for i, conv in enumerate(self.conv_blocks):
- output = conv(x) # (B, c_g, stride * L')
-
- k = kernels[:, i, :, :, :, :] # (B, 2 * c_g, c_g, kernel_size, cond_length)
- b = bias[:, i, :, :] # (B, 2 * c_g, cond_length)
-
- output = self.location_variable_convolution(output, k, b,
- hop_size=self.cond_hop_length) # (B, 2 * c_g, stride * L'): LVC
- x = x + torch.sigmoid(output[:, :in_channels, :]) * torch.tanh(
- output[:, in_channels:, :]) # (B, c_g, stride * L'): GAU
-
- return x
-
- def location_variable_convolution(self, x, kernel, bias, dilation=1, hop_size=256):
- ''' perform location-variable convolution operation on the input sequence (x) using the local convolution kernl.
- Time: 414 μs ± 309 ns per loop (mean ± std. dev. of 7 runs, 1000 loops each), test on NVIDIA V100.
- Args:
- x (Tensor): the input sequence (batch, in_channels, in_length).
- kernel (Tensor): the local convolution kernel (batch, in_channel, out_channels, kernel_size, kernel_length)
- bias (Tensor): the bias for the local convolution (batch, out_channels, kernel_length)
- dilation (int): the dilation of convolution.
- hop_size (int): the hop_size of the conditioning sequence.
- Returns:
- (Tensor): the output sequence after performing local convolution. (batch, out_channels, in_length).
- '''
- batch, _, in_length = x.shape
- batch, _, out_channels, kernel_size, kernel_length = kernel.shape
- assert in_length == (kernel_length * hop_size), "length of (x, kernel) is not matched"
-
- padding = dilation * int((kernel_size - 1) / 2)
- x = F.pad(x, (padding, padding), 'constant', 0) # (batch, in_channels, in_length + 2*padding)
- x = x.unfold(2, hop_size + 2 * padding, hop_size) # (batch, in_channels, kernel_length, hop_size + 2*padding)
-
- if hop_size < dilation:
- x = F.pad(x, (0, dilation), 'constant', 0)
- x = x.unfold(3, dilation,
- dilation) # (batch, in_channels, kernel_length, (hop_size + 2*padding)/dilation, dilation)
- x = x[:, :, :, :, :hop_size]
- x = x.transpose(3, 4) # (batch, in_channels, kernel_length, dilation, (hop_size + 2*padding)/dilation)
- x = x.unfold(4, kernel_size, 1) # (batch, in_channels, kernel_length, dilation, _, kernel_size)
-
- o = torch.einsum('bildsk,biokl->bolsd', x, kernel)
- o = o.to(memory_format=torch.channels_last_3d)
- bias = bias.unsqueeze(-1).unsqueeze(-1).to(memory_format=torch.channels_last_3d)
- o = o + bias
- o = o.contiguous().view(batch, out_channels, -1)
-
- return o
-
- def remove_weight_norm(self):
- self.kernel_predictor.remove_weight_norm()
- nn.utils.remove_weight_norm(self.convt_pre[1])
- for block in self.conv_blocks:
- nn.utils.remove_weight_norm(block[1])
-
-
-class UnivNetGenerator(nn.Module):
- """UnivNet Generator"""
-
- def __init__(self, noise_dim=64, channel_size=32, dilations=[1,3,9,27], strides=[8,8,4], lReLU_slope=.2, kpnet_conv_size=3,
- # Below are MEL configurations options that this generator requires.
- hop_length=256, n_mel_channels=100):
- super(UnivNetGenerator, self).__init__()
- self.mel_channel = n_mel_channels
- self.noise_dim = noise_dim
- self.hop_length = hop_length
- channel_size = channel_size
- kpnet_conv_size = kpnet_conv_size
-
- self.res_stack = nn.ModuleList()
- hop_length = 1
- for stride in strides:
- hop_length = stride * hop_length
- self.res_stack.append(
- LVCBlock(
- channel_size,
- n_mel_channels,
- stride=stride,
- dilations=dilations,
- lReLU_slope=lReLU_slope,
- cond_hop_length=hop_length,
- kpnet_conv_size=kpnet_conv_size
- )
- )
-
- self.conv_pre = \
- nn.utils.weight_norm(nn.Conv1d(noise_dim, channel_size, 7, padding=3, padding_mode='reflect'))
-
- self.conv_post = nn.Sequential(
- nn.LeakyReLU(lReLU_slope),
- nn.utils.weight_norm(nn.Conv1d(channel_size, 1, 7, padding=3, padding_mode='reflect')),
- nn.Tanh(),
- )
-
- def forward(self, c, z):
- '''
- Args:
- c (Tensor): the conditioning sequence of mel-spectrogram (batch, mel_channels, in_length)
- z (Tensor): the noise sequence (batch, noise_dim, in_length)
-
- '''
- z = self.conv_pre(z) # (B, c_g, L)
-
- for res_block in self.res_stack:
- res_block.to(z.device)
- z = res_block(z, c) # (B, c_g, L * s_0 * ... * s_i)
-
- z = self.conv_post(z) # (B, 1, L * 256)
-
- return z
-
- def eval(self, inference=False):
- super(UnivNetGenerator, self).eval()
- # don't remove weight norm while validation in training loop
- if inference:
- self.remove_weight_norm()
-
- def remove_weight_norm(self):
- print('Removing weight norm...')
-
- nn.utils.remove_weight_norm(self.conv_pre)
-
- for layer in self.conv_post:
- if len(layer.state_dict()) != 0:
- nn.utils.remove_weight_norm(layer)
-
- for res_block in self.res_stack:
- res_block.remove_weight_norm()
-
- def inference(self, c, z=None):
- # pad input mel with zeros to cut artifact
- # see https://github.com/seungwonpark/melgan/issues/8
- zero = torch.full((c.shape[0], self.mel_channel, 10), -11.5129).to(c.device)
- mel = torch.cat((c, zero), dim=2)
-
- if z is None:
- z = torch.randn(c.shape[0], self.noise_dim, mel.size(2)).to(mel.device)
-
- audio = self.forward(mel, z)
- audio = audio[:, :, :-(self.hop_length * 10)]
- audio = audio.clamp(min=-1, max=1)
- return audio
-
-
-if __name__ == '__main__':
- model = UnivNetGenerator()
-
- c = torch.randn(3, 100, 10)
- z = torch.randn(3, 64, 10)
- print(c.shape)
-
- y = model(c, z)
- print(y.shape)
- assert y.shape == torch.Size([3, 1, 2560])
-
- pytorch_total_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
- print(pytorch_total_params)
diff --git a/spaces/jleexp/Youtube-Whisperer/README.md b/spaces/jleexp/Youtube-Whisperer/README.md
deleted file mode 100644
index f30d4256155c480f0599698379f798a3365e5bc1..0000000000000000000000000000000000000000
--- a/spaces/jleexp/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/joaopdrm/Emotion_Analisys/README.md b/spaces/joaopdrm/Emotion_Analisys/README.md
deleted file mode 100644
index fa9c92223ed78db7a9758afc5dd021644439e733..0000000000000000000000000000000000000000
--- a/spaces/joaopdrm/Emotion_Analisys/README.md
+++ /dev/null
@@ -1,37 +0,0 @@
----
-title: Emotion_Analisys
-emoji: 💻
-colorFrom: blue
-colorTo: gray
-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/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/charset_normalizer/cli/__init__.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/charset_normalizer/cli/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/TupleVariation.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/TupleVariation.py
deleted file mode 100644
index 13ff8678746013a038a951fb28232f59b4d08324..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/fontTools/ttLib/tables/TupleVariation.py
+++ /dev/null
@@ -1,808 +0,0 @@
-from fontTools.misc.fixedTools import (
- fixedToFloat as fi2fl,
- floatToFixed as fl2fi,
- floatToFixedToStr as fl2str,
- strToFixedToFloat as str2fl,
- otRound,
-)
-from fontTools.misc.textTools import safeEval
-import array
-from collections import Counter, defaultdict
-import io
-import logging
-import struct
-import sys
-
-
-# https://www.microsoft.com/typography/otspec/otvarcommonformats.htm
-
-EMBEDDED_PEAK_TUPLE = 0x8000
-INTERMEDIATE_REGION = 0x4000
-PRIVATE_POINT_NUMBERS = 0x2000
-
-DELTAS_ARE_ZERO = 0x80
-DELTAS_ARE_WORDS = 0x40
-DELTA_RUN_COUNT_MASK = 0x3F
-
-POINTS_ARE_WORDS = 0x80
-POINT_RUN_COUNT_MASK = 0x7F
-
-TUPLES_SHARE_POINT_NUMBERS = 0x8000
-TUPLE_COUNT_MASK = 0x0FFF
-TUPLE_INDEX_MASK = 0x0FFF
-
-log = logging.getLogger(__name__)
-
-
-class TupleVariation(object):
- def __init__(self, axes, coordinates):
- self.axes = axes.copy()
- self.coordinates = list(coordinates)
-
- def __repr__(self):
- axes = ",".join(
- sorted(["%s=%s" % (name, value) for (name, value) in self.axes.items()])
- )
- return "" % (axes, self.coordinates)
-
- def __eq__(self, other):
- return self.coordinates == other.coordinates and self.axes == other.axes
-
- def getUsedPoints(self):
- # Empty set means "all points used".
- if None not in self.coordinates:
- return frozenset()
- used = frozenset([i for i, p in enumerate(self.coordinates) if p is not None])
- # Return None if no points used.
- return used if used else None
-
- def hasImpact(self):
- """Returns True if this TupleVariation has any visible impact.
-
- If the result is False, the TupleVariation can be omitted from the font
- without making any visible difference.
- """
- return any(c is not None for c in self.coordinates)
-
- def toXML(self, writer, axisTags):
- writer.begintag("tuple")
- writer.newline()
- for axis in axisTags:
- value = self.axes.get(axis)
- if value is not None:
- minValue, value, maxValue = value
- defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0
- defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7
- if minValue == defaultMinValue and maxValue == defaultMaxValue:
- writer.simpletag("coord", axis=axis, value=fl2str(value, 14))
- else:
- attrs = [
- ("axis", axis),
- ("min", fl2str(minValue, 14)),
- ("value", fl2str(value, 14)),
- ("max", fl2str(maxValue, 14)),
- ]
- writer.simpletag("coord", attrs)
- writer.newline()
- wrote_any_deltas = False
- for i, delta in enumerate(self.coordinates):
- if type(delta) == tuple and len(delta) == 2:
- writer.simpletag("delta", pt=i, x=delta[0], y=delta[1])
- writer.newline()
- wrote_any_deltas = True
- elif type(delta) == int:
- writer.simpletag("delta", cvt=i, value=delta)
- writer.newline()
- wrote_any_deltas = True
- elif delta is not None:
- log.error("bad delta format")
- writer.comment("bad delta #%d" % i)
- writer.newline()
- wrote_any_deltas = True
- if not wrote_any_deltas:
- writer.comment("no deltas")
- writer.newline()
- writer.endtag("tuple")
- writer.newline()
-
- def fromXML(self, name, attrs, _content):
- if name == "coord":
- axis = attrs["axis"]
- value = str2fl(attrs["value"], 14)
- defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0
- defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7
- minValue = str2fl(attrs.get("min", defaultMinValue), 14)
- maxValue = str2fl(attrs.get("max", defaultMaxValue), 14)
- self.axes[axis] = (minValue, value, maxValue)
- elif name == "delta":
- if "pt" in attrs:
- point = safeEval(attrs["pt"])
- x = safeEval(attrs["x"])
- y = safeEval(attrs["y"])
- self.coordinates[point] = (x, y)
- elif "cvt" in attrs:
- cvt = safeEval(attrs["cvt"])
- value = safeEval(attrs["value"])
- self.coordinates[cvt] = value
- else:
- log.warning("bad delta format: %s" % ", ".join(sorted(attrs.keys())))
-
- def compile(self, axisTags, sharedCoordIndices={}, pointData=None):
- assert set(self.axes.keys()) <= set(axisTags), (
- "Unknown axis tag found.",
- self.axes.keys(),
- axisTags,
- )
-
- tupleData = []
- auxData = []
-
- if pointData is None:
- usedPoints = self.getUsedPoints()
- if usedPoints is None: # Nothing to encode
- return b"", b""
- pointData = self.compilePoints(usedPoints)
-
- coord = self.compileCoord(axisTags)
- flags = sharedCoordIndices.get(coord)
- if flags is None:
- flags = EMBEDDED_PEAK_TUPLE
- tupleData.append(coord)
-
- intermediateCoord = self.compileIntermediateCoord(axisTags)
- if intermediateCoord is not None:
- flags |= INTERMEDIATE_REGION
- tupleData.append(intermediateCoord)
-
- # pointData of b'' implies "use shared points".
- if pointData:
- flags |= PRIVATE_POINT_NUMBERS
- auxData.append(pointData)
-
- auxData.append(self.compileDeltas())
- auxData = b"".join(auxData)
-
- tupleData.insert(0, struct.pack(">HH", len(auxData), flags))
- return b"".join(tupleData), auxData
-
- def compileCoord(self, axisTags):
- result = bytearray()
- axes = self.axes
- for axis in axisTags:
- triple = axes.get(axis)
- if triple is None:
- result.extend(b"\0\0")
- else:
- result.extend(struct.pack(">h", fl2fi(triple[1], 14)))
- return bytes(result)
-
- def compileIntermediateCoord(self, axisTags):
- needed = False
- for axis in axisTags:
- minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
- defaultMinValue = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0
- defaultMaxValue = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7
- if (minValue != defaultMinValue) or (maxValue != defaultMaxValue):
- needed = True
- break
- if not needed:
- return None
- minCoords = bytearray()
- maxCoords = bytearray()
- for axis in axisTags:
- minValue, value, maxValue = self.axes.get(axis, (0.0, 0.0, 0.0))
- minCoords.extend(struct.pack(">h", fl2fi(minValue, 14)))
- maxCoords.extend(struct.pack(">h", fl2fi(maxValue, 14)))
- return minCoords + maxCoords
-
- @staticmethod
- def decompileCoord_(axisTags, data, offset):
- coord = {}
- pos = offset
- for axis in axisTags:
- coord[axis] = fi2fl(struct.unpack(">h", data[pos : pos + 2])[0], 14)
- pos += 2
- return coord, pos
-
- @staticmethod
- def compilePoints(points):
- # If the set consists of all points in the glyph, it gets encoded with
- # a special encoding: a single zero byte.
- #
- # To use this optimization, points passed in must be empty set.
- # The following two lines are not strictly necessary as the main code
- # below would emit the same. But this is most common and faster.
- if not points:
- return b"\0"
-
- # In the 'gvar' table, the packing of point numbers is a little surprising.
- # It consists of multiple runs, each being a delta-encoded list of integers.
- # For example, the point set {17, 18, 19, 20, 21, 22, 23} gets encoded as
- # [6, 17, 1, 1, 1, 1, 1, 1]. The first value (6) is the run length minus 1.
- # There are two types of runs, with values being either 8 or 16 bit unsigned
- # integers.
- points = list(points)
- points.sort()
- numPoints = len(points)
-
- result = bytearray()
- # The binary representation starts with the total number of points in the set,
- # encoded into one or two bytes depending on the value.
- if numPoints < 0x80:
- result.append(numPoints)
- else:
- result.append((numPoints >> 8) | 0x80)
- result.append(numPoints & 0xFF)
-
- MAX_RUN_LENGTH = 127
- pos = 0
- lastValue = 0
- while pos < numPoints:
- runLength = 0
-
- headerPos = len(result)
- result.append(0)
-
- useByteEncoding = None
- while pos < numPoints and runLength <= MAX_RUN_LENGTH:
- curValue = points[pos]
- delta = curValue - lastValue
- if useByteEncoding is None:
- useByteEncoding = 0 <= delta <= 0xFF
- if useByteEncoding and (delta > 0xFF or delta < 0):
- # we need to start a new run (which will not use byte encoding)
- break
- # TODO This never switches back to a byte-encoding from a short-encoding.
- # That's suboptimal.
- if useByteEncoding:
- result.append(delta)
- else:
- result.append(delta >> 8)
- result.append(delta & 0xFF)
- lastValue = curValue
- pos += 1
- runLength += 1
- if useByteEncoding:
- result[headerPos] = runLength - 1
- else:
- result[headerPos] = (runLength - 1) | POINTS_ARE_WORDS
-
- return result
-
- @staticmethod
- def decompilePoints_(numPoints, data, offset, tableTag):
- """(numPoints, data, offset, tableTag) --> ([point1, point2, ...], newOffset)"""
- assert tableTag in ("cvar", "gvar")
- pos = offset
- numPointsInData = data[pos]
- pos += 1
- if (numPointsInData & POINTS_ARE_WORDS) != 0:
- numPointsInData = (numPointsInData & POINT_RUN_COUNT_MASK) << 8 | data[pos]
- pos += 1
- if numPointsInData == 0:
- return (range(numPoints), pos)
-
- result = []
- while len(result) < numPointsInData:
- runHeader = data[pos]
- pos += 1
- numPointsInRun = (runHeader & POINT_RUN_COUNT_MASK) + 1
- point = 0
- if (runHeader & POINTS_ARE_WORDS) != 0:
- points = array.array("H")
- pointsSize = numPointsInRun * 2
- else:
- points = array.array("B")
- pointsSize = numPointsInRun
- points.frombytes(data[pos : pos + pointsSize])
- if sys.byteorder != "big":
- points.byteswap()
-
- assert len(points) == numPointsInRun
- pos += pointsSize
-
- result.extend(points)
-
- # Convert relative to absolute
- absolute = []
- current = 0
- for delta in result:
- current += delta
- absolute.append(current)
- result = absolute
- del absolute
-
- badPoints = {str(p) for p in result if p < 0 or p >= numPoints}
- if badPoints:
- log.warning(
- "point %s out of range in '%s' table"
- % (",".join(sorted(badPoints)), tableTag)
- )
- return (result, pos)
-
- def compileDeltas(self):
- deltaX = []
- deltaY = []
- if self.getCoordWidth() == 2:
- for c in self.coordinates:
- if c is None:
- continue
- deltaX.append(c[0])
- deltaY.append(c[1])
- else:
- for c in self.coordinates:
- if c is None:
- continue
- deltaX.append(c)
- bytearr = bytearray()
- self.compileDeltaValues_(deltaX, bytearr)
- self.compileDeltaValues_(deltaY, bytearr)
- return bytearr
-
- @staticmethod
- def compileDeltaValues_(deltas, bytearr=None):
- """[value1, value2, value3, ...] --> bytearray
-
- Emits a sequence of runs. Each run starts with a
- byte-sized header whose 6 least significant bits
- (header & 0x3F) indicate how many values are encoded
- in this run. The stored length is the actual length
- minus one; run lengths are thus in the range [1..64].
- If the header byte has its most significant bit (0x80)
- set, all values in this run are zero, and no data
- follows. Otherwise, the header byte is followed by
- ((header & 0x3F) + 1) signed values. If (header &
- 0x40) is clear, the delta values are stored as signed
- bytes; if (header & 0x40) is set, the delta values are
- signed 16-bit integers.
- """ # Explaining the format because the 'gvar' spec is hard to understand.
- if bytearr is None:
- bytearr = bytearray()
- pos = 0
- numDeltas = len(deltas)
- while pos < numDeltas:
- value = deltas[pos]
- if value == 0:
- pos = TupleVariation.encodeDeltaRunAsZeroes_(deltas, pos, bytearr)
- elif -128 <= value <= 127:
- pos = TupleVariation.encodeDeltaRunAsBytes_(deltas, pos, bytearr)
- else:
- pos = TupleVariation.encodeDeltaRunAsWords_(deltas, pos, bytearr)
- return bytearr
-
- @staticmethod
- def encodeDeltaRunAsZeroes_(deltas, offset, bytearr):
- pos = offset
- numDeltas = len(deltas)
- while pos < numDeltas and deltas[pos] == 0:
- pos += 1
- runLength = pos - offset
- while runLength >= 64:
- bytearr.append(DELTAS_ARE_ZERO | 63)
- runLength -= 64
- if runLength:
- bytearr.append(DELTAS_ARE_ZERO | (runLength - 1))
- return pos
-
- @staticmethod
- def encodeDeltaRunAsBytes_(deltas, offset, bytearr):
- pos = offset
- numDeltas = len(deltas)
- while pos < numDeltas:
- value = deltas[pos]
- if not (-128 <= value <= 127):
- break
- # Within a byte-encoded run of deltas, a single zero
- # is best stored literally as 0x00 value. However,
- # if are two or more zeroes in a sequence, it is
- # better to start a new run. For example, the sequence
- # of deltas [15, 15, 0, 15, 15] becomes 6 bytes
- # (04 0F 0F 00 0F 0F) when storing the zero value
- # literally, but 7 bytes (01 0F 0F 80 01 0F 0F)
- # when starting a new run.
- if value == 0 and pos + 1 < numDeltas and deltas[pos + 1] == 0:
- break
- pos += 1
- runLength = pos - offset
- while runLength >= 64:
- bytearr.append(63)
- bytearr.extend(array.array("b", deltas[offset : offset + 64]))
- offset += 64
- runLength -= 64
- if runLength:
- bytearr.append(runLength - 1)
- bytearr.extend(array.array("b", deltas[offset:pos]))
- return pos
-
- @staticmethod
- def encodeDeltaRunAsWords_(deltas, offset, bytearr):
- pos = offset
- numDeltas = len(deltas)
- while pos < numDeltas:
- value = deltas[pos]
- # Within a word-encoded run of deltas, it is easiest
- # to start a new run (with a different encoding)
- # whenever we encounter a zero value. For example,
- # the sequence [0x6666, 0, 0x7777] needs 7 bytes when
- # storing the zero literally (42 66 66 00 00 77 77),
- # and equally 7 bytes when starting a new run
- # (40 66 66 80 40 77 77).
- if value == 0:
- break
-
- # Within a word-encoded run of deltas, a single value
- # in the range (-128..127) should be encoded literally
- # because it is more compact. For example, the sequence
- # [0x6666, 2, 0x7777] becomes 7 bytes when storing
- # the value literally (42 66 66 00 02 77 77), but 8 bytes
- # when starting a new run (40 66 66 00 02 40 77 77).
- if (
- (-128 <= value <= 127)
- and pos + 1 < numDeltas
- and (-128 <= deltas[pos + 1] <= 127)
- ):
- break
- pos += 1
- runLength = pos - offset
- while runLength >= 64:
- bytearr.append(DELTAS_ARE_WORDS | 63)
- a = array.array("h", deltas[offset : offset + 64])
- if sys.byteorder != "big":
- a.byteswap()
- bytearr.extend(a)
- offset += 64
- runLength -= 64
- if runLength:
- bytearr.append(DELTAS_ARE_WORDS | (runLength - 1))
- a = array.array("h", deltas[offset:pos])
- if sys.byteorder != "big":
- a.byteswap()
- bytearr.extend(a)
- return pos
-
- @staticmethod
- def decompileDeltas_(numDeltas, data, offset):
- """(numDeltas, data, offset) --> ([delta, delta, ...], newOffset)"""
- result = []
- pos = offset
- while len(result) < numDeltas:
- runHeader = data[pos]
- pos += 1
- numDeltasInRun = (runHeader & DELTA_RUN_COUNT_MASK) + 1
- if (runHeader & DELTAS_ARE_ZERO) != 0:
- result.extend([0] * numDeltasInRun)
- else:
- if (runHeader & DELTAS_ARE_WORDS) != 0:
- deltas = array.array("h")
- deltasSize = numDeltasInRun * 2
- else:
- deltas = array.array("b")
- deltasSize = numDeltasInRun
- deltas.frombytes(data[pos : pos + deltasSize])
- if sys.byteorder != "big":
- deltas.byteswap()
- assert len(deltas) == numDeltasInRun
- pos += deltasSize
- result.extend(deltas)
- assert len(result) == numDeltas
- return (result, pos)
-
- @staticmethod
- def getTupleSize_(flags, axisCount):
- size = 4
- if (flags & EMBEDDED_PEAK_TUPLE) != 0:
- size += axisCount * 2
- if (flags & INTERMEDIATE_REGION) != 0:
- size += axisCount * 4
- return size
-
- def getCoordWidth(self):
- """Return 2 if coordinates are (x, y) as in gvar, 1 if single values
- as in cvar, or 0 if empty.
- """
- firstDelta = next((c for c in self.coordinates if c is not None), None)
- if firstDelta is None:
- return 0 # empty or has no impact
- if type(firstDelta) in (int, float):
- return 1
- if type(firstDelta) is tuple and len(firstDelta) == 2:
- return 2
- raise TypeError(
- "invalid type of delta; expected (int or float) number, or "
- "Tuple[number, number]: %r" % firstDelta
- )
-
- def scaleDeltas(self, scalar):
- if scalar == 1.0:
- return # no change
- coordWidth = self.getCoordWidth()
- self.coordinates = [
- None
- if d is None
- else d * scalar
- if coordWidth == 1
- else (d[0] * scalar, d[1] * scalar)
- for d in self.coordinates
- ]
-
- def roundDeltas(self):
- coordWidth = self.getCoordWidth()
- self.coordinates = [
- None
- if d is None
- else otRound(d)
- if coordWidth == 1
- else (otRound(d[0]), otRound(d[1]))
- for d in self.coordinates
- ]
-
- def calcInferredDeltas(self, origCoords, endPts):
- from fontTools.varLib.iup import iup_delta
-
- if self.getCoordWidth() == 1:
- raise TypeError("Only 'gvar' TupleVariation can have inferred deltas")
- if None in self.coordinates:
- if len(self.coordinates) != len(origCoords):
- raise ValueError(
- "Expected len(origCoords) == %d; found %d"
- % (len(self.coordinates), len(origCoords))
- )
- self.coordinates = iup_delta(self.coordinates, origCoords, endPts)
-
- def optimize(self, origCoords, endPts, tolerance=0.5, isComposite=False):
- from fontTools.varLib.iup import iup_delta_optimize
-
- if None in self.coordinates:
- return # already optimized
-
- deltaOpt = iup_delta_optimize(
- self.coordinates, origCoords, endPts, tolerance=tolerance
- )
- if None in deltaOpt:
- if isComposite and all(d is None for d in deltaOpt):
- # Fix for macOS composites
- # https://github.com/fonttools/fonttools/issues/1381
- deltaOpt = [(0, 0)] + [None] * (len(deltaOpt) - 1)
- # Use "optimized" version only if smaller...
- varOpt = TupleVariation(self.axes, deltaOpt)
-
- # Shouldn't matter that this is different from fvar...?
- axisTags = sorted(self.axes.keys())
- tupleData, auxData = self.compile(axisTags)
- unoptimizedLength = len(tupleData) + len(auxData)
- tupleData, auxData = varOpt.compile(axisTags)
- optimizedLength = len(tupleData) + len(auxData)
-
- if optimizedLength < unoptimizedLength:
- self.coordinates = varOpt.coordinates
-
- def __imul__(self, scalar):
- self.scaleDeltas(scalar)
- return self
-
- def __iadd__(self, other):
- if not isinstance(other, TupleVariation):
- return NotImplemented
- deltas1 = self.coordinates
- length = len(deltas1)
- deltas2 = other.coordinates
- if len(deltas2) != length:
- raise ValueError("cannot sum TupleVariation deltas with different lengths")
- # 'None' values have different meanings in gvar vs cvar TupleVariations:
- # within the gvar, when deltas are not provided explicitly for some points,
- # they need to be inferred; whereas for the 'cvar' table, if deltas are not
- # provided for some CVT values, then no adjustments are made (i.e. None == 0).
- # Thus, we cannot sum deltas for gvar TupleVariations if they contain
- # inferred inferred deltas (the latter need to be computed first using
- # 'calcInferredDeltas' method), but we can treat 'None' values in cvar
- # deltas as if they are zeros.
- if self.getCoordWidth() == 2:
- for i, d2 in zip(range(length), deltas2):
- d1 = deltas1[i]
- try:
- deltas1[i] = (d1[0] + d2[0], d1[1] + d2[1])
- except TypeError:
- raise ValueError("cannot sum gvar deltas with inferred points")
- else:
- for i, d2 in zip(range(length), deltas2):
- d1 = deltas1[i]
- if d1 is not None and d2 is not None:
- deltas1[i] = d1 + d2
- elif d1 is None and d2 is not None:
- deltas1[i] = d2
- # elif d2 is None do nothing
- return self
-
-
-def decompileSharedTuples(axisTags, sharedTupleCount, data, offset):
- result = []
- for _ in range(sharedTupleCount):
- t, offset = TupleVariation.decompileCoord_(axisTags, data, offset)
- result.append(t)
- return result
-
-
-def compileSharedTuples(
- axisTags, variations, MAX_NUM_SHARED_COORDS=TUPLE_INDEX_MASK + 1
-):
- coordCount = Counter()
- for var in variations:
- coord = var.compileCoord(axisTags)
- coordCount[coord] += 1
- # In python < 3.7, most_common() ordering is non-deterministic
- # so apply a sort to make sure the ordering is consistent.
- sharedCoords = sorted(
- coordCount.most_common(MAX_NUM_SHARED_COORDS),
- key=lambda item: (-item[1], item[0]),
- )
- return [c[0] for c in sharedCoords if c[1] > 1]
-
-
-def compileTupleVariationStore(
- variations, pointCount, axisTags, sharedTupleIndices, useSharedPoints=True
-):
- # pointCount is actually unused. Keeping for API compat.
- del pointCount
- newVariations = []
- pointDatas = []
- # Compile all points and figure out sharing if desired
- sharedPoints = None
-
- # Collect, count, and compile point-sets for all variation sets
- pointSetCount = defaultdict(int)
- for v in variations:
- points = v.getUsedPoints()
- if points is None: # Empty variations
- continue
- pointSetCount[points] += 1
- newVariations.append(v)
- pointDatas.append(points)
- variations = newVariations
- del newVariations
-
- if not variations:
- return (0, b"", b"")
-
- n = len(variations[0].coordinates)
- assert all(
- len(v.coordinates) == n for v in variations
- ), "Variation sets have different sizes"
-
- compiledPoints = {
- pointSet: TupleVariation.compilePoints(pointSet) for pointSet in pointSetCount
- }
-
- tupleVariationCount = len(variations)
- tuples = []
- data = []
-
- if useSharedPoints:
- # Find point-set which saves most bytes.
- def key(pn):
- pointSet = pn[0]
- count = pn[1]
- return len(compiledPoints[pointSet]) * (count - 1)
-
- sharedPoints = max(pointSetCount.items(), key=key)[0]
-
- data.append(compiledPoints[sharedPoints])
- tupleVariationCount |= TUPLES_SHARE_POINT_NUMBERS
-
- # b'' implies "use shared points"
- pointDatas = [
- compiledPoints[points] if points != sharedPoints else b""
- for points in pointDatas
- ]
-
- for v, p in zip(variations, pointDatas):
- thisTuple, thisData = v.compile(axisTags, sharedTupleIndices, pointData=p)
-
- tuples.append(thisTuple)
- data.append(thisData)
-
- tuples = b"".join(tuples)
- data = b"".join(data)
- return tupleVariationCount, tuples, data
-
-
-def decompileTupleVariationStore(
- tableTag,
- axisTags,
- tupleVariationCount,
- pointCount,
- sharedTuples,
- data,
- pos,
- dataPos,
-):
- numAxes = len(axisTags)
- result = []
- if (tupleVariationCount & TUPLES_SHARE_POINT_NUMBERS) != 0:
- sharedPoints, dataPos = TupleVariation.decompilePoints_(
- pointCount, data, dataPos, tableTag
- )
- else:
- sharedPoints = []
- for _ in range(tupleVariationCount & TUPLE_COUNT_MASK):
- dataSize, flags = struct.unpack(">HH", data[pos : pos + 4])
- tupleSize = TupleVariation.getTupleSize_(flags, numAxes)
- tupleData = data[pos : pos + tupleSize]
- pointDeltaData = data[dataPos : dataPos + dataSize]
- result.append(
- decompileTupleVariation_(
- pointCount,
- sharedTuples,
- sharedPoints,
- tableTag,
- axisTags,
- tupleData,
- pointDeltaData,
- )
- )
- pos += tupleSize
- dataPos += dataSize
- return result
-
-
-def decompileTupleVariation_(
- pointCount, sharedTuples, sharedPoints, tableTag, axisTags, data, tupleData
-):
- assert tableTag in ("cvar", "gvar"), tableTag
- flags = struct.unpack(">H", data[2:4])[0]
- pos = 4
- if (flags & EMBEDDED_PEAK_TUPLE) == 0:
- peak = sharedTuples[flags & TUPLE_INDEX_MASK]
- else:
- peak, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
- if (flags & INTERMEDIATE_REGION) != 0:
- start, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
- end, pos = TupleVariation.decompileCoord_(axisTags, data, pos)
- else:
- start, end = inferRegion_(peak)
- axes = {}
- for axis in axisTags:
- region = start[axis], peak[axis], end[axis]
- if region != (0.0, 0.0, 0.0):
- axes[axis] = region
- pos = 0
- if (flags & PRIVATE_POINT_NUMBERS) != 0:
- points, pos = TupleVariation.decompilePoints_(
- pointCount, tupleData, pos, tableTag
- )
- else:
- points = sharedPoints
-
- deltas = [None] * pointCount
-
- if tableTag == "cvar":
- deltas_cvt, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
- for p, delta in zip(points, deltas_cvt):
- if 0 <= p < pointCount:
- deltas[p] = delta
-
- elif tableTag == "gvar":
- deltas_x, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
- deltas_y, pos = TupleVariation.decompileDeltas_(len(points), tupleData, pos)
- for p, x, y in zip(points, deltas_x, deltas_y):
- if 0 <= p < pointCount:
- deltas[p] = (x, y)
-
- return TupleVariation(axes, deltas)
-
-
-def inferRegion_(peak):
- """Infer start and end for a (non-intermediate) region
-
- This helper function computes the applicability region for
- variation tuples whose INTERMEDIATE_REGION flag is not set in the
- TupleVariationHeader structure. Variation tuples apply only to
- certain regions of the variation space; outside that region, the
- tuple has no effect. To make the binary encoding more compact,
- TupleVariationHeaders can omit the intermediateStartTuple and
- intermediateEndTuple fields.
- """
- start, end = {}, {}
- for (axis, value) in peak.items():
- start[axis] = min(value, 0.0) # -0.3 --> -0.3; 0.7 --> 0.0
- end[axis] = max(value, 0.0) # -0.3 --> 0.0; 0.7 --> 0.7
- return (start, end)
diff --git a/spaces/jordonpeter01/ai-comic-factory/src/lib/computeSha256.ts b/spaces/jordonpeter01/ai-comic-factory/src/lib/computeSha256.ts
deleted file mode 100644
index cb6ef0604fca9653408012fd6cef2a58b6acaf47..0000000000000000000000000000000000000000
--- a/spaces/jordonpeter01/ai-comic-factory/src/lib/computeSha256.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { createHash } from 'node:crypto'
-
-/**
- * Returns a SHA256 hash using SHA-3 for the given `content`.
- *
- * @see https://en.wikipedia.org/wiki/SHA-3
- *
- * @param {String} content
- *
- * @returns {String}
- */
-export function computeSha256(strContent: string) {
- return createHash('sha3-256').update(strContent).digest('hex')
-}
\ No newline at end of file
diff --git a/spaces/jpfearnworks/ai_agents/Dockerfile b/spaces/jpfearnworks/ai_agents/Dockerfile
deleted file mode 100644
index d0f48baac210b6f7c4f50792d270f77c699849d3..0000000000000000000000000000000000000000
--- a/spaces/jpfearnworks/ai_agents/Dockerfile
+++ /dev/null
@@ -1,18 +0,0 @@
-FROM python:3.9
-
-WORKDIR /app
-RUN pip install streamlit
-COPY requirements.txt requirements.txt
-RUN pip install -r requirements.txt
-
-
-COPY . .
-
-WORKDIR /app/
-
-ENV PATH="/root/.local/bin:${PATH}"
-
-EXPOSE 8501
-EXPOSE 7000
-
-CMD python server.py --port 7000
\ No newline at end of file
diff --git a/spaces/juancopi81/youtube-music-transcribe/t5x/optimizers_test.py b/spaces/juancopi81/youtube-music-transcribe/t5x/optimizers_test.py
deleted file mode 100644
index e7559b6e19536025cf2fead7b68f44ccff903ab2..0000000000000000000000000000000000000000
--- a/spaces/juancopi81/youtube-music-transcribe/t5x/optimizers_test.py
+++ /dev/null
@@ -1,317 +0,0 @@
-# Copyright 2022 The T5X Authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tests for t5x.optimizers."""
-
-import dataclasses
-import functools
-import operator
-
-from absl.testing import absltest
-from absl.testing import parameterized
-import chex
-import flax
-from flax.core import frozen_dict
-import jax
-import jax.numpy as jnp
-import numpy as np
-import optax
-import seqio
-from t5x import models
-from t5x import optimizers
-from t5x import partitioning
-from t5x import test_utils
-from t5x import trainer
-from t5x import utils
-from t5x.examples.t5 import network
-
-
-def _assert_numpy_allclose(a, b, atol=None, rtol=None):
- a, b = jnp.array(a), jnp.array(b)
- a = a.astype(np.float32) if a.dtype == jnp.bfloat16 else a
- b = b.astype(np.float32) if b.dtype == jnp.bfloat16 else b
- kw = {}
- if atol:
- kw['atol'] = atol
- if rtol:
- kw['rtol'] = rtol
- np.testing.assert_allclose(a, b, **kw)
-
-
-def check_eq(xs, ys, atol=None, rtol=None):
- xs_leaves, xs_tree = jax.tree_flatten(xs)
- ys_leaves, ys_tree = jax.tree_flatten(ys)
- assert xs_tree == ys_tree, f"Tree shapes don't match. \n{xs_tree}\n{ys_tree}"
- assert jax.tree_util.tree_all(
- jax.tree_multimap(lambda x, y: np.array(x).shape == np.array(y).shape,
- xs_leaves, ys_leaves)), "Leaves' shapes don't match."
- assert jax.tree_multimap(
- functools.partial(_assert_numpy_allclose, atol=atol, rtol=rtol),
- xs_leaves, ys_leaves)
-
-
-def flattened_state_dict(x):
- s = flax.serialization.to_state_dict(x)
- return flax.traverse_util.flatten_dict(s, sep='/')
-
-
-def tree_shape(x):
- return jax.tree_map(jnp.shape, x)
-
-
-def tree_equals(x, y):
- return jax.tree_util.tree_all(jax.tree_multimap(operator.eq, x, y))
-
-
-def get_fake_tokenized_dataset_no_pretokenized(*_, split='validation', **__):
- return test_utils.get_fake_tokenized_dataset(split=split).map(
- lambda x: {k: v for k, v in x.items() if not k.endswith('_pretokenized')})
-
-
-def get_t5_test_model(optimizer_def,
- **config_overrides) -> models.EncoderDecoderModel:
- """Returns a tiny T5 1.1 model to use for testing."""
- tiny_config = network.T5Config(
- vocab_size=128,
- dtype='bfloat16',
- emb_dim=8,
- num_heads=4,
- num_encoder_layers=2,
- num_decoder_layers=2,
- head_dim=3,
- mlp_dim=16,
- mlp_activations=('gelu', 'linear'),
- dropout_rate=0.0,
- logits_via_embedding=False,
- )
- tiny_config = dataclasses.replace(tiny_config, **config_overrides)
- vocabulary = test_utils.get_fake_vocab()
- return models.EncoderDecoderModel(
- module=network.Transformer(tiny_config),
- input_vocabulary=vocabulary,
- output_vocabulary=vocabulary,
- optimizer_def=optimizer_def)
-
-
-class BasicTest(chex.TestCase):
-
- @classmethod
- def get_params(cls):
- return frozen_dict.FrozenDict({
- 'forward': {
- 'input_layer': {
- 'embedding': jnp.zeros([16, 8], dtype=jnp.float32),
- },
- 'output_layer': {
- 'layer_norm': {
- 'scale': jnp.zeros([8], dtype=jnp.float32),
- },
- 'proj': {
- 'bias': jnp.zeros([1], dtype=jnp.float32),
- 'kernel': jnp.zeros([8, 1], dtype=jnp.float32),
- },
- },
- },
- 'loss': {
- 'loss_fn': {
- 'loss_biases': jnp.zeros([2], dtype=jnp.float32),
- },
- },
- })
-
- @classmethod
- def get_params_shapes(cls):
- return jax.tree_map(jnp.shape, cls.get_params())
-
- @classmethod
- def get_param_logical_axes(cls):
- return frozen_dict.FrozenDict({
- 'forward': {
- 'input_layer': {
- 'embedding': partitioning.PartitionSpec('vocab', 'embed'),
- },
- 'output_layer': {
- 'layer_norm': {
- 'scale': partitioning.PartitionSpec('embed',),
- },
- 'proj': {
- 'bias':
- partitioning.PartitionSpec('output_head',),
- 'kernel':
- partitioning.PartitionSpec('embed', 'output_head'),
- },
- },
- },
- 'loss': {
- 'loss_fn': {
- 'loss_biases': partitioning.PartitionSpec('unmodeled',),
- },
- },
- })
-
- def test_logical_axes_adamw(self):
- opt = optax.adamw(0.001, weight_decay=0.001)
- wrapper = optimizers.OptaxWrapper(opt)
- optimizer = wrapper.create(self.get_params())
- got = wrapper.derive_logical_axes(optimizer, self.get_param_logical_axes())
- want = optimizers.Optimizer(
- optimizer_def=wrapper,
- state=optimizers.OptimizerState(
- step=None,
- param_states=(
- optax.ScaleByAdamState(
- count=None,
- mu=self.get_param_logical_axes(),
- nu=self.get_param_logical_axes()),
- optax.EmptyState(),
- optax.EmptyState(),
- )),
- target=self.get_param_logical_axes())
- chex.assert_trees_all_equal(got, want)
-
- @parameterized.parameters(
- ('sgd', lambda: optax.sgd(1e-2, 0.0)),
- ('adam', lambda: optax.adam(1e-1)),
- ('adamw', lambda: optax.adamw(1e-1)),
- ('lamb', lambda: optax.adamw(1e-1)),
- ('rmsprop', lambda: optax.rmsprop(1e-1)),
- ('rmsprop_momentum', lambda: optax.rmsprop(5e-2, momentum=0.9)),
- ('fromage', lambda: optax.fromage(1e-2)),
- ('adabelief', lambda: optax.adabelief(1e-1)),
- ('radam', lambda: optax.radam(1e-1)),
- ('yogi', lambda: optax.yogi(1.0)),
- )
- def test_sanity_check_logical_axes(self, opt_name, opt_fn):
- opt = opt_fn()
-
- wrapper = optimizers.OptaxWrapper(opt)
- optimizer = wrapper.create(self.get_params())
- _ = wrapper.derive_logical_axes(optimizer, self.get_param_logical_axes())
-
- # TODO(rosun): basic sanity check, we just want to make sure if a param
- # name, e.g., `loss_biases` appear in the tree, the corresponding value is
- # always a PartitionSpec.
-
- def test_adamw_state_serialization(self):
- opt = optax.adamw(0.001, weight_decay=0.001)
- wrapper = optimizers.OptaxWrapper(opt)
- optimizer = wrapper.create(self.get_params())
-
- state_dict = optimizer.state_dict()
-
- chex.assert_trees_all_equal(
- frozen_dict.FrozenDict(jax.tree_map(jnp.shape, state_dict)),
- frozen_dict.FrozenDict({
- 'target': self.get_params_shapes(),
- 'state': {
- 'step': (),
- 'param_states': {
- '0': {
- 'count': (),
- 'mu': self.get_params_shapes(),
- 'nu': self.get_params_shapes(),
- },
- # NB: We eliminate empty tuple leaves from EmptyState() in
- # OptaxWrapper to avoid having the rest of T5X have to
- # correctly handle this detail. e.g. we omit these:
- # '1': {},
- # '2': {},
- },
- }
- }))
-
- new_optimizer = optimizer.restore_state(state_dict)
-
- chex.assert_trees_all_equal(optimizer, new_optimizer)
-
-
-class OptaxWrapperTest(chex.TestCase):
-
- def run_train_loop(self, optimizer_def):
- # Construct input data.
-
- ds = get_fake_tokenized_dataset_no_pretokenized(split='validation')
- ds = seqio.EncDecFeatureConverter()(
- ds, task_feature_lengths={
- 'inputs': 8,
- 'targets': 8
- })
- ds = ds.repeat().batch(8)
- ds_iter = ds.as_numpy_iterator()
- first_batch = next(ds_iter)
-
- model = get_t5_test_model(optimizer_def, vocab_size=128)
-
- learning_rate_fn = utils.create_learning_rate_scheduler()
-
- input_shapes = jax.tree_map(jnp.shape, first_batch)
- input_types = jax.tree_map(lambda x: jnp.dtype(x.dtype), first_batch)
-
- partitioner = partitioning.PjitPartitioner(
- num_partitions=2,
- logical_axis_rules=partitioning.standard_logical_axis_rules())
-
- train_state_initializer = utils.TrainStateInitializer(
- optimizer_def=model.optimizer_def,
- init_fn=model.get_initial_variables,
- input_shapes=input_shapes,
- input_types=input_types,
- partitioner=partitioner)
-
- train_state_axes = train_state_initializer.train_state_axes
- train_state = train_state_initializer.from_scratch(jax.random.PRNGKey(0))
-
- trainer_instance = trainer.Trainer(
- model,
- train_state=train_state,
- partitioner=partitioner,
- eval_names=[],
- summary_dir=None,
- train_state_axes=train_state_axes,
- rng=jax.random.PRNGKey(0),
- learning_rate_fn=learning_rate_fn,
- num_microbatches=1)
-
- chex.assert_tree_all_finite(train_state.params)
- for _ in range(2):
- trainer_instance.train(ds_iter, 1)
- chex.assert_tree_all_finite(train_state.params)
-
- # check save/restore structural equality
- restored_instance = trainer_instance.train_state.restore_state(
- trainer_instance.train_state.state_dict())
- chex.assert_tree_all_equal_structs(trainer_instance.train_state,
- restored_instance)
-
- # NOTE(levskaya): these are surprisingly slow tests on CPU.
- @parameterized.parameters(
- ('sgd', lambda: optax.sgd(1e-2, 0.0)),
- ('adam', lambda: optax.adam(1e-1)),
- ('adamw', lambda: optax.adamw(1e-1)),
- ('lamb', lambda: optax.adamw(1e-1)),
- # ('rmsprop', lambda: optax.rmsprop(1e-1)),
- # ('rmsprop_momentum', lambda: optax.rmsprop(5e-2, momentum=0.9)),
- # ('fromage', lambda: optax.fromage(1e-2)),
- ('adabelief', lambda: optax.adabelief(1e-1)),
- # ('radam', lambda: optax.radam(1e-1)),
- ('yogi', lambda: optax.yogi(1.0)),
- )
- def test_optimizer(self, opt_name, opt_fn):
- opt = opt_fn()
- optimizer_def = optimizers.OptaxWrapper(opt)
- self.run_train_loop(optimizer_def)
-
-
-if __name__ == '__main__':
- absltest.main()
diff --git a/spaces/justest/gpt4free/g4f/Provider/Providers/GetGpt.py b/spaces/justest/gpt4free/g4f/Provider/Providers/GetGpt.py
deleted file mode 100644
index 56a121f6ee5f430da7beda3b65abdea64a87c36b..0000000000000000000000000000000000000000
--- a/spaces/justest/gpt4free/g4f/Provider/Providers/GetGpt.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import os
-import json
-import uuid
-import requests
-from Crypto.Cipher import AES
-from ...typing import sha256, Dict, get_type_hints
-
-url = 'https://chat.getgpt.world/'
-model = ['gpt-3.5-turbo']
-supports_stream = True
-needs_auth = False
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- def encrypt(e):
- t = os.urandom(8).hex().encode('utf-8')
- n = os.urandom(8).hex().encode('utf-8')
- r = e.encode('utf-8')
- cipher = AES.new(t, AES.MODE_CBC, n)
- ciphertext = cipher.encrypt(pad_data(r))
- return ciphertext.hex() + t.decode('utf-8') + n.decode('utf-8')
-
- def pad_data(data: bytes) -> bytes:
- block_size = AES.block_size
- padding_size = block_size - len(data) % block_size
- padding = bytes([padding_size] * padding_size)
- return data + padding
-
- headers = {
- 'Content-Type': 'application/json',
- 'Referer': 'https://chat.getgpt.world/',
- 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36'
- }
-
- data = json.dumps({
- 'messages': messages,
- 'frequency_penalty': kwargs.get('frequency_penalty', 0),
- 'max_tokens': kwargs.get('max_tokens', 4000),
- 'model': 'gpt-3.5-turbo',
- 'presence_penalty': kwargs.get('presence_penalty', 0),
- 'temperature': kwargs.get('temperature', 1),
- 'top_p': kwargs.get('top_p', 1),
- 'stream': True,
- 'uuid': str(uuid.uuid4())
- })
-
- res = requests.post('https://chat.getgpt.world/api/chat/stream',
- headers=headers, json={'signature': encrypt(data)}, stream=True)
-
- for line in res.iter_lines():
- if b'content' in line:
- line_json = json.loads(line.decode('utf-8').split('data: ')[1])
- yield (line_json['choices'][0]['delta']['content'])
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f'{name}: {get_type_hints(_create_completion)[name].__name__}' for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/katanaml-org/sparrow-ml/routers/__init__.py b/spaces/katanaml-org/sparrow-ml/routers/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/kdrkdrkdr/YuukaTTS/utils.py b/spaces/kdrkdrkdr/YuukaTTS/utils.py
deleted file mode 100644
index 4cb5b43d0ca2bae496e7871b2094f2ffb26ab642..0000000000000000000000000000000000000000
--- a/spaces/kdrkdrkdr/YuukaTTS/utils.py
+++ /dev/null
@@ -1,226 +0,0 @@
-import os
-import glob
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.ERROR)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None):
- assert os.path.isfile(checkpoint_path)
- checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
- iteration = checkpoint_dict['iteration']
- learning_rate = checkpoint_dict['learning_rate']
- if optimizer is not None:
- optimizer.load_state_dict(checkpoint_dict['optimizer'])
- saved_state_dict = checkpoint_dict['model']
- if hasattr(model, 'module'):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict = {}
- for k, v in state_dict.items():
- try:
- new_state_dict[k] = saved_state_dict[k]
- except:
- logger.info("%s is not in the checkpoint" % k)
- new_state_dict[k] = v
- if hasattr(model, 'module'):
- model.module.load_state_dict(new_state_dict)
- else:
- model.load_state_dict(new_state_dict)
- logger.info("Loaded checkpoint '{}' (iteration {})".format(
- checkpoint_path, iteration))
- return model, optimizer, learning_rate, iteration
-
-
-def plot_spectrogram_to_numpy(spectrogram):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(10, 2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower",
- interpolation='none')
- plt.colorbar(im, ax=ax)
- plt.xlabel("Frames")
- plt.ylabel("Channels")
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(6, 4))
- im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
- interpolation='none')
- fig.colorbar(im, ax=ax)
- xlabel = 'Decoder timestep'
- if info is not None:
- xlabel += '\n\n' + info
- plt.xlabel(xlabel)
- plt.ylabel('Encoder timestep')
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def load_wav_to_torch(full_path):
- sampling_rate, data = read(full_path)
- return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-
-
-def load_filepaths_and_text(filename, split="|"):
- with open(filename, encoding='utf-8') as f:
- filepaths_and_text = [line.strip().split(split) for line in f]
- return filepaths_and_text
-
-
-def get_hparams(init=True):
- parser = argparse.ArgumentParser()
- parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
- help='JSON file for configuration')
- parser.add_argument('-m', '--model', type=str, required=True,
- help='Model name')
-
- args = parser.parse_args()
- model_dir = os.path.join("./logs", args.model)
-
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
-
- config_path = args.config
- config_save_path = os.path.join(model_dir, "config.json")
- if init:
- with open(config_path, "r") as f:
- data = f.read()
- with open(config_save_path, "w") as f:
- f.write(data)
- else:
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_dir(model_dir):
- config_save_path = os.path.join(model_dir, "config.json")
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_file(config_path):
- with open(config_path, "r", encoding="utf-8") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- return hparams
-
-
-def check_git_hash(model_dir):
- source_dir = os.path.dirname(os.path.realpath(__file__))
- if not os.path.exists(os.path.join(source_dir, ".git")):
- logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
- source_dir
- ))
- return
-
- cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
- path = os.path.join(model_dir, "githash")
- if os.path.exists(path):
- saved_hash = open(path).read()
- if saved_hash != cur_hash:
- logger.warn("git hash values are different. {}(saved) != {}(current)".format(
- saved_hash[:8], cur_hash[:8]))
- else:
- open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
- global logger
- logger = logging.getLogger(os.path.basename(model_dir))
- logger.setLevel(logging.DEBUG)
-
- formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
- h = logging.FileHandler(os.path.join(model_dir, filename))
- h.setLevel(logging.DEBUG)
- h.setFormatter(formatter)
- logger.addHandler(h)
- return logger
-
-
-class HParams():
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- if type(v) == dict:
- v = HParams(**v)
- self[k] = v
-
- def keys(self):
- return self.__dict__.keys()
-
- def items(self):
- return self.__dict__.items()
-
- def values(self):
- return self.__dict__.values()
-
- def __len__(self):
- return len(self.__dict__)
-
- def __getitem__(self, key):
- return getattr(self, key)
-
- def __setitem__(self, key, value):
- return setattr(self, key, value)
-
- def __contains__(self, key):
- return key in self.__dict__
-
- def __repr__(self):
- return self.__dict__.__repr__()
diff --git a/spaces/keanteng/job/README.md b/spaces/keanteng/job/README.md
deleted file mode 100644
index 192285d2ef1fc83a29e4ded8a08b165463d46540..0000000000000000000000000000000000000000
--- a/spaces/keanteng/job/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Job
-emoji: ⚡
-colorFrom: gray
-colorTo: yellow
-sdk: streamlit
-sdk_version: 1.28.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/kermitt2/grobid/Dockerfile b/spaces/kermitt2/grobid/Dockerfile
deleted file mode 100644
index e876c6a448f5e0c6eef45b2885ceebc2eff85801..0000000000000000000000000000000000000000
--- a/spaces/kermitt2/grobid/Dockerfile
+++ /dev/null
@@ -1,7 +0,0 @@
-FROM grobid/grobid:0.8.0-SNAPSHOT
-USER root
-RUN mkdir -m 777 -p /opt/grobid/grobid-home/tmp
-RUN mkdir -m 777 -p /opt/grobid/logs
-RUN chmod -R uog+rw /data/db
-#ENTRYPOINT ["/tini", "-s", "--"]
-CMD ["./grobid-service/bin/grobid-service"]
diff --git a/spaces/kevinwang676/ControlNet-with-GPT-4/app.py b/spaces/kevinwang676/ControlNet-with-GPT-4/app.py
deleted file mode 100644
index 73dd57dcc6b5595c0d4822419bdd5eb657d56e2c..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/ControlNet-with-GPT-4/app.py
+++ /dev/null
@@ -1,151 +0,0 @@
-#!/usr/bin/env python
-
-from __future__ import annotations
-
-import gradio as gr
-import torch
-import re
-import openai
-from cairosvg import svg2png
-
-from app_canny import create_demo as create_demo_canny
-from app_depth import create_demo as create_demo_depth
-from app_ip2p import create_demo as create_demo_ip2p
-from app_lineart import create_demo as create_demo_lineart
-from app_mlsd import create_demo as create_demo_mlsd
-from app_normal import create_demo as create_demo_normal
-from app_openpose import create_demo as create_demo_openpose
-from app_scribble import create_demo as create_demo_scribble
-from app_scribble_interactive import create_demo as create_demo_scribble_interactive
-from app_segmentation import create_demo as create_demo_segmentation
-from app_shuffle import create_demo as create_demo_shuffle
-from app_softedge import create_demo as create_demo_softedge
-from model import Model
-from settings import ALLOW_CHANGING_BASE_MODEL, DEFAULT_MODEL_ID, SHOW_DUPLICATE_BUTTON
-
-DESCRIPTION = "# ControlNet v1.1"
-
-if not torch.cuda.is_available():
- DESCRIPTION += "\nRunning on CPU 🥶 This demo does not work on CPU.
"
-
-model = Model(base_model_id=DEFAULT_MODEL_ID, task_name="Canny")
-
-def gpt_control(apikey, prompt):
-
- openai.api_key = apikey
-
- # gpt
- messages = [{"role": "system", "content": "You are an SVG expert with years of experience and multiple contributions to the SVG project. Based on the prompt and the description, please generate the corresponding SVG code."},
- {"role": "user", "content": f"""Provide only the shell command without any explanations.
-The current objective is below. Reply with the SVG code only:
-OBJECTIVE: {prompt}
-YOUR SVG CODE:
-"""}]
-
- completion = openai.ChatCompletion.create(
- model = "gpt-4",
- messages = messages
- )
-
- chat_response = completion.choices[0].message.content
-
- code = re.findall('<.*>', chat_response)
- code_new = '\n'.join(code)
-
- svg_code = f"""
- {code_new}
- """
- svg2png(bytestring=svg_code,write_to='output.png')
-
- return 'output.png'
-
-
-with gr.Blocks(css="style.css") as demo:
- gr.HTML(""
- "🌁🪄🌃 - ControlNet with GPT-4 "
- " ")
-
- gr.Markdown("## 🌟 Born to Create: Controllable Text-to-Image Generation with GPT-4 ")
-
- gr.DuplicateButton(
- value="Duplicate Space for private use",
- elem_id="duplicate-button",
- visible=SHOW_DUPLICATE_BUTTON,
- )
-
- with gr.Tab("GPT-4 Control"):
- with gr.Row():
- with gr.Column():
- inp1 = gr.Textbox(label="OpenAI API Key", type="password")
- inp2 = gr.Textbox(label="Position Prompt (as simple as possible)")
- btn1 = gr.Button("GPT-4 Control", variant="primary")
- with gr.Column():
- out1 = gr.Image(label="Output Image", type="pil", interactive=True)
-
- btn1.click(gpt_control, [inp1, inp2], [out1])
-
-
- with gr.Tabs():
- with gr.TabItem("Canny"):
- create_demo_canny(model.process_canny)
- with gr.TabItem("MLSD"):
- create_demo_mlsd(model.process_mlsd)
- with gr.TabItem("Scribble"):
- create_demo_scribble(model.process_scribble)
- with gr.TabItem("Scribble Interactive"):
- create_demo_scribble_interactive(model.process_scribble_interactive)
- with gr.TabItem("SoftEdge"):
- create_demo_softedge(model.process_softedge)
- with gr.TabItem("OpenPose"):
- create_demo_openpose(model.process_openpose)
- with gr.TabItem("Segmentation"):
- create_demo_segmentation(model.process_segmentation)
- with gr.TabItem("Depth"):
- create_demo_depth(model.process_depth)
- with gr.TabItem("Normal map"):
- create_demo_normal(model.process_normal)
- with gr.TabItem("Lineart"):
- create_demo_lineart(model.process_lineart)
- with gr.TabItem("Content Shuffle"):
- create_demo_shuffle(model.process_shuffle)
- with gr.TabItem("Instruct Pix2Pix"):
- create_demo_ip2p(model.process_ip2p)
-
- with gr.Accordion(label="Base model", open=False):
- with gr.Row():
- with gr.Column(scale=5):
- current_base_model = gr.Text(label="Current base model")
- with gr.Column(scale=1):
- check_base_model_button = gr.Button("Check current base model")
- with gr.Row():
- with gr.Column(scale=5):
- new_base_model_id = gr.Text(
- label="New base model",
- max_lines=1,
- placeholder="runwayml/stable-diffusion-v1-5",
- info="The base model must be compatible with Stable Diffusion v1.5.",
- interactive=ALLOW_CHANGING_BASE_MODEL,
- )
- with gr.Column(scale=1):
- change_base_model_button = gr.Button("Change base model", interactive=ALLOW_CHANGING_BASE_MODEL)
- if not ALLOW_CHANGING_BASE_MODEL:
- gr.Markdown(
- """The base model is not allowed to be changed in this Space so as not to slow down the demo, but it can be changed if you duplicate the Space."""
- )
-
- check_base_model_button.click(
- fn=lambda: model.base_model_id,
- outputs=current_base_model,
- queue=False,
- api_name="check_base_model",
- )
- gr.on(
- triggers=[new_base_model_id.submit, change_base_model_button.click],
- fn=model.set_base_model,
- inputs=new_base_model_id,
- outputs=current_base_model,
- api_name=False,
- )
-
-if __name__ == "__main__":
- demo.queue(max_size=20).launch()
diff --git a/spaces/kevinwang676/FreeVC/app.py b/spaces/kevinwang676/FreeVC/app.py
deleted file mode 100644
index ffd212c8e9295f1922b393b6a80596aafc6162d4..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/FreeVC/app.py
+++ /dev/null
@@ -1,481 +0,0 @@
-import os
-import torch
-import librosa
-import gradio as gr
-from scipy.io.wavfile import write
-from transformers import WavLMModel
-
-import utils
-from models import SynthesizerTrn
-from mel_processing import mel_spectrogram_torch
-from speaker_encoder.voice_encoder import SpeakerEncoder
-
-import time
-from textwrap import dedent
-
-import mdtex2html
-from loguru import logger
-from transformers import AutoModel, AutoTokenizer
-
-from tts_voice import tts_order_voice
-import edge_tts
-import tempfile
-import anyio
-
-'''
-def get_wavlm():
- os.system('gdown https://drive.google.com/uc?id=12-cB34qCTvByWT-QtOcZaqwwO21FLSqU')
- shutil.move('WavLM-Large.pt', 'wavlm')
-'''
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-smodel = SpeakerEncoder('speaker_encoder/ckpt/pretrained_bak_5805000.pt')
-
-print("Loading FreeVC(24k)...")
-hps = utils.get_hparams_from_file("configs/freevc-24.json")
-freevc_24 = SynthesizerTrn(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model).to(device)
-_ = freevc_24.eval()
-_ = utils.load_checkpoint("checkpoints/freevc-24.pth", freevc_24, None)
-
-print("Loading WavLM for content...")
-cmodel = WavLMModel.from_pretrained("microsoft/wavlm-large").to(device)
-
-def convert(model, src, tgt):
- with torch.no_grad():
- # tgt
- wav_tgt, _ = librosa.load(tgt, sr=hps.data.sampling_rate)
- wav_tgt, _ = librosa.effects.trim(wav_tgt, top_db=20)
- if model == "FreeVC" or model == "FreeVC (24kHz)":
- g_tgt = smodel.embed_utterance(wav_tgt)
- g_tgt = torch.from_numpy(g_tgt).unsqueeze(0).to(device)
- else:
- wav_tgt = torch.from_numpy(wav_tgt).unsqueeze(0).to(device)
- mel_tgt = mel_spectrogram_torch(
- wav_tgt,
- hps.data.filter_length,
- hps.data.n_mel_channels,
- hps.data.sampling_rate,
- hps.data.hop_length,
- hps.data.win_length,
- hps.data.mel_fmin,
- hps.data.mel_fmax
- )
- # src
- wav_src, _ = librosa.load(src, sr=hps.data.sampling_rate)
- wav_src = torch.from_numpy(wav_src).unsqueeze(0).to(device)
- c = cmodel(wav_src).last_hidden_state.transpose(1, 2).to(device)
- # infer
- if model == "FreeVC":
- audio = freevc.infer(c, g=g_tgt)
- elif model == "FreeVC-s":
- audio = freevc_s.infer(c, mel=mel_tgt)
- else:
- audio = freevc_24.infer(c, g=g_tgt)
- audio = audio[0][0].data.cpu().float().numpy()
- if model == "FreeVC" or model == "FreeVC-s":
- write("out.wav", hps.data.sampling_rate, audio)
- else:
- write("out.wav", 24000, audio)
- out = "out.wav"
- return out
-
-# GLM2
-
-language_dict = tts_order_voice
-
-# fix timezone in Linux
-os.environ["TZ"] = "Asia/Shanghai"
-try:
- time.tzset() # type: ignore # pylint: disable=no-member
-except Exception:
- # Windows
- logger.warning("Windows, cant run time.tzset()")
-
-# model_name = "THUDM/chatglm2-6b"
-model_name = "THUDM/chatglm2-6b-int4"
-
-RETRY_FLAG = False
-
-tokenizer = AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)
-
-# model = AutoModel.from_pretrained(model_name, trust_remote_code=True).cuda()
-
-# 4/8 bit
-# model = AutoModel.from_pretrained("THUDM/chatglm2-6b", trust_remote_code=True).quantize(4).cuda()
-
-has_cuda = torch.cuda.is_available()
-
-# has_cuda = False # force cpu
-
-if has_cuda:
- model_glm = (
- AutoModel.from_pretrained(model_name, trust_remote_code=True).cuda().half()
- ) # 3.92G
-else:
- model_glm = AutoModel.from_pretrained(
- model_name, trust_remote_code=True
- ).float() # .float() .half().float()
-
-model_glm = model_glm.eval()
-
-_ = """Override Chatbot.postprocess"""
-
-
-def postprocess(self, y):
- if y is None:
- return []
- for i, (message, response) in enumerate(y):
- y[i] = (
- None if message is None else mdtex2html.convert((message)),
- None if response is None else mdtex2html.convert(response),
- )
- return y
-
-
-gr.Chatbot.postprocess = postprocess
-
-
-def parse_text(text):
- """copy from https://github.com/GaiZhenbiao/ChuanhuChatGPT/"""
- lines = text.split("\n")
- lines = [line for line in lines if line != ""]
- count = 0
- for i, line in enumerate(lines):
- if "```" in line:
- count += 1
- items = line.split("`")
- if count % 2 == 1:
- lines[i] = f''
- else:
- lines[i] = ""
- "🥳💕🎶 - ChatGLM2 + 声音克隆：和你喜欢的角色畅所欲言吧！ "
- " ")
- gr.Markdown("## 💡 - 第二代ChatGLM大语言模型 + FreeVC变声，为您打造独一无二的沉浸式对话体验，支持中英双语 ")
- gr.Markdown("## 🌊 - 更多精彩应用，尽在[滔滔AI](http://www.talktalkai.com)；滔滔AI，为爱滔滔！💕 ")
- gr.Markdown("### ⭐ - 如果您喜欢这个程序，欢迎给我的[Github项目](https://github.com/KevinWang676/ChatGLM2-Voice-Cloning)点赞支持！ ")
-
- with gr.Accordion("📒 相关信息", open=False):
- _ = f""" ChatGLM2的可选参数信息：
- * Low temperature: responses will be more deterministic and focused; High temperature: responses more creative.
- * Suggested temperatures -- translation: up to 0.3; chatting: > 0.4
- * Top P controls dynamic vocabulary selection based on context.\n
- 如果您想让ChatGLM2进行角色扮演并与之对话，请先输入恰当的提示词，如“请你扮演成动漫角色蜡笔小新并和我进行对话”；您也可以为ChatGLM2提供自定义的角色设定\n
- 当您使用声音克隆功能时，请先在此程序的对应位置上传一段您喜欢的音频
- """
- gr.Markdown(dedent(_))
- chatbot = gr.Chatbot(height=300)
- with gr.Row():
- with gr.Column(scale=4):
- with gr.Column(scale=12):
- user_input = gr.Textbox(
- label="请在此处和GLM2聊天 (按回车键即可发送)",
- placeholder="聊点什么吧",
- )
- RETRY_FLAG = gr.Checkbox(value=False, visible=False)
- with gr.Column(min_width=32, scale=1):
- with gr.Row():
- submitBtn = gr.Button("开始和GLM2交流吧", variant="primary")
- deleteBtn = gr.Button("删除最新一轮对话", variant="secondary")
- retryBtn = gr.Button("重新生成最新一轮对话", variant="secondary")
-
- with gr.Accordion("🔧 更多设置", open=False):
- with gr.Row():
- emptyBtn = gr.Button("清空所有聊天记录")
- max_length = gr.Slider(
- 0,
- 32768,
- value=8192,
- step=1.0,
- label="Maximum length",
- interactive=True,
- )
- top_p = gr.Slider(
- 0, 1, value=0.85, step=0.01, label="Top P", interactive=True
- )
- temperature = gr.Slider(
- 0.01, 1, value=0.95, step=0.01, label="Temperature", interactive=True
- )
-
-
- with gr.Row():
- test1 = gr.Textbox(label="GLM2的最新回答 (可编辑)", lines = 3)
- with gr.Column():
- language = gr.Dropdown(choices=list(language_dict.keys()), value="普通话 (中国大陆)-Xiaoxiao-女", label="请选择文本对应的语言及您喜欢的说话人")
- tts_btn = gr.Button("生成对应的音频吧", variant="primary")
- output_audio = gr.Audio(type="filepath", label="为您生成的音频", interactive=False)
-
- tts_btn.click(text_to_speech_edge, inputs=[test1, language], outputs=[output_audio])
-
- with gr.Row():
- model_choice = gr.Dropdown(choices=["FreeVC", "FreeVC-s", "FreeVC (24kHz)"], value="FreeVC (24kHz)", label="Model", visible=False)
- audio1 = output_audio
- audio2 = gr.Audio(label="请上传您喜欢的声音进行声音克隆", type='filepath')
- clone_btn = gr.Button("开始AI声音克隆吧", variant="primary")
- audio_cloned = gr.Audio(label="为您生成的专属声音克隆音频", type='filepath')
-
- clone_btn.click(convert, inputs=[model_choice, audio1, audio2], outputs=[audio_cloned])
-
- history = gr.State([])
- past_key_values = gr.State(None)
-
- user_input.submit(
- predict,
- [
- RETRY_FLAG,
- user_input,
- chatbot,
- max_length,
- top_p,
- temperature,
- history,
- past_key_values,
- ],
- [chatbot, history, past_key_values, test1],
- show_progress="full",
- )
- submitBtn.click(
- predict,
- [
- RETRY_FLAG,
- user_input,
- chatbot,
- max_length,
- top_p,
- temperature,
- history,
- past_key_values,
- ],
- [chatbot, history, past_key_values, test1],
- show_progress="full",
- api_name="predict",
- )
- submitBtn.click(reset_user_input, [], [user_input])
-
- emptyBtn.click(
- reset_state, outputs=[chatbot, history, past_key_values, test1], show_progress="full"
- )
-
- retryBtn.click(
- retry_last_answer,
- inputs=[
- user_input,
- chatbot,
- max_length,
- top_p,
- temperature,
- history,
- past_key_values,
- ],
- # outputs = [chatbot, history, last_user_message, user_message]
- outputs=[chatbot, history, past_key_values, test1],
- )
- deleteBtn.click(delete_last_turn, [chatbot, history], [chatbot, history])
-
- with gr.Accordion("📔 提示词示例", open=False):
- etext = """In America, where cars are an important part of the national psyche, a decade ago people had suddenly started to drive less, which had not happened since the oil shocks of the 1970s. """
- examples = gr.Examples(
- examples=[
- ["Explain the plot of Cinderella in a sentence."],
- [
- "How long does it take to become proficient in French, and what are the best methods for retaining information?"
- ],
- ["What are some common mistakes to avoid when writing code?"],
- ["Build a prompt to generate a beautiful portrait of a horse"],
- ["Suggest four metaphors to describe the benefits of AI"],
- ["Write a pop song about leaving home for the sandy beaches."],
- ["Write a summary demonstrating my ability to tame lions"],
- ["鲁迅和周树人什么关系"],
- ["从前有一头牛，这头牛后面有什么？"],
- ["正无穷大加一大于正无穷大吗？"],
- ["正无穷大加正无穷大大于正无穷大吗？"],
- ["-2的平方根等于什么"],
- ["树上有5只鸟，猎人开枪打死了一只。树上还有几只鸟？"],
- ["树上有11只鸟，猎人开枪打死了一只。树上还有几只鸟？提示：需考虑鸟可能受惊吓飞走。"],
- ["鲁迅和周树人什么关系 用英文回答"],
- ["以红楼梦的行文风格写一张委婉的请假条。不少于320字。"],
- [f"{etext} 翻成中文，列出3个版本"],
- [f"{etext} \n 翻成中文，保留原意，但使用文学性的语言。不要写解释。列出3个版本"],
- ["js 判断一个数是不是质数"],
- ["js 实现python 的 range(10)"],
- ["js 实现python 的 [*(range(10)]"],
- ["假定 1 + 2 = 4, 试求 7 + 8"],
- ["Erkläre die Handlung von Cinderella in einem Satz."],
- ["Erkläre die Handlung von Cinderella in einem Satz. Auf Deutsch"],
- ],
- inputs=[user_input],
- examples_per_page=30,
- )
-
- with gr.Accordion("For Chat/Translation API", open=False, visible=False):
- input_text = gr.Text()
- tr_btn = gr.Button("Go", variant="primary")
- out_text = gr.Text()
- tr_btn.click(
- trans_api,
- [input_text, max_length, top_p, temperature],
- out_text,
- # show_progress="full",
- api_name="tr",
- )
- _ = """
- input_text.submit(
- trans_api,
- [input_text, max_length, top_p, temperature],
- out_text,
- show_progress="full",
- api_name="tr1",
- )
- # """
-
- gr.Markdown("### 注意❗：请不要生成会对个人以及组织造成侵害的内容，此程序仅供科研、学习及个人娱乐使用。 ")
- gr.Markdown("💡 - 如何使用此程序：输入您对ChatGLM的提问后，依次点击“开始和GLM2交流吧”、“生成对应的音频吧”、“开始AI声音克隆吧”三个按键即可；使用声音克隆功能时，请先上传一段您喜欢的音频 ")
- gr.HTML('''
-
- ''')
-
-
-demo.queue().launch(show_error=True, debug=True)
diff --git a/spaces/kevinwang676/SadTalker/src/facerender/modules/generator.py b/spaces/kevinwang676/SadTalker/src/facerender/modules/generator.py
deleted file mode 100644
index 5a9edcb3b328d3afc99072b2461d7ca69919f813..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/SadTalker/src/facerender/modules/generator.py
+++ /dev/null
@@ -1,255 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-from src.facerender.modules.util import ResBlock2d, SameBlock2d, UpBlock2d, DownBlock2d, ResBlock3d, SPADEResnetBlock
-from src.facerender.modules.dense_motion import DenseMotionNetwork
-
-
-class OcclusionAwareGenerator(nn.Module):
- """
- Generator follows NVIDIA architecture.
- """
-
- def __init__(self, image_channel, feature_channel, num_kp, block_expansion, max_features, num_down_blocks, reshape_channel, reshape_depth,
- num_resblocks, estimate_occlusion_map=False, dense_motion_params=None, estimate_jacobian=False):
- super(OcclusionAwareGenerator, self).__init__()
-
- if dense_motion_params is not None:
- self.dense_motion_network = DenseMotionNetwork(num_kp=num_kp, feature_channel=feature_channel,
- estimate_occlusion_map=estimate_occlusion_map,
- **dense_motion_params)
- else:
- self.dense_motion_network = None
-
- self.first = SameBlock2d(image_channel, block_expansion, kernel_size=(7, 7), padding=(3, 3))
-
- down_blocks = []
- for i in range(num_down_blocks):
- in_features = min(max_features, block_expansion * (2 ** i))
- out_features = min(max_features, block_expansion * (2 ** (i + 1)))
- down_blocks.append(DownBlock2d(in_features, out_features, kernel_size=(3, 3), padding=(1, 1)))
- self.down_blocks = nn.ModuleList(down_blocks)
-
- self.second = nn.Conv2d(in_channels=out_features, out_channels=max_features, kernel_size=1, stride=1)
-
- self.reshape_channel = reshape_channel
- self.reshape_depth = reshape_depth
-
- self.resblocks_3d = torch.nn.Sequential()
- for i in range(num_resblocks):
- self.resblocks_3d.add_module('3dr' + str(i), ResBlock3d(reshape_channel, kernel_size=3, padding=1))
-
- out_features = block_expansion * (2 ** (num_down_blocks))
- self.third = SameBlock2d(max_features, out_features, kernel_size=(3, 3), padding=(1, 1), lrelu=True)
- self.fourth = nn.Conv2d(in_channels=out_features, out_channels=out_features, kernel_size=1, stride=1)
-
- self.resblocks_2d = torch.nn.Sequential()
- for i in range(num_resblocks):
- self.resblocks_2d.add_module('2dr' + str(i), ResBlock2d(out_features, kernel_size=3, padding=1))
-
- up_blocks = []
- for i in range(num_down_blocks):
- in_features = max(block_expansion, block_expansion * (2 ** (num_down_blocks - i)))
- out_features = max(block_expansion, block_expansion * (2 ** (num_down_blocks - i - 1)))
- up_blocks.append(UpBlock2d(in_features, out_features, kernel_size=(3, 3), padding=(1, 1)))
- self.up_blocks = nn.ModuleList(up_blocks)
-
- self.final = nn.Conv2d(block_expansion, image_channel, kernel_size=(7, 7), padding=(3, 3))
- self.estimate_occlusion_map = estimate_occlusion_map
- self.image_channel = image_channel
-
- def deform_input(self, inp, deformation):
- _, d_old, h_old, w_old, _ = deformation.shape
- _, _, d, h, w = inp.shape
- if d_old != d or h_old != h or w_old != w:
- deformation = deformation.permute(0, 4, 1, 2, 3)
- deformation = F.interpolate(deformation, size=(d, h, w), mode='trilinear')
- deformation = deformation.permute(0, 2, 3, 4, 1)
- return F.grid_sample(inp, deformation)
-
- def forward(self, source_image, kp_driving, kp_source):
- # Encoding (downsampling) part
- out = self.first(source_image)
- for i in range(len(self.down_blocks)):
- out = self.down_blocks[i](out)
- out = self.second(out)
- bs, c, h, w = out.shape
- # print(out.shape)
- feature_3d = out.view(bs, self.reshape_channel, self.reshape_depth, h ,w)
- feature_3d = self.resblocks_3d(feature_3d)
-
- # Transforming feature representation according to deformation and occlusion
- output_dict = {}
- if self.dense_motion_network is not None:
- dense_motion = self.dense_motion_network(feature=feature_3d, kp_driving=kp_driving,
- kp_source=kp_source)
- output_dict['mask'] = dense_motion['mask']
-
- if 'occlusion_map' in dense_motion:
- occlusion_map = dense_motion['occlusion_map']
- output_dict['occlusion_map'] = occlusion_map
- else:
- occlusion_map = None
- deformation = dense_motion['deformation']
- out = self.deform_input(feature_3d, deformation)
-
- bs, c, d, h, w = out.shape
- out = out.view(bs, c*d, h, w)
- out = self.third(out)
- out = self.fourth(out)
-
- if occlusion_map is not None:
- if out.shape[2] != occlusion_map.shape[2] or out.shape[3] != occlusion_map.shape[3]:
- occlusion_map = F.interpolate(occlusion_map, size=out.shape[2:], mode='bilinear')
- out = out * occlusion_map
-
- # output_dict["deformed"] = self.deform_input(source_image, deformation) # 3d deformation cannot deform 2d image
-
- # Decoding part
- out = self.resblocks_2d(out)
- for i in range(len(self.up_blocks)):
- out = self.up_blocks[i](out)
- out = self.final(out)
- out = F.sigmoid(out)
-
- output_dict["prediction"] = out
-
- return output_dict
-
-
-class SPADEDecoder(nn.Module):
- def __init__(self):
- super().__init__()
- ic = 256
- oc = 64
- norm_G = 'spadespectralinstance'
- label_nc = 256
-
- self.fc = nn.Conv2d(ic, 2 * ic, 3, padding=1)
- self.G_middle_0 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.G_middle_1 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.G_middle_2 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.G_middle_3 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.G_middle_4 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.G_middle_5 = SPADEResnetBlock(2 * ic, 2 * ic, norm_G, label_nc)
- self.up_0 = SPADEResnetBlock(2 * ic, ic, norm_G, label_nc)
- self.up_1 = SPADEResnetBlock(ic, oc, norm_G, label_nc)
- self.conv_img = nn.Conv2d(oc, 3, 3, padding=1)
- self.up = nn.Upsample(scale_factor=2)
-
- def forward(self, feature):
- seg = feature
- x = self.fc(feature)
- x = self.G_middle_0(x, seg)
- x = self.G_middle_1(x, seg)
- x = self.G_middle_2(x, seg)
- x = self.G_middle_3(x, seg)
- x = self.G_middle_4(x, seg)
- x = self.G_middle_5(x, seg)
- x = self.up(x)
- x = self.up_0(x, seg) # 256, 128, 128
- x = self.up(x)
- x = self.up_1(x, seg) # 64, 256, 256
-
- x = self.conv_img(F.leaky_relu(x, 2e-1))
- # x = torch.tanh(x)
- x = F.sigmoid(x)
-
- return x
-
-
-class OcclusionAwareSPADEGenerator(nn.Module):
-
- def __init__(self, image_channel, feature_channel, num_kp, block_expansion, max_features, num_down_blocks, reshape_channel, reshape_depth,
- num_resblocks, estimate_occlusion_map=False, dense_motion_params=None, estimate_jacobian=False):
- super(OcclusionAwareSPADEGenerator, self).__init__()
-
- if dense_motion_params is not None:
- self.dense_motion_network = DenseMotionNetwork(num_kp=num_kp, feature_channel=feature_channel,
- estimate_occlusion_map=estimate_occlusion_map,
- **dense_motion_params)
- else:
- self.dense_motion_network = None
-
- self.first = SameBlock2d(image_channel, block_expansion, kernel_size=(3, 3), padding=(1, 1))
-
- down_blocks = []
- for i in range(num_down_blocks):
- in_features = min(max_features, block_expansion * (2 ** i))
- out_features = min(max_features, block_expansion * (2 ** (i + 1)))
- down_blocks.append(DownBlock2d(in_features, out_features, kernel_size=(3, 3), padding=(1, 1)))
- self.down_blocks = nn.ModuleList(down_blocks)
-
- self.second = nn.Conv2d(in_channels=out_features, out_channels=max_features, kernel_size=1, stride=1)
-
- self.reshape_channel = reshape_channel
- self.reshape_depth = reshape_depth
-
- self.resblocks_3d = torch.nn.Sequential()
- for i in range(num_resblocks):
- self.resblocks_3d.add_module('3dr' + str(i), ResBlock3d(reshape_channel, kernel_size=3, padding=1))
-
- out_features = block_expansion * (2 ** (num_down_blocks))
- self.third = SameBlock2d(max_features, out_features, kernel_size=(3, 3), padding=(1, 1), lrelu=True)
- self.fourth = nn.Conv2d(in_channels=out_features, out_channels=out_features, kernel_size=1, stride=1)
-
- self.estimate_occlusion_map = estimate_occlusion_map
- self.image_channel = image_channel
-
- self.decoder = SPADEDecoder()
-
- def deform_input(self, inp, deformation):
- _, d_old, h_old, w_old, _ = deformation.shape
- _, _, d, h, w = inp.shape
- if d_old != d or h_old != h or w_old != w:
- deformation = deformation.permute(0, 4, 1, 2, 3)
- deformation = F.interpolate(deformation, size=(d, h, w), mode='trilinear')
- deformation = deformation.permute(0, 2, 3, 4, 1)
- return F.grid_sample(inp, deformation)
-
- def forward(self, source_image, kp_driving, kp_source):
- # Encoding (downsampling) part
- out = self.first(source_image)
- for i in range(len(self.down_blocks)):
- out = self.down_blocks[i](out)
- out = self.second(out)
- bs, c, h, w = out.shape
- # print(out.shape)
- feature_3d = out.view(bs, self.reshape_channel, self.reshape_depth, h ,w)
- feature_3d = self.resblocks_3d(feature_3d)
-
- # Transforming feature representation according to deformation and occlusion
- output_dict = {}
- if self.dense_motion_network is not None:
- dense_motion = self.dense_motion_network(feature=feature_3d, kp_driving=kp_driving,
- kp_source=kp_source)
- output_dict['mask'] = dense_motion['mask']
-
- # import pdb; pdb.set_trace()
-
- if 'occlusion_map' in dense_motion:
- occlusion_map = dense_motion['occlusion_map']
- output_dict['occlusion_map'] = occlusion_map
- else:
- occlusion_map = None
- deformation = dense_motion['deformation']
- out = self.deform_input(feature_3d, deformation)
-
- bs, c, d, h, w = out.shape
- out = out.view(bs, c*d, h, w)
- out = self.third(out)
- out = self.fourth(out)
-
- # occlusion_map = torch.where(occlusion_map < 0.95, 0, occlusion_map)
-
- if occlusion_map is not None:
- if out.shape[2] != occlusion_map.shape[2] or out.shape[3] != occlusion_map.shape[3]:
- occlusion_map = F.interpolate(occlusion_map, size=out.shape[2:], mode='bilinear')
- out = out * occlusion_map
-
- # Decoding part
- out = self.decoder(out)
-
- output_dict["prediction"] = out
-
- return output_dict
\ No newline at end of file
diff --git a/spaces/kevinwang676/VALLE/modules/transformer.py b/spaces/kevinwang676/VALLE/modules/transformer.py
deleted file mode 100644
index ea8826b193c5053cb8ae74312f65ac95fe440350..0000000000000000000000000000000000000000
--- a/spaces/kevinwang676/VALLE/modules/transformer.py
+++ /dev/null
@@ -1,683 +0,0 @@
-import copy
-import numbers
-from functools import partial
-from typing import Any, Callable, List, Optional, Tuple, Union
-
-import torch
-from torch import Tensor, nn
-from torch.nn import functional as F
-
-from .activation import MultiheadAttention
-from .scaling import ActivationBalancer, BalancedDoubleSwish
-from .scaling import BasicNorm as _BasicNorm
-
-_shape_t = Union[int, List[int], torch.Size]
-
-
-class LayerNorm(nn.Module):
- __constants__ = ["normalized_shape", "eps", "elementwise_affine"]
- normalized_shape: Tuple[int, ...]
- eps: float
- elementwise_affine: bool
-
- def __init__(
- self,
- normalized_shape: _shape_t,
- eps: float = 1e-5,
- elementwise_affine: bool = True,
- device=None,
- dtype=None,
- ) -> None:
- factory_kwargs = {"device": device, "dtype": dtype}
- super(LayerNorm, self).__init__()
- if isinstance(normalized_shape, numbers.Integral):
- # mypy error: incompatible types in assignment
- normalized_shape = (normalized_shape,) # type: ignore[assignment]
- self.normalized_shape = tuple(normalized_shape) # type: ignore[arg-type]
- self.eps = eps
- self.elementwise_affine = elementwise_affine
- if self.elementwise_affine:
- self.weight = nn.Parameter(
- torch.empty(self.normalized_shape, **factory_kwargs)
- )
- self.bias = nn.Parameter(
- torch.empty(self.normalized_shape, **factory_kwargs)
- )
- else:
- self.register_parameter("weight", None)
- self.register_parameter("bias", None)
-
- self.reset_parameters()
-
- def reset_parameters(self) -> None:
- if self.elementwise_affine:
- nn.init.ones_(self.weight)
- nn.init.zeros_(self.bias)
-
- def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
- if isinstance(input, tuple):
- input, embedding = input
- return (
- F.layer_norm(
- input,
- self.normalized_shape,
- self.weight,
- self.bias,
- self.eps,
- ),
- embedding,
- )
-
- assert embedding is None
- return F.layer_norm(
- input, self.normalized_shape, self.weight, self.bias, self.eps
- )
-
- def extra_repr(self) -> str:
- return (
- "{normalized_shape}, eps={eps}, "
- "elementwise_affine={elementwise_affine}".format(**self.__dict__)
- )
-
-
-class AdaptiveLayerNorm(nn.Module):
- r"""Adaptive Layer Normalization"""
-
- def __init__(self, d_model, norm) -> None:
- super(AdaptiveLayerNorm, self).__init__()
- self.project_layer = nn.Linear(d_model, 2 * d_model)
- self.norm = norm
- self.d_model = d_model
- self.eps = self.norm.eps
-
- def forward(self, input: Tensor, embedding: Tensor = None) -> Tensor:
- if isinstance(input, tuple):
- input, embedding = input
- weight, bias = torch.split(
- self.project_layer(embedding),
- split_size_or_sections=self.d_model,
- dim=-1,
- )
- return (weight * self.norm(input) + bias, embedding)
-
- weight, bias = torch.split(
- self.project_layer(embedding),
- split_size_or_sections=self.d_model,
- dim=-1,
- )
- return weight * self.norm(input) + bias
-
-
-class BasicNorm(_BasicNorm):
- def __init__(
- self,
- d_model: int,
- eps: float = 1e-5,
- device=None,
- dtype=None,
- ):
- super(BasicNorm, self).__init__(d_model, eps=eps)
-
- def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
- if isinstance(input, tuple):
- input, embedding = input
- return (
- super(BasicNorm, self).forward(input),
- embedding,
- )
-
- assert embedding is None
- return super(BasicNorm, self).forward(input)
-
-
-class BalancedBasicNorm(nn.Module):
- def __init__(
- self,
- d_model: int,
- eps: float = 1e-5,
- device=None,
- dtype=None,
- ):
- super(BalancedBasicNorm, self).__init__()
- self.balancer = ActivationBalancer(
- d_model,
- channel_dim=-1,
- min_positive=0.45,
- max_positive=0.55,
- max_abs=6.0,
- )
- self.norm = BasicNorm(d_model, eps, device=device, dtype=dtype)
-
- def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
- if isinstance(input, tuple):
- input, embedding = input
- return self.norm((self.balancer(input), embedding))
-
- assert embedding is None
- return self.norm(self.balancer(input))
-
-
-class IdentityNorm(nn.Module):
- def __init__(
- self,
- d_model: int,
- eps: float = 1e-5,
- device=None,
- dtype=None,
- ) -> None:
- super(IdentityNorm, self).__init__()
-
- def forward(self, input: Tensor, embedding: Any = None) -> Tensor:
- if isinstance(input, tuple):
- return input
-
- assert embedding is None
- return input
-
-
-class TransformerEncoderLayer(nn.Module):
- __constants__ = ["batch_first", "norm_first"]
-
- def __init__(
- self,
- d_model: int,
- nhead: int,
- dim_feedforward: int = 2048,
- dropout: float = 0.1,
- activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
- batch_first: bool = False,
- norm_first: bool = False,
- device=None,
- dtype=None,
- linear1_self_attention_cls: nn.Module = nn.Linear,
- linear2_self_attention_cls: nn.Module = nn.Linear,
- linear1_feedforward_cls: nn.Module = nn.Linear,
- linear2_feedforward_cls: nn.Module = nn.Linear,
- layer_norm_cls: nn.Module = LayerNorm,
- layer_norm_eps: float = 1e-5,
- adaptive_layer_norm=False,
- ) -> None:
- factory_kwargs = {"device": device, "dtype": dtype}
- super(TransformerEncoderLayer, self).__init__()
- self.self_attn = MultiheadAttention(
- d_model,
- nhead,
- dropout=dropout,
- batch_first=batch_first,
- linear1_cls=linear1_self_attention_cls,
- linear2_cls=linear2_self_attention_cls,
- **factory_kwargs,
- )
-
- # Implementation of Feedforward model
- self.linear1 = linear1_feedforward_cls(
- d_model, dim_feedforward, **factory_kwargs
- )
- self.dropout = nn.Dropout(dropout)
- self.linear2 = linear2_feedforward_cls(
- dim_feedforward, d_model, **factory_kwargs
- )
-
- self.norm_first = norm_first
- self.dropout1 = nn.Dropout(dropout)
- self.dropout2 = nn.Dropout(dropout)
-
- # Legacy string support for activation function.
- if isinstance(activation, str):
- activation = _get_activation_fn(activation)
- elif isinstance(activation, partial):
- activation = activation(d_model)
- elif activation == BalancedDoubleSwish:
- activation = BalancedDoubleSwish(d_model)
-
- # # We can't test self.activation in forward() in TorchScript,
- # # so stash some information about it instead.
- # if activation is F.relu or isinstance(activation, torch.nn.ReLU):
- # self.activation_relu_or_gelu = 1
- # elif activation is F.gelu or isinstance(activation, torch.nn.GELU):
- # self.activation_relu_or_gelu = 2
- # else:
- # self.activation_relu_or_gelu = 0
- self.activation = activation
-
- norm1 = layer_norm_cls(d_model, eps=layer_norm_eps, **factory_kwargs)
- if layer_norm_cls == IdentityNorm:
- norm2 = BalancedBasicNorm(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- else:
- norm2 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
-
- if adaptive_layer_norm:
- self.norm1 = AdaptiveLayerNorm(d_model, norm1)
- self.norm2 = AdaptiveLayerNorm(d_model, norm2)
- else:
- self.norm1 = norm1
- self.norm2 = norm2
-
- def __setstate__(self, state):
- super(TransformerEncoderLayer, self).__setstate__(state)
- if not hasattr(self, "activation"):
- self.activation = F.relu
-
- def forward(
- self,
- src: Tensor,
- src_mask: Optional[Tensor] = None,
- src_key_padding_mask: Optional[Tensor] = None,
- ) -> Tensor:
- r"""Pass the input through the encoder layer.
-
- Args:
- src: the sequence to the encoder layer (required).
- src_mask: the mask for the src sequence (optional).
- src_key_padding_mask: the mask for the src keys per batch (optional).
-
- Shape:
- see the docs in Transformer class.
- """
- x, stage_embedding = src, None
- is_src_tuple = False
- if isinstance(src, tuple):
- x, stage_embedding = src
- is_src_tuple = True
-
- if src_key_padding_mask is not None:
- _skpm_dtype = src_key_padding_mask.dtype
- if _skpm_dtype != torch.bool and not torch.is_floating_point(
- src_key_padding_mask
- ):
- raise AssertionError(
- "only bool and floating types of key_padding_mask are supported"
- )
-
- if self.norm_first:
- x = x + self._sa_block(
- self.norm1(x, stage_embedding),
- src_mask,
- src_key_padding_mask,
- )
- x = x + self._ff_block(self.norm2(x, stage_embedding))
- else:
- x = self.norm1(
- x + self._sa_block(x, src_mask, src_key_padding_mask),
- stage_embedding,
- )
- x = self.norm2(x + self._ff_block(x), stage_embedding)
-
- if is_src_tuple:
- return (x, stage_embedding)
- return x
-
- def infer(
- self,
- src: Tensor,
- src_mask: Optional[Tensor] = None,
- src_key_padding_mask: Optional[Tensor] = None,
- past_kv: Optional[Tensor] = None,
- use_cache: bool = False,
- ):
- x, stage_embedding = src, None
- is_src_tuple = False
- if isinstance(src, tuple):
- x, stage_embedding = src
- is_src_tuple = True
-
- if src_key_padding_mask is not None:
- _skpm_dtype = src_key_padding_mask.dtype
- if _skpm_dtype != torch.bool and not torch.is_floating_point(
- src_key_padding_mask
- ):
- raise AssertionError(
- "only bool and floating types of key_padding_mask are supported"
- )
-
- if self.norm_first:
- x_attn_out, kv = self.self_attn.infer(
- self.norm1(x, stage_embedding),
- attn_mask=src_mask,
- key_padding_mask=src_key_padding_mask,
- need_weights=False,
- past_kv=past_kv,
- use_cache=use_cache,
- )
- x = x + x_attn_out
- x = x + self._ff_block(self.norm2(x, stage_embedding))
-
- if is_src_tuple:
- return (x, stage_embedding)
- return (x, kv)
-
- # self-attention block
- def _sa_block(
- self,
- x: Tensor,
- attn_mask: Optional[Tensor],
- key_padding_mask: Optional[Tensor],
- ) -> Tensor:
- x = self.self_attn(
- x,
- x,
- x,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask,
- need_weights=False,
- )[0]
- return self.dropout1(x)
-
- # feed forward block
- def _ff_block(self, x: Tensor) -> Tensor:
- x = self.linear2(self.dropout(self.activation(self.linear1(x))))
- return self.dropout2(x)
-
-
-class TransformerEncoder(nn.Module):
- r"""TransformerEncoder is a stack of N encoder layers. Users can build the
- BERT(https://arxiv.org/abs/1810.04805) model with corresponding parameters.
-
- Args:
- encoder_layer: an instance of the TransformerEncoderLayer() class (required).
- num_layers: the number of sub-encoder-layers in the encoder (required).
- norm: the layer normalization component (optional).
- enable_nested_tensor: if True, input will automatically convert to nested tensor
- (and convert back on output). This will improve the overall performance of
- TransformerEncoder when padding rate is high. Default: ``True`` (enabled).
-
- Examples::
- >>> encoder_layer = TransformerEncoderLayer(d_model=512, nhead=8)
- >>> transformer_encoder = TransformerEncoder(encoder_layer, num_layers=6)
- >>> src = torch.rand(10, 32, 512)
- >>> out = transformer_encoder(src)
- """
- __constants__ = ["norm"]
-
- def __init__(self, encoder_layer, num_layers, norm=None):
- super(TransformerEncoder, self).__init__()
- self.layers = _get_clones(encoder_layer, num_layers)
- self.num_layers = num_layers
- self.norm = norm
-
- def forward(
- self,
- src: Tensor,
- mask: Optional[Tensor] = None,
- src_key_padding_mask: Optional[Tensor] = None,
- return_layer_states: bool = False,
- ) -> Tensor:
- r"""Pass the input through the encoder layers in turn.
-
- Args:
- src: the sequence to the encoder (required).
- mask: the mask for the src sequence (optional).
- src_key_padding_mask: the mask for the src keys per batch (optional).
- return_layer_states: return layers' state (optional).
-
- Shape:
- see the docs in Transformer class.
- """
- if return_layer_states:
- layer_states = [] # layers' output
- output = src
- for mod in self.layers:
- output = mod(
- output,
- src_mask=mask,
- src_key_padding_mask=src_key_padding_mask,
- )
- layer_states.append(output[0])
-
- if self.norm is not None:
- output = self.norm(output)
-
- return layer_states, output
-
- output = src
- for mod in self.layers:
- output = mod(
- output, src_mask=mask, src_key_padding_mask=src_key_padding_mask
- )
-
- if self.norm is not None:
- output = self.norm(output)
-
- return output
-
- def infer(
- self,
- src: Tensor,
- mask: Optional[Tensor] = None,
- src_key_padding_mask: Optional[Tensor] = None,
- return_layer_states: bool = False,
- past_kv: Optional[Tensor] = None,
- use_cache: bool = False,
- ):
- if past_kv is None:
- past_length = 0
- past_kv = tuple([None] * self.num_layers)
- else:
- past_length = past_kv[0][0].size(-2)
- new_kv = () if use_cache else None
- output = src
- for mod, past_layer_kv in zip(self.layers, past_kv):
- output, kv = mod.infer(
- output, src_mask=mask, src_key_padding_mask=src_key_padding_mask, past_kv=past_layer_kv, use_cache=use_cache
- )
- if use_cache:
- new_kv = new_kv + (kv,)
-
- if self.norm is not None:
- output = self.norm(output)
-
- return output, new_kv
-
-
-class TransformerDecoderLayer(nn.Module):
- __constants__ = ["batch_first", "norm_first"]
-
- def __init__(
- self,
- d_model: int,
- nhead: int,
- dim_feedforward: int = 2048,
- dropout: float = 0.1,
- activation: Union[str, Callable[[Tensor], Tensor]] = F.relu,
- linear1_self_attention_cls: nn.Module = nn.Linear,
- linear2_self_attention_cls: nn.Module = nn.Linear,
- linear1_feedforward_cls: nn.Module = nn.Linear,
- linear2_feedforward_cls: nn.Module = nn.Linear,
- batch_first: bool = False,
- norm_first: bool = False,
- device=None,
- dtype=None,
- layer_norm_cls: nn.Module = LayerNorm,
- layer_norm_eps: float = 1e-5,
- adaptive_layer_norm=False,
- ) -> None:
- factory_kwargs = {"device": device, "dtype": dtype}
- super(TransformerDecoderLayer, self).__init__()
- self.self_attn = MultiheadAttention(
- d_model,
- nhead,
- dropout=dropout,
- batch_first=batch_first,
- linear1_cls=linear1_self_attention_cls,
- linear2_cls=linear2_self_attention_cls,
- **factory_kwargs,
- )
- self.multihead_attn = MultiheadAttention(
- d_model,
- nhead,
- dropout=dropout,
- batch_first=batch_first,
- linear1_cls=linear1_self_attention_cls,
- linear2_cls=linear2_self_attention_cls,
- **factory_kwargs,
- )
- # Implementation of Feedforward model
- self.linear1 = linear1_feedforward_cls(
- d_model, dim_feedforward, **factory_kwargs
- )
- self.dropout = nn.Dropout(dropout)
- self.linear2 = linear2_feedforward_cls(
- dim_feedforward, d_model, **factory_kwargs
- )
-
- self.norm_first = norm_first
- self.dropout1 = nn.Dropout(dropout)
- self.dropout2 = nn.Dropout(dropout)
- self.dropout3 = nn.Dropout(dropout)
-
- # Legacy string support for activation function.
- if isinstance(activation, str):
- self.activation = _get_activation_fn(activation)
- elif isinstance(activation, partial):
- self.activation = activation(d_model)
- elif activation == BalancedDoubleSwish:
- self.activation = BalancedDoubleSwish(d_model)
- else:
- self.activation = activation
-
- if adaptive_layer_norm:
- norm1 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- norm2 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- norm3 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
-
- self.norm1 = AdaptiveLayerNorm(d_model, norm1)
- self.norm2 = AdaptiveLayerNorm(d_model, norm2)
- self.norm3 = AdaptiveLayerNorm(d_model, norm3)
- else:
- self.norm1 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- self.norm2 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- if layer_norm_cls == IdentityNorm:
- self.norm3 = BalancedBasicNorm(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
- else:
- self.norm3 = layer_norm_cls(
- d_model, eps=layer_norm_eps, **factory_kwargs
- )
-
- def forward(
- self,
- tgt: Tensor,
- memory: Tensor,
- tgt_mask: Optional[Tensor] = None,
- memory_mask: Optional[Tensor] = None,
- tgt_key_padding_mask: Optional[Tensor] = None,
- memory_key_padding_mask: Optional[Tensor] = None,
- ) -> Tensor:
- r"""Pass the inputs (and mask) through the decoder layer.
-
- Args:
- tgt: the sequence to the decoder layer (required).
- memory: the sequence from the last layer of the encoder (required).
- tgt_mask: the mask for the tgt sequence (optional).
- memory_mask: the mask for the memory sequence (optional).
- tgt_key_padding_mask: the mask for the tgt keys per batch (optional).
- memory_key_padding_mask: the mask for the memory keys per batch (optional).
-
- Shape:
- see the docs in Transformer class.
- """
- tgt_is_tuple = False
- if isinstance(tgt, tuple):
- x, stage_embedding = tgt
- tgt_is_tuple = True
- else:
- x, stage_embedding = tgt, None
-
- if self.norm_first:
- x = x + self._sa_block(
- self.norm1(x, stage_embedding), tgt_mask, tgt_key_padding_mask
- )
- x = x + self._mha_block(
- self.norm2(x, stage_embedding),
- memory,
- memory_mask,
- memory_key_padding_mask,
- )
- x = x + self._ff_block(self.norm3(x, stage_embedding))
- else:
- x = self.norm1(
- x + self._sa_block(x, tgt_mask, tgt_key_padding_mask),
- stage_embedding,
- )
- x = self.norm2(
- x
- + self._mha_block(
- x, memory, memory_mask, memory_key_padding_mask
- ),
- stage_embedding,
- )
- x = self.norm3(x + self._ff_block(x), stage_embedding)
-
- if tgt_is_tuple:
- return (x, stage_embedding)
- return x
-
- # self-attention block
- def _sa_block(
- self,
- x: Tensor,
- attn_mask: Optional[Tensor],
- key_padding_mask: Optional[Tensor],
- ) -> Tensor:
- x = self.self_attn(
- x,
- x,
- x,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask,
- need_weights=False,
- )[0]
- return self.dropout1(x)
-
- # multihead attention block
- def _mha_block(
- self,
- x: Tensor,
- mem: Tensor,
- attn_mask: Optional[Tensor],
- key_padding_mask: Optional[Tensor],
- ) -> Tensor:
- x = self.multihead_attn(
- x,
- mem,
- mem,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask,
- need_weights=False,
- )[0]
- return self.dropout2(x)
-
- # feed forward block
- def _ff_block(self, x: Tensor) -> Tensor:
- x = self.linear2(self.dropout(self.activation(self.linear1(x))))
- return self.dropout3(x)
-
-
-def _get_clones(module, N):
- return nn.ModuleList([copy.deepcopy(module) for i in range(N)])
-
-
-def _get_activation_fn(activation: str) -> Callable[[Tensor], Tensor]:
- if activation == "relu":
- return F.relu
- elif activation == "gelu":
- return F.gelu
-
- raise RuntimeError(
- "activation should be relu/gelu, not {}".format(activation)
- )
diff --git a/spaces/kira4424/Tacotron-zero-short-voice-clone/web/static/js/jquery.js b/spaces/kira4424/Tacotron-zero-short-voice-clone/web/static/js/jquery.js
deleted file mode 100644
index fc6c299b73e792ef288e785c22393a5df9dded4b..0000000000000000000000000000000000000000
--- a/spaces/kira4424/Tacotron-zero-short-voice-clone/web/static/js/jquery.js
+++ /dev/null
@@ -1,10881 +0,0 @@
-/*!
- * jQuery JavaScript Library v3.6.0
- * https://jquery.com/
- *
- * Includes Sizzle.js
- * https://sizzlejs.com/
- *
- * Copyright OpenJS Foundation and other contributors
- * Released under the MIT license
- * https://jquery.org/license
- *
- * Date: 2021-03-02T17:08Z
- */
-( function( global, factory ) {
-
- "use strict";
-
- if ( typeof module === "object" && typeof module.exports === "object" ) {
-
- // For CommonJS and CommonJS-like environments where a proper `window`
- // is present, execute the factory and get jQuery.
- // For environments that do not have a `window` with a `document`
- // (such as Node.js), expose a factory as module.exports.
- // This accentuates the need for the creation of a real `window`.
- // e.g. var jQuery = require("jquery")(window);
- // See ticket #14549 for more info.
- module.exports = global.document ?
- factory( global, true ) :
- function( w ) {
- if ( !w.document ) {
- throw new Error( "jQuery requires a window with a document" );
- }
- return factory( w );
- };
- } else {
- factory( global );
- }
-
-// Pass this if window is not defined yet
-} )( typeof window !== "undefined" ? window : this, function( window, noGlobal ) {
-
-// Edge <= 12 - 13+, Firefox <=18 - 45+, IE 10 - 11, Safari 5.1 - 9+, iOS 6 - 9.1
-// throw exceptions when non-strict code (e.g., ASP.NET 4.5) accesses strict mode
-// arguments.callee.caller (trac-13335). But as of jQuery 3.0 (2016), strict mode should be common
-// enough that all such attempts are guarded in a try block.
-"use strict";
-
-var arr = [];
-
-var getProto = Object.getPrototypeOf;
-
-var slice = arr.slice;
-
-var flat = arr.flat ? function( array ) {
- return arr.flat.call( array );
-} : function( array ) {
- return arr.concat.apply( [], array );
-};
-
-
-var push = arr.push;
-
-var indexOf = arr.indexOf;
-
-var class2type = {};
-
-var toString = class2type.toString;
-
-var hasOwn = class2type.hasOwnProperty;
-
-var fnToString = hasOwn.toString;
-
-var ObjectFunctionString = fnToString.call( Object );
-
-var support = {};
-
-var isFunction = function isFunction( obj ) {
-
- // Support: Chrome <=57, Firefox <=52
- // In some browsers, typeof returns "function" for HTML elements
- // (i.e., `typeof document.createElement( "object" ) === "function"`).
- // We don't want to classify *any* DOM node as a function.
- // Support: QtWeb <=3.8.5, WebKit <=534.34, wkhtmltopdf tool <=0.12.5
- // Plus for old WebKit, typeof returns "function" for HTML collections
- // (e.g., `typeof document.getElementsByTagName("div") === "function"`). (gh-4756)
- return typeof obj === "function" && typeof obj.nodeType !== "number" &&
- typeof obj.item !== "function";
- };
-
-
-var isWindow = function isWindow( obj ) {
- return obj != null && obj === obj.window;
- };
-
-
-var document = window.document;
-
-
-
- var preservedScriptAttributes = {
- type: true,
- src: true,
- nonce: true,
- noModule: true
- };
-
- function DOMEval( code, node, doc ) {
- doc = doc || document;
-
- var i, val,
- script = doc.createElement( "script" );
-
- script.text = code;
- if ( node ) {
- for ( i in preservedScriptAttributes ) {
-
- // Support: Firefox 64+, Edge 18+
- // Some browsers don't support the "nonce" property on scripts.
- // On the other hand, just using `getAttribute` is not enough as
- // the `nonce` attribute is reset to an empty string whenever it
- // becomes browsing-context connected.
- // See https://github.com/whatwg/html/issues/2369
- // See https://html.spec.whatwg.org/#nonce-attributes
- // The `node.getAttribute` check was added for the sake of
- // `jQuery.globalEval` so that it can fake a nonce-containing node
- // via an object.
- val = node[ i ] || node.getAttribute && node.getAttribute( i );
- if ( val ) {
- script.setAttribute( i, val );
- }
- }
- }
- doc.head.appendChild( script ).parentNode.removeChild( script );
- }
-
-
-function toType( obj ) {
- if ( obj == null ) {
- return obj + "";
- }
-
- // Support: Android <=2.3 only (functionish RegExp)
- return typeof obj === "object" || typeof obj === "function" ?
- class2type[ toString.call( obj ) ] || "object" :
- typeof obj;
-}
-/* global Symbol */
-// Defining this global in .eslintrc.json would create a danger of using the global
-// unguarded in another place, it seems safer to define global only for this module
-
-
-
-var
- version = "3.6.0",
-
- // Define a local copy of jQuery
- jQuery = function( selector, context ) {
-
- // The jQuery object is actually just the init constructor 'enhanced'
- // Need init if jQuery is called (just allow error to be thrown if not included)
- return new jQuery.fn.init( selector, context );
- };
-
-jQuery.fn = jQuery.prototype = {
-
- // The current version of jQuery being used
- jquery: version,
-
- constructor: jQuery,
-
- // The default length of a jQuery object is 0
- length: 0,
-
- toArray: function() {
- return slice.call( this );
- },
-
- // Get the Nth element in the matched element set OR
- // Get the whole matched element set as a clean array
- get: function( num ) {
-
- // Return all the elements in a clean array
- if ( num == null ) {
- return slice.call( this );
- }
-
- // Return just the one element from the set
- return num < 0 ? this[ num + this.length ] : this[ num ];
- },
-
- // Take an array of elements and push it onto the stack
- // (returning the new matched element set)
- pushStack: function( elems ) {
-
- // Build a new jQuery matched element set
- var ret = jQuery.merge( this.constructor(), elems );
-
- // Add the old object onto the stack (as a reference)
- ret.prevObject = this;
-
- // Return the newly-formed element set
- return ret;
- },
-
- // Execute a callback for every element in the matched set.
- each: function( callback ) {
- return jQuery.each( this, callback );
- },
-
- map: function( callback ) {
- return this.pushStack( jQuery.map( this, function( elem, i ) {
- return callback.call( elem, i, elem );
- } ) );
- },
-
- slice: function() {
- return this.pushStack( slice.apply( this, arguments ) );
- },
-
- first: function() {
- return this.eq( 0 );
- },
-
- last: function() {
- return this.eq( -1 );
- },
-
- even: function() {
- return this.pushStack( jQuery.grep( this, function( _elem, i ) {
- return ( i + 1 ) % 2;
- } ) );
- },
-
- odd: function() {
- return this.pushStack( jQuery.grep( this, function( _elem, i ) {
- return i % 2;
- } ) );
- },
-
- eq: function( i ) {
- var len = this.length,
- j = +i + ( i < 0 ? len : 0 );
- return this.pushStack( j >= 0 && j < len ? [ this[ j ] ] : [] );
- },
-
- end: function() {
- return this.prevObject || this.constructor();
- },
-
- // For internal use only.
- // Behaves like an Array's method, not like a jQuery method.
- push: push,
- sort: arr.sort,
- splice: arr.splice
-};
-
-jQuery.extend = jQuery.fn.extend = function() {
- var options, name, src, copy, copyIsArray, clone,
- target = arguments[ 0 ] || {},
- i = 1,
- length = arguments.length,
- deep = false;
-
- // Handle a deep copy situation
- if ( typeof target === "boolean" ) {
- deep = target;
-
- // Skip the boolean and the target
- target = arguments[ i ] || {};
- i++;
- }
-
- // Handle case when target is a string or something (possible in deep copy)
- if ( typeof target !== "object" && !isFunction( target ) ) {
- target = {};
- }
-
- // Extend jQuery itself if only one argument is passed
- if ( i === length ) {
- target = this;
- i--;
- }
-
- for ( ; i < length; i++ ) {
-
- // Only deal with non-null/undefined values
- if ( ( options = arguments[ i ] ) != null ) {
-
- // Extend the base object
- for ( name in options ) {
- copy = options[ name ];
-
- // Prevent Object.prototype pollution
- // Prevent never-ending loop
- if ( name === "__proto__" || target === copy ) {
- continue;
- }
-
- // Recurse if we're merging plain objects or arrays
- if ( deep && copy && ( jQuery.isPlainObject( copy ) ||
- ( copyIsArray = Array.isArray( copy ) ) ) ) {
- src = target[ name ];
-
- // Ensure proper type for the source value
- if ( copyIsArray && !Array.isArray( src ) ) {
- clone = [];
- } else if ( !copyIsArray && !jQuery.isPlainObject( src ) ) {
- clone = {};
- } else {
- clone = src;
- }
- copyIsArray = false;
-
- // Never move original objects, clone them
- target[ name ] = jQuery.extend( deep, clone, copy );
-
- // Don't bring in undefined values
- } else if ( copy !== undefined ) {
- target[ name ] = copy;
- }
- }
- }
- }
-
- // Return the modified object
- return target;
-};
-
-jQuery.extend( {
-
- // Unique for each copy of jQuery on the page
- expando: "jQuery" + ( version + Math.random() ).replace( /\D/g, "" ),
-
- // Assume jQuery is ready without the ready module
- isReady: true,
-
- error: function( msg ) {
- throw new Error( msg );
- },
-
- noop: function() {},
-
- isPlainObject: function( obj ) {
- var proto, Ctor;
-
- // Detect obvious negatives
- // Use toString instead of jQuery.type to catch host objects
- if ( !obj || toString.call( obj ) !== "[object Object]" ) {
- return false;
- }
-
- proto = getProto( obj );
-
- // Objects with no prototype (e.g., `Object.create( null )`) are plain
- if ( !proto ) {
- return true;
- }
-
- // Objects with prototype are plain iff they were constructed by a global Object function
- Ctor = hasOwn.call( proto, "constructor" ) && proto.constructor;
- return typeof Ctor === "function" && fnToString.call( Ctor ) === ObjectFunctionString;
- },
-
- isEmptyObject: function( obj ) {
- var name;
-
- for ( name in obj ) {
- return false;
- }
- return true;
- },
-
- // Evaluates a script in a provided context; falls back to the global one
- // if not specified.
- globalEval: function( code, options, doc ) {
- DOMEval( code, { nonce: options && options.nonce }, doc );
- },
-
- each: function( obj, callback ) {
- var length, i = 0;
-
- if ( isArrayLike( obj ) ) {
- length = obj.length;
- for ( ; i < length; i++ ) {
- if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
- break;
- }
- }
- } else {
- for ( i in obj ) {
- if ( callback.call( obj[ i ], i, obj[ i ] ) === false ) {
- break;
- }
- }
- }
-
- return obj;
- },
-
- // results is for internal usage only
- makeArray: function( arr, results ) {
- var ret = results || [];
-
- if ( arr != null ) {
- if ( isArrayLike( Object( arr ) ) ) {
- jQuery.merge( ret,
- typeof arr === "string" ?
- [ arr ] : arr
- );
- } else {
- push.call( ret, arr );
- }
- }
-
- return ret;
- },
-
- inArray: function( elem, arr, i ) {
- return arr == null ? -1 : indexOf.call( arr, elem, i );
- },
-
- // Support: Android <=4.0 only, PhantomJS 1 only
- // push.apply(_, arraylike) throws on ancient WebKit
- merge: function( first, second ) {
- var len = +second.length,
- j = 0,
- i = first.length;
-
- for ( ; j < len; j++ ) {
- first[ i++ ] = second[ j ];
- }
-
- first.length = i;
-
- return first;
- },
-
- grep: function( elems, callback, invert ) {
- var callbackInverse,
- matches = [],
- i = 0,
- length = elems.length,
- callbackExpect = !invert;
-
- // Go through the array, only saving the items
- // that pass the validator function
- for ( ; i < length; i++ ) {
- callbackInverse = !callback( elems[ i ], i );
- if ( callbackInverse !== callbackExpect ) {
- matches.push( elems[ i ] );
- }
- }
-
- return matches;
- },
-
- // arg is for internal usage only
- map: function( elems, callback, arg ) {
- var length, value,
- i = 0,
- ret = [];
-
- // Go through the array, translating each of the items to their new values
- if ( isArrayLike( elems ) ) {
- length = elems.length;
- for ( ; i < length; i++ ) {
- value = callback( elems[ i ], i, arg );
-
- if ( value != null ) {
- ret.push( value );
- }
- }
-
- // Go through every key on the object,
- } else {
- for ( i in elems ) {
- value = callback( elems[ i ], i, arg );
-
- if ( value != null ) {
- ret.push( value );
- }
- }
- }
-
- // Flatten any nested arrays
- return flat( ret );
- },
-
- // A global GUID counter for objects
- guid: 1,
-
- // jQuery.support is not used in Core but other projects attach their
- // properties to it so it needs to exist.
- support: support
-} );
-
-if ( typeof Symbol === "function" ) {
- jQuery.fn[ Symbol.iterator ] = arr[ Symbol.iterator ];
-}
-
-// Populate the class2type map
-jQuery.each( "Boolean Number String Function Array Date RegExp Object Error Symbol".split( " " ),
- function( _i, name ) {
- class2type[ "[object " + name + "]" ] = name.toLowerCase();
- } );
-
-function isArrayLike( obj ) {
-
- // Support: real iOS 8.2 only (not reproducible in simulator)
- // `in` check used to prevent JIT error (gh-2145)
- // hasOwn isn't used here due to false negatives
- // regarding Nodelist length in IE
- var length = !!obj && "length" in obj && obj.length,
- type = toType( obj );
-
- if ( isFunction( obj ) || isWindow( obj ) ) {
- return false;
- }
-
- return type === "array" || length === 0 ||
- typeof length === "number" && length > 0 && ( length - 1 ) in obj;
-}
-var Sizzle =
-/*!
- * Sizzle CSS Selector Engine v2.3.6
- * https://sizzlejs.com/
- *
- * Copyright JS Foundation and other contributors
- * Released under the MIT license
- * https://js.foundation/
- *
- * Date: 2021-02-16
- */
-( function( window ) {
-var i,
- support,
- Expr,
- getText,
- isXML,
- tokenize,
- compile,
- select,
- outermostContext,
- sortInput,
- hasDuplicate,
-
- // Local document vars
- setDocument,
- document,
- docElem,
- documentIsHTML,
- rbuggyQSA,
- rbuggyMatches,
- matches,
- contains,
-
- // Instance-specific data
- expando = "sizzle" + 1 * new Date(),
- preferredDoc = window.document,
- dirruns = 0,
- done = 0,
- classCache = createCache(),
- tokenCache = createCache(),
- compilerCache = createCache(),
- nonnativeSelectorCache = createCache(),
- sortOrder = function( a, b ) {
- if ( a === b ) {
- hasDuplicate = true;
- }
- return 0;
- },
-
- // Instance methods
- hasOwn = ( {} ).hasOwnProperty,
- arr = [],
- pop = arr.pop,
- pushNative = arr.push,
- push = arr.push,
- slice = arr.slice,
-
- // Use a stripped-down indexOf as it's faster than native
- // https://jsperf.com/thor-indexof-vs-for/5
- indexOf = function( list, elem ) {
- var i = 0,
- len = list.length;
- for ( ; i < len; i++ ) {
- if ( list[ i ] === elem ) {
- return i;
- }
- }
- return -1;
- },
-
- booleans = "checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|" +
- "ismap|loop|multiple|open|readonly|required|scoped",
-
- // Regular expressions
-
- // http://www.w3.org/TR/css3-selectors/#whitespace
- whitespace = "[\\x20\\t\\r\\n\\f]",
-
- // https://www.w3.org/TR/css-syntax-3/#ident-token-diagram
- identifier = "(?:\\\\[\\da-fA-F]{1,6}" + whitespace +
- "?|\\\\[^\\r\\n\\f]|[\\w-]|[^\0-\\x7f])+",
-
- // Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
- attributes = "\\[" + whitespace + "*(" + identifier + ")(?:" + whitespace +
-
- // Operator (capture 2)
- "*([*^$|!~]?=)" + whitespace +
-
- // "Attribute values must be CSS identifiers [capture 5]
- // or strings [capture 3 or capture 4]"
- "*(?:'((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\"|(" + identifier + "))|)" +
- whitespace + "*\\]",
-
- pseudos = ":(" + identifier + ")(?:\\((" +
-
- // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
- // 1. quoted (capture 3; capture 4 or capture 5)
- "('((?:\\\\.|[^\\\\'])*)'|\"((?:\\\\.|[^\\\\\"])*)\")|" +
-
- // 2. simple (capture 6)
- "((?:\\\\.|[^\\\\()[\\]]|" + attributes + ")*)|" +
-
- // 3. anything else (capture 2)
- ".*" +
- ")\\)|)",
-
- // Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
- rwhitespace = new RegExp( whitespace + "+", "g" ),
- rtrim = new RegExp( "^" + whitespace + "+|((?:^|[^\\\\])(?:\\\\.)*)" +
- whitespace + "+$", "g" ),
-
- rcomma = new RegExp( "^" + whitespace + "*," + whitespace + "*" ),
- rcombinators = new RegExp( "^" + whitespace + "*([>+~]|" + whitespace + ")" + whitespace +
- "*" ),
- rdescend = new RegExp( whitespace + "|>" ),
-
- rpseudo = new RegExp( pseudos ),
- ridentifier = new RegExp( "^" + identifier + "$" ),
-
- matchExpr = {
- "ID": new RegExp( "^#(" + identifier + ")" ),
- "CLASS": new RegExp( "^\\.(" + identifier + ")" ),
- "TAG": new RegExp( "^(" + identifier + "|[*])" ),
- "ATTR": new RegExp( "^" + attributes ),
- "PSEUDO": new RegExp( "^" + pseudos ),
- "CHILD": new RegExp( "^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(" +
- whitespace + "*(even|odd|(([+-]|)(\\d*)n|)" + whitespace + "*(?:([+-]|)" +
- whitespace + "*(\\d+)|))" + whitespace + "*\\)|)", "i" ),
- "bool": new RegExp( "^(?:" + booleans + ")$", "i" ),
-
- // For use in libraries implementing .is()
- // We use this for POS matching in `select`
- "needsContext": new RegExp( "^" + whitespace +
- "*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(" + whitespace +
- "*((?:-\\d)?\\d*)" + whitespace + "*\\)|)(?=[^-]|$)", "i" )
- },
-
- rhtml = /HTML$/i,
- rinputs = /^(?:input|select|textarea|button)$/i,
- rheader = /^h\d$/i,
-
- rnative = /^[^{]+\{\s*\[native \w/,
-
- // Easily-parseable/retrievable ID or TAG or CLASS selectors
- rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/,
-
- rsibling = /[+~]/,
-
- // CSS escapes
- // http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
- runescape = new RegExp( "\\\\[\\da-fA-F]{1,6}" + whitespace + "?|\\\\([^\\r\\n\\f])", "g" ),
- funescape = function( escape, nonHex ) {
- var high = "0x" + escape.slice( 1 ) - 0x10000;
-
- return nonHex ?
-
- // Strip the backslash prefix from a non-hex escape sequence
- nonHex :
-
- // Replace a hexadecimal escape sequence with the encoded Unicode code point
- // Support: IE <=11+
- // For values outside the Basic Multilingual Plane (BMP), manually construct a
- // surrogate pair
- high < 0 ?
- String.fromCharCode( high + 0x10000 ) :
- String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
- },
-
- // CSS string/identifier serialization
- // https://drafts.csswg.org/cssom/#common-serializing-idioms
- rcssescape = /([\0-\x1f\x7f]|^-?\d)|^-$|[^\0-\x1f\x7f-\uFFFF\w-]/g,
- fcssescape = function( ch, asCodePoint ) {
- if ( asCodePoint ) {
-
- // U+0000 NULL becomes U+FFFD REPLACEMENT CHARACTER
- if ( ch === "\0" ) {
- return "\uFFFD";
- }
-
- // Control characters and (dependent upon position) numbers get escaped as code points
- return ch.slice( 0, -1 ) + "\\" +
- ch.charCodeAt( ch.length - 1 ).toString( 16 ) + " ";
- }
-
- // Other potentially-special ASCII characters get backslash-escaped
- return "\\" + ch;
- },
-
- // Used for iframes
- // See setDocument()
- // Removing the function wrapper causes a "Permission Denied"
- // error in IE
- unloadHandler = function() {
- setDocument();
- },
-
- inDisabledFieldset = addCombinator(
- function( elem ) {
- return elem.disabled === true && elem.nodeName.toLowerCase() === "fieldset";
- },
- { dir: "parentNode", next: "legend" }
- );
-
-// Optimize for push.apply( _, NodeList )
-try {
- push.apply(
- ( arr = slice.call( preferredDoc.childNodes ) ),
- preferredDoc.childNodes
- );
-
- // Support: Android<4.0
- // Detect silently failing push.apply
- // eslint-disable-next-line no-unused-expressions
- arr[ preferredDoc.childNodes.length ].nodeType;
-} catch ( e ) {
- push = { apply: arr.length ?
-
- // Leverage slice if possible
- function( target, els ) {
- pushNative.apply( target, slice.call( els ) );
- } :
-
- // Support: IE<9
- // Otherwise append directly
- function( target, els ) {
- var j = target.length,
- i = 0;
-
- // Can't trust NodeList.length
- while ( ( target[ j++ ] = els[ i++ ] ) ) {}
- target.length = j - 1;
- }
- };
-}
-
-function Sizzle( selector, context, results, seed ) {
- var m, i, elem, nid, match, groups, newSelector,
- newContext = context && context.ownerDocument,
-
- // nodeType defaults to 9, since context defaults to document
- nodeType = context ? context.nodeType : 9;
-
- results = results || [];
-
- // Return early from calls with invalid selector or context
- if ( typeof selector !== "string" || !selector ||
- nodeType !== 1 && nodeType !== 9 && nodeType !== 11 ) {
-
- return results;
- }
-
- // Try to shortcut find operations (as opposed to filters) in HTML documents
- if ( !seed ) {
- setDocument( context );
- context = context || document;
-
- if ( documentIsHTML ) {
-
- // If the selector is sufficiently simple, try using a "get*By*" DOM method
- // (excepting DocumentFragment context, where the methods don't exist)
- if ( nodeType !== 11 && ( match = rquickExpr.exec( selector ) ) ) {
-
- // ID selector
- if ( ( m = match[ 1 ] ) ) {
-
- // Document context
- if ( nodeType === 9 ) {
- if ( ( elem = context.getElementById( m ) ) ) {
-
- // Support: IE, Opera, Webkit
- // TODO: identify versions
- // getElementById can match elements by name instead of ID
- if ( elem.id === m ) {
- results.push( elem );
- return results;
- }
- } else {
- return results;
- }
-
- // Element context
- } else {
-
- // Support: IE, Opera, Webkit
- // TODO: identify versions
- // getElementById can match elements by name instead of ID
- if ( newContext && ( elem = newContext.getElementById( m ) ) &&
- contains( context, elem ) &&
- elem.id === m ) {
-
- results.push( elem );
- return results;
- }
- }
-
- // Type selector
- } else if ( match[ 2 ] ) {
- push.apply( results, context.getElementsByTagName( selector ) );
- return results;
-
- // Class selector
- } else if ( ( m = match[ 3 ] ) && support.getElementsByClassName &&
- context.getElementsByClassName ) {
-
- push.apply( results, context.getElementsByClassName( m ) );
- return results;
- }
- }
-
- // Take advantage of querySelectorAll
- if ( support.qsa &&
- !nonnativeSelectorCache[ selector + " " ] &&
- ( !rbuggyQSA || !rbuggyQSA.test( selector ) ) &&
-
- // Support: IE 8 only
- // Exclude object elements
- ( nodeType !== 1 || context.nodeName.toLowerCase() !== "object" ) ) {
-
- newSelector = selector;
- newContext = context;
-
- // qSA considers elements outside a scoping root when evaluating child or
- // descendant combinators, which is not what we want.
- // In such cases, we work around the behavior by prefixing every selector in the
- // list with an ID selector referencing the scope context.
- // The technique has to be used as well when a leading combinator is used
- // as such selectors are not recognized by querySelectorAll.
- // Thanks to Andrew Dupont for this technique.
- if ( nodeType === 1 &&
- ( rdescend.test( selector ) || rcombinators.test( selector ) ) ) {
-
- // Expand context for sibling selectors
- newContext = rsibling.test( selector ) && testContext( context.parentNode ) ||
- context;
-
- // We can use :scope instead of the ID hack if the browser
- // supports it & if we're not changing the context.
- if ( newContext !== context || !support.scope ) {
-
- // Capture the context ID, setting it first if necessary
- if ( ( nid = context.getAttribute( "id" ) ) ) {
- nid = nid.replace( rcssescape, fcssescape );
- } else {
- context.setAttribute( "id", ( nid = expando ) );
- }
- }
-
- // Prefix every selector in the list
- groups = tokenize( selector );
- i = groups.length;
- while ( i-- ) {
- groups[ i ] = ( nid ? "#" + nid : ":scope" ) + " " +
- toSelector( groups[ i ] );
- }
- newSelector = groups.join( "," );
- }
-
- try {
- push.apply( results,
- newContext.querySelectorAll( newSelector )
- );
- return results;
- } catch ( qsaError ) {
- nonnativeSelectorCache( selector, true );
- } finally {
- if ( nid === expando ) {
- context.removeAttribute( "id" );
- }
- }
- }
- }
- }
-
- // All others
- return select( selector.replace( rtrim, "$1" ), context, results, seed );
-}
-
-/**
- * Create key-value caches of limited size
- * @returns {function(string, object)} Returns the Object data after storing it on itself with
- * property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
- * deleting the oldest entry
- */
-function createCache() {
- var keys = [];
-
- function cache( key, value ) {
-
- // Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
- if ( keys.push( key + " " ) > Expr.cacheLength ) {
-
- // Only keep the most recent entries
- delete cache[ keys.shift() ];
- }
- return ( cache[ key + " " ] = value );
- }
- return cache;
-}
-
-/**
- * Mark a function for special use by Sizzle
- * @param {Function} fn The function to mark
- */
-function markFunction( fn ) {
- fn[ expando ] = true;
- return fn;
-}
-
-/**
- * Support testing using an element
- * @param {Function} fn Passed the created element and returns a boolean result
- */
-function assert( fn ) {
- var el = document.createElement( "fieldset" );
-
- try {
- return !!fn( el );
- } catch ( e ) {
- return false;
- } finally {
-
- // Remove from its parent by default
- if ( el.parentNode ) {
- el.parentNode.removeChild( el );
- }
-
- // release memory in IE
- el = null;
- }
-}
-
-/**
- * Adds the same handler for all of the specified attrs
- * @param {String} attrs Pipe-separated list of attributes
- * @param {Function} handler The method that will be applied
- */
-function addHandle( attrs, handler ) {
- var arr = attrs.split( "|" ),
- i = arr.length;
-
- while ( i-- ) {
- Expr.attrHandle[ arr[ i ] ] = handler;
- }
-}
-
-/**
- * Checks document order of two siblings
- * @param {Element} a
- * @param {Element} b
- * @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
- */
-function siblingCheck( a, b ) {
- var cur = b && a,
- diff = cur && a.nodeType === 1 && b.nodeType === 1 &&
- a.sourceIndex - b.sourceIndex;
-
- // Use IE sourceIndex if available on both nodes
- if ( diff ) {
- return diff;
- }
-
- // Check if b follows a
- if ( cur ) {
- while ( ( cur = cur.nextSibling ) ) {
- if ( cur === b ) {
- return -1;
- }
- }
- }
-
- return a ? 1 : -1;
-}
-
-/**
- * Returns a function to use in pseudos for input types
- * @param {String} type
- */
-function createInputPseudo( type ) {
- return function( elem ) {
- var name = elem.nodeName.toLowerCase();
- return name === "input" && elem.type === type;
- };
-}
-
-/**
- * Returns a function to use in pseudos for buttons
- * @param {String} type
- */
-function createButtonPseudo( type ) {
- return function( elem ) {
- var name = elem.nodeName.toLowerCase();
- return ( name === "input" || name === "button" ) && elem.type === type;
- };
-}
-
-/**
- * Returns a function to use in pseudos for :enabled/:disabled
- * @param {Boolean} disabled true for :disabled; false for :enabled
- */
-function createDisabledPseudo( disabled ) {
-
- // Known :disabled false positives: fieldset[disabled] > legend:nth-of-type(n+2) :can-disable
- return function( elem ) {
-
- // Only certain elements can match :enabled or :disabled
- // https://html.spec.whatwg.org/multipage/scripting.html#selector-enabled
- // https://html.spec.whatwg.org/multipage/scripting.html#selector-disabled
- if ( "form" in elem ) {
-
- // Check for inherited disabledness on relevant non-disabled elements:
- // * listed form-associated elements in a disabled fieldset
- // https://html.spec.whatwg.org/multipage/forms.html#category-listed
- // https://html.spec.whatwg.org/multipage/forms.html#concept-fe-disabled
- // * option elements in a disabled optgroup
- // https://html.spec.whatwg.org/multipage/forms.html#concept-option-disabled
- // All such elements have a "form" property.
- if ( elem.parentNode && elem.disabled === false ) {
-
- // Option elements defer to a parent optgroup if present
- if ( "label" in elem ) {
- if ( "label" in elem.parentNode ) {
- return elem.parentNode.disabled === disabled;
- } else {
- return elem.disabled === disabled;
- }
- }
-
- // Support: IE 6 - 11
- // Use the isDisabled shortcut property to check for disabled fieldset ancestors
- return elem.isDisabled === disabled ||
-
- // Where there is no isDisabled, check manually
- /* jshint -W018 */
- elem.isDisabled !== !disabled &&
- inDisabledFieldset( elem ) === disabled;
- }
-
- return elem.disabled === disabled;
-
- // Try to winnow out elements that can't be disabled before trusting the disabled property.
- // Some victims get caught in our net (label, legend, menu, track), but it shouldn't
- // even exist on them, let alone have a boolean value.
- } else if ( "label" in elem ) {
- return elem.disabled === disabled;
- }
-
- // Remaining elements are neither :enabled nor :disabled
- return false;
- };
-}
-
-/**
- * Returns a function to use in pseudos for positionals
- * @param {Function} fn
- */
-function createPositionalPseudo( fn ) {
- return markFunction( function( argument ) {
- argument = +argument;
- return markFunction( function( seed, matches ) {
- var j,
- matchIndexes = fn( [], seed.length, argument ),
- i = matchIndexes.length;
-
- // Match elements found at the specified indexes
- while ( i-- ) {
- if ( seed[ ( j = matchIndexes[ i ] ) ] ) {
- seed[ j ] = !( matches[ j ] = seed[ j ] );
- }
- }
- } );
- } );
-}
-
-/**
- * Checks a node for validity as a Sizzle context
- * @param {Element|Object=} context
- * @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
- */
-function testContext( context ) {
- return context && typeof context.getElementsByTagName !== "undefined" && context;
-}
-
-// Expose support vars for convenience
-support = Sizzle.support = {};
-
-/**
- * Detects XML nodes
- * @param {Element|Object} elem An element or a document
- * @returns {Boolean} True iff elem is a non-HTML XML node
- */
-isXML = Sizzle.isXML = function( elem ) {
- var namespace = elem && elem.namespaceURI,
- docElem = elem && ( elem.ownerDocument || elem ).documentElement;
-
- // Support: IE <=8
- // Assume HTML when documentElement doesn't yet exist, such as inside loading iframes
- // https://bugs.jquery.com/ticket/4833
- return !rhtml.test( namespace || docElem && docElem.nodeName || "HTML" );
-};
-
-/**
- * Sets document-related variables once based on the current document
- * @param {Element|Object} [doc] An element or document object to use to set the document
- * @returns {Object} Returns the current document
- */
-setDocument = Sizzle.setDocument = function( node ) {
- var hasCompare, subWindow,
- doc = node ? node.ownerDocument || node : preferredDoc;
-
- // Return early if doc is invalid or already selected
- // Support: IE 11+, Edge 17 - 18+
- // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
- // two documents; shallow comparisons work.
- // eslint-disable-next-line eqeqeq
- if ( doc == document || doc.nodeType !== 9 || !doc.documentElement ) {
- return document;
- }
-
- // Update global variables
- document = doc;
- docElem = document.documentElement;
- documentIsHTML = !isXML( document );
-
- // Support: IE 9 - 11+, Edge 12 - 18+
- // Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
- // Support: IE 11+, Edge 17 - 18+
- // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
- // two documents; shallow comparisons work.
- // eslint-disable-next-line eqeqeq
- if ( preferredDoc != document &&
- ( subWindow = document.defaultView ) && subWindow.top !== subWindow ) {
-
- // Support: IE 11, Edge
- if ( subWindow.addEventListener ) {
- subWindow.addEventListener( "unload", unloadHandler, false );
-
- // Support: IE 9 - 10 only
- } else if ( subWindow.attachEvent ) {
- subWindow.attachEvent( "onunload", unloadHandler );
- }
- }
-
- // Support: IE 8 - 11+, Edge 12 - 18+, Chrome <=16 - 25 only, Firefox <=3.6 - 31 only,
- // Safari 4 - 5 only, Opera <=11.6 - 12.x only
- // IE/Edge & older browsers don't support the :scope pseudo-class.
- // Support: Safari 6.0 only
- // Safari 6.0 supports :scope but it's an alias of :root there.
- support.scope = assert( function( el ) {
- docElem.appendChild( el ).appendChild( document.createElement( "div" ) );
- return typeof el.querySelectorAll !== "undefined" &&
- !el.querySelectorAll( ":scope fieldset div" ).length;
- } );
-
- /* Attributes
- ---------------------------------------------------------------------- */
-
- // Support: IE<8
- // Verify that getAttribute really returns attributes and not properties
- // (excepting IE8 booleans)
- support.attributes = assert( function( el ) {
- el.className = "i";
- return !el.getAttribute( "className" );
- } );
-
- /* getElement(s)By*
- ---------------------------------------------------------------------- */
-
- // Check if getElementsByTagName("*") returns only elements
- support.getElementsByTagName = assert( function( el ) {
- el.appendChild( document.createComment( "" ) );
- return !el.getElementsByTagName( "*" ).length;
- } );
-
- // Support: IE<9
- support.getElementsByClassName = rnative.test( document.getElementsByClassName );
-
- // Support: IE<10
- // Check if getElementById returns elements by name
- // The broken getElementById methods don't pick up programmatically-set names,
- // so use a roundabout getElementsByName test
- support.getById = assert( function( el ) {
- docElem.appendChild( el ).id = expando;
- return !document.getElementsByName || !document.getElementsByName( expando ).length;
- } );
-
- // ID filter and find
- if ( support.getById ) {
- Expr.filter[ "ID" ] = function( id ) {
- var attrId = id.replace( runescape, funescape );
- return function( elem ) {
- return elem.getAttribute( "id" ) === attrId;
- };
- };
- Expr.find[ "ID" ] = function( id, context ) {
- if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
- var elem = context.getElementById( id );
- return elem ? [ elem ] : [];
- }
- };
- } else {
- Expr.filter[ "ID" ] = function( id ) {
- var attrId = id.replace( runescape, funescape );
- return function( elem ) {
- var node = typeof elem.getAttributeNode !== "undefined" &&
- elem.getAttributeNode( "id" );
- return node && node.value === attrId;
- };
- };
-
- // Support: IE 6 - 7 only
- // getElementById is not reliable as a find shortcut
- Expr.find[ "ID" ] = function( id, context ) {
- if ( typeof context.getElementById !== "undefined" && documentIsHTML ) {
- var node, i, elems,
- elem = context.getElementById( id );
-
- if ( elem ) {
-
- // Verify the id attribute
- node = elem.getAttributeNode( "id" );
- if ( node && node.value === id ) {
- return [ elem ];
- }
-
- // Fall back on getElementsByName
- elems = context.getElementsByName( id );
- i = 0;
- while ( ( elem = elems[ i++ ] ) ) {
- node = elem.getAttributeNode( "id" );
- if ( node && node.value === id ) {
- return [ elem ];
- }
- }
- }
-
- return [];
- }
- };
- }
-
- // Tag
- Expr.find[ "TAG" ] = support.getElementsByTagName ?
- function( tag, context ) {
- if ( typeof context.getElementsByTagName !== "undefined" ) {
- return context.getElementsByTagName( tag );
-
- // DocumentFragment nodes don't have gEBTN
- } else if ( support.qsa ) {
- return context.querySelectorAll( tag );
- }
- } :
-
- function( tag, context ) {
- var elem,
- tmp = [],
- i = 0,
-
- // By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
- results = context.getElementsByTagName( tag );
-
- // Filter out possible comments
- if ( tag === "*" ) {
- while ( ( elem = results[ i++ ] ) ) {
- if ( elem.nodeType === 1 ) {
- tmp.push( elem );
- }
- }
-
- return tmp;
- }
- return results;
- };
-
- // Class
- Expr.find[ "CLASS" ] = support.getElementsByClassName && function( className, context ) {
- if ( typeof context.getElementsByClassName !== "undefined" && documentIsHTML ) {
- return context.getElementsByClassName( className );
- }
- };
-
- /* QSA/matchesSelector
- ---------------------------------------------------------------------- */
-
- // QSA and matchesSelector support
-
- // matchesSelector(:active) reports false when true (IE9/Opera 11.5)
- rbuggyMatches = [];
-
- // qSa(:focus) reports false when true (Chrome 21)
- // We allow this because of a bug in IE8/9 that throws an error
- // whenever `document.activeElement` is accessed on an iframe
- // So, we allow :focus to pass through QSA all the time to avoid the IE error
- // See https://bugs.jquery.com/ticket/13378
- rbuggyQSA = [];
-
- if ( ( support.qsa = rnative.test( document.querySelectorAll ) ) ) {
-
- // Build QSA regex
- // Regex strategy adopted from Diego Perini
- assert( function( el ) {
-
- var input;
-
- // Select is set to empty string on purpose
- // This is to test IE's treatment of not explicitly
- // setting a boolean content attribute,
- // since its presence should be enough
- // https://bugs.jquery.com/ticket/12359
- docElem.appendChild( el ).innerHTML = "" +
- " ";
-
- // Support: IE8, Opera 11-12.16
- // Nothing should be selected when empty strings follow ^= or $= or *=
- // The test attribute must be unknown in Opera but "safe" for WinRT
- // https://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
- if ( el.querySelectorAll( "[msallowcapture^='']" ).length ) {
- rbuggyQSA.push( "[*^$]=" + whitespace + "*(?:''|\"\")" );
- }
-
- // Support: IE8
- // Boolean attributes and "value" are not treated correctly
- if ( !el.querySelectorAll( "[selected]" ).length ) {
- rbuggyQSA.push( "\\[" + whitespace + "*(?:value|" + booleans + ")" );
- }
-
- // Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
- if ( !el.querySelectorAll( "[id~=" + expando + "-]" ).length ) {
- rbuggyQSA.push( "~=" );
- }
-
- // Support: IE 11+, Edge 15 - 18+
- // IE 11/Edge don't find elements on a `[name='']` query in some cases.
- // Adding a temporary attribute to the document before the selection works
- // around the issue.
- // Interestingly, IE 10 & older don't seem to have the issue.
- input = document.createElement( "input" );
- input.setAttribute( "name", "" );
- el.appendChild( input );
- if ( !el.querySelectorAll( "[name='']" ).length ) {
- rbuggyQSA.push( "\\[" + whitespace + "*name" + whitespace + "*=" +
- whitespace + "*(?:''|\"\")" );
- }
-
- // Webkit/Opera - :checked should return selected option elements
- // http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
- // IE8 throws error here and will not see later tests
- if ( !el.querySelectorAll( ":checked" ).length ) {
- rbuggyQSA.push( ":checked" );
- }
-
- // Support: Safari 8+, iOS 8+
- // https://bugs.webkit.org/show_bug.cgi?id=136851
- // In-page `selector#id sibling-combinator selector` fails
- if ( !el.querySelectorAll( "a#" + expando + "+*" ).length ) {
- rbuggyQSA.push( ".#.+[+~]" );
- }
-
- // Support: Firefox <=3.6 - 5 only
- // Old Firefox doesn't throw on a badly-escaped identifier.
- el.querySelectorAll( "\\\f" );
- rbuggyQSA.push( "[\\r\\n\\f]" );
- } );
-
- assert( function( el ) {
- el.innerHTML = ") matching elements by id
- for ( ; i !== len && ( elem = elems[ i ] ) != null; i++ ) {
- if ( byElement && elem ) {
- j = 0;
-
- // Support: IE 11+, Edge 17 - 18+
- // IE/Edge sometimes throw a "Permission denied" error when strict-comparing
- // two documents; shallow comparisons work.
- // eslint-disable-next-line eqeqeq
- if ( !context && elem.ownerDocument != document ) {
- setDocument( elem );
- xml = !documentIsHTML;
- }
- while ( ( matcher = elementMatchers[ j++ ] ) ) {
- if ( matcher( elem, context || document, xml ) ) {
- results.push( elem );
- break;
- }
- }
- if ( outermost ) {
- dirruns = dirrunsUnique;
- }
- }
-
- // Track unmatched elements for set filters
- if ( bySet ) {
-
- // They will have gone through all possible matchers
- if ( ( elem = !matcher && elem ) ) {
- matchedCount--;
- }
-
- // Lengthen the array for every element, matched or not
- if ( seed ) {
- unmatched.push( elem );
- }
- }
- }
-
- // `i` is now the count of elements visited above, and adding it to `matchedCount`
- // makes the latter nonnegative.
- matchedCount += i;
-
- // Apply set filters to unmatched elements
- // NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
- // equals `i`), unless we didn't visit _any_ elements in the above loop because we have
- // no element matchers and no seed.
- // Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
- // case, which will result in a "00" `matchedCount` that differs from `i` but is also
- // numerically zero.
- if ( bySet && i !== matchedCount ) {
- j = 0;
- while ( ( matcher = setMatchers[ j++ ] ) ) {
- matcher( unmatched, setMatched, context, xml );
- }
-
- if ( seed ) {
-
- // Reintegrate element matches to eliminate the need for sorting
- if ( matchedCount > 0 ) {
- while ( i-- ) {
- if ( !( unmatched[ i ] || setMatched[ i ] ) ) {
- setMatched[ i ] = pop.call( results );
- }
- }
- }
-
- // Discard index placeholder values to get only actual matches
- setMatched = condense( setMatched );
- }
-
- // Add matches to results
- push.apply( results, setMatched );
-
- // Seedless set matches succeeding multiple successful matchers stipulate sorting
- if ( outermost && !seed && setMatched.length > 0 &&
- ( matchedCount + setMatchers.length ) > 1 ) {
-
- Sizzle.uniqueSort( results );
- }
- }
-
- // Override manipulation of globals by nested matchers
- if ( outermost ) {
- dirruns = dirrunsUnique;
- outermostContext = contextBackup;
- }
-
- return unmatched;
- };
-
- return bySet ?
- markFunction( superMatcher ) :
- superMatcher;
-}
-
-compile = Sizzle.compile = function( selector, match /* Internal Use Only */ ) {
- var i,
- setMatchers = [],
- elementMatchers = [],
- cached = compilerCache[ selector + " " ];
-
- if ( !cached ) {
-
- // Generate a function of recursive functions that can be used to check each element
- if ( !match ) {
- match = tokenize( selector );
- }
- i = match.length;
- while ( i-- ) {
- cached = matcherFromTokens( match[ i ] );
- if ( cached[ expando ] ) {
- setMatchers.push( cached );
- } else {
- elementMatchers.push( cached );
- }
- }
-
- // Cache the compiled function
- cached = compilerCache(
- selector,
- matcherFromGroupMatchers( elementMatchers, setMatchers )
- );
-
- // Save selector and tokenization
- cached.selector = selector;
- }
- return cached;
-};
-
-/**
- * A low-level selection function that works with Sizzle's compiled
- * selector functions
- * @param {String|Function} selector A selector or a pre-compiled
- * selector function built with Sizzle.compile
- * @param {Element} context
- * @param {Array} [results]
- * @param {Array} [seed] A set of elements to match against
- */
-select = Sizzle.select = function( selector, context, results, seed ) {
- var i, tokens, token, type, find,
- compiled = typeof selector === "function" && selector,
- match = !seed && tokenize( ( selector = compiled.selector || selector ) );
-
- results = results || [];
-
- // Try to minimize operations if there is only one selector in the list and no seed
- // (the latter of which guarantees us context)
- if ( match.length === 1 ) {
-
- // Reduce context if the leading compound selector is an ID
- tokens = match[ 0 ] = match[ 0 ].slice( 0 );
- if ( tokens.length > 2 && ( token = tokens[ 0 ] ).type === "ID" &&
- context.nodeType === 9 && documentIsHTML && Expr.relative[ tokens[ 1 ].type ] ) {
-
- context = ( Expr.find[ "ID" ]( token.matches[ 0 ]
- .replace( runescape, funescape ), context ) || [] )[ 0 ];
- if ( !context ) {
- return results;
-
- // Precompiled matchers will still verify ancestry, so step up a level
- } else if ( compiled ) {
- context = context.parentNode;
- }
-
- selector = selector.slice( tokens.shift().value.length );
- }
-
- // Fetch a seed set for right-to-left matching
- i = matchExpr[ "needsContext" ].test( selector ) ? 0 : tokens.length;
- while ( i-- ) {
- token = tokens[ i ];
-
- // Abort if we hit a combinator
- if ( Expr.relative[ ( type = token.type ) ] ) {
- break;
- }
- if ( ( find = Expr.find[ type ] ) ) {
-
- // Search, expanding context for leading sibling combinators
- if ( ( seed = find(
- token.matches[ 0 ].replace( runescape, funescape ),
- rsibling.test( tokens[ 0 ].type ) && testContext( context.parentNode ) ||
- context
- ) ) ) {
-
- // If seed is empty or no tokens remain, we can return early
- tokens.splice( i, 1 );
- selector = seed.length && toSelector( tokens );
- if ( !selector ) {
- push.apply( results, seed );
- return results;
- }
-
- break;
- }
- }
- }
- }
-
- // Compile and execute a filtering function if one is not provided
- // Provide `match` to avoid retokenization if we modified the selector above
- ( compiled || compile( selector, match ) )(
- seed,
- context,
- !documentIsHTML,
- results,
- !context || rsibling.test( selector ) && testContext( context.parentNode ) || context
- );
- return results;
-};
-
-// One-time assignments
-
-// Sort stability
-support.sortStable = expando.split( "" ).sort( sortOrder ).join( "" ) === expando;
-
-// Support: Chrome 14-35+
-// Always assume duplicates if they aren't passed to the comparison function
-support.detectDuplicates = !!hasDuplicate;
-
-// Initialize against the default document
-setDocument();
-
-// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
-// Detached nodes confoundingly follow *each other*
-support.sortDetached = assert( function( el ) {
-
- // Should return 1, but returns 4 (following)
- return el.compareDocumentPosition( document.createElement( "fieldset" ) ) & 1;
-} );
-
-// Support: IE<8
-// Prevent attribute/property "interpolation"
-// https://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
-if ( !assert( function( el ) {
- el.innerHTML = " to avoid XSS via location.hash (#9521)
- // Strict HTML recognition (#11290: must start with <)
- // Shortcut simple #id case for speed
- rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]+))$/,
-
- init = jQuery.fn.init = function( selector, context, root ) {
- var match, elem;
-
- // HANDLE: $(""), $(null), $(undefined), $(false)
- if ( !selector ) {
- return this;
- }
-
- // Method init() accepts an alternate rootjQuery
- // so migrate can support jQuery.sub (gh-2101)
- root = root || rootjQuery;
-
- // Handle HTML strings
- if ( typeof selector === "string" ) {
- if ( selector[ 0 ] === "<" &&
- selector[ selector.length - 1 ] === ">" &&
- selector.length >= 3 ) {
-
- // Assume that strings that start and end with <> are HTML and skip the regex check
- match = [ null, selector, null ];
-
- } else {
- match = rquickExpr.exec( selector );
- }
-
- // Match html or make sure no context is specified for #id
- if ( match && ( match[ 1 ] || !context ) ) {
-
- // HANDLE: $(html) -> $(array)
- if ( match[ 1 ] ) {
- context = context instanceof jQuery ? context[ 0 ] : context;
-
- // Option to run scripts is true for back-compat
- // Intentionally let the error be thrown if parseHTML is not present
- jQuery.merge( this, jQuery.parseHTML(
- match[ 1 ],
- context && context.nodeType ? context.ownerDocument || context : document,
- true
- ) );
-
- // HANDLE: $(html, props)
- if ( rsingleTag.test( match[ 1 ] ) && jQuery.isPlainObject( context ) ) {
- for ( match in context ) {
-
- // Properties of context are called as methods if possible
- if ( isFunction( this[ match ] ) ) {
- this[ match ]( context[ match ] );
-
- // ...and otherwise set as attributes
- } else {
- this.attr( match, context[ match ] );
- }
- }
- }
-
- return this;
-
- // HANDLE: $(#id)
- } else {
- elem = document.getElementById( match[ 2 ] );
-
- if ( elem ) {
-
- // Inject the element directly into the jQuery object
- this[ 0 ] = elem;
- this.length = 1;
- }
- return this;
- }
-
- // HANDLE: $(expr, $(...))
- } else if ( !context || context.jquery ) {
- return ( context || root ).find( selector );
-
- // HANDLE: $(expr, context)
- // (which is just equivalent to: $(context).find(expr)
- } else {
- return this.constructor( context ).find( selector );
- }
-
- // HANDLE: $(DOMElement)
- } else if ( selector.nodeType ) {
- this[ 0 ] = selector;
- this.length = 1;
- return this;
-
- // HANDLE: $(function)
- // Shortcut for document ready
- } else if ( isFunction( selector ) ) {
- return root.ready !== undefined ?
- root.ready( selector ) :
-
- // Execute immediately if ready is not present
- selector( jQuery );
- }
-
- return jQuery.makeArray( selector, this );
- };
-
-// Give the init function the jQuery prototype for later instantiation
-init.prototype = jQuery.fn;
-
-// Initialize central reference
-rootjQuery = jQuery( document );
-
-
-var rparentsprev = /^(?:parents|prev(?:Until|All))/,
-
- // Methods guaranteed to produce a unique set when starting from a unique set
- guaranteedUnique = {
- children: true,
- contents: true,
- next: true,
- prev: true
- };
-
-jQuery.fn.extend( {
- has: function( target ) {
- var targets = jQuery( target, this ),
- l = targets.length;
-
- return this.filter( function() {
- var i = 0;
- for ( ; i < l; i++ ) {
- if ( jQuery.contains( this, targets[ i ] ) ) {
- return true;
- }
- }
- } );
- },
-
- closest: function( selectors, context ) {
- var cur,
- i = 0,
- l = this.length,
- matched = [],
- targets = typeof selectors !== "string" && jQuery( selectors );
-
- // Positional selectors never match, since there's no _selection_ context
- if ( !rneedsContext.test( selectors ) ) {
- for ( ; i < l; i++ ) {
- for ( cur = this[ i ]; cur && cur !== context; cur = cur.parentNode ) {
-
- // Always skip document fragments
- if ( cur.nodeType < 11 && ( targets ?
- targets.index( cur ) > -1 :
-
- // Don't pass non-elements to Sizzle
- cur.nodeType === 1 &&
- jQuery.find.matchesSelector( cur, selectors ) ) ) {
-
- matched.push( cur );
- break;
- }
- }
- }
- }
-
- return this.pushStack( matched.length > 1 ? jQuery.uniqueSort( matched ) : matched );
- },
-
- // Determine the position of an element within the set
- index: function( elem ) {
-
- // No argument, return index in parent
- if ( !elem ) {
- return ( this[ 0 ] && this[ 0 ].parentNode ) ? this.first().prevAll().length : -1;
- }
-
- // Index in selector
- if ( typeof elem === "string" ) {
- return indexOf.call( jQuery( elem ), this[ 0 ] );
- }
-
- // Locate the position of the desired element
- return indexOf.call( this,
-
- // If it receives a jQuery object, the first element is used
- elem.jquery ? elem[ 0 ] : elem
- );
- },
-
- add: function( selector, context ) {
- return this.pushStack(
- jQuery.uniqueSort(
- jQuery.merge( this.get(), jQuery( selector, context ) )
- )
- );
- },
-
- addBack: function( selector ) {
- return this.add( selector == null ?
- this.prevObject : this.prevObject.filter( selector )
- );
- }
-} );
-
-function sibling( cur, dir ) {
- while ( ( cur = cur[ dir ] ) && cur.nodeType !== 1 ) {}
- return cur;
-}
-
-jQuery.each( {
- parent: function( elem ) {
- var parent = elem.parentNode;
- return parent && parent.nodeType !== 11 ? parent : null;
- },
- parents: function( elem ) {
- return dir( elem, "parentNode" );
- },
- parentsUntil: function( elem, _i, until ) {
- return dir( elem, "parentNode", until );
- },
- next: function( elem ) {
- return sibling( elem, "nextSibling" );
- },
- prev: function( elem ) {
- return sibling( elem, "previousSibling" );
- },
- nextAll: function( elem ) {
- return dir( elem, "nextSibling" );
- },
- prevAll: function( elem ) {
- return dir( elem, "previousSibling" );
- },
- nextUntil: function( elem, _i, until ) {
- return dir( elem, "nextSibling", until );
- },
- prevUntil: function( elem, _i, until ) {
- return dir( elem, "previousSibling", until );
- },
- siblings: function( elem ) {
- return siblings( ( elem.parentNode || {} ).firstChild, elem );
- },
- children: function( elem ) {
- return siblings( elem.firstChild );
- },
- contents: function( elem ) {
- if ( elem.contentDocument != null &&
-
- // Support: IE 11+
- // elements with no `data` attribute has an object
- // `contentDocument` with a `null` prototype.
- getProto( elem.contentDocument ) ) {
-
- return elem.contentDocument;
- }
-
- // Support: IE 9 - 11 only, iOS 7 only, Android Browser <=4.3 only
- // Treat the template element as a regular one in browsers that
- // don't support it.
- if ( nodeName( elem, "template" ) ) {
- elem = elem.content || elem;
- }
-
- return jQuery.merge( [], elem.childNodes );
- }
-}, function( name, fn ) {
- jQuery.fn[ name ] = function( until, selector ) {
- var matched = jQuery.map( this, fn, until );
-
- if ( name.slice( -5 ) !== "Until" ) {
- selector = until;
- }
-
- if ( selector && typeof selector === "string" ) {
- matched = jQuery.filter( selector, matched );
- }
-
- if ( this.length > 1 ) {
-
- // Remove duplicates
- if ( !guaranteedUnique[ name ] ) {
- jQuery.uniqueSort( matched );
- }
-
- // Reverse order for parents* and prev-derivatives
- if ( rparentsprev.test( name ) ) {
- matched.reverse();
- }
- }
-
- return this.pushStack( matched );
- };
-} );
-var rnothtmlwhite = ( /[^\x20\t\r\n\f]+/g );
-
-
-
-// Convert String-formatted options into Object-formatted ones
-function createOptions( options ) {
- var object = {};
- jQuery.each( options.match( rnothtmlwhite ) || [], function( _, flag ) {
- object[ flag ] = true;
- } );
- return object;
-}
-
-/*
- * Create a callback list using the following parameters:
- *
- * options: an optional list of space-separated options that will change how
- * the callback list behaves or a more traditional option object
- *
- * By default a callback list will act like an event callback list and can be
- * "fired" multiple times.
- *
- * Possible options:
- *
- * once: will ensure the callback list can only be fired once (like a Deferred)
- *
- * memory: will keep track of previous values and will call any callback added
- * after the list has been fired right away with the latest "memorized"
- * values (like a Deferred)
- *
- * unique: will ensure a callback can only be added once (no duplicate in the list)
- *
- * stopOnFalse: interrupt callings when a callback returns false
- *
- */
-jQuery.Callbacks = function( options ) {
-
- // Convert options from String-formatted to Object-formatted if needed
- // (we check in cache first)
- options = typeof options === "string" ?
- createOptions( options ) :
- jQuery.extend( {}, options );
-
- var // Flag to know if list is currently firing
- firing,
-
- // Last fire value for non-forgettable lists
- memory,
-
- // Flag to know if list was already fired
- fired,
-
- // Flag to prevent firing
- locked,
-
- // Actual callback list
- list = [],
-
- // Queue of execution data for repeatable lists
- queue = [],
-
- // Index of currently firing callback (modified by add/remove as needed)
- firingIndex = -1,
-
- // Fire callbacks
- fire = function() {
-
- // Enforce single-firing
- locked = locked || options.once;
-
- // Execute callbacks for all pending executions,
- // respecting firingIndex overrides and runtime changes
- fired = firing = true;
- for ( ; queue.length; firingIndex = -1 ) {
- memory = queue.shift();
- while ( ++firingIndex < list.length ) {
-
- // Run callback and check for early termination
- if ( list[ firingIndex ].apply( memory[ 0 ], memory[ 1 ] ) === false &&
- options.stopOnFalse ) {
-
- // Jump to end and forget the data so .add doesn't re-fire
- firingIndex = list.length;
- memory = false;
- }
- }
- }
-
- // Forget the data if we're done with it
- if ( !options.memory ) {
- memory = false;
- }
-
- firing = false;
-
- // Clean up if we're done firing for good
- if ( locked ) {
-
- // Keep an empty list if we have data for future add calls
- if ( memory ) {
- list = [];
-
- // Otherwise, this object is spent
- } else {
- list = "";
- }
- }
- },
-
- // Actual Callbacks object
- self = {
-
- // Add a callback or a collection of callbacks to the list
- add: function() {
- if ( list ) {
-
- // If we have memory from a past run, we should fire after adding
- if ( memory && !firing ) {
- firingIndex = list.length - 1;
- queue.push( memory );
- }
-
- ( function add( args ) {
- jQuery.each( args, function( _, arg ) {
- if ( isFunction( arg ) ) {
- if ( !options.unique || !self.has( arg ) ) {
- list.push( arg );
- }
- } else if ( arg && arg.length && toType( arg ) !== "string" ) {
-
- // Inspect recursively
- add( arg );
- }
- } );
- } )( arguments );
-
- if ( memory && !firing ) {
- fire();
- }
- }
- return this;
- },
-
- // Remove a callback from the list
- remove: function() {
- jQuery.each( arguments, function( _, arg ) {
- var index;
- while ( ( index = jQuery.inArray( arg, list, index ) ) > -1 ) {
- list.splice( index, 1 );
-
- // Handle firing indexes
- if ( index <= firingIndex ) {
- firingIndex--;
- }
- }
- } );
- return this;
- },
-
- // Check if a given callback is in the list.
- // If no argument is given, return whether or not list has callbacks attached.
- has: function( fn ) {
- return fn ?
- jQuery.inArray( fn, list ) > -1 :
- list.length > 0;
- },
-
- // Remove all callbacks from the list
- empty: function() {
- if ( list ) {
- list = [];
- }
- return this;
- },
-
- // Disable .fire and .add
- // Abort any current/pending executions
- // Clear all callbacks and values
- disable: function() {
- locked = queue = [];
- list = memory = "";
- return this;
- },
- disabled: function() {
- return !list;
- },
-
- // Disable .fire
- // Also disable .add unless we have memory (since it would have no effect)
- // Abort any pending executions
- lock: function() {
- locked = queue = [];
- if ( !memory && !firing ) {
- list = memory = "";
- }
- return this;
- },
- locked: function() {
- return !!locked;
- },
-
- // Call all callbacks with the given context and arguments
- fireWith: function( context, args ) {
- if ( !locked ) {
- args = args || [];
- args = [ context, args.slice ? args.slice() : args ];
- queue.push( args );
- if ( !firing ) {
- fire();
- }
- }
- return this;
- },
-
- // Call all the callbacks with the given arguments
- fire: function() {
- self.fireWith( this, arguments );
- return this;
- },
-
- // To know if the callbacks have already been called at least once
- fired: function() {
- return !!fired;
- }
- };
-
- return self;
-};
-
-
-function Identity( v ) {
- return v;
-}
-function Thrower( ex ) {
- throw ex;
-}
-
-function adoptValue( value, resolve, reject, noValue ) {
- var method;
-
- try {
-
- // Check for promise aspect first to privilege synchronous behavior
- if ( value && isFunction( ( method = value.promise ) ) ) {
- method.call( value ).done( resolve ).fail( reject );
-
- // Other thenables
- } else if ( value && isFunction( ( method = value.then ) ) ) {
- method.call( value, resolve, reject );
-
- // Other non-thenables
- } else {
-
- // Control `resolve` arguments by letting Array#slice cast boolean `noValue` to integer:
- // * false: [ value ].slice( 0 ) => resolve( value )
- // * true: [ value ].slice( 1 ) => resolve()
- resolve.apply( undefined, [ value ].slice( noValue ) );
- }
-
- // For Promises/A+, convert exceptions into rejections
- // Since jQuery.when doesn't unwrap thenables, we can skip the extra checks appearing in
- // Deferred#then to conditionally suppress rejection.
- } catch ( value ) {
-
- // Support: Android 4.0 only
- // Strict mode functions invoked without .call/.apply get global-object context
- reject.apply( undefined, [ value ] );
- }
-}
-
-jQuery.extend( {
-
- Deferred: function( func ) {
- var tuples = [
-
- // action, add listener, callbacks,
- // ... .then handlers, argument index, [final state]
- [ "notify", "progress", jQuery.Callbacks( "memory" ),
- jQuery.Callbacks( "memory" ), 2 ],
- [ "resolve", "done", jQuery.Callbacks( "once memory" ),
- jQuery.Callbacks( "once memory" ), 0, "resolved" ],
- [ "reject", "fail", jQuery.Callbacks( "once memory" ),
- jQuery.Callbacks( "once memory" ), 1, "rejected" ]
- ],
- state = "pending",
- promise = {
- state: function() {
- return state;
- },
- always: function() {
- deferred.done( arguments ).fail( arguments );
- return this;
- },
- "catch": function( fn ) {
- return promise.then( null, fn );
- },
-
- // Keep pipe for back-compat
- pipe: function( /* fnDone, fnFail, fnProgress */ ) {
- var fns = arguments;
-
- return jQuery.Deferred( function( newDefer ) {
- jQuery.each( tuples, function( _i, tuple ) {
-
- // Map tuples (progress, done, fail) to arguments (done, fail, progress)
- var fn = isFunction( fns[ tuple[ 4 ] ] ) && fns[ tuple[ 4 ] ];
-
- // deferred.progress(function() { bind to newDefer or newDefer.notify })
- // deferred.done(function() { bind to newDefer or newDefer.resolve })
- // deferred.fail(function() { bind to newDefer or newDefer.reject })
- deferred[ tuple[ 1 ] ]( function() {
- var returned = fn && fn.apply( this, arguments );
- if ( returned && isFunction( returned.promise ) ) {
- returned.promise()
- .progress( newDefer.notify )
- .done( newDefer.resolve )
- .fail( newDefer.reject );
- } else {
- newDefer[ tuple[ 0 ] + "With" ](
- this,
- fn ? [ returned ] : arguments
- );
- }
- } );
- } );
- fns = null;
- } ).promise();
- },
- then: function( onFulfilled, onRejected, onProgress ) {
- var maxDepth = 0;
- function resolve( depth, deferred, handler, special ) {
- return function() {
- var that = this,
- args = arguments,
- mightThrow = function() {
- var returned, then;
-
- // Support: Promises/A+ section 2.3.3.3.3
- // https://promisesaplus.com/#point-59
- // Ignore double-resolution attempts
- if ( depth < maxDepth ) {
- return;
- }
-
- returned = handler.apply( that, args );
-
- // Support: Promises/A+ section 2.3.1
- // https://promisesaplus.com/#point-48
- if ( returned === deferred.promise() ) {
- throw new TypeError( "Thenable self-resolution" );
- }
-
- // Support: Promises/A+ sections 2.3.3.1, 3.5
- // https://promisesaplus.com/#point-54
- // https://promisesaplus.com/#point-75
- // Retrieve `then` only once
- then = returned &&
-
- // Support: Promises/A+ section 2.3.4
- // https://promisesaplus.com/#point-64
- // Only check objects and functions for thenability
- ( typeof returned === "object" ||
- typeof returned === "function" ) &&
- returned.then;
-
- // Handle a returned thenable
- if ( isFunction( then ) ) {
-
- // Special processors (notify) just wait for resolution
- if ( special ) {
- then.call(
- returned,
- resolve( maxDepth, deferred, Identity, special ),
- resolve( maxDepth, deferred, Thrower, special )
- );
-
- // Normal processors (resolve) also hook into progress
- } else {
-
- // ...and disregard older resolution values
- maxDepth++;
-
- then.call(
- returned,
- resolve( maxDepth, deferred, Identity, special ),
- resolve( maxDepth, deferred, Thrower, special ),
- resolve( maxDepth, deferred, Identity,
- deferred.notifyWith )
- );
- }
-
- // Handle all other returned values
- } else {
-
- // Only substitute handlers pass on context
- // and multiple values (non-spec behavior)
- if ( handler !== Identity ) {
- that = undefined;
- args = [ returned ];
- }
-
- // Process the value(s)
- // Default process is resolve
- ( special || deferred.resolveWith )( that, args );
- }
- },
-
- // Only normal processors (resolve) catch and reject exceptions
- process = special ?
- mightThrow :
- function() {
- try {
- mightThrow();
- } catch ( e ) {
-
- if ( jQuery.Deferred.exceptionHook ) {
- jQuery.Deferred.exceptionHook( e,
- process.stackTrace );
- }
-
- // Support: Promises/A+ section 2.3.3.3.4.1
- // https://promisesaplus.com/#point-61
- // Ignore post-resolution exceptions
- if ( depth + 1 >= maxDepth ) {
-
- // Only substitute handlers pass on context
- // and multiple values (non-spec behavior)
- if ( handler !== Thrower ) {
- that = undefined;
- args = [ e ];
- }
-
- deferred.rejectWith( that, args );
- }
- }
- };
-
- // Support: Promises/A+ section 2.3.3.3.1
- // https://promisesaplus.com/#point-57
- // Re-resolve promises immediately to dodge false rejection from
- // subsequent errors
- if ( depth ) {
- process();
- } else {
-
- // Call an optional hook to record the stack, in case of exception
- // since it's otherwise lost when execution goes async
- if ( jQuery.Deferred.getStackHook ) {
- process.stackTrace = jQuery.Deferred.getStackHook();
- }
- window.setTimeout( process );
- }
- };
- }
-
- return jQuery.Deferred( function( newDefer ) {
-
- // progress_handlers.add( ... )
- tuples[ 0 ][ 3 ].add(
- resolve(
- 0,
- newDefer,
- isFunction( onProgress ) ?
- onProgress :
- Identity,
- newDefer.notifyWith
- )
- );
-
- // fulfilled_handlers.add( ... )
- tuples[ 1 ][ 3 ].add(
- resolve(
- 0,
- newDefer,
- isFunction( onFulfilled ) ?
- onFulfilled :
- Identity
- )
- );
-
- // rejected_handlers.add( ... )
- tuples[ 2 ][ 3 ].add(
- resolve(
- 0,
- newDefer,
- isFunction( onRejected ) ?
- onRejected :
- Thrower
- )
- );
- } ).promise();
- },
-
- // Get a promise for this deferred
- // If obj is provided, the promise aspect is added to the object
- promise: function( obj ) {
- return obj != null ? jQuery.extend( obj, promise ) : promise;
- }
- },
- deferred = {};
-
- // Add list-specific methods
- jQuery.each( tuples, function( i, tuple ) {
- var list = tuple[ 2 ],
- stateString = tuple[ 5 ];
-
- // promise.progress = list.add
- // promise.done = list.add
- // promise.fail = list.add
- promise[ tuple[ 1 ] ] = list.add;
-
- // Handle state
- if ( stateString ) {
- list.add(
- function() {
-
- // state = "resolved" (i.e., fulfilled)
- // state = "rejected"
- state = stateString;
- },
-
- // rejected_callbacks.disable
- // fulfilled_callbacks.disable
- tuples[ 3 - i ][ 2 ].disable,
-
- // rejected_handlers.disable
- // fulfilled_handlers.disable
- tuples[ 3 - i ][ 3 ].disable,
-
- // progress_callbacks.lock
- tuples[ 0 ][ 2 ].lock,
-
- // progress_handlers.lock
- tuples[ 0 ][ 3 ].lock
- );
- }
-
- // progress_handlers.fire
- // fulfilled_handlers.fire
- // rejected_handlers.fire
- list.add( tuple[ 3 ].fire );
-
- // deferred.notify = function() { deferred.notifyWith(...) }
- // deferred.resolve = function() { deferred.resolveWith(...) }
- // deferred.reject = function() { deferred.rejectWith(...) }
- deferred[ tuple[ 0 ] ] = function() {
- deferred[ tuple[ 0 ] + "With" ]( this === deferred ? undefined : this, arguments );
- return this;
- };
-
- // deferred.notifyWith = list.fireWith
- // deferred.resolveWith = list.fireWith
- // deferred.rejectWith = list.fireWith
- deferred[ tuple[ 0 ] + "With" ] = list.fireWith;
- } );
-
- // Make the deferred a promise
- promise.promise( deferred );
-
- // Call given func if any
- if ( func ) {
- func.call( deferred, deferred );
- }
-
- // All done!
- return deferred;
- },
-
- // Deferred helper
- when: function( singleValue ) {
- var
-
- // count of uncompleted subordinates
- remaining = arguments.length,
-
- // count of unprocessed arguments
- i = remaining,
-
- // subordinate fulfillment data
- resolveContexts = Array( i ),
- resolveValues = slice.call( arguments ),
-
- // the primary Deferred
- primary = jQuery.Deferred(),
-
- // subordinate callback factory
- updateFunc = function( i ) {
- return function( value ) {
- resolveContexts[ i ] = this;
- resolveValues[ i ] = arguments.length > 1 ? slice.call( arguments ) : value;
- if ( !( --remaining ) ) {
- primary.resolveWith( resolveContexts, resolveValues );
- }
- };
- };
-
- // Single- and empty arguments are adopted like Promise.resolve
- if ( remaining <= 1 ) {
- adoptValue( singleValue, primary.done( updateFunc( i ) ).resolve, primary.reject,
- !remaining );
-
- // Use .then() to unwrap secondary thenables (cf. gh-3000)
- if ( primary.state() === "pending" ||
- isFunction( resolveValues[ i ] && resolveValues[ i ].then ) ) {
-
- return primary.then();
- }
- }
-
- // Multiple arguments are aggregated like Promise.all array elements
- while ( i-- ) {
- adoptValue( resolveValues[ i ], updateFunc( i ), primary.reject );
- }
-
- return primary.promise();
- }
-} );
-
-
-// These usually indicate a programmer mistake during development,
-// warn about them ASAP rather than swallowing them by default.
-var rerrorNames = /^(Eval|Internal|Range|Reference|Syntax|Type|URI)Error$/;
-
-jQuery.Deferred.exceptionHook = function( error, stack ) {
-
- // Support: IE 8 - 9 only
- // Console exists when dev tools are open, which can happen at any time
- if ( window.console && window.console.warn && error && rerrorNames.test( error.name ) ) {
- window.console.warn( "jQuery.Deferred exception: " + error.message, error.stack, stack );
- }
-};
-
-
-
-
-jQuery.readyException = function( error ) {
- window.setTimeout( function() {
- throw error;
- } );
-};
-
-
-
-
-// The deferred used on DOM ready
-var readyList = jQuery.Deferred();
-
-jQuery.fn.ready = function( fn ) {
-
- readyList
- .then( fn )
-
- // Wrap jQuery.readyException in a function so that the lookup
- // happens at the time of error handling instead of callback
- // registration.
- .catch( function( error ) {
- jQuery.readyException( error );
- } );
-
- return this;
-};
-
-jQuery.extend( {
-
- // Is the DOM ready to be used? Set to true once it occurs.
- isReady: false,
-
- // A counter to track how many items to wait for before
- // the ready event fires. See #6781
- readyWait: 1,
-
- // Handle when the DOM is ready
- ready: function( wait ) {
-
- // Abort if there are pending holds or we're already ready
- if ( wait === true ? --jQuery.readyWait : jQuery.isReady ) {
- return;
- }
-
- // Remember that the DOM is ready
- jQuery.isReady = true;
-
- // If a normal DOM Ready event fired, decrement, and wait if need be
- if ( wait !== true && --jQuery.readyWait > 0 ) {
- return;
- }
-
- // If there are functions bound, to execute
- readyList.resolveWith( document, [ jQuery ] );
- }
-} );
-
-jQuery.ready.then = readyList.then;
-
-// The ready event handler and self cleanup method
-function completed() {
- document.removeEventListener( "DOMContentLoaded", completed );
- window.removeEventListener( "load", completed );
- jQuery.ready();
-}
-
-// Catch cases where $(document).ready() is called
-// after the browser event has already occurred.
-// Support: IE <=9 - 10 only
-// Older IE sometimes signals "interactive" too soon
-if ( document.readyState === "complete" ||
- ( document.readyState !== "loading" && !document.documentElement.doScroll ) ) {
-
- // Handle it asynchronously to allow scripts the opportunity to delay ready
- window.setTimeout( jQuery.ready );
-
-} else {
-
- // Use the handy event callback
- document.addEventListener( "DOMContentLoaded", completed );
-
- // A fallback to window.onload, that will always work
- window.addEventListener( "load", completed );
-}
-
-
-
-
-// Multifunctional method to get and set values of a collection
-// The value/s can optionally be executed if it's a function
-var access = function( elems, fn, key, value, chainable, emptyGet, raw ) {
- var i = 0,
- len = elems.length,
- bulk = key == null;
-
- // Sets many values
- if ( toType( key ) === "object" ) {
- chainable = true;
- for ( i in key ) {
- access( elems, fn, i, key[ i ], true, emptyGet, raw );
- }
-
- // Sets one value
- } else if ( value !== undefined ) {
- chainable = true;
-
- if ( !isFunction( value ) ) {
- raw = true;
- }
-
- if ( bulk ) {
-
- // Bulk operations run against the entire set
- if ( raw ) {
- fn.call( elems, value );
- fn = null;
-
- // ...except when executing function values
- } else {
- bulk = fn;
- fn = function( elem, _key, value ) {
- return bulk.call( jQuery( elem ), value );
- };
- }
- }
-
- if ( fn ) {
- for ( ; i < len; i++ ) {
- fn(
- elems[ i ], key, raw ?
- value :
- value.call( elems[ i ], i, fn( elems[ i ], key ) )
- );
- }
- }
- }
-
- if ( chainable ) {
- return elems;
- }
-
- // Gets
- if ( bulk ) {
- return fn.call( elems );
- }
-
- return len ? fn( elems[ 0 ], key ) : emptyGet;
-};
-
-
-// Matches dashed string for camelizing
-var rmsPrefix = /^-ms-/,
- rdashAlpha = /-([a-z])/g;
-
-// Used by camelCase as callback to replace()
-function fcamelCase( _all, letter ) {
- return letter.toUpperCase();
-}
-
-// Convert dashed to camelCase; used by the css and data modules
-// Support: IE <=9 - 11, Edge 12 - 15
-// Microsoft forgot to hump their vendor prefix (#9572)
-function camelCase( string ) {
- return string.replace( rmsPrefix, "ms-" ).replace( rdashAlpha, fcamelCase );
-}
-var acceptData = function( owner ) {
-
- // Accepts only:
- // - Node
- // - Node.ELEMENT_NODE
- // - Node.DOCUMENT_NODE
- // - Object
- // - Any
- return owner.nodeType === 1 || owner.nodeType === 9 || !( +owner.nodeType );
-};
-
-
-
-
-function Data() {
- this.expando = jQuery.expando + Data.uid++;
-}
-
-Data.uid = 1;
-
-Data.prototype = {
-
- cache: function( owner ) {
-
- // Check if the owner object already has a cache
- var value = owner[ this.expando ];
-
- // If not, create one
- if ( !value ) {
- value = {};
-
- // We can accept data for non-element nodes in modern browsers,
- // but we should not, see #8335.
- // Always return an empty object.
- if ( acceptData( owner ) ) {
-
- // If it is a node unlikely to be stringify-ed or looped over
- // use plain assignment
- if ( owner.nodeType ) {
- owner[ this.expando ] = value;
-
- // Otherwise secure it in a non-enumerable property
- // configurable must be true to allow the property to be
- // deleted when data is removed
- } else {
- Object.defineProperty( owner, this.expando, {
- value: value,
- configurable: true
- } );
- }
- }
- }
-
- return value;
- },
- set: function( owner, data, value ) {
- var prop,
- cache = this.cache( owner );
-
- // Handle: [ owner, key, value ] args
- // Always use camelCase key (gh-2257)
- if ( typeof data === "string" ) {
- cache[ camelCase( data ) ] = value;
-
- // Handle: [ owner, { properties } ] args
- } else {
-
- // Copy the properties one-by-one to the cache object
- for ( prop in data ) {
- cache[ camelCase( prop ) ] = data[ prop ];
- }
- }
- return cache;
- },
- get: function( owner, key ) {
- return key === undefined ?
- this.cache( owner ) :
-
- // Always use camelCase key (gh-2257)
- owner[ this.expando ] && owner[ this.expando ][ camelCase( key ) ];
- },
- access: function( owner, key, value ) {
-
- // In cases where either:
- //
- // 1. No key was specified
- // 2. A string key was specified, but no value provided
- //
- // Take the "read" path and allow the get method to determine
- // which value to return, respectively either:
- //
- // 1. The entire cache object
- // 2. The data stored at the key
- //
- if ( key === undefined ||
- ( ( key && typeof key === "string" ) && value === undefined ) ) {
-
- return this.get( owner, key );
- }
-
- // When the key is not a string, or both a key and value
- // are specified, set or extend (existing objects) with either:
- //
- // 1. An object of properties
- // 2. A key and value
- //
- this.set( owner, key, value );
-
- // Since the "set" path can have two possible entry points
- // return the expected data based on which path was taken[*]
- return value !== undefined ? value : key;
- },
- remove: function( owner, key ) {
- var i,
- cache = owner[ this.expando ];
-
- if ( cache === undefined ) {
- return;
- }
-
- if ( key !== undefined ) {
-
- // Support array or space separated string of keys
- if ( Array.isArray( key ) ) {
-
- // If key is an array of keys...
- // We always set camelCase keys, so remove that.
- key = key.map( camelCase );
- } else {
- key = camelCase( key );
-
- // If a key with the spaces exists, use it.
- // Otherwise, create an array by matching non-whitespace
- key = key in cache ?
- [ key ] :
- ( key.match( rnothtmlwhite ) || [] );
- }
-
- i = key.length;
-
- while ( i-- ) {
- delete cache[ key[ i ] ];
- }
- }
-
- // Remove the expando if there's no more data
- if ( key === undefined || jQuery.isEmptyObject( cache ) ) {
-
- // Support: Chrome <=35 - 45
- // Webkit & Blink performance suffers when deleting properties
- // from DOM nodes, so set to undefined instead
- // https://bugs.chromium.org/p/chromium/issues/detail?id=378607 (bug restricted)
- if ( owner.nodeType ) {
- owner[ this.expando ] = undefined;
- } else {
- delete owner[ this.expando ];
- }
- }
- },
- hasData: function( owner ) {
- var cache = owner[ this.expando ];
- return cache !== undefined && !jQuery.isEmptyObject( cache );
- }
-};
-var dataPriv = new Data();
-
-var dataUser = new Data();
-
-
-
-// Implementation Summary
-//
-// 1. Enforce API surface and semantic compatibility with 1.9.x branch
-// 2. Improve the module's maintainability by reducing the storage
-// paths to a single mechanism.
-// 3. Use the same single mechanism to support "private" and "user" data.
-// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
-// 5. Avoid exposing implementation details on user objects (eg. expando properties)
-// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
-
-var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/,
- rmultiDash = /[A-Z]/g;
-
-function getData( data ) {
- if ( data === "true" ) {
- return true;
- }
-
- if ( data === "false" ) {
- return false;
- }
-
- if ( data === "null" ) {
- return null;
- }
-
- // Only convert to a number if it doesn't change the string
- if ( data === +data + "" ) {
- return +data;
- }
-
- if ( rbrace.test( data ) ) {
- return JSON.parse( data );
- }
-
- return data;
-}
-
-function dataAttr( elem, key, data ) {
- var name;
-
- // If nothing was found internally, try to fetch any
- // data from the HTML5 data-* attribute
- if ( data === undefined && elem.nodeType === 1 ) {
- name = "data-" + key.replace( rmultiDash, "-$&" ).toLowerCase();
- data = elem.getAttribute( name );
-
- if ( typeof data === "string" ) {
- try {
- data = getData( data );
- } catch ( e ) {}
-
- // Make sure we set the data so it isn't changed later
- dataUser.set( elem, key, data );
- } else {
- data = undefined;
- }
- }
- return data;
-}
-
-jQuery.extend( {
- hasData: function( elem ) {
- return dataUser.hasData( elem ) || dataPriv.hasData( elem );
- },
-
- data: function( elem, name, data ) {
- return dataUser.access( elem, name, data );
- },
-
- removeData: function( elem, name ) {
- dataUser.remove( elem, name );
- },
-
- // TODO: Now that all calls to _data and _removeData have been replaced
- // with direct calls to dataPriv methods, these can be deprecated.
- _data: function( elem, name, data ) {
- return dataPriv.access( elem, name, data );
- },
-
- _removeData: function( elem, name ) {
- dataPriv.remove( elem, name );
- }
-} );
-
-jQuery.fn.extend( {
- data: function( key, value ) {
- var i, name, data,
- elem = this[ 0 ],
- attrs = elem && elem.attributes;
-
- // Gets all values
- if ( key === undefined ) {
- if ( this.length ) {
- data = dataUser.get( elem );
-
- if ( elem.nodeType === 1 && !dataPriv.get( elem, "hasDataAttrs" ) ) {
- i = attrs.length;
- while ( i-- ) {
-
- // Support: IE 11 only
- // The attrs elements can be null (#14894)
- if ( attrs[ i ] ) {
- name = attrs[ i ].name;
- if ( name.indexOf( "data-" ) === 0 ) {
- name = camelCase( name.slice( 5 ) );
- dataAttr( elem, name, data[ name ] );
- }
- }
- }
- dataPriv.set( elem, "hasDataAttrs", true );
- }
- }
-
- return data;
- }
-
- // Sets multiple values
- if ( typeof key === "object" ) {
- return this.each( function() {
- dataUser.set( this, key );
- } );
- }
-
- return access( this, function( value ) {
- var data;
-
- // The calling jQuery object (element matches) is not empty
- // (and therefore has an element appears at this[ 0 ]) and the
- // `value` parameter was not undefined. An empty jQuery object
- // will result in `undefined` for elem = this[ 0 ] which will
- // throw an exception if an attempt to read a data cache is made.
- if ( elem && value === undefined ) {
-
- // Attempt to get data from the cache
- // The key will always be camelCased in Data
- data = dataUser.get( elem, key );
- if ( data !== undefined ) {
- return data;
- }
-
- // Attempt to "discover" the data in
- // HTML5 custom data-* attrs
- data = dataAttr( elem, key );
- if ( data !== undefined ) {
- return data;
- }
-
- // We tried really hard, but the data doesn't exist.
- return;
- }
-
- // Set the data...
- this.each( function() {
-
- // We always store the camelCased key
- dataUser.set( this, key, value );
- } );
- }, null, value, arguments.length > 1, null, true );
- },
-
- removeData: function( key ) {
- return this.each( function() {
- dataUser.remove( this, key );
- } );
- }
-} );
-
-
-jQuery.extend( {
- queue: function( elem, type, data ) {
- var queue;
-
- if ( elem ) {
- type = ( type || "fx" ) + "queue";
- queue = dataPriv.get( elem, type );
-
- // Speed up dequeue by getting out quickly if this is just a lookup
- if ( data ) {
- if ( !queue || Array.isArray( data ) ) {
- queue = dataPriv.access( elem, type, jQuery.makeArray( data ) );
- } else {
- queue.push( data );
- }
- }
- return queue || [];
- }
- },
-
- dequeue: function( elem, type ) {
- type = type || "fx";
-
- var queue = jQuery.queue( elem, type ),
- startLength = queue.length,
- fn = queue.shift(),
- hooks = jQuery._queueHooks( elem, type ),
- next = function() {
- jQuery.dequeue( elem, type );
- };
-
- // If the fx queue is dequeued, always remove the progress sentinel
- if ( fn === "inprogress" ) {
- fn = queue.shift();
- startLength--;
- }
-
- if ( fn ) {
-
- // Add a progress sentinel to prevent the fx queue from being
- // automatically dequeued
- if ( type === "fx" ) {
- queue.unshift( "inprogress" );
- }
-
- // Clear up the last queue stop function
- delete hooks.stop;
- fn.call( elem, next, hooks );
- }
-
- if ( !startLength && hooks ) {
- hooks.empty.fire();
- }
- },
-
- // Not public - generate a queueHooks object, or return the current one
- _queueHooks: function( elem, type ) {
- var key = type + "queueHooks";
- return dataPriv.get( elem, key ) || dataPriv.access( elem, key, {
- empty: jQuery.Callbacks( "once memory" ).add( function() {
- dataPriv.remove( elem, [ type + "queue", key ] );
- } )
- } );
- }
-} );
-
-jQuery.fn.extend( {
- queue: function( type, data ) {
- var setter = 2;
-
- if ( typeof type !== "string" ) {
- data = type;
- type = "fx";
- setter--;
- }
-
- if ( arguments.length < setter ) {
- return jQuery.queue( this[ 0 ], type );
- }
-
- return data === undefined ?
- this :
- this.each( function() {
- var queue = jQuery.queue( this, type, data );
-
- // Ensure a hooks for this queue
- jQuery._queueHooks( this, type );
-
- if ( type === "fx" && queue[ 0 ] !== "inprogress" ) {
- jQuery.dequeue( this, type );
- }
- } );
- },
- dequeue: function( type ) {
- return this.each( function() {
- jQuery.dequeue( this, type );
- } );
- },
- clearQueue: function( type ) {
- return this.queue( type || "fx", [] );
- },
-
- // Get a promise resolved when queues of a certain type
- // are emptied (fx is the type by default)
- promise: function( type, obj ) {
- var tmp,
- count = 1,
- defer = jQuery.Deferred(),
- elements = this,
- i = this.length,
- resolve = function() {
- if ( !( --count ) ) {
- defer.resolveWith( elements, [ elements ] );
- }
- };
-
- if ( typeof type !== "string" ) {
- obj = type;
- type = undefined;
- }
- type = type || "fx";
-
- while ( i-- ) {
- tmp = dataPriv.get( elements[ i ], type + "queueHooks" );
- if ( tmp && tmp.empty ) {
- count++;
- tmp.empty.add( resolve );
- }
- }
- resolve();
- return defer.promise( obj );
- }
-} );
-var pnum = ( /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/ ).source;
-
-var rcssNum = new RegExp( "^(?:([+-])=|)(" + pnum + ")([a-z%]*)$", "i" );
-
-
-var cssExpand = [ "Top", "Right", "Bottom", "Left" ];
-
-var documentElement = document.documentElement;
-
-
-
- var isAttached = function( elem ) {
- return jQuery.contains( elem.ownerDocument, elem );
- },
- composed = { composed: true };
-
- // Support: IE 9 - 11+, Edge 12 - 18+, iOS 10.0 - 10.2 only
- // Check attachment across shadow DOM boundaries when possible (gh-3504)
- // Support: iOS 10.0-10.2 only
- // Early iOS 10 versions support `attachShadow` but not `getRootNode`,
- // leading to errors. We need to check for `getRootNode`.
- if ( documentElement.getRootNode ) {
- isAttached = function( elem ) {
- return jQuery.contains( elem.ownerDocument, elem ) ||
- elem.getRootNode( composed ) === elem.ownerDocument;
- };
- }
-var isHiddenWithinTree = function( elem, el ) {
-
- // isHiddenWithinTree might be called from jQuery#filter function;
- // in that case, element will be second argument
- elem = el || elem;
-
- // Inline style trumps all
- return elem.style.display === "none" ||
- elem.style.display === "" &&
-
- // Otherwise, check computed style
- // Support: Firefox <=43 - 45
- // Disconnected elements can have computed display: none, so first confirm that elem is
- // in the document.
- isAttached( elem ) &&
-
- jQuery.css( elem, "display" ) === "none";
- };
-
-
-
-function adjustCSS( elem, prop, valueParts, tween ) {
- var adjusted, scale,
- maxIterations = 20,
- currentValue = tween ?
- function() {
- return tween.cur();
- } :
- function() {
- return jQuery.css( elem, prop, "" );
- },
- initial = currentValue(),
- unit = valueParts && valueParts[ 3 ] || ( jQuery.cssNumber[ prop ] ? "" : "px" ),
-
- // Starting value computation is required for potential unit mismatches
- initialInUnit = elem.nodeType &&
- ( jQuery.cssNumber[ prop ] || unit !== "px" && +initial ) &&
- rcssNum.exec( jQuery.css( elem, prop ) );
-
- if ( initialInUnit && initialInUnit[ 3 ] !== unit ) {
-
- // Support: Firefox <=54
- // Halve the iteration target value to prevent interference from CSS upper bounds (gh-2144)
- initial = initial / 2;
-
- // Trust units reported by jQuery.css
- unit = unit || initialInUnit[ 3 ];
-
- // Iteratively approximate from a nonzero starting point
- initialInUnit = +initial || 1;
-
- while ( maxIterations-- ) {
-
- // Evaluate and update our best guess (doubling guesses that zero out).
- // Finish if the scale equals or crosses 1 (making the old*new product non-positive).
- jQuery.style( elem, prop, initialInUnit + unit );
- if ( ( 1 - scale ) * ( 1 - ( scale = currentValue() / initial || 0.5 ) ) <= 0 ) {
- maxIterations = 0;
- }
- initialInUnit = initialInUnit / scale;
-
- }
-
- initialInUnit = initialInUnit * 2;
- jQuery.style( elem, prop, initialInUnit + unit );
-
- // Make sure we update the tween properties later on
- valueParts = valueParts || [];
- }
-
- if ( valueParts ) {
- initialInUnit = +initialInUnit || +initial || 0;
-
- // Apply relative offset (+=/-=) if specified
- adjusted = valueParts[ 1 ] ?
- initialInUnit + ( valueParts[ 1 ] + 1 ) * valueParts[ 2 ] :
- +valueParts[ 2 ];
- if ( tween ) {
- tween.unit = unit;
- tween.start = initialInUnit;
- tween.end = adjusted;
- }
- }
- return adjusted;
-}
-
-
-var defaultDisplayMap = {};
-
-function getDefaultDisplay( elem ) {
- var temp,
- doc = elem.ownerDocument,
- nodeName = elem.nodeName,
- display = defaultDisplayMap[ nodeName ];
-
- if ( display ) {
- return display;
- }
-
- temp = doc.body.appendChild( doc.createElement( nodeName ) );
- display = jQuery.css( temp, "display" );
-
- temp.parentNode.removeChild( temp );
-
- if ( display === "none" ) {
- display = "block";
- }
- defaultDisplayMap[ nodeName ] = display;
-
- return display;
-}
-
-function showHide( elements, show ) {
- var display, elem,
- values = [],
- index = 0,
- length = elements.length;
-
- // Determine new display value for elements that need to change
- for ( ; index < length; index++ ) {
- elem = elements[ index ];
- if ( !elem.style ) {
- continue;
- }
-
- display = elem.style.display;
- if ( show ) {
-
- // Since we force visibility upon cascade-hidden elements, an immediate (and slow)
- // check is required in this first loop unless we have a nonempty display value (either
- // inline or about-to-be-restored)
- if ( display === "none" ) {
- values[ index ] = dataPriv.get( elem, "display" ) || null;
- if ( !values[ index ] ) {
- elem.style.display = "";
- }
- }
- if ( elem.style.display === "" && isHiddenWithinTree( elem ) ) {
- values[ index ] = getDefaultDisplay( elem );
- }
- } else {
- if ( display !== "none" ) {
- values[ index ] = "none";
-
- // Remember what we're overwriting
- dataPriv.set( elem, "display", display );
- }
- }
- }
-
- // Set the display of the elements in a second loop to avoid constant reflow
- for ( index = 0; index < length; index++ ) {
- if ( values[ index ] != null ) {
- elements[ index ].style.display = values[ index ];
- }
- }
-
- return elements;
-}
-
-jQuery.fn.extend( {
- show: function() {
- return showHide( this, true );
- },
- hide: function() {
- return showHide( this );
- },
- toggle: function( state ) {
- if ( typeof state === "boolean" ) {
- return state ? this.show() : this.hide();
- }
-
- return this.each( function() {
- if ( isHiddenWithinTree( this ) ) {
- jQuery( this ).show();
- } else {
- jQuery( this ).hide();
- }
- } );
- }
-} );
-var rcheckableType = ( /^(?:checkbox|radio)$/i );
-
-var rtagName = ( /<([a-z][^\/\0>\x20\t\r\n\f]*)/i );
-
-var rscriptType = ( /^$|^module$|\/(?:java|ecma)script/i );
-
-
-
-( function() {
- var fragment = document.createDocumentFragment(),
- div = fragment.appendChild( document.createElement( "div" ) ),
- input = document.createElement( "input" );
-
- // Support: Android 4.0 - 4.3 only
- // Check state lost if the name is set (#11217)
- // Support: Windows Web Apps (WWA)
- // `name` and `type` must use .setAttribute for WWA (#14901)
- input.setAttribute( "type", "radio" );
- input.setAttribute( "checked", "checked" );
- input.setAttribute( "name", "t" );
-
- div.appendChild( input );
-
- // Support: Android <=4.1 only
- // Older WebKit doesn't clone checked state correctly in fragments
- support.checkClone = div.cloneNode( true ).cloneNode( true ).lastChild.checked;
-
- // Support: IE <=11 only
- // Make sure textarea (and checkbox) defaultValue is properly cloned
- div.innerHTML = "";
- support.noCloneChecked = !!div.cloneNode( true ).lastChild.defaultValue;
-
- // Support: IE <=9 only
- // IE <=9 replaces tags with their contents when inserted outside of
- // the select element.
- div.innerHTML = " or other required elements.
- thead: [ 1, "" ],
- col: [ 2, "" ],
- tr: [ 2, "" ],
- td: [ 3, "" ],
-
- _default: [ 0, "", "" ]
-};
-
-wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
-wrapMap.th = wrapMap.td;
-
-// Support: IE <=9 only
-if ( !support.option ) {
- wrapMap.optgroup = wrapMap.option = [ 1, "", " " ];
-}
-
-
-function getAll( context, tag ) {
-
- // Support: IE <=9 - 11 only
- // Use typeof to avoid zero-argument method invocation on host objects (#15151)
- var ret;
-
- if ( typeof context.getElementsByTagName !== "undefined" ) {
- ret = context.getElementsByTagName( tag || "*" );
-
- } else if ( typeof context.querySelectorAll !== "undefined" ) {
- ret = context.querySelectorAll( tag || "*" );
-
- } else {
- ret = [];
- }
-
- if ( tag === undefined || tag && nodeName( context, tag ) ) {
- return jQuery.merge( [ context ], ret );
- }
-
- return ret;
-}
-
-
-// Mark scripts as having already been evaluated
-function setGlobalEval( elems, refElements ) {
- var i = 0,
- l = elems.length;
-
- for ( ; i < l; i++ ) {
- dataPriv.set(
- elems[ i ],
- "globalEval",
- !refElements || dataPriv.get( refElements[ i ], "globalEval" )
- );
- }
-}
-
-
-var rhtml = /<|&#?\w+;/;
-
-function buildFragment( elems, context, scripts, selection, ignored ) {
- var elem, tmp, tag, wrap, attached, j,
- fragment = context.createDocumentFragment(),
- nodes = [],
- i = 0,
- l = elems.length;
-
- for ( ; i < l; i++ ) {
- elem = elems[ i ];
-
- if ( elem || elem === 0 ) {
-
- // Add nodes directly
- if ( toType( elem ) === "object" ) {
-
- // Support: Android <=4.0 only, PhantomJS 1 only
- // push.apply(_, arraylike) throws on ancient WebKit
- jQuery.merge( nodes, elem.nodeType ? [ elem ] : elem );
-
- // Convert non-html into a text node
- } else if ( !rhtml.test( elem ) ) {
- nodes.push( context.createTextNode( elem ) );
-
- // Convert html into DOM nodes
- } else {
- tmp = tmp || fragment.appendChild( context.createElement( "div" ) );
-
- // Deserialize a standard representation
- tag = ( rtagName.exec( elem ) || [ "", "" ] )[ 1 ].toLowerCase();
- wrap = wrapMap[ tag ] || wrapMap._default;
- tmp.innerHTML = wrap[ 1 ] + jQuery.htmlPrefilter( elem ) + wrap[ 2 ];
-
- // Descend through wrappers to the right content
- j = wrap[ 0 ];
- while ( j-- ) {
- tmp = tmp.lastChild;
- }
-
- // Support: Android <=4.0 only, PhantomJS 1 only
- // push.apply(_, arraylike) throws on ancient WebKit
- jQuery.merge( nodes, tmp.childNodes );
-
- // Remember the top-level container
- tmp = fragment.firstChild;
-
- // Ensure the created nodes are orphaned (#12392)
- tmp.textContent = "";
- }
- }
- }
-
- // Remove wrapper from fragment
- fragment.textContent = "";
-
- i = 0;
- while ( ( elem = nodes[ i++ ] ) ) {
-
- // Skip elements already in the context collection (trac-4087)
- if ( selection && jQuery.inArray( elem, selection ) > -1 ) {
- if ( ignored ) {
- ignored.push( elem );
- }
- continue;
- }
-
- attached = isAttached( elem );
-
- // Append to fragment
- tmp = getAll( fragment.appendChild( elem ), "script" );
-
- // Preserve script evaluation history
- if ( attached ) {
- setGlobalEval( tmp );
- }
-
- // Capture executables
- if ( scripts ) {
- j = 0;
- while ( ( elem = tmp[ j++ ] ) ) {
- if ( rscriptType.test( elem.type || "" ) ) {
- scripts.push( elem );
- }
- }
- }
- }
-
- return fragment;
-}
-
-
-var rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
-
-function returnTrue() {
- return true;
-}
-
-function returnFalse() {
- return false;
-}
-
-// Support: IE <=9 - 11+
-// focus() and blur() are asynchronous, except when they are no-op.
-// So expect focus to be synchronous when the element is already active,
-// and blur to be synchronous when the element is not already active.
-// (focus and blur are always synchronous in other supported browsers,
-// this just defines when we can count on it).
-function expectSync( elem, type ) {
- return ( elem === safeActiveElement() ) === ( type === "focus" );
-}
-
-// Support: IE <=9 only
-// Accessing document.activeElement can throw unexpectedly
-// https://bugs.jquery.com/ticket/13393
-function safeActiveElement() {
- try {
- return document.activeElement;
- } catch ( err ) { }
-}
-
-function on( elem, types, selector, data, fn, one ) {
- var origFn, type;
-
- // Types can be a map of types/handlers
- if ( typeof types === "object" ) {
-
- // ( types-Object, selector, data )
- if ( typeof selector !== "string" ) {
-
- // ( types-Object, data )
- data = data || selector;
- selector = undefined;
- }
- for ( type in types ) {
- on( elem, type, selector, data, types[ type ], one );
- }
- return elem;
- }
-
- if ( data == null && fn == null ) {
-
- // ( types, fn )
- fn = selector;
- data = selector = undefined;
- } else if ( fn == null ) {
- if ( typeof selector === "string" ) {
-
- // ( types, selector, fn )
- fn = data;
- data = undefined;
- } else {
-
- // ( types, data, fn )
- fn = data;
- data = selector;
- selector = undefined;
- }
- }
- if ( fn === false ) {
- fn = returnFalse;
- } else if ( !fn ) {
- return elem;
- }
-
- if ( one === 1 ) {
- origFn = fn;
- fn = function( event ) {
-
- // Can use an empty set, since event contains the info
- jQuery().off( event );
- return origFn.apply( this, arguments );
- };
-
- // Use same guid so caller can remove using origFn
- fn.guid = origFn.guid || ( origFn.guid = jQuery.guid++ );
- }
- return elem.each( function() {
- jQuery.event.add( this, types, fn, data, selector );
- } );
-}
-
-/*
- * Helper functions for managing events -- not part of the public interface.
- * Props to Dean Edwards' addEvent library for many of the ideas.
- */
-jQuery.event = {
-
- global: {},
-
- add: function( elem, types, handler, data, selector ) {
-
- var handleObjIn, eventHandle, tmp,
- events, t, handleObj,
- special, handlers, type, namespaces, origType,
- elemData = dataPriv.get( elem );
-
- // Only attach events to objects that accept data
- if ( !acceptData( elem ) ) {
- return;
- }
-
- // Caller can pass in an object of custom data in lieu of the handler
- if ( handler.handler ) {
- handleObjIn = handler;
- handler = handleObjIn.handler;
- selector = handleObjIn.selector;
- }
-
- // Ensure that invalid selectors throw exceptions at attach time
- // Evaluate against documentElement in case elem is a non-element node (e.g., document)
- if ( selector ) {
- jQuery.find.matchesSelector( documentElement, selector );
- }
-
- // Make sure that the handler has a unique ID, used to find/remove it later
- if ( !handler.guid ) {
- handler.guid = jQuery.guid++;
- }
-
- // Init the element's event structure and main handler, if this is the first
- if ( !( events = elemData.events ) ) {
- events = elemData.events = Object.create( null );
- }
- if ( !( eventHandle = elemData.handle ) ) {
- eventHandle = elemData.handle = function( e ) {
-
- // Discard the second event of a jQuery.event.trigger() and
- // when an event is called after a page has unloaded
- return typeof jQuery !== "undefined" && jQuery.event.triggered !== e.type ?
- jQuery.event.dispatch.apply( elem, arguments ) : undefined;
- };
- }
-
- // Handle multiple events separated by a space
- types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
- t = types.length;
- while ( t-- ) {
- tmp = rtypenamespace.exec( types[ t ] ) || [];
- type = origType = tmp[ 1 ];
- namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
-
- // There *must* be a type, no attaching namespace-only handlers
- if ( !type ) {
- continue;
- }
-
- // If event changes its type, use the special event handlers for the changed type
- special = jQuery.event.special[ type ] || {};
-
- // If selector defined, determine special event api type, otherwise given type
- type = ( selector ? special.delegateType : special.bindType ) || type;
-
- // Update special based on newly reset type
- special = jQuery.event.special[ type ] || {};
-
- // handleObj is passed to all event handlers
- handleObj = jQuery.extend( {
- type: type,
- origType: origType,
- data: data,
- handler: handler,
- guid: handler.guid,
- selector: selector,
- needsContext: selector && jQuery.expr.match.needsContext.test( selector ),
- namespace: namespaces.join( "." )
- }, handleObjIn );
-
- // Init the event handler queue if we're the first
- if ( !( handlers = events[ type ] ) ) {
- handlers = events[ type ] = [];
- handlers.delegateCount = 0;
-
- // Only use addEventListener if the special events handler returns false
- if ( !special.setup ||
- special.setup.call( elem, data, namespaces, eventHandle ) === false ) {
-
- if ( elem.addEventListener ) {
- elem.addEventListener( type, eventHandle );
- }
- }
- }
-
- if ( special.add ) {
- special.add.call( elem, handleObj );
-
- if ( !handleObj.handler.guid ) {
- handleObj.handler.guid = handler.guid;
- }
- }
-
- // Add to the element's handler list, delegates in front
- if ( selector ) {
- handlers.splice( handlers.delegateCount++, 0, handleObj );
- } else {
- handlers.push( handleObj );
- }
-
- // Keep track of which events have ever been used, for event optimization
- jQuery.event.global[ type ] = true;
- }
-
- },
-
- // Detach an event or set of events from an element
- remove: function( elem, types, handler, selector, mappedTypes ) {
-
- var j, origCount, tmp,
- events, t, handleObj,
- special, handlers, type, namespaces, origType,
- elemData = dataPriv.hasData( elem ) && dataPriv.get( elem );
-
- if ( !elemData || !( events = elemData.events ) ) {
- return;
- }
-
- // Once for each type.namespace in types; type may be omitted
- types = ( types || "" ).match( rnothtmlwhite ) || [ "" ];
- t = types.length;
- while ( t-- ) {
- tmp = rtypenamespace.exec( types[ t ] ) || [];
- type = origType = tmp[ 1 ];
- namespaces = ( tmp[ 2 ] || "" ).split( "." ).sort();
-
- // Unbind all events (on this namespace, if provided) for the element
- if ( !type ) {
- for ( type in events ) {
- jQuery.event.remove( elem, type + types[ t ], handler, selector, true );
- }
- continue;
- }
-
- special = jQuery.event.special[ type ] || {};
- type = ( selector ? special.delegateType : special.bindType ) || type;
- handlers = events[ type ] || [];
- tmp = tmp[ 2 ] &&
- new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" );
-
- // Remove matching events
- origCount = j = handlers.length;
- while ( j-- ) {
- handleObj = handlers[ j ];
-
- if ( ( mappedTypes || origType === handleObj.origType ) &&
- ( !handler || handler.guid === handleObj.guid ) &&
- ( !tmp || tmp.test( handleObj.namespace ) ) &&
- ( !selector || selector === handleObj.selector ||
- selector === "**" && handleObj.selector ) ) {
- handlers.splice( j, 1 );
-
- if ( handleObj.selector ) {
- handlers.delegateCount--;
- }
- if ( special.remove ) {
- special.remove.call( elem, handleObj );
- }
- }
- }
-
- // Remove generic event handler if we removed something and no more handlers exist
- // (avoids potential for endless recursion during removal of special event handlers)
- if ( origCount && !handlers.length ) {
- if ( !special.teardown ||
- special.teardown.call( elem, namespaces, elemData.handle ) === false ) {
-
- jQuery.removeEvent( elem, type, elemData.handle );
- }
-
- delete events[ type ];
- }
- }
-
- // Remove data and the expando if it's no longer used
- if ( jQuery.isEmptyObject( events ) ) {
- dataPriv.remove( elem, "handle events" );
- }
- },
-
- dispatch: function( nativeEvent ) {
-
- var i, j, ret, matched, handleObj, handlerQueue,
- args = new Array( arguments.length ),
-
- // Make a writable jQuery.Event from the native event object
- event = jQuery.event.fix( nativeEvent ),
-
- handlers = (
- dataPriv.get( this, "events" ) || Object.create( null )
- )[ event.type ] || [],
- special = jQuery.event.special[ event.type ] || {};
-
- // Use the fix-ed jQuery.Event rather than the (read-only) native event
- args[ 0 ] = event;
-
- for ( i = 1; i < arguments.length; i++ ) {
- args[ i ] = arguments[ i ];
- }
-
- event.delegateTarget = this;
-
- // Call the preDispatch hook for the mapped type, and let it bail if desired
- if ( special.preDispatch && special.preDispatch.call( this, event ) === false ) {
- return;
- }
-
- // Determine handlers
- handlerQueue = jQuery.event.handlers.call( this, event, handlers );
-
- // Run delegates first; they may want to stop propagation beneath us
- i = 0;
- while ( ( matched = handlerQueue[ i++ ] ) && !event.isPropagationStopped() ) {
- event.currentTarget = matched.elem;
-
- j = 0;
- while ( ( handleObj = matched.handlers[ j++ ] ) &&
- !event.isImmediatePropagationStopped() ) {
-
- // If the event is namespaced, then each handler is only invoked if it is
- // specially universal or its namespaces are a superset of the event's.
- if ( !event.rnamespace || handleObj.namespace === false ||
- event.rnamespace.test( handleObj.namespace ) ) {
-
- event.handleObj = handleObj;
- event.data = handleObj.data;
-
- ret = ( ( jQuery.event.special[ handleObj.origType ] || {} ).handle ||
- handleObj.handler ).apply( matched.elem, args );
-
- if ( ret !== undefined ) {
- if ( ( event.result = ret ) === false ) {
- event.preventDefault();
- event.stopPropagation();
- }
- }
- }
- }
- }
-
- // Call the postDispatch hook for the mapped type
- if ( special.postDispatch ) {
- special.postDispatch.call( this, event );
- }
-
- return event.result;
- },
-
- handlers: function( event, handlers ) {
- var i, handleObj, sel, matchedHandlers, matchedSelectors,
- handlerQueue = [],
- delegateCount = handlers.delegateCount,
- cur = event.target;
-
- // Find delegate handlers
- if ( delegateCount &&
-
- // Support: IE <=9
- // Black-hole SVG instance trees (trac-13180)
- cur.nodeType &&
-
- // Support: Firefox <=42
- // Suppress spec-violating clicks indicating a non-primary pointer button (trac-3861)
- // https://www.w3.org/TR/DOM-Level-3-Events/#event-type-click
- // Support: IE 11 only
- // ...but not arrow key "clicks" of radio inputs, which can have `button` -1 (gh-2343)
- !( event.type === "click" && event.button >= 1 ) ) {
-
- for ( ; cur !== this; cur = cur.parentNode || this ) {
-
- // Don't check non-elements (#13208)
- // Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
- if ( cur.nodeType === 1 && !( event.type === "click" && cur.disabled === true ) ) {
- matchedHandlers = [];
- matchedSelectors = {};
- for ( i = 0; i < delegateCount; i++ ) {
- handleObj = handlers[ i ];
-
- // Don't conflict with Object.prototype properties (#13203)
- sel = handleObj.selector + " ";
-
- if ( matchedSelectors[ sel ] === undefined ) {
- matchedSelectors[ sel ] = handleObj.needsContext ?
- jQuery( sel, this ).index( cur ) > -1 :
- jQuery.find( sel, this, null, [ cur ] ).length;
- }
- if ( matchedSelectors[ sel ] ) {
- matchedHandlers.push( handleObj );
- }
- }
- if ( matchedHandlers.length ) {
- handlerQueue.push( { elem: cur, handlers: matchedHandlers } );
- }
- }
- }
- }
-
- // Add the remaining (directly-bound) handlers
- cur = this;
- if ( delegateCount < handlers.length ) {
- handlerQueue.push( { elem: cur, handlers: handlers.slice( delegateCount ) } );
- }
-
- return handlerQueue;
- },
-
- addProp: function( name, hook ) {
- Object.defineProperty( jQuery.Event.prototype, name, {
- enumerable: true,
- configurable: true,
-
- get: isFunction( hook ) ?
- function() {
- if ( this.originalEvent ) {
- return hook( this.originalEvent );
- }
- } :
- function() {
- if ( this.originalEvent ) {
- return this.originalEvent[ name ];
- }
- },
-
- set: function( value ) {
- Object.defineProperty( this, name, {
- enumerable: true,
- configurable: true,
- writable: true,
- value: value
- } );
- }
- } );
- },
-
- fix: function( originalEvent ) {
- return originalEvent[ jQuery.expando ] ?
- originalEvent :
- new jQuery.Event( originalEvent );
- },
-
- special: {
- load: {
-
- // Prevent triggered image.load events from bubbling to window.load
- noBubble: true
- },
- click: {
-
- // Utilize native event to ensure correct state for checkable inputs
- setup: function( data ) {
-
- // For mutual compressibility with _default, replace `this` access with a local var.
- // `|| data` is dead code meant only to preserve the variable through minification.
- var el = this || data;
-
- // Claim the first handler
- if ( rcheckableType.test( el.type ) &&
- el.click && nodeName( el, "input" ) ) {
-
- // dataPriv.set( el, "click", ... )
- leverageNative( el, "click", returnTrue );
- }
-
- // Return false to allow normal processing in the caller
- return false;
- },
- trigger: function( data ) {
-
- // For mutual compressibility with _default, replace `this` access with a local var.
- // `|| data` is dead code meant only to preserve the variable through minification.
- var el = this || data;
-
- // Force setup before triggering a click
- if ( rcheckableType.test( el.type ) &&
- el.click && nodeName( el, "input" ) ) {
-
- leverageNative( el, "click" );
- }
-
- // Return non-false to allow normal event-path propagation
- return true;
- },
-
- // For cross-browser consistency, suppress native .click() on links
- // Also prevent it if we're currently inside a leveraged native-event stack
- _default: function( event ) {
- var target = event.target;
- return rcheckableType.test( target.type ) &&
- target.click && nodeName( target, "input" ) &&
- dataPriv.get( target, "click" ) ||
- nodeName( target, "a" );
- }
- },
-
- beforeunload: {
- postDispatch: function( event ) {
-
- // Support: Firefox 20+
- // Firefox doesn't alert if the returnValue field is not set.
- if ( event.result !== undefined && event.originalEvent ) {
- event.originalEvent.returnValue = event.result;
- }
- }
- }
- }
-};
-
-// Ensure the presence of an event listener that handles manually-triggered
-// synthetic events by interrupting progress until reinvoked in response to
-// *native* events that it fires directly, ensuring that state changes have
-// already occurred before other listeners are invoked.
-function leverageNative( el, type, expectSync ) {
-
- // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
- if ( !expectSync ) {
- if ( dataPriv.get( el, type ) === undefined ) {
- jQuery.event.add( el, type, returnTrue );
- }
- return;
- }
-
- // Register the controller as a special universal handler for all event namespaces
- dataPriv.set( el, type, false );
- jQuery.event.add( el, type, {
- namespace: false,
- handler: function( event ) {
- var notAsync, result,
- saved = dataPriv.get( this, type );
-
- if ( ( event.isTrigger & 1 ) && this[ type ] ) {
-
- // Interrupt processing of the outer synthetic .trigger()ed event
- // Saved data should be false in such cases, but might be a leftover capture object
- // from an async native handler (gh-4350)
- if ( !saved.length ) {
-
- // Store arguments for use when handling the inner native event
- // There will always be at least one argument (an event object), so this array
- // will not be confused with a leftover capture object.
- saved = slice.call( arguments );
- dataPriv.set( this, type, saved );
-
- // Trigger the native event and capture its result
- // Support: IE <=9 - 11+
- // focus() and blur() are asynchronous
- notAsync = expectSync( this, type );
- this[ type ]();
- result = dataPriv.get( this, type );
- if ( saved !== result || notAsync ) {
- dataPriv.set( this, type, false );
- } else {
- result = {};
- }
- if ( saved !== result ) {
-
- // Cancel the outer synthetic event
- event.stopImmediatePropagation();
- event.preventDefault();
-
- // Support: Chrome 86+
- // In Chrome, if an element having a focusout handler is blurred by
- // clicking outside of it, it invokes the handler synchronously. If
- // that handler calls `.remove()` on the element, the data is cleared,
- // leaving `result` undefined. We need to guard against this.
- return result && result.value;
- }
-
- // If this is an inner synthetic event for an event with a bubbling surrogate
- // (focus or blur), assume that the surrogate already propagated from triggering the
- // native event and prevent that from happening again here.
- // This technically gets the ordering wrong w.r.t. to `.trigger()` (in which the
- // bubbling surrogate propagates *after* the non-bubbling base), but that seems
- // less bad than duplication.
- } else if ( ( jQuery.event.special[ type ] || {} ).delegateType ) {
- event.stopPropagation();
- }
-
- // If this is a native event triggered above, everything is now in order
- // Fire an inner synthetic event with the original arguments
- } else if ( saved.length ) {
-
- // ...and capture the result
- dataPriv.set( this, type, {
- value: jQuery.event.trigger(
-
- // Support: IE <=9 - 11+
- // Extend with the prototype to reset the above stopImmediatePropagation()
- jQuery.extend( saved[ 0 ], jQuery.Event.prototype ),
- saved.slice( 1 ),
- this
- )
- } );
-
- // Abort handling of the native event
- event.stopImmediatePropagation();
- }
- }
- } );
-}
-
-jQuery.removeEvent = function( elem, type, handle ) {
-
- // This "if" is needed for plain objects
- if ( elem.removeEventListener ) {
- elem.removeEventListener( type, handle );
- }
-};
-
-jQuery.Event = function( src, props ) {
-
- // Allow instantiation without the 'new' keyword
- if ( !( this instanceof jQuery.Event ) ) {
- return new jQuery.Event( src, props );
- }
-
- // Event object
- if ( src && src.type ) {
- this.originalEvent = src;
- this.type = src.type;
-
- // Events bubbling up the document may have been marked as prevented
- // by a handler lower down the tree; reflect the correct value.
- this.isDefaultPrevented = src.defaultPrevented ||
- src.defaultPrevented === undefined &&
-
- // Support: Android <=2.3 only
- src.returnValue === false ?
- returnTrue :
- returnFalse;
-
- // Create target properties
- // Support: Safari <=6 - 7 only
- // Target should not be a text node (#504, #13143)
- this.target = ( src.target && src.target.nodeType === 3 ) ?
- src.target.parentNode :
- src.target;
-
- this.currentTarget = src.currentTarget;
- this.relatedTarget = src.relatedTarget;
-
- // Event type
- } else {
- this.type = src;
- }
-
- // Put explicitly provided properties onto the event object
- if ( props ) {
- jQuery.extend( this, props );
- }
-
- // Create a timestamp if incoming event doesn't have one
- this.timeStamp = src && src.timeStamp || Date.now();
-
- // Mark it as fixed
- this[ jQuery.expando ] = true;
-};
-
-// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
-// https://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
-jQuery.Event.prototype = {
- constructor: jQuery.Event,
- isDefaultPrevented: returnFalse,
- isPropagationStopped: returnFalse,
- isImmediatePropagationStopped: returnFalse,
- isSimulated: false,
-
- preventDefault: function() {
- var e = this.originalEvent;
-
- this.isDefaultPrevented = returnTrue;
-
- if ( e && !this.isSimulated ) {
- e.preventDefault();
- }
- },
- stopPropagation: function() {
- var e = this.originalEvent;
-
- this.isPropagationStopped = returnTrue;
-
- if ( e && !this.isSimulated ) {
- e.stopPropagation();
- }
- },
- stopImmediatePropagation: function() {
- var e = this.originalEvent;
-
- this.isImmediatePropagationStopped = returnTrue;
-
- if ( e && !this.isSimulated ) {
- e.stopImmediatePropagation();
- }
-
- this.stopPropagation();
- }
-};
-
-// Includes all common event props including KeyEvent and MouseEvent specific props
-jQuery.each( {
- altKey: true,
- bubbles: true,
- cancelable: true,
- changedTouches: true,
- ctrlKey: true,
- detail: true,
- eventPhase: true,
- metaKey: true,
- pageX: true,
- pageY: true,
- shiftKey: true,
- view: true,
- "char": true,
- code: true,
- charCode: true,
- key: true,
- keyCode: true,
- button: true,
- buttons: true,
- clientX: true,
- clientY: true,
- offsetX: true,
- offsetY: true,
- pointerId: true,
- pointerType: true,
- screenX: true,
- screenY: true,
- targetTouches: true,
- toElement: true,
- touches: true,
- which: true
-}, jQuery.event.addProp );
-
-jQuery.each( { focus: "focusin", blur: "focusout" }, function( type, delegateType ) {
- jQuery.event.special[ type ] = {
-
- // Utilize native event if possible so blur/focus sequence is correct
- setup: function() {
-
- // Claim the first handler
- // dataPriv.set( this, "focus", ... )
- // dataPriv.set( this, "blur", ... )
- leverageNative( this, type, expectSync );
-
- // Return false to allow normal processing in the caller
- return false;
- },
- trigger: function() {
-
- // Force setup before trigger
- leverageNative( this, type );
-
- // Return non-false to allow normal event-path propagation
- return true;
- },
-
- // Suppress native focus or blur as it's already being fired
- // in leverageNative.
- _default: function() {
- return true;
- },
-
- delegateType: delegateType
- };
-} );
-
-// Create mouseenter/leave events using mouseover/out and event-time checks
-// so that event delegation works in jQuery.
-// Do the same for pointerenter/pointerleave and pointerover/pointerout
-//
-// Support: Safari 7 only
-// Safari sends mouseenter too often; see:
-// https://bugs.chromium.org/p/chromium/issues/detail?id=470258
-// for the description of the bug (it existed in older Chrome versions as well).
-jQuery.each( {
- mouseenter: "mouseover",
- mouseleave: "mouseout",
- pointerenter: "pointerover",
- pointerleave: "pointerout"
-}, function( orig, fix ) {
- jQuery.event.special[ orig ] = {
- delegateType: fix,
- bindType: fix,
-
- handle: function( event ) {
- var ret,
- target = this,
- related = event.relatedTarget,
- handleObj = event.handleObj;
-
- // For mouseenter/leave call the handler if related is outside the target.
- // NB: No relatedTarget if the mouse left/entered the browser window
- if ( !related || ( related !== target && !jQuery.contains( target, related ) ) ) {
- event.type = handleObj.origType;
- ret = handleObj.handler.apply( this, arguments );
- event.type = fix;
- }
- return ret;
- }
- };
-} );
-
-jQuery.fn.extend( {
-
- on: function( types, selector, data, fn ) {
- return on( this, types, selector, data, fn );
- },
- one: function( types, selector, data, fn ) {
- return on( this, types, selector, data, fn, 1 );
- },
- off: function( types, selector, fn ) {
- var handleObj, type;
- if ( types && types.preventDefault && types.handleObj ) {
-
- // ( event ) dispatched jQuery.Event
- handleObj = types.handleObj;
- jQuery( types.delegateTarget ).off(
- handleObj.namespace ?
- handleObj.origType + "." + handleObj.namespace :
- handleObj.origType,
- handleObj.selector,
- handleObj.handler
- );
- return this;
- }
- if ( typeof types === "object" ) {
-
- // ( types-object [, selector] )
- for ( type in types ) {
- this.off( type, selector, types[ type ] );
- }
- return this;
- }
- if ( selector === false || typeof selector === "function" ) {
-
- // ( types [, fn] )
- fn = selector;
- selector = undefined;
- }
- if ( fn === false ) {
- fn = returnFalse;
- }
- return this.each( function() {
- jQuery.event.remove( this, types, fn, selector );
- } );
- }
-} );
-
-
-var
-
- // Support: IE <=10 - 11, Edge 12 - 13 only
- // In IE/Edge using regex groups here causes severe slowdowns.
- // See https://connect.microsoft.com/IE/feedback/details/1736512/
- rnoInnerhtml = /\s*$/g;
-
-// Prefer a tbody over its parent table for containing new rows
-function manipulationTarget( elem, content ) {
- if ( nodeName( elem, "table" ) &&
- nodeName( content.nodeType !== 11 ? content : content.firstChild, "tr" ) ) {
-
- return jQuery( elem ).children( "tbody" )[ 0 ] || elem;
- }
-
- return elem;
-}
-
-// Replace/restore the type attribute of script elements for safe DOM manipulation
-function disableScript( elem ) {
- elem.type = ( elem.getAttribute( "type" ) !== null ) + "/" + elem.type;
- return elem;
-}
-function restoreScript( elem ) {
- if ( ( elem.type || "" ).slice( 0, 5 ) === "true/" ) {
- elem.type = elem.type.slice( 5 );
- } else {
- elem.removeAttribute( "type" );
- }
-
- return elem;
-}
-
-function cloneCopyEvent( src, dest ) {
- var i, l, type, pdataOld, udataOld, udataCur, events;
-
- if ( dest.nodeType !== 1 ) {
- return;
- }
-
- // 1. Copy private data: events, handlers, etc.
- if ( dataPriv.hasData( src ) ) {
- pdataOld = dataPriv.get( src );
- events = pdataOld.events;
-
- if ( events ) {
- dataPriv.remove( dest, "handle events" );
-
- for ( type in events ) {
- for ( i = 0, l = events[ type ].length; i < l; i++ ) {
- jQuery.event.add( dest, type, events[ type ][ i ] );
- }
- }
- }
- }
-
- // 2. Copy user data
- if ( dataUser.hasData( src ) ) {
- udataOld = dataUser.access( src );
- udataCur = jQuery.extend( {}, udataOld );
-
- dataUser.set( dest, udataCur );
- }
-}
-
-// Fix IE bugs, see support tests
-function fixInput( src, dest ) {
- var nodeName = dest.nodeName.toLowerCase();
-
- // Fails to persist the checked state of a cloned checkbox or radio button.
- if ( nodeName === "input" && rcheckableType.test( src.type ) ) {
- dest.checked = src.checked;
-
- // Fails to return the selected option to the default selected state when cloning options
- } else if ( nodeName === "input" || nodeName === "textarea" ) {
- dest.defaultValue = src.defaultValue;
- }
-}
-
-function domManip( collection, args, callback, ignored ) {
-
- // Flatten any nested arrays
- args = flat( args );
-
- var fragment, first, scripts, hasScripts, node, doc,
- i = 0,
- l = collection.length,
- iNoClone = l - 1,
- value = args[ 0 ],
- valueIsFunction = isFunction( value );
-
- // We can't cloneNode fragments that contain checked, in WebKit
- if ( valueIsFunction ||
- ( l > 1 && typeof value === "string" &&
- !support.checkClone && rchecked.test( value ) ) ) {
- return collection.each( function( index ) {
- var self = collection.eq( index );
- if ( valueIsFunction ) {
- args[ 0 ] = value.call( this, index, self.html() );
- }
- domManip( self, args, callback, ignored );
- } );
- }
-
- if ( l ) {
- fragment = buildFragment( args, collection[ 0 ].ownerDocument, false, collection, ignored );
- first = fragment.firstChild;
-
- if ( fragment.childNodes.length === 1 ) {
- fragment = first;
- }
-
- // Require either new content or an interest in ignored elements to invoke the callback
- if ( first || ignored ) {
- scripts = jQuery.map( getAll( fragment, "script" ), disableScript );
- hasScripts = scripts.length;
-
- // Use the original fragment for the last item
- // instead of the first because it can end up
- // being emptied incorrectly in certain situations (#8070).
- for ( ; i < l; i++ ) {
- node = fragment;
-
- if ( i !== iNoClone ) {
- node = jQuery.clone( node, true, true );
-
- // Keep references to cloned scripts for later restoration
- if ( hasScripts ) {
-
- // Support: Android <=4.0 only, PhantomJS 1 only
- // push.apply(_, arraylike) throws on ancient WebKit
- jQuery.merge( scripts, getAll( node, "script" ) );
- }
- }
-
- callback.call( collection[ i ], node, i );
- }
-
- if ( hasScripts ) {
- doc = scripts[ scripts.length - 1 ].ownerDocument;
-
- // Reenable scripts
- jQuery.map( scripts, restoreScript );
-
- // Evaluate executable scripts on first document insertion
- for ( i = 0; i < hasScripts; i++ ) {
- node = scripts[ i ];
- if ( rscriptType.test( node.type || "" ) &&
- !dataPriv.access( node, "globalEval" ) &&
- jQuery.contains( doc, node ) ) {
-
- if ( node.src && ( node.type || "" ).toLowerCase() !== "module" ) {
-
- // Optional AJAX dependency, but won't run scripts if not present
- if ( jQuery._evalUrl && !node.noModule ) {
- jQuery._evalUrl( node.src, {
- nonce: node.nonce || node.getAttribute( "nonce" )
- }, doc );
- }
- } else {
- DOMEval( node.textContent.replace( rcleanScript, "" ), node, doc );
- }
- }
- }
- }
- }
- }
-
- return collection;
-}
-
-function remove( elem, selector, keepData ) {
- var node,
- nodes = selector ? jQuery.filter( selector, elem ) : elem,
- i = 0;
-
- for ( ; ( node = nodes[ i ] ) != null; i++ ) {
- if ( !keepData && node.nodeType === 1 ) {
- jQuery.cleanData( getAll( node ) );
- }
-
- if ( node.parentNode ) {
- if ( keepData && isAttached( node ) ) {
- setGlobalEval( getAll( node, "script" ) );
- }
- node.parentNode.removeChild( node );
- }
- }
-
- return elem;
-}
-
-jQuery.extend( {
- htmlPrefilter: function( html ) {
- return html;
- },
-
- clone: function( elem, dataAndEvents, deepDataAndEvents ) {
- var i, l, srcElements, destElements,
- clone = elem.cloneNode( true ),
- inPage = isAttached( elem );
-
- // Fix IE cloning issues
- if ( !support.noCloneChecked && ( elem.nodeType === 1 || elem.nodeType === 11 ) &&
- !jQuery.isXMLDoc( elem ) ) {
-
- // We eschew Sizzle here for performance reasons: https://jsperf.com/getall-vs-sizzle/2
- destElements = getAll( clone );
- srcElements = getAll( elem );
-
- for ( i = 0, l = srcElements.length; i < l; i++ ) {
- fixInput( srcElements[ i ], destElements[ i ] );
- }
- }
-
- // Copy the events from the original to the clone
- if ( dataAndEvents ) {
- if ( deepDataAndEvents ) {
- srcElements = srcElements || getAll( elem );
- destElements = destElements || getAll( clone );
-
- for ( i = 0, l = srcElements.length; i < l; i++ ) {
- cloneCopyEvent( srcElements[ i ], destElements[ i ] );
- }
- } else {
- cloneCopyEvent( elem, clone );
- }
- }
-
- // Preserve script evaluation history
- destElements = getAll( clone, "script" );
- if ( destElements.length > 0 ) {
- setGlobalEval( destElements, !inPage && getAll( elem, "script" ) );
- }
-
- // Return the cloned set
- return clone;
- },
-
- cleanData: function( elems ) {
- var data, elem, type,
- special = jQuery.event.special,
- i = 0;
-
- for ( ; ( elem = elems[ i ] ) !== undefined; i++ ) {
- if ( acceptData( elem ) ) {
- if ( ( data = elem[ dataPriv.expando ] ) ) {
- if ( data.events ) {
- for ( type in data.events ) {
- if ( special[ type ] ) {
- jQuery.event.remove( elem, type );
-
- // This is a shortcut to avoid jQuery.event.remove's overhead
- } else {
- jQuery.removeEvent( elem, type, data.handle );
- }
- }
- }
-
- // Support: Chrome <=35 - 45+
- // Assign undefined instead of using delete, see Data#remove
- elem[ dataPriv.expando ] = undefined;
- }
- if ( elem[ dataUser.expando ] ) {
-
- // Support: Chrome <=35 - 45+
- // Assign undefined instead of using delete, see Data#remove
- elem[ dataUser.expando ] = undefined;
- }
- }
- }
- }
-} );
-
-jQuery.fn.extend( {
- detach: function( selector ) {
- return remove( this, selector, true );
- },
-
- remove: function( selector ) {
- return remove( this, selector );
- },
-
- text: function( value ) {
- return access( this, function( value ) {
- return value === undefined ?
- jQuery.text( this ) :
- this.empty().each( function() {
- if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
- this.textContent = value;
- }
- } );
- }, null, value, arguments.length );
- },
-
- append: function() {
- return domManip( this, arguments, function( elem ) {
- if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
- var target = manipulationTarget( this, elem );
- target.appendChild( elem );
- }
- } );
- },
-
- prepend: function() {
- return domManip( this, arguments, function( elem ) {
- if ( this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9 ) {
- var target = manipulationTarget( this, elem );
- target.insertBefore( elem, target.firstChild );
- }
- } );
- },
-
- before: function() {
- return domManip( this, arguments, function( elem ) {
- if ( this.parentNode ) {
- this.parentNode.insertBefore( elem, this );
- }
- } );
- },
-
- after: function() {
- return domManip( this, arguments, function( elem ) {
- if ( this.parentNode ) {
- this.parentNode.insertBefore( elem, this.nextSibling );
- }
- } );
- },
-
- empty: function() {
- var elem,
- i = 0;
-
- for ( ; ( elem = this[ i ] ) != null; i++ ) {
- if ( elem.nodeType === 1 ) {
-
- // Prevent memory leaks
- jQuery.cleanData( getAll( elem, false ) );
-
- // Remove any remaining nodes
- elem.textContent = "";
- }
- }
-
- return this;
- },
-
- clone: function( dataAndEvents, deepDataAndEvents ) {
- dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
- deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
-
- return this.map( function() {
- return jQuery.clone( this, dataAndEvents, deepDataAndEvents );
- } );
- },
-
- html: function( value ) {
- return access( this, function( value ) {
- var elem = this[ 0 ] || {},
- i = 0,
- l = this.length;
-
- if ( value === undefined && elem.nodeType === 1 ) {
- return elem.innerHTML;
- }
-
- // See if we can take a shortcut and just use innerHTML
- if ( typeof value === "string" && !rnoInnerhtml.test( value ) &&
- !wrapMap[ ( rtagName.exec( value ) || [ "", "" ] )[ 1 ].toLowerCase() ] ) {
-
- value = jQuery.htmlPrefilter( value );
-
- try {
- for ( ; i < l; i++ ) {
- elem = this[ i ] || {};
-
- // Remove element nodes and prevent memory leaks
- if ( elem.nodeType === 1 ) {
- jQuery.cleanData( getAll( elem, false ) );
- elem.innerHTML = value;
- }
- }
-
- elem = 0;
-
- // If using innerHTML throws an exception, use the fallback method
- } catch ( e ) {}
- }
-
- if ( elem ) {
- this.empty().append( value );
- }
- }, null, value, arguments.length );
- },
-
- replaceWith: function() {
- var ignored = [];
-
- // Make the changes, replacing each non-ignored context element with the new content
- return domManip( this, arguments, function( elem ) {
- var parent = this.parentNode;
-
- if ( jQuery.inArray( this, ignored ) < 0 ) {
- jQuery.cleanData( getAll( this ) );
- if ( parent ) {
- parent.replaceChild( elem, this );
- }
- }
-
- // Force callback invocation
- }, ignored );
- }
-} );
-
-jQuery.each( {
- appendTo: "append",
- prependTo: "prepend",
- insertBefore: "before",
- insertAfter: "after",
- replaceAll: "replaceWith"
-}, function( name, original ) {
- jQuery.fn[ name ] = function( selector ) {
- var elems,
- ret = [],
- insert = jQuery( selector ),
- last = insert.length - 1,
- i = 0;
-
- for ( ; i <= last; i++ ) {
- elems = i === last ? this : this.clone( true );
- jQuery( insert[ i ] )[ original ]( elems );
-
- // Support: Android <=4.0 only, PhantomJS 1 only
- // .get() because push.apply(_, arraylike) throws on ancient WebKit
- push.apply( ret, elems.get() );
- }
-
- return this.pushStack( ret );
- };
-} );
-var rnumnonpx = new RegExp( "^(" + pnum + ")(?!px)[a-z%]+$", "i" );
-
-var getStyles = function( elem ) {
-
- // Support: IE <=11 only, Firefox <=30 (#15098, #14150)
- // IE throws on elements created in popups
- // FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
- var view = elem.ownerDocument.defaultView;
-
- if ( !view || !view.opener ) {
- view = window;
- }
-
- return view.getComputedStyle( elem );
- };
-
-var swap = function( elem, options, callback ) {
- var ret, name,
- old = {};
-
- // Remember the old values, and insert the new ones
- for ( name in options ) {
- old[ name ] = elem.style[ name ];
- elem.style[ name ] = options[ name ];
- }
-
- ret = callback.call( elem );
-
- // Revert the old values
- for ( name in options ) {
- elem.style[ name ] = old[ name ];
- }
-
- return ret;
-};
-
-
-var rboxStyle = new RegExp( cssExpand.join( "|" ), "i" );
-
-
-
-( function() {
-
- // Executing both pixelPosition & boxSizingReliable tests require only one layout
- // so they're executed at the same time to save the second computation.
- function computeStyleTests() {
-
- // This is a singleton, we need to execute it only once
- if ( !div ) {
- return;
- }
-
- container.style.cssText = "position:absolute;left:-11111px;width:60px;" +
- "margin-top:1px;padding:0;border:0";
- div.style.cssText =
- "position:relative;display:block;box-sizing:border-box;overflow:scroll;" +
- "margin:auto;border:1px;padding:1px;" +
- "width:60%;top:1%";
- documentElement.appendChild( container ).appendChild( div );
-
- var divStyle = window.getComputedStyle( div );
- pixelPositionVal = divStyle.top !== "1%";
-
- // Support: Android 4.0 - 4.3 only, Firefox <=3 - 44
- reliableMarginLeftVal = roundPixelMeasures( divStyle.marginLeft ) === 12;
-
- // Support: Android 4.0 - 4.3 only, Safari <=9.1 - 10.1, iOS <=7.0 - 9.3
- // Some styles come back with percentage values, even though they shouldn't
- div.style.right = "60%";
- pixelBoxStylesVal = roundPixelMeasures( divStyle.right ) === 36;
-
- // Support: IE 9 - 11 only
- // Detect misreporting of content dimensions for box-sizing:border-box elements
- boxSizingReliableVal = roundPixelMeasures( divStyle.width ) === 36;
-
- // Support: IE 9 only
- // Detect overflow:scroll screwiness (gh-3699)
- // Support: Chrome <=64
- // Don't get tricked when zoom affects offsetWidth (gh-4029)
- div.style.position = "absolute";
- scrollboxSizeVal = roundPixelMeasures( div.offsetWidth / 3 ) === 12;
-
- documentElement.removeChild( container );
-
- // Nullify the div so it wouldn't be stored in the memory and
- // it will also be a sign that checks already performed
- div = null;
- }
-
- function roundPixelMeasures( measure ) {
- return Math.round( parseFloat( measure ) );
- }
-
- var pixelPositionVal, boxSizingReliableVal, scrollboxSizeVal, pixelBoxStylesVal,
- reliableTrDimensionsVal, reliableMarginLeftVal,
- container = document.createElement( "div" ),
- div = document.createElement( "div" );
-
- // Finish early in limited (non-browser) environments
- if ( !div.style ) {
- return;
- }
-
- // Support: IE <=9 - 11 only
- // Style of cloned element affects source element cloned (#8908)
- div.style.backgroundClip = "content-box";
- div.cloneNode( true ).style.backgroundClip = "";
- support.clearCloneStyle = div.style.backgroundClip === "content-box";
-
- jQuery.extend( support, {
- boxSizingReliable: function() {
- computeStyleTests();
- return boxSizingReliableVal;
- },
- pixelBoxStyles: function() {
- computeStyleTests();
- return pixelBoxStylesVal;
- },
- pixelPosition: function() {
- computeStyleTests();
- return pixelPositionVal;
- },
- reliableMarginLeft: function() {
- computeStyleTests();
- return reliableMarginLeftVal;
- },
- scrollboxSize: function() {
- computeStyleTests();
- return scrollboxSizeVal;
- },
-
- // Support: IE 9 - 11+, Edge 15 - 18+
- // IE/Edge misreport `getComputedStyle` of table rows with width/height
- // set in CSS while `offset*` properties report correct values.
- // Behavior in IE 9 is more subtle than in newer versions & it passes
- // some versions of this test; make sure not to make it pass there!
- //
- // Support: Firefox 70+
- // Only Firefox includes border widths
- // in computed dimensions. (gh-4529)
- reliableTrDimensions: function() {
- var table, tr, trChild, trStyle;
- if ( reliableTrDimensionsVal == null ) {
- table = document.createElement( "table" );
- tr = document.createElement( "tr" );
- trChild = document.createElement( "div" );
-
- table.style.cssText = "position:absolute;left:-11111px;border-collapse:separate";
- tr.style.cssText = "border:1px solid";
-
- // Support: Chrome 86+
- // Height set through cssText does not get applied.
- // Computed height then comes back as 0.
- tr.style.height = "1px";
- trChild.style.height = "9px";
-
- // Support: Android 8 Chrome 86+
- // In our bodyBackground.html iframe,
- // display for all div elements is set to "inline",
- // which causes a problem only in Android 8 Chrome 86.
- // Ensuring the div is display: block
- // gets around this issue.
- trChild.style.display = "block";
-
- documentElement
- .appendChild( table )
- .appendChild( tr )
- .appendChild( trChild );
-
- trStyle = window.getComputedStyle( tr );
- reliableTrDimensionsVal = ( parseInt( trStyle.height, 10 ) +
- parseInt( trStyle.borderTopWidth, 10 ) +
- parseInt( trStyle.borderBottomWidth, 10 ) ) === tr.offsetHeight;
-
- documentElement.removeChild( table );
- }
- return reliableTrDimensionsVal;
- }
- } );
-} )();
-
-
-function curCSS( elem, name, computed ) {
- var width, minWidth, maxWidth, ret,
-
- // Support: Firefox 51+
- // Retrieving style before computed somehow
- // fixes an issue with getting wrong values
- // on detached elements
- style = elem.style;
-
- computed = computed || getStyles( elem );
-
- // getPropertyValue is needed for:
- // .css('filter') (IE 9 only, #12537)
- // .css('--customProperty) (#3144)
- if ( computed ) {
- ret = computed.getPropertyValue( name ) || computed[ name ];
-
- if ( ret === "" && !isAttached( elem ) ) {
- ret = jQuery.style( elem, name );
- }
-
- // A tribute to the "awesome hack by Dean Edwards"
- // Android Browser returns percentage for some values,
- // but width seems to be reliably pixels.
- // This is against the CSSOM draft spec:
- // https://drafts.csswg.org/cssom/#resolved-values
- if ( !support.pixelBoxStyles() && rnumnonpx.test( ret ) && rboxStyle.test( name ) ) {
-
- // Remember the original values
- width = style.width;
- minWidth = style.minWidth;
- maxWidth = style.maxWidth;
-
- // Put in the new values to get a computed value out
- style.minWidth = style.maxWidth = style.width = ret;
- ret = computed.width;
-
- // Revert the changed values
- style.width = width;
- style.minWidth = minWidth;
- style.maxWidth = maxWidth;
- }
- }
-
- return ret !== undefined ?
-
- // Support: IE <=9 - 11 only
- // IE returns zIndex value as an integer.
- ret + "" :
- ret;
-}
-
-
-function addGetHookIf( conditionFn, hookFn ) {
-
- // Define the hook, we'll check on the first run if it's really needed.
- return {
- get: function() {
- if ( conditionFn() ) {
-
- // Hook not needed (or it's not possible to use it due
- // to missing dependency), remove it.
- delete this.get;
- return;
- }
-
- // Hook needed; redefine it so that the support test is not executed again.
- return ( this.get = hookFn ).apply( this, arguments );
- }
- };
-}
-
-
-var cssPrefixes = [ "Webkit", "Moz", "ms" ],
- emptyStyle = document.createElement( "div" ).style,
- vendorProps = {};
-
-// Return a vendor-prefixed property or undefined
-function vendorPropName( name ) {
-
- // Check for vendor prefixed names
- var capName = name[ 0 ].toUpperCase() + name.slice( 1 ),
- i = cssPrefixes.length;
-
- while ( i-- ) {
- name = cssPrefixes[ i ] + capName;
- if ( name in emptyStyle ) {
- return name;
- }
- }
-}
-
-// Return a potentially-mapped jQuery.cssProps or vendor prefixed property
-function finalPropName( name ) {
- var final = jQuery.cssProps[ name ] || vendorProps[ name ];
-
- if ( final ) {
- return final;
- }
- if ( name in emptyStyle ) {
- return name;
- }
- return vendorProps[ name ] = vendorPropName( name ) || name;
-}
-
-
-var
-
- // Swappable if display is none or starts with table
- // except "table", "table-cell", or "table-caption"
- // See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
- rdisplayswap = /^(none|table(?!-c[ea]).+)/,
- rcustomProp = /^--/,
- cssShow = { position: "absolute", visibility: "hidden", display: "block" },
- cssNormalTransform = {
- letterSpacing: "0",
- fontWeight: "400"
- };
-
-function setPositiveNumber( _elem, value, subtract ) {
-
- // Any relative (+/-) values have already been
- // normalized at this point
- var matches = rcssNum.exec( value );
- return matches ?
-
- // Guard against undefined "subtract", e.g., when used as in cssHooks
- Math.max( 0, matches[ 2 ] - ( subtract || 0 ) ) + ( matches[ 3 ] || "px" ) :
- value;
-}
-
-function boxModelAdjustment( elem, dimension, box, isBorderBox, styles, computedVal ) {
- var i = dimension === "width" ? 1 : 0,
- extra = 0,
- delta = 0;
-
- // Adjustment may not be necessary
- if ( box === ( isBorderBox ? "border" : "content" ) ) {
- return 0;
- }
-
- for ( ; i < 4; i += 2 ) {
-
- // Both box models exclude margin
- if ( box === "margin" ) {
- delta += jQuery.css( elem, box + cssExpand[ i ], true, styles );
- }
-
- // If we get here with a content-box, we're seeking "padding" or "border" or "margin"
- if ( !isBorderBox ) {
-
- // Add padding
- delta += jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
-
- // For "border" or "margin", add border
- if ( box !== "padding" ) {
- delta += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
-
- // But still keep track of it otherwise
- } else {
- extra += jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
- }
-
- // If we get here with a border-box (content + padding + border), we're seeking "content" or
- // "padding" or "margin"
- } else {
-
- // For "content", subtract padding
- if ( box === "content" ) {
- delta -= jQuery.css( elem, "padding" + cssExpand[ i ], true, styles );
- }
-
- // For "content" or "padding", subtract border
- if ( box !== "margin" ) {
- delta -= jQuery.css( elem, "border" + cssExpand[ i ] + "Width", true, styles );
- }
- }
- }
-
- // Account for positive content-box scroll gutter when requested by providing computedVal
- if ( !isBorderBox && computedVal >= 0 ) {
-
- // offsetWidth/offsetHeight is a rounded sum of content, padding, scroll gutter, and border
- // Assuming integer scroll gutter, subtract the rest and round down
- delta += Math.max( 0, Math.ceil(
- elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
- computedVal -
- delta -
- extra -
- 0.5
-
- // If offsetWidth/offsetHeight is unknown, then we can't determine content-box scroll gutter
- // Use an explicit zero to avoid NaN (gh-3964)
- ) ) || 0;
- }
-
- return delta;
-}
-
-function getWidthOrHeight( elem, dimension, extra ) {
-
- // Start with computed style
- var styles = getStyles( elem ),
-
- // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-4322).
- // Fake content-box until we know it's needed to know the true value.
- boxSizingNeeded = !support.boxSizingReliable() || extra,
- isBorderBox = boxSizingNeeded &&
- jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
- valueIsBorderBox = isBorderBox,
-
- val = curCSS( elem, dimension, styles ),
- offsetProp = "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 );
-
- // Support: Firefox <=54
- // Return a confounding non-pixel value or feign ignorance, as appropriate.
- if ( rnumnonpx.test( val ) ) {
- if ( !extra ) {
- return val;
- }
- val = "auto";
- }
-
-
- // Support: IE 9 - 11 only
- // Use offsetWidth/offsetHeight for when box sizing is unreliable.
- // In those cases, the computed value can be trusted to be border-box.
- if ( ( !support.boxSizingReliable() && isBorderBox ||
-
- // Support: IE 10 - 11+, Edge 15 - 18+
- // IE/Edge misreport `getComputedStyle` of table rows with width/height
- // set in CSS while `offset*` properties report correct values.
- // Interestingly, in some cases IE 9 doesn't suffer from this issue.
- !support.reliableTrDimensions() && nodeName( elem, "tr" ) ||
-
- // Fall back to offsetWidth/offsetHeight when value is "auto"
- // This happens for inline elements with no explicit setting (gh-3571)
- val === "auto" ||
-
- // Support: Android <=4.1 - 4.3 only
- // Also use offsetWidth/offsetHeight for misreported inline dimensions (gh-3602)
- !parseFloat( val ) && jQuery.css( elem, "display", false, styles ) === "inline" ) &&
-
- // Make sure the element is visible & connected
- elem.getClientRects().length ) {
-
- isBorderBox = jQuery.css( elem, "boxSizing", false, styles ) === "border-box";
-
- // Where available, offsetWidth/offsetHeight approximate border box dimensions.
- // Where not available (e.g., SVG), assume unreliable box-sizing and interpret the
- // retrieved value as a content box dimension.
- valueIsBorderBox = offsetProp in elem;
- if ( valueIsBorderBox ) {
- val = elem[ offsetProp ];
- }
- }
-
- // Normalize "" and auto
- val = parseFloat( val ) || 0;
-
- // Adjust for the element's box model
- return ( val +
- boxModelAdjustment(
- elem,
- dimension,
- extra || ( isBorderBox ? "border" : "content" ),
- valueIsBorderBox,
- styles,
-
- // Provide the current computed size to request scroll gutter calculation (gh-3589)
- val
- )
- ) + "px";
-}
-
-jQuery.extend( {
-
- // Add in style property hooks for overriding the default
- // behavior of getting and setting a style property
- cssHooks: {
- opacity: {
- get: function( elem, computed ) {
- if ( computed ) {
-
- // We should always get a number back from opacity
- var ret = curCSS( elem, "opacity" );
- return ret === "" ? "1" : ret;
- }
- }
- }
- },
-
- // Don't automatically add "px" to these possibly-unitless properties
- cssNumber: {
- "animationIterationCount": true,
- "columnCount": true,
- "fillOpacity": true,
- "flexGrow": true,
- "flexShrink": true,
- "fontWeight": true,
- "gridArea": true,
- "gridColumn": true,
- "gridColumnEnd": true,
- "gridColumnStart": true,
- "gridRow": true,
- "gridRowEnd": true,
- "gridRowStart": true,
- "lineHeight": true,
- "opacity": true,
- "order": true,
- "orphans": true,
- "widows": true,
- "zIndex": true,
- "zoom": true
- },
-
- // Add in properties whose names you wish to fix before
- // setting or getting the value
- cssProps: {},
-
- // Get and set the style property on a DOM Node
- style: function( elem, name, value, extra ) {
-
- // Don't set styles on text and comment nodes
- if ( !elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style ) {
- return;
- }
-
- // Make sure that we're working with the right name
- var ret, type, hooks,
- origName = camelCase( name ),
- isCustomProp = rcustomProp.test( name ),
- style = elem.style;
-
- // Make sure that we're working with the right name. We don't
- // want to query the value if it is a CSS custom property
- // since they are user-defined.
- if ( !isCustomProp ) {
- name = finalPropName( origName );
- }
-
- // Gets hook for the prefixed version, then unprefixed version
- hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
-
- // Check if we're setting a value
- if ( value !== undefined ) {
- type = typeof value;
-
- // Convert "+=" or "-=" to relative numbers (#7345)
- if ( type === "string" && ( ret = rcssNum.exec( value ) ) && ret[ 1 ] ) {
- value = adjustCSS( elem, name, ret );
-
- // Fixes bug #9237
- type = "number";
- }
-
- // Make sure that null and NaN values aren't set (#7116)
- if ( value == null || value !== value ) {
- return;
- }
-
- // If a number was passed in, add the unit (except for certain CSS properties)
- // The isCustomProp check can be removed in jQuery 4.0 when we only auto-append
- // "px" to a few hardcoded values.
- if ( type === "number" && !isCustomProp ) {
- value += ret && ret[ 3 ] || ( jQuery.cssNumber[ origName ] ? "" : "px" );
- }
-
- // background-* props affect original clone's values
- if ( !support.clearCloneStyle && value === "" && name.indexOf( "background" ) === 0 ) {
- style[ name ] = "inherit";
- }
-
- // If a hook was provided, use that value, otherwise just set the specified value
- if ( !hooks || !( "set" in hooks ) ||
- ( value = hooks.set( elem, value, extra ) ) !== undefined ) {
-
- if ( isCustomProp ) {
- style.setProperty( name, value );
- } else {
- style[ name ] = value;
- }
- }
-
- } else {
-
- // If a hook was provided get the non-computed value from there
- if ( hooks && "get" in hooks &&
- ( ret = hooks.get( elem, false, extra ) ) !== undefined ) {
-
- return ret;
- }
-
- // Otherwise just get the value from the style object
- return style[ name ];
- }
- },
-
- css: function( elem, name, extra, styles ) {
- var val, num, hooks,
- origName = camelCase( name ),
- isCustomProp = rcustomProp.test( name );
-
- // Make sure that we're working with the right name. We don't
- // want to modify the value if it is a CSS custom property
- // since they are user-defined.
- if ( !isCustomProp ) {
- name = finalPropName( origName );
- }
-
- // Try prefixed name followed by the unprefixed name
- hooks = jQuery.cssHooks[ name ] || jQuery.cssHooks[ origName ];
-
- // If a hook was provided get the computed value from there
- if ( hooks && "get" in hooks ) {
- val = hooks.get( elem, true, extra );
- }
-
- // Otherwise, if a way to get the computed value exists, use that
- if ( val === undefined ) {
- val = curCSS( elem, name, styles );
- }
-
- // Convert "normal" to computed value
- if ( val === "normal" && name in cssNormalTransform ) {
- val = cssNormalTransform[ name ];
- }
-
- // Make numeric if forced or a qualifier was provided and val looks numeric
- if ( extra === "" || extra ) {
- num = parseFloat( val );
- return extra === true || isFinite( num ) ? num || 0 : val;
- }
-
- return val;
- }
-} );
-
-jQuery.each( [ "height", "width" ], function( _i, dimension ) {
- jQuery.cssHooks[ dimension ] = {
- get: function( elem, computed, extra ) {
- if ( computed ) {
-
- // Certain elements can have dimension info if we invisibly show them
- // but it must have a current display style that would benefit
- return rdisplayswap.test( jQuery.css( elem, "display" ) ) &&
-
- // Support: Safari 8+
- // Table columns in Safari have non-zero offsetWidth & zero
- // getBoundingClientRect().width unless display is changed.
- // Support: IE <=11 only
- // Running getBoundingClientRect on a disconnected node
- // in IE throws an error.
- ( !elem.getClientRects().length || !elem.getBoundingClientRect().width ) ?
- swap( elem, cssShow, function() {
- return getWidthOrHeight( elem, dimension, extra );
- } ) :
- getWidthOrHeight( elem, dimension, extra );
- }
- },
-
- set: function( elem, value, extra ) {
- var matches,
- styles = getStyles( elem ),
-
- // Only read styles.position if the test has a chance to fail
- // to avoid forcing a reflow.
- scrollboxSizeBuggy = !support.scrollboxSize() &&
- styles.position === "absolute",
-
- // To avoid forcing a reflow, only fetch boxSizing if we need it (gh-3991)
- boxSizingNeeded = scrollboxSizeBuggy || extra,
- isBorderBox = boxSizingNeeded &&
- jQuery.css( elem, "boxSizing", false, styles ) === "border-box",
- subtract = extra ?
- boxModelAdjustment(
- elem,
- dimension,
- extra,
- isBorderBox,
- styles
- ) :
- 0;
-
- // Account for unreliable border-box dimensions by comparing offset* to computed and
- // faking a content-box to get border and padding (gh-3699)
- if ( isBorderBox && scrollboxSizeBuggy ) {
- subtract -= Math.ceil(
- elem[ "offset" + dimension[ 0 ].toUpperCase() + dimension.slice( 1 ) ] -
- parseFloat( styles[ dimension ] ) -
- boxModelAdjustment( elem, dimension, "border", false, styles ) -
- 0.5
- );
- }
-
- // Convert to pixels if value adjustment is needed
- if ( subtract && ( matches = rcssNum.exec( value ) ) &&
- ( matches[ 3 ] || "px" ) !== "px" ) {
-
- elem.style[ dimension ] = value;
- value = jQuery.css( elem, dimension );
- }
-
- return setPositiveNumber( elem, value, subtract );
- }
- };
-} );
-
-jQuery.cssHooks.marginLeft = addGetHookIf( support.reliableMarginLeft,
- function( elem, computed ) {
- if ( computed ) {
- return ( parseFloat( curCSS( elem, "marginLeft" ) ) ||
- elem.getBoundingClientRect().left -
- swap( elem, { marginLeft: 0 }, function() {
- return elem.getBoundingClientRect().left;
- } )
- ) + "px";
- }
- }
-);
-
-// These hooks are used by animate to expand properties
-jQuery.each( {
- margin: "",
- padding: "",
- border: "Width"
-}, function( prefix, suffix ) {
- jQuery.cssHooks[ prefix + suffix ] = {
- expand: function( value ) {
- var i = 0,
- expanded = {},
-
- // Assumes a single number if not a string
- parts = typeof value === "string" ? value.split( " " ) : [ value ];
-
- for ( ; i < 4; i++ ) {
- expanded[ prefix + cssExpand[ i ] + suffix ] =
- parts[ i ] || parts[ i - 2 ] || parts[ 0 ];
- }
-
- return expanded;
- }
- };
-
- if ( prefix !== "margin" ) {
- jQuery.cssHooks[ prefix + suffix ].set = setPositiveNumber;
- }
-} );
-
-jQuery.fn.extend( {
- css: function( name, value ) {
- return access( this, function( elem, name, value ) {
- var styles, len,
- map = {},
- i = 0;
-
- if ( Array.isArray( name ) ) {
- styles = getStyles( elem );
- len = name.length;
-
- for ( ; i < len; i++ ) {
- map[ name[ i ] ] = jQuery.css( elem, name[ i ], false, styles );
- }
-
- return map;
- }
-
- return value !== undefined ?
- jQuery.style( elem, name, value ) :
- jQuery.css( elem, name );
- }, name, value, arguments.length > 1 );
- }
-} );
-
-
-function Tween( elem, options, prop, end, easing ) {
- return new Tween.prototype.init( elem, options, prop, end, easing );
-}
-jQuery.Tween = Tween;
-
-Tween.prototype = {
- constructor: Tween,
- init: function( elem, options, prop, end, easing, unit ) {
- this.elem = elem;
- this.prop = prop;
- this.easing = easing || jQuery.easing._default;
- this.options = options;
- this.start = this.now = this.cur();
- this.end = end;
- this.unit = unit || ( jQuery.cssNumber[ prop ] ? "" : "px" );
- },
- cur: function() {
- var hooks = Tween.propHooks[ this.prop ];
-
- return hooks && hooks.get ?
- hooks.get( this ) :
- Tween.propHooks._default.get( this );
- },
- run: function( percent ) {
- var eased,
- hooks = Tween.propHooks[ this.prop ];
-
- if ( this.options.duration ) {
- this.pos = eased = jQuery.easing[ this.easing ](
- percent, this.options.duration * percent, 0, 1, this.options.duration
- );
- } else {
- this.pos = eased = percent;
- }
- this.now = ( this.end - this.start ) * eased + this.start;
-
- if ( this.options.step ) {
- this.options.step.call( this.elem, this.now, this );
- }
-
- if ( hooks && hooks.set ) {
- hooks.set( this );
- } else {
- Tween.propHooks._default.set( this );
- }
- return this;
- }
-};
-
-Tween.prototype.init.prototype = Tween.prototype;
-
-Tween.propHooks = {
- _default: {
- get: function( tween ) {
- var result;
-
- // Use a property on the element directly when it is not a DOM element,
- // or when there is no matching style property that exists.
- if ( tween.elem.nodeType !== 1 ||
- tween.elem[ tween.prop ] != null && tween.elem.style[ tween.prop ] == null ) {
- return tween.elem[ tween.prop ];
- }
-
- // Passing an empty string as a 3rd parameter to .css will automatically
- // attempt a parseFloat and fallback to a string if the parse fails.
- // Simple values such as "10px" are parsed to Float;
- // complex values such as "rotate(1rad)" are returned as-is.
- result = jQuery.css( tween.elem, tween.prop, "" );
-
- // Empty strings, null, undefined and "auto" are converted to 0.
- return !result || result === "auto" ? 0 : result;
- },
- set: function( tween ) {
-
- // Use step hook for back compat.
- // Use cssHook if its there.
- // Use .style if available and use plain properties where available.
- if ( jQuery.fx.step[ tween.prop ] ) {
- jQuery.fx.step[ tween.prop ]( tween );
- } else if ( tween.elem.nodeType === 1 && (
- jQuery.cssHooks[ tween.prop ] ||
- tween.elem.style[ finalPropName( tween.prop ) ] != null ) ) {
- jQuery.style( tween.elem, tween.prop, tween.now + tween.unit );
- } else {
- tween.elem[ tween.prop ] = tween.now;
- }
- }
- }
-};
-
-// Support: IE <=9 only
-// Panic based approach to setting things on disconnected nodes
-Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
- set: function( tween ) {
- if ( tween.elem.nodeType && tween.elem.parentNode ) {
- tween.elem[ tween.prop ] = tween.now;
- }
- }
-};
-
-jQuery.easing = {
- linear: function( p ) {
- return p;
- },
- swing: function( p ) {
- return 0.5 - Math.cos( p * Math.PI ) / 2;
- },
- _default: "swing"
-};
-
-jQuery.fx = Tween.prototype.init;
-
-// Back compat <1.8 extension point
-jQuery.fx.step = {};
-
-
-
-
-var
- fxNow, inProgress,
- rfxtypes = /^(?:toggle|show|hide)$/,
- rrun = /queueHooks$/;
-
-function schedule() {
- if ( inProgress ) {
- if ( document.hidden === false && window.requestAnimationFrame ) {
- window.requestAnimationFrame( schedule );
- } else {
- window.setTimeout( schedule, jQuery.fx.interval );
- }
-
- jQuery.fx.tick();
- }
-}
-
-// Animations created synchronously will run synchronously
-function createFxNow() {
- window.setTimeout( function() {
- fxNow = undefined;
- } );
- return ( fxNow = Date.now() );
-}
-
-// Generate parameters to create a standard animation
-function genFx( type, includeWidth ) {
- var which,
- i = 0,
- attrs = { height: type };
-
- // If we include width, step value is 1 to do all cssExpand values,
- // otherwise step value is 2 to skip over Left and Right
- includeWidth = includeWidth ? 1 : 0;
- for ( ; i < 4; i += 2 - includeWidth ) {
- which = cssExpand[ i ];
- attrs[ "margin" + which ] = attrs[ "padding" + which ] = type;
- }
-
- if ( includeWidth ) {
- attrs.opacity = attrs.width = type;
- }
-
- return attrs;
-}
-
-function createTween( value, prop, animation ) {
- var tween,
- collection = ( Animation.tweeners[ prop ] || [] ).concat( Animation.tweeners[ "*" ] ),
- index = 0,
- length = collection.length;
- for ( ; index < length; index++ ) {
- if ( ( tween = collection[ index ].call( animation, prop, value ) ) ) {
-
- // We're done with this property
- return tween;
- }
- }
-}
-
-function defaultPrefilter( elem, props, opts ) {
- var prop, value, toggle, hooks, oldfire, propTween, restoreDisplay, display,
- isBox = "width" in props || "height" in props,
- anim = this,
- orig = {},
- style = elem.style,
- hidden = elem.nodeType && isHiddenWithinTree( elem ),
- dataShow = dataPriv.get( elem, "fxshow" );
-
- // Queue-skipping animations hijack the fx hooks
- if ( !opts.queue ) {
- hooks = jQuery._queueHooks( elem, "fx" );
- if ( hooks.unqueued == null ) {
- hooks.unqueued = 0;
- oldfire = hooks.empty.fire;
- hooks.empty.fire = function() {
- if ( !hooks.unqueued ) {
- oldfire();
- }
- };
- }
- hooks.unqueued++;
-
- anim.always( function() {
-
- // Ensure the complete handler is called before this completes
- anim.always( function() {
- hooks.unqueued--;
- if ( !jQuery.queue( elem, "fx" ).length ) {
- hooks.empty.fire();
- }
- } );
- } );
- }
-
- // Detect show/hide animations
- for ( prop in props ) {
- value = props[ prop ];
- if ( rfxtypes.test( value ) ) {
- delete props[ prop ];
- toggle = toggle || value === "toggle";
- if ( value === ( hidden ? "hide" : "show" ) ) {
-
- // Pretend to be hidden if this is a "show" and
- // there is still data from a stopped show/hide
- if ( value === "show" && dataShow && dataShow[ prop ] !== undefined ) {
- hidden = true;
-
- // Ignore all other no-op show/hide data
- } else {
- continue;
- }
- }
- orig[ prop ] = dataShow && dataShow[ prop ] || jQuery.style( elem, prop );
- }
- }
-
- // Bail out if this is a no-op like .hide().hide()
- propTween = !jQuery.isEmptyObject( props );
- if ( !propTween && jQuery.isEmptyObject( orig ) ) {
- return;
- }
-
- // Restrict "overflow" and "display" styles during box animations
- if ( isBox && elem.nodeType === 1 ) {
-
- // Support: IE <=9 - 11, Edge 12 - 15
- // Record all 3 overflow attributes because IE does not infer the shorthand
- // from identically-valued overflowX and overflowY and Edge just mirrors
- // the overflowX value there.
- opts.overflow = [ style.overflow, style.overflowX, style.overflowY ];
-
- // Identify a display type, preferring old show/hide data over the CSS cascade
- restoreDisplay = dataShow && dataShow.display;
- if ( restoreDisplay == null ) {
- restoreDisplay = dataPriv.get( elem, "display" );
- }
- display = jQuery.css( elem, "display" );
- if ( display === "none" ) {
- if ( restoreDisplay ) {
- display = restoreDisplay;
- } else {
-
- // Get nonempty value(s) by temporarily forcing visibility
- showHide( [ elem ], true );
- restoreDisplay = elem.style.display || restoreDisplay;
- display = jQuery.css( elem, "display" );
- showHide( [ elem ] );
- }
- }
-
- // Animate inline elements as inline-block
- if ( display === "inline" || display === "inline-block" && restoreDisplay != null ) {
- if ( jQuery.css( elem, "float" ) === "none" ) {
-
- // Restore the original display value at the end of pure show/hide animations
- if ( !propTween ) {
- anim.done( function() {
- style.display = restoreDisplay;
- } );
- if ( restoreDisplay == null ) {
- display = style.display;
- restoreDisplay = display === "none" ? "" : display;
- }
- }
- style.display = "inline-block";
- }
- }
- }
-
- if ( opts.overflow ) {
- style.overflow = "hidden";
- anim.always( function() {
- style.overflow = opts.overflow[ 0 ];
- style.overflowX = opts.overflow[ 1 ];
- style.overflowY = opts.overflow[ 2 ];
- } );
- }
-
- // Implement show/hide animations
- propTween = false;
- for ( prop in orig ) {
-
- // General show/hide setup for this element animation
- if ( !propTween ) {
- if ( dataShow ) {
- if ( "hidden" in dataShow ) {
- hidden = dataShow.hidden;
- }
- } else {
- dataShow = dataPriv.access( elem, "fxshow", { display: restoreDisplay } );
- }
-
- // Store hidden/visible for toggle so `.stop().toggle()` "reverses"
- if ( toggle ) {
- dataShow.hidden = !hidden;
- }
-
- // Show elements before animating them
- if ( hidden ) {
- showHide( [ elem ], true );
- }
-
- /* eslint-disable no-loop-func */
-
- anim.done( function() {
-
- /* eslint-enable no-loop-func */
-
- // The final step of a "hide" animation is actually hiding the element
- if ( !hidden ) {
- showHide( [ elem ] );
- }
- dataPriv.remove( elem, "fxshow" );
- for ( prop in orig ) {
- jQuery.style( elem, prop, orig[ prop ] );
- }
- } );
- }
-
- // Per-property setup
- propTween = createTween( hidden ? dataShow[ prop ] : 0, prop, anim );
- if ( !( prop in dataShow ) ) {
- dataShow[ prop ] = propTween.start;
- if ( hidden ) {
- propTween.end = propTween.start;
- propTween.start = 0;
- }
- }
- }
-}
-
-function propFilter( props, specialEasing ) {
- var index, name, easing, value, hooks;
-
- // camelCase, specialEasing and expand cssHook pass
- for ( index in props ) {
- name = camelCase( index );
- easing = specialEasing[ name ];
- value = props[ index ];
- if ( Array.isArray( value ) ) {
- easing = value[ 1 ];
- value = props[ index ] = value[ 0 ];
- }
-
- if ( index !== name ) {
- props[ name ] = value;
- delete props[ index ];
- }
-
- hooks = jQuery.cssHooks[ name ];
- if ( hooks && "expand" in hooks ) {
- value = hooks.expand( value );
- delete props[ name ];
-
- // Not quite $.extend, this won't overwrite existing keys.
- // Reusing 'index' because we have the correct "name"
- for ( index in value ) {
- if ( !( index in props ) ) {
- props[ index ] = value[ index ];
- specialEasing[ index ] = easing;
- }
- }
- } else {
- specialEasing[ name ] = easing;
- }
- }
-}
-
-function Animation( elem, properties, options ) {
- var result,
- stopped,
- index = 0,
- length = Animation.prefilters.length,
- deferred = jQuery.Deferred().always( function() {
-
- // Don't match elem in the :animated selector
- delete tick.elem;
- } ),
- tick = function() {
- if ( stopped ) {
- return false;
- }
- var currentTime = fxNow || createFxNow(),
- remaining = Math.max( 0, animation.startTime + animation.duration - currentTime ),
-
- // Support: Android 2.3 only
- // Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
- temp = remaining / animation.duration || 0,
- percent = 1 - temp,
- index = 0,
- length = animation.tweens.length;
-
- for ( ; index < length; index++ ) {
- animation.tweens[ index ].run( percent );
- }
-
- deferred.notifyWith( elem, [ animation, percent, remaining ] );
-
- // If there's more to do, yield
- if ( percent < 1 && length ) {
- return remaining;
- }
-
- // If this was an empty animation, synthesize a final progress notification
- if ( !length ) {
- deferred.notifyWith( elem, [ animation, 1, 0 ] );
- }
-
- // Resolve the animation and report its conclusion
- deferred.resolveWith( elem, [ animation ] );
- return false;
- },
- animation = deferred.promise( {
- elem: elem,
- props: jQuery.extend( {}, properties ),
- opts: jQuery.extend( true, {
- specialEasing: {},
- easing: jQuery.easing._default
- }, options ),
- originalProperties: properties,
- originalOptions: options,
- startTime: fxNow || createFxNow(),
- duration: options.duration,
- tweens: [],
- createTween: function( prop, end ) {
- var tween = jQuery.Tween( elem, animation.opts, prop, end,
- animation.opts.specialEasing[ prop ] || animation.opts.easing );
- animation.tweens.push( tween );
- return tween;
- },
- stop: function( gotoEnd ) {
- var index = 0,
-
- // If we are going to the end, we want to run all the tweens
- // otherwise we skip this part
- length = gotoEnd ? animation.tweens.length : 0;
- if ( stopped ) {
- return this;
- }
- stopped = true;
- for ( ; index < length; index++ ) {
- animation.tweens[ index ].run( 1 );
- }
-
- // Resolve when we played the last frame; otherwise, reject
- if ( gotoEnd ) {
- deferred.notifyWith( elem, [ animation, 1, 0 ] );
- deferred.resolveWith( elem, [ animation, gotoEnd ] );
- } else {
- deferred.rejectWith( elem, [ animation, gotoEnd ] );
- }
- return this;
- }
- } ),
- props = animation.props;
-
- propFilter( props, animation.opts.specialEasing );
-
- for ( ; index < length; index++ ) {
- result = Animation.prefilters[ index ].call( animation, elem, props, animation.opts );
- if ( result ) {
- if ( isFunction( result.stop ) ) {
- jQuery._queueHooks( animation.elem, animation.opts.queue ).stop =
- result.stop.bind( result );
- }
- return result;
- }
- }
-
- jQuery.map( props, createTween, animation );
-
- if ( isFunction( animation.opts.start ) ) {
- animation.opts.start.call( elem, animation );
- }
-
- // Attach callbacks from options
- animation
- .progress( animation.opts.progress )
- .done( animation.opts.done, animation.opts.complete )
- .fail( animation.opts.fail )
- .always( animation.opts.always );
-
- jQuery.fx.timer(
- jQuery.extend( tick, {
- elem: elem,
- anim: animation,
- queue: animation.opts.queue
- } )
- );
-
- return animation;
-}
-
-jQuery.Animation = jQuery.extend( Animation, {
-
- tweeners: {
- "*": [ function( prop, value ) {
- var tween = this.createTween( prop, value );
- adjustCSS( tween.elem, prop, rcssNum.exec( value ), tween );
- return tween;
- } ]
- },
-
- tweener: function( props, callback ) {
- if ( isFunction( props ) ) {
- callback = props;
- props = [ "*" ];
- } else {
- props = props.match( rnothtmlwhite );
- }
-
- var prop,
- index = 0,
- length = props.length;
-
- for ( ; index < length; index++ ) {
- prop = props[ index ];
- Animation.tweeners[ prop ] = Animation.tweeners[ prop ] || [];
- Animation.tweeners[ prop ].unshift( callback );
- }
- },
-
- prefilters: [ defaultPrefilter ],
-
- prefilter: function( callback, prepend ) {
- if ( prepend ) {
- Animation.prefilters.unshift( callback );
- } else {
- Animation.prefilters.push( callback );
- }
- }
-} );
-
-jQuery.speed = function( speed, easing, fn ) {
- var opt = speed && typeof speed === "object" ? jQuery.extend( {}, speed ) : {
- complete: fn || !fn && easing ||
- isFunction( speed ) && speed,
- duration: speed,
- easing: fn && easing || easing && !isFunction( easing ) && easing
- };
-
- // Go to the end state if fx are off
- if ( jQuery.fx.off ) {
- opt.duration = 0;
-
- } else {
- if ( typeof opt.duration !== "number" ) {
- if ( opt.duration in jQuery.fx.speeds ) {
- opt.duration = jQuery.fx.speeds[ opt.duration ];
-
- } else {
- opt.duration = jQuery.fx.speeds._default;
- }
- }
- }
-
- // Normalize opt.queue - true/undefined/null -> "fx"
- if ( opt.queue == null || opt.queue === true ) {
- opt.queue = "fx";
- }
-
- // Queueing
- opt.old = opt.complete;
-
- opt.complete = function() {
- if ( isFunction( opt.old ) ) {
- opt.old.call( this );
- }
-
- if ( opt.queue ) {
- jQuery.dequeue( this, opt.queue );
- }
- };
-
- return opt;
-};
-
-jQuery.fn.extend( {
- fadeTo: function( speed, to, easing, callback ) {
-
- // Show any hidden elements after setting opacity to 0
- return this.filter( isHiddenWithinTree ).css( "opacity", 0 ).show()
-
- // Animate to the value specified
- .end().animate( { opacity: to }, speed, easing, callback );
- },
- animate: function( prop, speed, easing, callback ) {
- var empty = jQuery.isEmptyObject( prop ),
- optall = jQuery.speed( speed, easing, callback ),
- doAnimation = function() {
-
- // Operate on a copy of prop so per-property easing won't be lost
- var anim = Animation( this, jQuery.extend( {}, prop ), optall );
-
- // Empty animations, or finishing resolves immediately
- if ( empty || dataPriv.get( this, "finish" ) ) {
- anim.stop( true );
- }
- };
-
- doAnimation.finish = doAnimation;
-
- return empty || optall.queue === false ?
- this.each( doAnimation ) :
- this.queue( optall.queue, doAnimation );
- },
- stop: function( type, clearQueue, gotoEnd ) {
- var stopQueue = function( hooks ) {
- var stop = hooks.stop;
- delete hooks.stop;
- stop( gotoEnd );
- };
-
- if ( typeof type !== "string" ) {
- gotoEnd = clearQueue;
- clearQueue = type;
- type = undefined;
- }
- if ( clearQueue ) {
- this.queue( type || "fx", [] );
- }
-
- return this.each( function() {
- var dequeue = true,
- index = type != null && type + "queueHooks",
- timers = jQuery.timers,
- data = dataPriv.get( this );
-
- if ( index ) {
- if ( data[ index ] && data[ index ].stop ) {
- stopQueue( data[ index ] );
- }
- } else {
- for ( index in data ) {
- if ( data[ index ] && data[ index ].stop && rrun.test( index ) ) {
- stopQueue( data[ index ] );
- }
- }
- }
-
- for ( index = timers.length; index--; ) {
- if ( timers[ index ].elem === this &&
- ( type == null || timers[ index ].queue === type ) ) {
-
- timers[ index ].anim.stop( gotoEnd );
- dequeue = false;
- timers.splice( index, 1 );
- }
- }
-
- // Start the next in the queue if the last step wasn't forced.
- // Timers currently will call their complete callbacks, which
- // will dequeue but only if they were gotoEnd.
- if ( dequeue || !gotoEnd ) {
- jQuery.dequeue( this, type );
- }
- } );
- },
- finish: function( type ) {
- if ( type !== false ) {
- type = type || "fx";
- }
- return this.each( function() {
- var index,
- data = dataPriv.get( this ),
- queue = data[ type + "queue" ],
- hooks = data[ type + "queueHooks" ],
- timers = jQuery.timers,
- length = queue ? queue.length : 0;
-
- // Enable finishing flag on private data
- data.finish = true;
-
- // Empty the queue first
- jQuery.queue( this, type, [] );
-
- if ( hooks && hooks.stop ) {
- hooks.stop.call( this, true );
- }
-
- // Look for any active animations, and finish them
- for ( index = timers.length; index--; ) {
- if ( timers[ index ].elem === this && timers[ index ].queue === type ) {
- timers[ index ].anim.stop( true );
- timers.splice( index, 1 );
- }
- }
-
- // Look for any animations in the old queue and finish them
- for ( index = 0; index < length; index++ ) {
- if ( queue[ index ] && queue[ index ].finish ) {
- queue[ index ].finish.call( this );
- }
- }
-
- // Turn off finishing flag
- delete data.finish;
- } );
- }
-} );
-
-jQuery.each( [ "toggle", "show", "hide" ], function( _i, name ) {
- var cssFn = jQuery.fn[ name ];
- jQuery.fn[ name ] = function( speed, easing, callback ) {
- return speed == null || typeof speed === "boolean" ?
- cssFn.apply( this, arguments ) :
- this.animate( genFx( name, true ), speed, easing, callback );
- };
-} );
-
-// Generate shortcuts for custom animations
-jQuery.each( {
- slideDown: genFx( "show" ),
- slideUp: genFx( "hide" ),
- slideToggle: genFx( "toggle" ),
- fadeIn: { opacity: "show" },
- fadeOut: { opacity: "hide" },
- fadeToggle: { opacity: "toggle" }
-}, function( name, props ) {
- jQuery.fn[ name ] = function( speed, easing, callback ) {
- return this.animate( props, speed, easing, callback );
- };
-} );
-
-jQuery.timers = [];
-jQuery.fx.tick = function() {
- var timer,
- i = 0,
- timers = jQuery.timers;
-
- fxNow = Date.now();
-
- for ( ; i < timers.length; i++ ) {
- timer = timers[ i ];
-
- // Run the timer and safely remove it when done (allowing for external removal)
- if ( !timer() && timers[ i ] === timer ) {
- timers.splice( i--, 1 );
- }
- }
-
- if ( !timers.length ) {
- jQuery.fx.stop();
- }
- fxNow = undefined;
-};
-
-jQuery.fx.timer = function( timer ) {
- jQuery.timers.push( timer );
- jQuery.fx.start();
-};
-
-jQuery.fx.interval = 13;
-jQuery.fx.start = function() {
- if ( inProgress ) {
- return;
- }
-
- inProgress = true;
- schedule();
-};
-
-jQuery.fx.stop = function() {
- inProgress = null;
-};
-
-jQuery.fx.speeds = {
- slow: 600,
- fast: 200,
-
- // Default speed
- _default: 400
-};
-
-
-// Based off of the plugin by Clint Helfers, with permission.
-// https://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
-jQuery.fn.delay = function( time, type ) {
- time = jQuery.fx ? jQuery.fx.speeds[ time ] || time : time;
- type = type || "fx";
-
- return this.queue( type, function( next, hooks ) {
- var timeout = window.setTimeout( next, time );
- hooks.stop = function() {
- window.clearTimeout( timeout );
- };
- } );
-};
-
-
-( function() {
- var input = document.createElement( "input" ),
- select = document.createElement( "select" ),
- opt = select.appendChild( document.createElement( "option" ) );
-
- input.type = "checkbox";
-
- // Support: Android <=4.3 only
- // Default value for a checkbox should be "on"
- support.checkOn = input.value !== "";
-
- // Support: IE <=11 only
- // Must access selectedIndex to make default options select
- support.optSelected = opt.selected;
-
- // Support: IE <=11 only
- // An input loses its value after becoming a radio
- input = document.createElement( "input" );
- input.value = "t";
- input.type = "radio";
- support.radioValue = input.value === "t";
-} )();
-
-
-var boolHook,
- attrHandle = jQuery.expr.attrHandle;
-
-jQuery.fn.extend( {
- attr: function( name, value ) {
- return access( this, jQuery.attr, name, value, arguments.length > 1 );
- },
-
- removeAttr: function( name ) {
- return this.each( function() {
- jQuery.removeAttr( this, name );
- } );
- }
-} );
-
-jQuery.extend( {
- attr: function( elem, name, value ) {
- var ret, hooks,
- nType = elem.nodeType;
-
- // Don't get/set attributes on text, comment and attribute nodes
- if ( nType === 3 || nType === 8 || nType === 2 ) {
- return;
- }
-
- // Fallback to prop when attributes are not supported
- if ( typeof elem.getAttribute === "undefined" ) {
- return jQuery.prop( elem, name, value );
- }
-
- // Attribute hooks are determined by the lowercase version
- // Grab necessary hook if one is defined
- if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
- hooks = jQuery.attrHooks[ name.toLowerCase() ] ||
- ( jQuery.expr.match.bool.test( name ) ? boolHook : undefined );
- }
-
- if ( value !== undefined ) {
- if ( value === null ) {
- jQuery.removeAttr( elem, name );
- return;
- }
-
- if ( hooks && "set" in hooks &&
- ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
- return ret;
- }
-
- elem.setAttribute( name, value + "" );
- return value;
- }
-
- if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
- return ret;
- }
-
- ret = jQuery.find.attr( elem, name );
-
- // Non-existent attributes return null, we normalize to undefined
- return ret == null ? undefined : ret;
- },
-
- attrHooks: {
- type: {
- set: function( elem, value ) {
- if ( !support.radioValue && value === "radio" &&
- nodeName( elem, "input" ) ) {
- var val = elem.value;
- elem.setAttribute( "type", value );
- if ( val ) {
- elem.value = val;
- }
- return value;
- }
- }
- }
- },
-
- removeAttr: function( elem, value ) {
- var name,
- i = 0,
-
- // Attribute names can contain non-HTML whitespace characters
- // https://html.spec.whatwg.org/multipage/syntax.html#attributes-2
- attrNames = value && value.match( rnothtmlwhite );
-
- if ( attrNames && elem.nodeType === 1 ) {
- while ( ( name = attrNames[ i++ ] ) ) {
- elem.removeAttribute( name );
- }
- }
- }
-} );
-
-// Hooks for boolean attributes
-boolHook = {
- set: function( elem, value, name ) {
- if ( value === false ) {
-
- // Remove boolean attributes when set to false
- jQuery.removeAttr( elem, name );
- } else {
- elem.setAttribute( name, name );
- }
- return name;
- }
-};
-
-jQuery.each( jQuery.expr.match.bool.source.match( /\w+/g ), function( _i, name ) {
- var getter = attrHandle[ name ] || jQuery.find.attr;
-
- attrHandle[ name ] = function( elem, name, isXML ) {
- var ret, handle,
- lowercaseName = name.toLowerCase();
-
- if ( !isXML ) {
-
- // Avoid an infinite loop by temporarily removing this function from the getter
- handle = attrHandle[ lowercaseName ];
- attrHandle[ lowercaseName ] = ret;
- ret = getter( elem, name, isXML ) != null ?
- lowercaseName :
- null;
- attrHandle[ lowercaseName ] = handle;
- }
- return ret;
- };
-} );
-
-
-
-
-var rfocusable = /^(?:input|select|textarea|button)$/i,
- rclickable = /^(?:a|area)$/i;
-
-jQuery.fn.extend( {
- prop: function( name, value ) {
- return access( this, jQuery.prop, name, value, arguments.length > 1 );
- },
-
- removeProp: function( name ) {
- return this.each( function() {
- delete this[ jQuery.propFix[ name ] || name ];
- } );
- }
-} );
-
-jQuery.extend( {
- prop: function( elem, name, value ) {
- var ret, hooks,
- nType = elem.nodeType;
-
- // Don't get/set properties on text, comment and attribute nodes
- if ( nType === 3 || nType === 8 || nType === 2 ) {
- return;
- }
-
- if ( nType !== 1 || !jQuery.isXMLDoc( elem ) ) {
-
- // Fix name and attach hooks
- name = jQuery.propFix[ name ] || name;
- hooks = jQuery.propHooks[ name ];
- }
-
- if ( value !== undefined ) {
- if ( hooks && "set" in hooks &&
- ( ret = hooks.set( elem, value, name ) ) !== undefined ) {
- return ret;
- }
-
- return ( elem[ name ] = value );
- }
-
- if ( hooks && "get" in hooks && ( ret = hooks.get( elem, name ) ) !== null ) {
- return ret;
- }
-
- return elem[ name ];
- },
-
- propHooks: {
- tabIndex: {
- get: function( elem ) {
-
- // Support: IE <=9 - 11 only
- // elem.tabIndex doesn't always return the
- // correct value when it hasn't been explicitly set
- // https://web.archive.org/web/20141116233347/http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
- // Use proper attribute retrieval(#12072)
- var tabindex = jQuery.find.attr( elem, "tabindex" );
-
- if ( tabindex ) {
- return parseInt( tabindex, 10 );
- }
-
- if (
- rfocusable.test( elem.nodeName ) ||
- rclickable.test( elem.nodeName ) &&
- elem.href
- ) {
- return 0;
- }
-
- return -1;
- }
- }
- },
-
- propFix: {
- "for": "htmlFor",
- "class": "className"
- }
-} );
-
-// Support: IE <=11 only
-// Accessing the selectedIndex property
-// forces the browser to respect setting selected
-// on the option
-// The getter ensures a default option is selected
-// when in an optgroup
-// eslint rule "no-unused-expressions" is disabled for this code
-// since it considers such accessions noop
-if ( !support.optSelected ) {
- jQuery.propHooks.selected = {
- get: function( elem ) {
-
- /* eslint no-unused-expressions: "off" */
-
- var parent = elem.parentNode;
- if ( parent && parent.parentNode ) {
- parent.parentNode.selectedIndex;
- }
- return null;
- },
- set: function( elem ) {
-
- /* eslint no-unused-expressions: "off" */
-
- var parent = elem.parentNode;
- if ( parent ) {
- parent.selectedIndex;
-
- if ( parent.parentNode ) {
- parent.parentNode.selectedIndex;
- }
- }
- }
- };
-}
-
-jQuery.each( [
- "tabIndex",
- "readOnly",
- "maxLength",
- "cellSpacing",
- "cellPadding",
- "rowSpan",
- "colSpan",
- "useMap",
- "frameBorder",
- "contentEditable"
-], function() {
- jQuery.propFix[ this.toLowerCase() ] = this;
-} );
-
-
-
-
- // Strip and collapse whitespace according to HTML spec
- // https://infra.spec.whatwg.org/#strip-and-collapse-ascii-whitespace
- function stripAndCollapse( value ) {
- var tokens = value.match( rnothtmlwhite ) || [];
- return tokens.join( " " );
- }
-
-
-function getClass( elem ) {
- return elem.getAttribute && elem.getAttribute( "class" ) || "";
-}
-
-function classesToArray( value ) {
- if ( Array.isArray( value ) ) {
- return value;
- }
- if ( typeof value === "string" ) {
- return value.match( rnothtmlwhite ) || [];
- }
- return [];
-}
-
-jQuery.fn.extend( {
- addClass: function( value ) {
- var classes, elem, cur, curValue, clazz, j, finalValue,
- i = 0;
-
- if ( isFunction( value ) ) {
- return this.each( function( j ) {
- jQuery( this ).addClass( value.call( this, j, getClass( this ) ) );
- } );
- }
-
- classes = classesToArray( value );
-
- if ( classes.length ) {
- while ( ( elem = this[ i++ ] ) ) {
- curValue = getClass( elem );
- cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
-
- if ( cur ) {
- j = 0;
- while ( ( clazz = classes[ j++ ] ) ) {
- if ( cur.indexOf( " " + clazz + " " ) < 0 ) {
- cur += clazz + " ";
- }
- }
-
- // Only assign if different to avoid unneeded rendering.
- finalValue = stripAndCollapse( cur );
- if ( curValue !== finalValue ) {
- elem.setAttribute( "class", finalValue );
- }
- }
- }
- }
-
- return this;
- },
-
- removeClass: function( value ) {
- var classes, elem, cur, curValue, clazz, j, finalValue,
- i = 0;
-
- if ( isFunction( value ) ) {
- return this.each( function( j ) {
- jQuery( this ).removeClass( value.call( this, j, getClass( this ) ) );
- } );
- }
-
- if ( !arguments.length ) {
- return this.attr( "class", "" );
- }
-
- classes = classesToArray( value );
-
- if ( classes.length ) {
- while ( ( elem = this[ i++ ] ) ) {
- curValue = getClass( elem );
-
- // This expression is here for better compressibility (see addClass)
- cur = elem.nodeType === 1 && ( " " + stripAndCollapse( curValue ) + " " );
-
- if ( cur ) {
- j = 0;
- while ( ( clazz = classes[ j++ ] ) ) {
-
- // Remove *all* instances
- while ( cur.indexOf( " " + clazz + " " ) > -1 ) {
- cur = cur.replace( " " + clazz + " ", " " );
- }
- }
-
- // Only assign if different to avoid unneeded rendering.
- finalValue = stripAndCollapse( cur );
- if ( curValue !== finalValue ) {
- elem.setAttribute( "class", finalValue );
- }
- }
- }
- }
-
- return this;
- },
-
- toggleClass: function( value, stateVal ) {
- var type = typeof value,
- isValidValue = type === "string" || Array.isArray( value );
-
- if ( typeof stateVal === "boolean" && isValidValue ) {
- return stateVal ? this.addClass( value ) : this.removeClass( value );
- }
-
- if ( isFunction( value ) ) {
- return this.each( function( i ) {
- jQuery( this ).toggleClass(
- value.call( this, i, getClass( this ), stateVal ),
- stateVal
- );
- } );
- }
-
- return this.each( function() {
- var className, i, self, classNames;
-
- if ( isValidValue ) {
-
- // Toggle individual class names
- i = 0;
- self = jQuery( this );
- classNames = classesToArray( value );
-
- while ( ( className = classNames[ i++ ] ) ) {
-
- // Check each className given, space separated list
- if ( self.hasClass( className ) ) {
- self.removeClass( className );
- } else {
- self.addClass( className );
- }
- }
-
- // Toggle whole class name
- } else if ( value === undefined || type === "boolean" ) {
- className = getClass( this );
- if ( className ) {
-
- // Store className if set
- dataPriv.set( this, "__className__", className );
- }
-
- // If the element has a class name or if we're passed `false`,
- // then remove the whole classname (if there was one, the above saved it).
- // Otherwise bring back whatever was previously saved (if anything),
- // falling back to the empty string if nothing was stored.
- if ( this.setAttribute ) {
- this.setAttribute( "class",
- className || value === false ?
- "" :
- dataPriv.get( this, "__className__" ) || ""
- );
- }
- }
- } );
- },
-
- hasClass: function( selector ) {
- var className, elem,
- i = 0;
-
- className = " " + selector + " ";
- while ( ( elem = this[ i++ ] ) ) {
- if ( elem.nodeType === 1 &&
- ( " " + stripAndCollapse( getClass( elem ) ) + " " ).indexOf( className ) > -1 ) {
- return true;
- }
- }
-
- return false;
- }
-} );
-
-
-
-
-var rreturn = /\r/g;
-
-jQuery.fn.extend( {
- val: function( value ) {
- var hooks, ret, valueIsFunction,
- elem = this[ 0 ];
-
- if ( !arguments.length ) {
- if ( elem ) {
- hooks = jQuery.valHooks[ elem.type ] ||
- jQuery.valHooks[ elem.nodeName.toLowerCase() ];
-
- if ( hooks &&
- "get" in hooks &&
- ( ret = hooks.get( elem, "value" ) ) !== undefined
- ) {
- return ret;
- }
-
- ret = elem.value;
-
- // Handle most common string cases
- if ( typeof ret === "string" ) {
- return ret.replace( rreturn, "" );
- }
-
- // Handle cases where value is null/undef or number
- return ret == null ? "" : ret;
- }
-
- return;
- }
-
- valueIsFunction = isFunction( value );
-
- return this.each( function( i ) {
- var val;
-
- if ( this.nodeType !== 1 ) {
- return;
- }
-
- if ( valueIsFunction ) {
- val = value.call( this, i, jQuery( this ).val() );
- } else {
- val = value;
- }
-
- // Treat null/undefined as ""; convert numbers to string
- if ( val == null ) {
- val = "";
-
- } else if ( typeof val === "number" ) {
- val += "";
-
- } else if ( Array.isArray( val ) ) {
- val = jQuery.map( val, function( value ) {
- return value == null ? "" : value + "";
- } );
- }
-
- hooks = jQuery.valHooks[ this.type ] || jQuery.valHooks[ this.nodeName.toLowerCase() ];
-
- // If set returns undefined, fall back to normal setting
- if ( !hooks || !( "set" in hooks ) || hooks.set( this, val, "value" ) === undefined ) {
- this.value = val;
- }
- } );
- }
-} );
-
-jQuery.extend( {
- valHooks: {
- option: {
- get: function( elem ) {
-
- var val = jQuery.find.attr( elem, "value" );
- return val != null ?
- val :
-
- // Support: IE <=10 - 11 only
- // option.text throws exceptions (#14686, #14858)
- // Strip and collapse whitespace
- // https://html.spec.whatwg.org/#strip-and-collapse-whitespace
- stripAndCollapse( jQuery.text( elem ) );
- }
- },
- select: {
- get: function( elem ) {
- var value, option, i,
- options = elem.options,
- index = elem.selectedIndex,
- one = elem.type === "select-one",
- values = one ? null : [],
- max = one ? index + 1 : options.length;
-
- if ( index < 0 ) {
- i = max;
-
- } else {
- i = one ? index : 0;
- }
-
- // Loop through all the selected options
- for ( ; i < max; i++ ) {
- option = options[ i ];
-
- // Support: IE <=9 only
- // IE8-9 doesn't update selected after form reset (#2551)
- if ( ( option.selected || i === index ) &&
-
- // Don't return options that are disabled or in a disabled optgroup
- !option.disabled &&
- ( !option.parentNode.disabled ||
- !nodeName( option.parentNode, "optgroup" ) ) ) {
-
- // Get the specific value for the option
- value = jQuery( option ).val();
-
- // We don't need an array for one selects
- if ( one ) {
- return value;
- }
-
- // Multi-Selects return an array
- values.push( value );
- }
- }
-
- return values;
- },
-
- set: function( elem, value ) {
- var optionSet, option,
- options = elem.options,
- values = jQuery.makeArray( value ),
- i = options.length;
-
- while ( i-- ) {
- option = options[ i ];
-
- /* eslint-disable no-cond-assign */
-
- if ( option.selected =
- jQuery.inArray( jQuery.valHooks.option.get( option ), values ) > -1
- ) {
- optionSet = true;
- }
-
- /* eslint-enable no-cond-assign */
- }
-
- // Force browsers to behave consistently when non-matching value is set
- if ( !optionSet ) {
- elem.selectedIndex = -1;
- }
- return values;
- }
- }
- }
-} );
-
-// Radios and checkboxes getter/setter
-jQuery.each( [ "radio", "checkbox" ], function() {
- jQuery.valHooks[ this ] = {
- set: function( elem, value ) {
- if ( Array.isArray( value ) ) {
- return ( elem.checked = jQuery.inArray( jQuery( elem ).val(), value ) > -1 );
- }
- }
- };
- if ( !support.checkOn ) {
- jQuery.valHooks[ this ].get = function( elem ) {
- return elem.getAttribute( "value" ) === null ? "on" : elem.value;
- };
- }
-} );
-
-
-
-
-// Return jQuery for attributes-only inclusion
-
-
-support.focusin = "onfocusin" in window;
-
-
-var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/,
- stopPropagationCallback = function( e ) {
- e.stopPropagation();
- };
-
-jQuery.extend( jQuery.event, {
-
- trigger: function( event, data, elem, onlyHandlers ) {
-
- var i, cur, tmp, bubbleType, ontype, handle, special, lastElement,
- eventPath = [ elem || document ],
- type = hasOwn.call( event, "type" ) ? event.type : event,
- namespaces = hasOwn.call( event, "namespace" ) ? event.namespace.split( "." ) : [];
-
- cur = lastElement = tmp = elem = elem || document;
-
- // Don't do events on text and comment nodes
- if ( elem.nodeType === 3 || elem.nodeType === 8 ) {
- return;
- }
-
- // focus/blur morphs to focusin/out; ensure we're not firing them right now
- if ( rfocusMorph.test( type + jQuery.event.triggered ) ) {
- return;
- }
-
- if ( type.indexOf( "." ) > -1 ) {
-
- // Namespaced trigger; create a regexp to match event type in handle()
- namespaces = type.split( "." );
- type = namespaces.shift();
- namespaces.sort();
- }
- ontype = type.indexOf( ":" ) < 0 && "on" + type;
-
- // Caller can pass in a jQuery.Event object, Object, or just an event type string
- event = event[ jQuery.expando ] ?
- event :
- new jQuery.Event( type, typeof event === "object" && event );
-
- // Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
- event.isTrigger = onlyHandlers ? 2 : 3;
- event.namespace = namespaces.join( "." );
- event.rnamespace = event.namespace ?
- new RegExp( "(^|\\.)" + namespaces.join( "\\.(?:.*\\.|)" ) + "(\\.|$)" ) :
- null;
-
- // Clean up the event in case it is being reused
- event.result = undefined;
- if ( !event.target ) {
- event.target = elem;
- }
-
- // Clone any incoming data and prepend the event, creating the handler arg list
- data = data == null ?
- [ event ] :
- jQuery.makeArray( data, [ event ] );
-
- // Allow special events to draw outside the lines
- special = jQuery.event.special[ type ] || {};
- if ( !onlyHandlers && special.trigger && special.trigger.apply( elem, data ) === false ) {
- return;
- }
-
- // Determine event propagation path in advance, per W3C events spec (#9951)
- // Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
- if ( !onlyHandlers && !special.noBubble && !isWindow( elem ) ) {
-
- bubbleType = special.delegateType || type;
- if ( !rfocusMorph.test( bubbleType + type ) ) {
- cur = cur.parentNode;
- }
- for ( ; cur; cur = cur.parentNode ) {
- eventPath.push( cur );
- tmp = cur;
- }
-
- // Only add window if we got to document (e.g., not plain obj or detached DOM)
- if ( tmp === ( elem.ownerDocument || document ) ) {
- eventPath.push( tmp.defaultView || tmp.parentWindow || window );
- }
- }
-
- // Fire handlers on the event path
- i = 0;
- while ( ( cur = eventPath[ i++ ] ) && !event.isPropagationStopped() ) {
- lastElement = cur;
- event.type = i > 1 ?
- bubbleType :
- special.bindType || type;
-
- // jQuery handler
- handle = ( dataPriv.get( cur, "events" ) || Object.create( null ) )[ event.type ] &&
- dataPriv.get( cur, "handle" );
- if ( handle ) {
- handle.apply( cur, data );
- }
-
- // Native handler
- handle = ontype && cur[ ontype ];
- if ( handle && handle.apply && acceptData( cur ) ) {
- event.result = handle.apply( cur, data );
- if ( event.result === false ) {
- event.preventDefault();
- }
- }
- }
- event.type = type;
-
- // If nobody prevented the default action, do it now
- if ( !onlyHandlers && !event.isDefaultPrevented() ) {
-
- if ( ( !special._default ||
- special._default.apply( eventPath.pop(), data ) === false ) &&
- acceptData( elem ) ) {
-
- // Call a native DOM method on the target with the same name as the event.
- // Don't do default actions on window, that's where global variables be (#6170)
- if ( ontype && isFunction( elem[ type ] ) && !isWindow( elem ) ) {
-
- // Don't re-trigger an onFOO event when we call its FOO() method
- tmp = elem[ ontype ];
-
- if ( tmp ) {
- elem[ ontype ] = null;
- }
-
- // Prevent re-triggering of the same event, since we already bubbled it above
- jQuery.event.triggered = type;
-
- if ( event.isPropagationStopped() ) {
- lastElement.addEventListener( type, stopPropagationCallback );
- }
-
- elem[ type ]();
-
- if ( event.isPropagationStopped() ) {
- lastElement.removeEventListener( type, stopPropagationCallback );
- }
-
- jQuery.event.triggered = undefined;
-
- if ( tmp ) {
- elem[ ontype ] = tmp;
- }
- }
- }
- }
-
- return event.result;
- },
-
- // Piggyback on a donor event to simulate a different one
- // Used only for `focus(in | out)` events
- simulate: function( type, elem, event ) {
- var e = jQuery.extend(
- new jQuery.Event(),
- event,
- {
- type: type,
- isSimulated: true
- }
- );
-
- jQuery.event.trigger( e, null, elem );
- }
-
-} );
-
-jQuery.fn.extend( {
-
- trigger: function( type, data ) {
- return this.each( function() {
- jQuery.event.trigger( type, data, this );
- } );
- },
- triggerHandler: function( type, data ) {
- var elem = this[ 0 ];
- if ( elem ) {
- return jQuery.event.trigger( type, data, elem, true );
- }
- }
-} );
-
-
-// Support: Firefox <=44
-// Firefox doesn't have focus(in | out) events
-// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
-//
-// Support: Chrome <=48 - 49, Safari <=9.0 - 9.1
-// focus(in | out) events fire after focus & blur events,
-// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
-// Related ticket - https://bugs.chromium.org/p/chromium/issues/detail?id=449857
-if ( !support.focusin ) {
- jQuery.each( { focus: "focusin", blur: "focusout" }, function( orig, fix ) {
-
- // Attach a single capturing handler on the document while someone wants focusin/focusout
- var handler = function( event ) {
- jQuery.event.simulate( fix, event.target, jQuery.event.fix( event ) );
- };
-
- jQuery.event.special[ fix ] = {
- setup: function() {
-
- // Handle: regular nodes (via `this.ownerDocument`), window
- // (via `this.document`) & document (via `this`).
- var doc = this.ownerDocument || this.document || this,
- attaches = dataPriv.access( doc, fix );
-
- if ( !attaches ) {
- doc.addEventListener( orig, handler, true );
- }
- dataPriv.access( doc, fix, ( attaches || 0 ) + 1 );
- },
- teardown: function() {
- var doc = this.ownerDocument || this.document || this,
- attaches = dataPriv.access( doc, fix ) - 1;
-
- if ( !attaches ) {
- doc.removeEventListener( orig, handler, true );
- dataPriv.remove( doc, fix );
-
- } else {
- dataPriv.access( doc, fix, attaches );
- }
- }
- };
- } );
-}
-var location = window.location;
-
-var nonce = { guid: Date.now() };
-
-var rquery = ( /\?/ );
-
-
-
-// Cross-browser xml parsing
-jQuery.parseXML = function( data ) {
- var xml, parserErrorElem;
- if ( !data || typeof data !== "string" ) {
- return null;
- }
-
- // Support: IE 9 - 11 only
- // IE throws on parseFromString with invalid input.
- try {
- xml = ( new window.DOMParser() ).parseFromString( data, "text/xml" );
- } catch ( e ) {}
-
- parserErrorElem = xml && xml.getElementsByTagName( "parsererror" )[ 0 ];
- if ( !xml || parserErrorElem ) {
- jQuery.error( "Invalid XML: " + (
- parserErrorElem ?
- jQuery.map( parserErrorElem.childNodes, function( el ) {
- return el.textContent;
- } ).join( "\n" ) :
- data
- ) );
- }
- return xml;
-};
-
-
-var
- rbracket = /\[\]$/,
- rCRLF = /\r?\n/g,
- rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i,
- rsubmittable = /^(?:input|select|textarea|keygen)/i;
-
-function buildParams( prefix, obj, traditional, add ) {
- var name;
-
- if ( Array.isArray( obj ) ) {
-
- // Serialize array item.
- jQuery.each( obj, function( i, v ) {
- if ( traditional || rbracket.test( prefix ) ) {
-
- // Treat each array item as a scalar.
- add( prefix, v );
-
- } else {
-
- // Item is non-scalar (array or object), encode its numeric index.
- buildParams(
- prefix + "[" + ( typeof v === "object" && v != null ? i : "" ) + "]",
- v,
- traditional,
- add
- );
- }
- } );
-
- } else if ( !traditional && toType( obj ) === "object" ) {
-
- // Serialize object item.
- for ( name in obj ) {
- buildParams( prefix + "[" + name + "]", obj[ name ], traditional, add );
- }
-
- } else {
-
- // Serialize scalar item.
- add( prefix, obj );
- }
-}
-
-// Serialize an array of form elements or a set of
-// key/values into a query string
-jQuery.param = function( a, traditional ) {
- var prefix,
- s = [],
- add = function( key, valueOrFunction ) {
-
- // If value is a function, invoke it and use its return value
- var value = isFunction( valueOrFunction ) ?
- valueOrFunction() :
- valueOrFunction;
-
- s[ s.length ] = encodeURIComponent( key ) + "=" +
- encodeURIComponent( value == null ? "" : value );
- };
-
- if ( a == null ) {
- return "";
- }
-
- // If an array was passed in, assume that it is an array of form elements.
- if ( Array.isArray( a ) || ( a.jquery && !jQuery.isPlainObject( a ) ) ) {
-
- // Serialize the form elements
- jQuery.each( a, function() {
- add( this.name, this.value );
- } );
-
- } else {
-
- // If traditional, encode the "old" way (the way 1.3.2 or older
- // did it), otherwise encode params recursively.
- for ( prefix in a ) {
- buildParams( prefix, a[ prefix ], traditional, add );
- }
- }
-
- // Return the resulting serialization
- return s.join( "&" );
-};
-
-jQuery.fn.extend( {
- serialize: function() {
- return jQuery.param( this.serializeArray() );
- },
- serializeArray: function() {
- return this.map( function() {
-
- // Can add propHook for "elements" to filter or add form elements
- var elements = jQuery.prop( this, "elements" );
- return elements ? jQuery.makeArray( elements ) : this;
- } ).filter( function() {
- var type = this.type;
-
- // Use .is( ":disabled" ) so that fieldset[disabled] works
- return this.name && !jQuery( this ).is( ":disabled" ) &&
- rsubmittable.test( this.nodeName ) && !rsubmitterTypes.test( type ) &&
- ( this.checked || !rcheckableType.test( type ) );
- } ).map( function( _i, elem ) {
- var val = jQuery( this ).val();
-
- if ( val == null ) {
- return null;
- }
-
- if ( Array.isArray( val ) ) {
- return jQuery.map( val, function( val ) {
- return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
- } );
- }
-
- return { name: elem.name, value: val.replace( rCRLF, "\r\n" ) };
- } ).get();
- }
-} );
-
-
-var
- r20 = /%20/g,
- rhash = /#.*$/,
- rantiCache = /([?&])_=[^&]*/,
- rheaders = /^(.*?):[ \t]*([^\r\n]*)$/mg,
-
- // #7653, #8125, #8152: local protocol detection
- rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/,
- rnoContent = /^(?:GET|HEAD)$/,
- rprotocol = /^\/\//,
-
- /* Prefilters
- * 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
- * 2) These are called:
- * - BEFORE asking for a transport
- * - AFTER param serialization (s.data is a string if s.processData is true)
- * 3) key is the dataType
- * 4) the catchall symbol "*" can be used
- * 5) execution will start with transport dataType and THEN continue down to "*" if needed
- */
- prefilters = {},
-
- /* Transports bindings
- * 1) key is the dataType
- * 2) the catchall symbol "*" can be used
- * 3) selection will start with transport dataType and THEN go to "*" if needed
- */
- transports = {},
-
- // Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
- allTypes = "*/".concat( "*" ),
-
- // Anchor tag for parsing the document origin
- originAnchor = document.createElement( "a" );
-
-originAnchor.href = location.href;
-
-// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
-function addToPrefiltersOrTransports( structure ) {
-
- // dataTypeExpression is optional and defaults to "*"
- return function( dataTypeExpression, func ) {
-
- if ( typeof dataTypeExpression !== "string" ) {
- func = dataTypeExpression;
- dataTypeExpression = "*";
- }
-
- var dataType,
- i = 0,
- dataTypes = dataTypeExpression.toLowerCase().match( rnothtmlwhite ) || [];
-
- if ( isFunction( func ) ) {
-
- // For each dataType in the dataTypeExpression
- while ( ( dataType = dataTypes[ i++ ] ) ) {
-
- // Prepend if requested
- if ( dataType[ 0 ] === "+" ) {
- dataType = dataType.slice( 1 ) || "*";
- ( structure[ dataType ] = structure[ dataType ] || [] ).unshift( func );
-
- // Otherwise append
- } else {
- ( structure[ dataType ] = structure[ dataType ] || [] ).push( func );
- }
- }
- }
- };
-}
-
-// Base inspection function for prefilters and transports
-function inspectPrefiltersOrTransports( structure, options, originalOptions, jqXHR ) {
-
- var inspected = {},
- seekingTransport = ( structure === transports );
-
- function inspect( dataType ) {
- var selected;
- inspected[ dataType ] = true;
- jQuery.each( structure[ dataType ] || [], function( _, prefilterOrFactory ) {
- var dataTypeOrTransport = prefilterOrFactory( options, originalOptions, jqXHR );
- if ( typeof dataTypeOrTransport === "string" &&
- !seekingTransport && !inspected[ dataTypeOrTransport ] ) {
-
- options.dataTypes.unshift( dataTypeOrTransport );
- inspect( dataTypeOrTransport );
- return false;
- } else if ( seekingTransport ) {
- return !( selected = dataTypeOrTransport );
- }
- } );
- return selected;
- }
-
- return inspect( options.dataTypes[ 0 ] ) || !inspected[ "*" ] && inspect( "*" );
-}
-
-// A special extend for ajax options
-// that takes "flat" options (not to be deep extended)
-// Fixes #9887
-function ajaxExtend( target, src ) {
- var key, deep,
- flatOptions = jQuery.ajaxSettings.flatOptions || {};
-
- for ( key in src ) {
- if ( src[ key ] !== undefined ) {
- ( flatOptions[ key ] ? target : ( deep || ( deep = {} ) ) )[ key ] = src[ key ];
- }
- }
- if ( deep ) {
- jQuery.extend( true, target, deep );
- }
-
- return target;
-}
-
-/* Handles responses to an ajax request:
- * - finds the right dataType (mediates between content-type and expected dataType)
- * - returns the corresponding response
- */
-function ajaxHandleResponses( s, jqXHR, responses ) {
-
- var ct, type, finalDataType, firstDataType,
- contents = s.contents,
- dataTypes = s.dataTypes;
-
- // Remove auto dataType and get content-type in the process
- while ( dataTypes[ 0 ] === "*" ) {
- dataTypes.shift();
- if ( ct === undefined ) {
- ct = s.mimeType || jqXHR.getResponseHeader( "Content-Type" );
- }
- }
-
- // Check if we're dealing with a known content-type
- if ( ct ) {
- for ( type in contents ) {
- if ( contents[ type ] && contents[ type ].test( ct ) ) {
- dataTypes.unshift( type );
- break;
- }
- }
- }
-
- // Check to see if we have a response for the expected dataType
- if ( dataTypes[ 0 ] in responses ) {
- finalDataType = dataTypes[ 0 ];
- } else {
-
- // Try convertible dataTypes
- for ( type in responses ) {
- if ( !dataTypes[ 0 ] || s.converters[ type + " " + dataTypes[ 0 ] ] ) {
- finalDataType = type;
- break;
- }
- if ( !firstDataType ) {
- firstDataType = type;
- }
- }
-
- // Or just use first one
- finalDataType = finalDataType || firstDataType;
- }
-
- // If we found a dataType
- // We add the dataType to the list if needed
- // and return the corresponding response
- if ( finalDataType ) {
- if ( finalDataType !== dataTypes[ 0 ] ) {
- dataTypes.unshift( finalDataType );
- }
- return responses[ finalDataType ];
- }
-}
-
-/* Chain conversions given the request and the original response
- * Also sets the responseXXX fields on the jqXHR instance
- */
-function ajaxConvert( s, response, jqXHR, isSuccess ) {
- var conv2, current, conv, tmp, prev,
- converters = {},
-
- // Work with a copy of dataTypes in case we need to modify it for conversion
- dataTypes = s.dataTypes.slice();
-
- // Create converters map with lowercased keys
- if ( dataTypes[ 1 ] ) {
- for ( conv in s.converters ) {
- converters[ conv.toLowerCase() ] = s.converters[ conv ];
- }
- }
-
- current = dataTypes.shift();
-
- // Convert to each sequential dataType
- while ( current ) {
-
- if ( s.responseFields[ current ] ) {
- jqXHR[ s.responseFields[ current ] ] = response;
- }
-
- // Apply the dataFilter if provided
- if ( !prev && isSuccess && s.dataFilter ) {
- response = s.dataFilter( response, s.dataType );
- }
-
- prev = current;
- current = dataTypes.shift();
-
- if ( current ) {
-
- // There's only work to do if current dataType is non-auto
- if ( current === "*" ) {
-
- current = prev;
-
- // Convert response if prev dataType is non-auto and differs from current
- } else if ( prev !== "*" && prev !== current ) {
-
- // Seek a direct converter
- conv = converters[ prev + " " + current ] || converters[ "* " + current ];
-
- // If none found, seek a pair
- if ( !conv ) {
- for ( conv2 in converters ) {
-
- // If conv2 outputs current
- tmp = conv2.split( " " );
- if ( tmp[ 1 ] === current ) {
-
- // If prev can be converted to accepted input
- conv = converters[ prev + " " + tmp[ 0 ] ] ||
- converters[ "* " + tmp[ 0 ] ];
- if ( conv ) {
-
- // Condense equivalence converters
- if ( conv === true ) {
- conv = converters[ conv2 ];
-
- // Otherwise, insert the intermediate dataType
- } else if ( converters[ conv2 ] !== true ) {
- current = tmp[ 0 ];
- dataTypes.unshift( tmp[ 1 ] );
- }
- break;
- }
- }
- }
- }
-
- // Apply converter (if not an equivalence)
- if ( conv !== true ) {
-
- // Unless errors are allowed to bubble, catch and return them
- if ( conv && s.throws ) {
- response = conv( response );
- } else {
- try {
- response = conv( response );
- } catch ( e ) {
- return {
- state: "parsererror",
- error: conv ? e : "No conversion from " + prev + " to " + current
- };
- }
- }
- }
- }
- }
- }
-
- return { state: "success", data: response };
-}
-
-jQuery.extend( {
-
- // Counter for holding the number of active queries
- active: 0,
-
- // Last-Modified header cache for next request
- lastModified: {},
- etag: {},
-
- ajaxSettings: {
- url: location.href,
- type: "GET",
- isLocal: rlocalProtocol.test( location.protocol ),
- global: true,
- processData: true,
- async: true,
- contentType: "application/x-www-form-urlencoded; charset=UTF-8",
-
- /*
- timeout: 0,
- data: null,
- dataType: null,
- username: null,
- password: null,
- cache: null,
- throws: false,
- traditional: false,
- headers: {},
- */
-
- accepts: {
- "*": allTypes,
- text: "text/plain",
- html: "text/html",
- xml: "application/xml, text/xml",
- json: "application/json, text/javascript"
- },
-
- contents: {
- xml: /\bxml\b/,
- html: /\bhtml/,
- json: /\bjson\b/
- },
-
- responseFields: {
- xml: "responseXML",
- text: "responseText",
- json: "responseJSON"
- },
-
- // Data converters
- // Keys separate source (or catchall "*") and destination types with a single space
- converters: {
-
- // Convert anything to text
- "* text": String,
-
- // Text to html (true = no transformation)
- "text html": true,
-
- // Evaluate text as a json expression
- "text json": JSON.parse,
-
- // Parse text as xml
- "text xml": jQuery.parseXML
- },
-
- // For options that shouldn't be deep extended:
- // you can add your own custom options here if
- // and when you create one that shouldn't be
- // deep extended (see ajaxExtend)
- flatOptions: {
- url: true,
- context: true
- }
- },
-
- // Creates a full fledged settings object into target
- // with both ajaxSettings and settings fields.
- // If target is omitted, writes into ajaxSettings.
- ajaxSetup: function( target, settings ) {
- return settings ?
-
- // Building a settings object
- ajaxExtend( ajaxExtend( target, jQuery.ajaxSettings ), settings ) :
-
- // Extending ajaxSettings
- ajaxExtend( jQuery.ajaxSettings, target );
- },
-
- ajaxPrefilter: addToPrefiltersOrTransports( prefilters ),
- ajaxTransport: addToPrefiltersOrTransports( transports ),
-
- // Main method
- ajax: function( url, options ) {
-
- // If url is an object, simulate pre-1.5 signature
- if ( typeof url === "object" ) {
- options = url;
- url = undefined;
- }
-
- // Force options to be an object
- options = options || {};
-
- var transport,
-
- // URL without anti-cache param
- cacheURL,
-
- // Response headers
- responseHeadersString,
- responseHeaders,
-
- // timeout handle
- timeoutTimer,
-
- // Url cleanup var
- urlAnchor,
-
- // Request state (becomes false upon send and true upon completion)
- completed,
-
- // To know if global events are to be dispatched
- fireGlobals,
-
- // Loop variable
- i,
-
- // uncached part of the url
- uncached,
-
- // Create the final options object
- s = jQuery.ajaxSetup( {}, options ),
-
- // Callbacks context
- callbackContext = s.context || s,
-
- // Context for global events is callbackContext if it is a DOM node or jQuery collection
- globalEventContext = s.context &&
- ( callbackContext.nodeType || callbackContext.jquery ) ?
- jQuery( callbackContext ) :
- jQuery.event,
-
- // Deferreds
- deferred = jQuery.Deferred(),
- completeDeferred = jQuery.Callbacks( "once memory" ),
-
- // Status-dependent callbacks
- statusCode = s.statusCode || {},
-
- // Headers (they are sent all at once)
- requestHeaders = {},
- requestHeadersNames = {},
-
- // Default abort message
- strAbort = "canceled",
-
- // Fake xhr
- jqXHR = {
- readyState: 0,
-
- // Builds headers hashtable if needed
- getResponseHeader: function( key ) {
- var match;
- if ( completed ) {
- if ( !responseHeaders ) {
- responseHeaders = {};
- while ( ( match = rheaders.exec( responseHeadersString ) ) ) {
- responseHeaders[ match[ 1 ].toLowerCase() + " " ] =
- ( responseHeaders[ match[ 1 ].toLowerCase() + " " ] || [] )
- .concat( match[ 2 ] );
- }
- }
- match = responseHeaders[ key.toLowerCase() + " " ];
- }
- return match == null ? null : match.join( ", " );
- },
-
- // Raw string
- getAllResponseHeaders: function() {
- return completed ? responseHeadersString : null;
- },
-
- // Caches the header
- setRequestHeader: function( name, value ) {
- if ( completed == null ) {
- name = requestHeadersNames[ name.toLowerCase() ] =
- requestHeadersNames[ name.toLowerCase() ] || name;
- requestHeaders[ name ] = value;
- }
- return this;
- },
-
- // Overrides response content-type header
- overrideMimeType: function( type ) {
- if ( completed == null ) {
- s.mimeType = type;
- }
- return this;
- },
-
- // Status-dependent callbacks
- statusCode: function( map ) {
- var code;
- if ( map ) {
- if ( completed ) {
-
- // Execute the appropriate callbacks
- jqXHR.always( map[ jqXHR.status ] );
- } else {
-
- // Lazy-add the new callbacks in a way that preserves old ones
- for ( code in map ) {
- statusCode[ code ] = [ statusCode[ code ], map[ code ] ];
- }
- }
- }
- return this;
- },
-
- // Cancel the request
- abort: function( statusText ) {
- var finalText = statusText || strAbort;
- if ( transport ) {
- transport.abort( finalText );
- }
- done( 0, finalText );
- return this;
- }
- };
-
- // Attach deferreds
- deferred.promise( jqXHR );
-
- // Add protocol if not provided (prefilters might expect it)
- // Handle falsy url in the settings object (#10093: consistency with old signature)
- // We also use the url parameter if available
- s.url = ( ( url || s.url || location.href ) + "" )
- .replace( rprotocol, location.protocol + "//" );
-
- // Alias method option to type as per ticket #12004
- s.type = options.method || options.type || s.method || s.type;
-
- // Extract dataTypes list
- s.dataTypes = ( s.dataType || "*" ).toLowerCase().match( rnothtmlwhite ) || [ "" ];
-
- // A cross-domain request is in order when the origin doesn't match the current origin.
- if ( s.crossDomain == null ) {
- urlAnchor = document.createElement( "a" );
-
- // Support: IE <=8 - 11, Edge 12 - 15
- // IE throws exception on accessing the href property if url is malformed,
- // e.g. http://example.com:80x/
- try {
- urlAnchor.href = s.url;
-
- // Support: IE <=8 - 11 only
- // Anchor's host property isn't correctly set when s.url is relative
- urlAnchor.href = urlAnchor.href;
- s.crossDomain = originAnchor.protocol + "//" + originAnchor.host !==
- urlAnchor.protocol + "//" + urlAnchor.host;
- } catch ( e ) {
-
- // If there is an error parsing the URL, assume it is crossDomain,
- // it can be rejected by the transport if it is invalid
- s.crossDomain = true;
- }
- }
-
- // Convert data if not already a string
- if ( s.data && s.processData && typeof s.data !== "string" ) {
- s.data = jQuery.param( s.data, s.traditional );
- }
-
- // Apply prefilters
- inspectPrefiltersOrTransports( prefilters, s, options, jqXHR );
-
- // If request was aborted inside a prefilter, stop there
- if ( completed ) {
- return jqXHR;
- }
-
- // We can fire global events as of now if asked to
- // Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
- fireGlobals = jQuery.event && s.global;
-
- // Watch for a new set of requests
- if ( fireGlobals && jQuery.active++ === 0 ) {
- jQuery.event.trigger( "ajaxStart" );
- }
-
- // Uppercase the type
- s.type = s.type.toUpperCase();
-
- // Determine if request has content
- s.hasContent = !rnoContent.test( s.type );
-
- // Save the URL in case we're toying with the If-Modified-Since
- // and/or If-None-Match header later on
- // Remove hash to simplify url manipulation
- cacheURL = s.url.replace( rhash, "" );
-
- // More options handling for requests with no content
- if ( !s.hasContent ) {
-
- // Remember the hash so we can put it back
- uncached = s.url.slice( cacheURL.length );
-
- // If data is available and should be processed, append data to url
- if ( s.data && ( s.processData || typeof s.data === "string" ) ) {
- cacheURL += ( rquery.test( cacheURL ) ? "&" : "?" ) + s.data;
-
- // #9682: remove data so that it's not used in an eventual retry
- delete s.data;
- }
-
- // Add or update anti-cache param if needed
- if ( s.cache === false ) {
- cacheURL = cacheURL.replace( rantiCache, "$1" );
- uncached = ( rquery.test( cacheURL ) ? "&" : "?" ) + "_=" + ( nonce.guid++ ) +
- uncached;
- }
-
- // Put hash and anti-cache on the URL that will be requested (gh-1732)
- s.url = cacheURL + uncached;
-
- // Change '%20' to '+' if this is encoded form body content (gh-2658)
- } else if ( s.data && s.processData &&
- ( s.contentType || "" ).indexOf( "application/x-www-form-urlencoded" ) === 0 ) {
- s.data = s.data.replace( r20, "+" );
- }
-
- // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
- if ( s.ifModified ) {
- if ( jQuery.lastModified[ cacheURL ] ) {
- jqXHR.setRequestHeader( "If-Modified-Since", jQuery.lastModified[ cacheURL ] );
- }
- if ( jQuery.etag[ cacheURL ] ) {
- jqXHR.setRequestHeader( "If-None-Match", jQuery.etag[ cacheURL ] );
- }
- }
-
- // Set the correct header, if data is being sent
- if ( s.data && s.hasContent && s.contentType !== false || options.contentType ) {
- jqXHR.setRequestHeader( "Content-Type", s.contentType );
- }
-
- // Set the Accepts header for the server, depending on the dataType
- jqXHR.setRequestHeader(
- "Accept",
- s.dataTypes[ 0 ] && s.accepts[ s.dataTypes[ 0 ] ] ?
- s.accepts[ s.dataTypes[ 0 ] ] +
- ( s.dataTypes[ 0 ] !== "*" ? ", " + allTypes + "; q=0.01" : "" ) :
- s.accepts[ "*" ]
- );
-
- // Check for headers option
- for ( i in s.headers ) {
- jqXHR.setRequestHeader( i, s.headers[ i ] );
- }
-
- // Allow custom headers/mimetypes and early abort
- if ( s.beforeSend &&
- ( s.beforeSend.call( callbackContext, jqXHR, s ) === false || completed ) ) {
-
- // Abort if not done already and return
- return jqXHR.abort();
- }
-
- // Aborting is no longer a cancellation
- strAbort = "abort";
-
- // Install callbacks on deferreds
- completeDeferred.add( s.complete );
- jqXHR.done( s.success );
- jqXHR.fail( s.error );
-
- // Get transport
- transport = inspectPrefiltersOrTransports( transports, s, options, jqXHR );
-
- // If no transport, we auto-abort
- if ( !transport ) {
- done( -1, "No Transport" );
- } else {
- jqXHR.readyState = 1;
-
- // Send global event
- if ( fireGlobals ) {
- globalEventContext.trigger( "ajaxSend", [ jqXHR, s ] );
- }
-
- // If request was aborted inside ajaxSend, stop there
- if ( completed ) {
- return jqXHR;
- }
-
- // Timeout
- if ( s.async && s.timeout > 0 ) {
- timeoutTimer = window.setTimeout( function() {
- jqXHR.abort( "timeout" );
- }, s.timeout );
- }
-
- try {
- completed = false;
- transport.send( requestHeaders, done );
- } catch ( e ) {
-
- // Rethrow post-completion exceptions
- if ( completed ) {
- throw e;
- }
-
- // Propagate others as results
- done( -1, e );
- }
- }
-
- // Callback for when everything is done
- function done( status, nativeStatusText, responses, headers ) {
- var isSuccess, success, error, response, modified,
- statusText = nativeStatusText;
-
- // Ignore repeat invocations
- if ( completed ) {
- return;
- }
-
- completed = true;
-
- // Clear timeout if it exists
- if ( timeoutTimer ) {
- window.clearTimeout( timeoutTimer );
- }
-
- // Dereference transport for early garbage collection
- // (no matter how long the jqXHR object will be used)
- transport = undefined;
-
- // Cache response headers
- responseHeadersString = headers || "";
-
- // Set readyState
- jqXHR.readyState = status > 0 ? 4 : 0;
-
- // Determine if successful
- isSuccess = status >= 200 && status < 300 || status === 304;
-
- // Get response data
- if ( responses ) {
- response = ajaxHandleResponses( s, jqXHR, responses );
- }
-
- // Use a noop converter for missing script but not if jsonp
- if ( !isSuccess &&
- jQuery.inArray( "script", s.dataTypes ) > -1 &&
- jQuery.inArray( "json", s.dataTypes ) < 0 ) {
- s.converters[ "text script" ] = function() {};
- }
-
- // Convert no matter what (that way responseXXX fields are always set)
- response = ajaxConvert( s, response, jqXHR, isSuccess );
-
- // If successful, handle type chaining
- if ( isSuccess ) {
-
- // Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
- if ( s.ifModified ) {
- modified = jqXHR.getResponseHeader( "Last-Modified" );
- if ( modified ) {
- jQuery.lastModified[ cacheURL ] = modified;
- }
- modified = jqXHR.getResponseHeader( "etag" );
- if ( modified ) {
- jQuery.etag[ cacheURL ] = modified;
- }
- }
-
- // if no content
- if ( status === 204 || s.type === "HEAD" ) {
- statusText = "nocontent";
-
- // if not modified
- } else if ( status === 304 ) {
- statusText = "notmodified";
-
- // If we have data, let's convert it
- } else {
- statusText = response.state;
- success = response.data;
- error = response.error;
- isSuccess = !error;
- }
- } else {
-
- // Extract error from statusText and normalize for non-aborts
- error = statusText;
- if ( status || !statusText ) {
- statusText = "error";
- if ( status < 0 ) {
- status = 0;
- }
- }
- }
-
- // Set data for the fake xhr object
- jqXHR.status = status;
- jqXHR.statusText = ( nativeStatusText || statusText ) + "";
-
- // Success/Error
- if ( isSuccess ) {
- deferred.resolveWith( callbackContext, [ success, statusText, jqXHR ] );
- } else {
- deferred.rejectWith( callbackContext, [ jqXHR, statusText, error ] );
- }
-
- // Status-dependent callbacks
- jqXHR.statusCode( statusCode );
- statusCode = undefined;
-
- if ( fireGlobals ) {
- globalEventContext.trigger( isSuccess ? "ajaxSuccess" : "ajaxError",
- [ jqXHR, s, isSuccess ? success : error ] );
- }
-
- // Complete
- completeDeferred.fireWith( callbackContext, [ jqXHR, statusText ] );
-
- if ( fireGlobals ) {
- globalEventContext.trigger( "ajaxComplete", [ jqXHR, s ] );
-
- // Handle the global AJAX counter
- if ( !( --jQuery.active ) ) {
- jQuery.event.trigger( "ajaxStop" );
- }
- }
- }
-
- return jqXHR;
- },
-
- getJSON: function( url, data, callback ) {
- return jQuery.get( url, data, callback, "json" );
- },
-
- getScript: function( url, callback ) {
- return jQuery.get( url, undefined, callback, "script" );
- }
-} );
-
-jQuery.each( [ "get", "post" ], function( _i, method ) {
- jQuery[ method ] = function( url, data, callback, type ) {
-
- // Shift arguments if data argument was omitted
- if ( isFunction( data ) ) {
- type = type || callback;
- callback = data;
- data = undefined;
- }
-
- // The url can be an options object (which then must have .url)
- return jQuery.ajax( jQuery.extend( {
- url: url,
- type: method,
- dataType: type,
- data: data,
- success: callback
- }, jQuery.isPlainObject( url ) && url ) );
- };
-} );
-
-jQuery.ajaxPrefilter( function( s ) {
- var i;
- for ( i in s.headers ) {
- if ( i.toLowerCase() === "content-type" ) {
- s.contentType = s.headers[ i ] || "";
- }
- }
-} );
-
-
-jQuery._evalUrl = function( url, options, doc ) {
- return jQuery.ajax( {
- url: url,
-
- // Make this explicit, since user can override this through ajaxSetup (#11264)
- type: "GET",
- dataType: "script",
- cache: true,
- async: false,
- global: false,
-
- // Only evaluate the response if it is successful (gh-4126)
- // dataFilter is not invoked for failure responses, so using it instead
- // of the default converter is kludgy but it works.
- converters: {
- "text script": function() {}
- },
- dataFilter: function( response ) {
- jQuery.globalEval( response, options, doc );
- }
- } );
-};
-
-
-jQuery.fn.extend( {
- wrapAll: function( html ) {
- var wrap;
-
- if ( this[ 0 ] ) {
- if ( isFunction( html ) ) {
- html = html.call( this[ 0 ] );
- }
-
- // The elements to wrap the target around
- wrap = jQuery( html, this[ 0 ].ownerDocument ).eq( 0 ).clone( true );
-
- if ( this[ 0 ].parentNode ) {
- wrap.insertBefore( this[ 0 ] );
- }
-
- wrap.map( function() {
- var elem = this;
-
- while ( elem.firstElementChild ) {
- elem = elem.firstElementChild;
- }
-
- return elem;
- } ).append( this );
- }
-
- return this;
- },
-
- wrapInner: function( html ) {
- if ( isFunction( html ) ) {
- return this.each( function( i ) {
- jQuery( this ).wrapInner( html.call( this, i ) );
- } );
- }
-
- return this.each( function() {
- var self = jQuery( this ),
- contents = self.contents();
-
- if ( contents.length ) {
- contents.wrapAll( html );
-
- } else {
- self.append( html );
- }
- } );
- },
-
- wrap: function( html ) {
- var htmlIsFunction = isFunction( html );
-
- return this.each( function( i ) {
- jQuery( this ).wrapAll( htmlIsFunction ? html.call( this, i ) : html );
- } );
- },
-
- unwrap: function( selector ) {
- this.parent( selector ).not( "body" ).each( function() {
- jQuery( this ).replaceWith( this.childNodes );
- } );
- return this;
- }
-} );
-
-
-jQuery.expr.pseudos.hidden = function( elem ) {
- return !jQuery.expr.pseudos.visible( elem );
-};
-jQuery.expr.pseudos.visible = function( elem ) {
- return !!( elem.offsetWidth || elem.offsetHeight || elem.getClientRects().length );
-};
-
-
-
-
-jQuery.ajaxSettings.xhr = function() {
- try {
- return new window.XMLHttpRequest();
- } catch ( e ) {}
-};
-
-var xhrSuccessStatus = {
-
- // File protocol always yields status code 0, assume 200
- 0: 200,
-
- // Support: IE <=9 only
- // #1450: sometimes IE returns 1223 when it should be 204
- 1223: 204
- },
- xhrSupported = jQuery.ajaxSettings.xhr();
-
-support.cors = !!xhrSupported && ( "withCredentials" in xhrSupported );
-support.ajax = xhrSupported = !!xhrSupported;
-
-jQuery.ajaxTransport( function( options ) {
- var callback, errorCallback;
-
- // Cross domain only allowed if supported through XMLHttpRequest
- if ( support.cors || xhrSupported && !options.crossDomain ) {
- return {
- send: function( headers, complete ) {
- var i,
- xhr = options.xhr();
-
- xhr.open(
- options.type,
- options.url,
- options.async,
- options.username,
- options.password
- );
-
- // Apply custom fields if provided
- if ( options.xhrFields ) {
- for ( i in options.xhrFields ) {
- xhr[ i ] = options.xhrFields[ i ];
- }
- }
-
- // Override mime type if needed
- if ( options.mimeType && xhr.overrideMimeType ) {
- xhr.overrideMimeType( options.mimeType );
- }
-
- // X-Requested-With header
- // For cross-domain requests, seeing as conditions for a preflight are
- // akin to a jigsaw puzzle, we simply never set it to be sure.
- // (it can always be set on a per-request basis or even using ajaxSetup)
- // For same-domain requests, won't change header if already provided.
- if ( !options.crossDomain && !headers[ "X-Requested-With" ] ) {
- headers[ "X-Requested-With" ] = "XMLHttpRequest";
- }
-
- // Set headers
- for ( i in headers ) {
- xhr.setRequestHeader( i, headers[ i ] );
- }
-
- // Callback
- callback = function( type ) {
- return function() {
- if ( callback ) {
- callback = errorCallback = xhr.onload =
- xhr.onerror = xhr.onabort = xhr.ontimeout =
- xhr.onreadystatechange = null;
-
- if ( type === "abort" ) {
- xhr.abort();
- } else if ( type === "error" ) {
-
- // Support: IE <=9 only
- // On a manual native abort, IE9 throws
- // errors on any property access that is not readyState
- if ( typeof xhr.status !== "number" ) {
- complete( 0, "error" );
- } else {
- complete(
-
- // File: protocol always yields status 0; see #8605, #14207
- xhr.status,
- xhr.statusText
- );
- }
- } else {
- complete(
- xhrSuccessStatus[ xhr.status ] || xhr.status,
- xhr.statusText,
-
- // Support: IE <=9 only
- // IE9 has no XHR2 but throws on binary (trac-11426)
- // For XHR2 non-text, let the caller handle it (gh-2498)
- ( xhr.responseType || "text" ) !== "text" ||
- typeof xhr.responseText !== "string" ?
- { binary: xhr.response } :
- { text: xhr.responseText },
- xhr.getAllResponseHeaders()
- );
- }
- }
- };
- };
-
- // Listen to events
- xhr.onload = callback();
- errorCallback = xhr.onerror = xhr.ontimeout = callback( "error" );
-
- // Support: IE 9 only
- // Use onreadystatechange to replace onabort
- // to handle uncaught aborts
- if ( xhr.onabort !== undefined ) {
- xhr.onabort = errorCallback;
- } else {
- xhr.onreadystatechange = function() {
-
- // Check readyState before timeout as it changes
- if ( xhr.readyState === 4 ) {
-
- // Allow onerror to be called first,
- // but that will not handle a native abort
- // Also, save errorCallback to a variable
- // as xhr.onerror cannot be accessed
- window.setTimeout( function() {
- if ( callback ) {
- errorCallback();
- }
- } );
- }
- };
- }
-
- // Create the abort callback
- callback = callback( "abort" );
-
- try {
-
- // Do send the request (this may raise an exception)
- xhr.send( options.hasContent && options.data || null );
- } catch ( e ) {
-
- // #14683: Only rethrow if this hasn't been notified as an error yet
- if ( callback ) {
- throw e;
- }
- }
- },
-
- abort: function() {
- if ( callback ) {
- callback();
- }
- }
- };
- }
-} );
-
-
-
-
-// Prevent auto-execution of scripts when no explicit dataType was provided (See gh-2432)
-jQuery.ajaxPrefilter( function( s ) {
- if ( s.crossDomain ) {
- s.contents.script = false;
- }
-} );
-
-// Install script dataType
-jQuery.ajaxSetup( {
- accepts: {
- script: "text/javascript, application/javascript, " +
- "application/ecmascript, application/x-ecmascript"
- },
- contents: {
- script: /\b(?:java|ecma)script\b/
- },
- converters: {
- "text script": function( text ) {
- jQuery.globalEval( text );
- return text;
- }
- }
-} );
-
-// Handle cache's special case and crossDomain
-jQuery.ajaxPrefilter( "script", function( s ) {
- if ( s.cache === undefined ) {
- s.cache = false;
- }
- if ( s.crossDomain ) {
- s.type = "GET";
- }
-} );
-
-// Bind script tag hack transport
-jQuery.ajaxTransport( "script", function( s ) {
-
- // This transport only deals with cross domain or forced-by-attrs requests
- if ( s.crossDomain || s.scriptAttrs ) {
- var script, callback;
- return {
- send: function( _, complete ) {
- script = jQuery( "
-
-
diff --git a/spaces/pycoming/bingo/src/lib/bots/bing/types.ts b/spaces/pycoming/bingo/src/lib/bots/bing/types.ts
deleted file mode 100644
index 02cd5e8b01e3529642d28dc1539bf958f4ac420b..0000000000000000000000000000000000000000
--- a/spaces/pycoming/bingo/src/lib/bots/bing/types.ts
+++ /dev/null
@@ -1,259 +0,0 @@
-export type Author = 'user' | 'system' | 'bot'
-
-export type BotId = 'bing'
-
-export enum BingConversationStyle {
- Creative = 'Creative',
- Balanced = 'Balanced',
- Precise = 'Precise'
-}
-
-export enum ErrorCode {
- CONVERSATION_LIMIT = 'CONVERSATION_LIMIT',
- BING_UNAUTHORIZED = 'BING_UNAUTHORIZED',
- BING_FORBIDDEN = 'BING_FORBIDDEN',
- BING_CAPTCHA = 'BING_CAPTCHA',
- THROTTLE_LIMIT = 'THROTTLE_LIMIT',
- NOTFOUND_ERROR = 'NOT_FOUND_ERROR',
- UNKOWN_ERROR = 'UNKOWN_ERROR',
- NETWORK_ERROR = 'NETWORK_ERROR',
-}
-
-export class ChatError extends Error {
- code: ErrorCode
- constructor(message: string, code: ErrorCode) {
- super(message)
- this.code = code
- }
-}
-
-export type ChatMessageModel = {
- id: string
- author: Author
- text: string
- error?: ChatError
- throttling?: Throttling
- sourceAttributions?: SourceAttribution[]
- suggestedResponses?: SuggestedResponse[]
-}
-
-export interface ConversationModel {
- messages: ChatMessageModel[]
-}
-
-export type Event =
- | {
- type: 'UPDATE_ANSWER'
- data: {
- text: string
- spokenText?: string
- sourceAttributions?: SourceAttribution[]
- suggestedResponses?: SuggestedResponse[]
- throttling?: Throttling
- }
- }
- | {
- type: 'DONE'
- }
- | {
- type: 'ERROR'
- error: ChatError
- }
-
-export interface SendMessageParams {
- prompt: string
- imageUrl?: string
- options: T
- onEvent: (event: Event) => void
- signal?: AbortSignal
-}
-
-export interface ConversationResponse {
- conversationId: string
- clientId: string
- conversationSignature: string
- result: {
- value: string
- message?: string
- }
-}
-
-export interface Telemetry {
- metrics?: null
- startTime: string
-}
-
-export interface ChatUpdateArgument {
- messages?: ChatResponseMessage[]
- throttling?: Throttling
- requestId: string
- result: null
-}
-
-export type ChatUpdateCompleteResponse = {
- type: 2
- invocationId: string
- item: ChatResponseItem
-} | {
- type: 1
- target: string
- arguments: ChatUpdateArgument[]
-} | {
- type: 3
- invocationId: string
-} | {
- type: 6 | 7
-}
-
-export interface ChatRequestResult {
- value: string
- serviceVersion: string
- error?: string
-}
-
-export interface ChatResponseItem {
- messages: ChatResponseMessage[]
- firstNewMessageIndex: number
- suggestedResponses: null
- conversationId: string
- requestId: string
- conversationExpiryTime: string
- telemetry: Telemetry
- result: ChatRequestResult
- throttling: Throttling
-}
-export enum InvocationEventType {
- Invocation = 1,
- StreamItem = 2,
- Completion = 3,
- StreamInvocation = 4,
- CancelInvocation = 5,
- Ping = 6,
- Close = 7,
-}
-
-// https://github.com/bytemate/bingchat-api/blob/main/src/lib.ts
-
-export interface ConversationInfo {
- conversationId: string
- clientId: string
- conversationSignature: string
- invocationId: number
- conversationStyle: BingConversationStyle
- prompt: string
- imageUrl?: string
-}
-
-export interface BingChatResponse {
- conversationSignature: string
- conversationId: string
- clientId: string
- invocationId: number
- conversationExpiryTime: Date
- response: string
- details: ChatResponseMessage
-}
-
-export interface Throttling {
- maxNumLongDocSummaryUserMessagesInConversation: number
- maxNumUserMessagesInConversation: number
- numLongDocSummaryUserMessagesInConversation: number
- numUserMessagesInConversation: number
-}
-
-export interface ChatResponseMessage {
- text: string
- spokenText?: string
- author: string
- createdAt: Date
- timestamp: Date
- messageId: string
- requestId: string
- offense: string
- adaptiveCards: AdaptiveCard[]
- sourceAttributions: SourceAttribution[]
- feedback: Feedback
- contentOrigin: string
- messageType?: string
- contentType?: string
- privacy: null
- suggestedResponses: SuggestedResponse[]
-}
-
-export interface AdaptiveCard {
- type: string
- version: string
- body: Body[]
-}
-
-export interface Body {
- type: string
- text: string
- wrap: boolean
- size?: string
-}
-
-export interface Feedback {
- tag: null
- updatedOn: null
- type: string
-}
-
-export interface SourceAttribution {
- providerDisplayName: string
- seeMoreUrl: string
- searchQuery: string
-}
-
-export interface SuggestedResponse {
- text: string
- author?: Author
- createdAt?: Date
- timestamp?: Date
- messageId?: string
- messageType?: string
- offense?: string
- feedback?: Feedback
- contentOrigin?: string
- privacy?: null
-}
-
-export interface KBlobRequest {
- knowledgeRequest: KnowledgeRequestContext
- imageBase64?: string
-}
-
-export interface KBlobResponse {
- blobId: string
- processedBlobId?: string
-}
-
-export interface KnowledgeRequestContext {
- imageInfo: ImageInfo;
- knowledgeRequest: KnowledgeRequest;
-}
-
-export interface ImageInfo {
- url?: string;
-}
-
-export interface KnowledgeRequest {
- invokedSkills: string[];
- subscriptionId: string;
- invokedSkillsRequestData: InvokedSkillsRequestData;
- convoData: ConvoData;
-}
-
-export interface ConvoData {
- convoid: string;
- convotone: BingConversationStyle;
-}
-
-export interface InvokedSkillsRequestData {
- enableFaceBlur: boolean;
-}
-
-export interface FileItem {
- url: string;
- status?: 'loading' | 'error' | 'loaded'
-}
diff --git a/spaces/pytorch/DeepLabV3/app.py b/spaces/pytorch/DeepLabV3/app.py
deleted file mode 100644
index 0d67dc053a711c0c00aa9e6132b526901aa3e8f0..0000000000000000000000000000000000000000
--- a/spaces/pytorch/DeepLabV3/app.py
+++ /dev/null
@@ -1,57 +0,0 @@
-import torch
-model = torch.hub.load('pytorch/vision:v0.9.0', 'deeplabv3_resnet101', pretrained=True)
-model.eval()
-# Download an example image from the pytorch website
-import urllib
-url, filename = ("https://github.com/pytorch/hub/raw/master/images/dog.jpg", "dog.jpg")
-try: urllib.URLopener().retrieve(url, filename)
-except: urllib.request.urlretrieve(url, filename)
-# sample execution (requires torchvision)
-from PIL import Image
-from torchvision import transforms
-import gradio as gr
-import matplotlib.pyplot as plt
-
-
-def inference(input_image):
- preprocess = transforms.Compose([
- transforms.ToTensor(),
- transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
- ])
-
- input_tensor = preprocess(input_image)
- input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
-
- # move the input and model to GPU for speed if available
- if torch.cuda.is_available():
- input_batch = input_batch.to('cuda')
- model.to('cuda')
-
- with torch.no_grad():
- output = model(input_batch)['out'][0]
- output_predictions = output.argmax(0)
- # create a color pallette, selecting a color for each class
- palette = torch.tensor([2 ** 25 - 1, 2 ** 15 - 1, 2 ** 21 - 1])
- colors = torch.as_tensor([i for i in range(21)])[:, None] * palette
- colors = (colors % 255).numpy().astype("uint8")
-
- # plot the semantic segmentation predictions of 21 classes in each color
- r = Image.fromarray(output_predictions.byte().cpu().numpy()).resize(input_image.size)
- r.putpalette(colors)
- plt.imshow(r)
- return plt
-
-title = "DEEPLABV3-RESNET101"
-description = "demo for DEEPLABV3-RESNET101, DeepLabV3 model with a ResNet-101 backbone. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below."
-article = "Rethinking Atrous Convolution for Semantic Image Segmentation | Github Repo
"
-
-gr.Interface(
- inference,
- gr.inputs.Image(type="pil", label="Input"),
- gr.outputs.Image(type="plot", label="Output"),
- title=title,
- description=description,
- article=article,
- examples=[
- ["dog.jpg"]
- ]).launch()
\ No newline at end of file
diff --git a/spaces/qefunaba/nicky007-stable-diffusion-logo-fine-tuned/app.py b/spaces/qefunaba/nicky007-stable-diffusion-logo-fine-tuned/app.py
deleted file mode 100644
index 64b4b06d5c2039e5b801d77f1388c0cdddfa76dd..0000000000000000000000000000000000000000
--- a/spaces/qefunaba/nicky007-stable-diffusion-logo-fine-tuned/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/nicky007/stable-diffusion-logo-fine-tuned").launch()
\ No newline at end of file
diff --git a/spaces/qingxu98/academic-chatgpt-beta/theme.py b/spaces/qingxu98/academic-chatgpt-beta/theme.py
deleted file mode 100644
index 1cc26b06d994eba6d37aa86f3bbfc12fc164731c..0000000000000000000000000000000000000000
--- a/spaces/qingxu98/academic-chatgpt-beta/theme.py
+++ /dev/null
@@ -1,231 +0,0 @@
-import gradio as gr
-from toolbox import get_conf
-CODE_HIGHLIGHT, = get_conf('CODE_HIGHLIGHT')
-# gradio可用颜色列表
-# gr.themes.utils.colors.slate (石板色)
-# gr.themes.utils.colors.gray (灰色)
-# gr.themes.utils.colors.zinc (锌色)
-# gr.themes.utils.colors.neutral (中性色)
-# gr.themes.utils.colors.stone (石头色)
-# gr.themes.utils.colors.red (红色)
-# gr.themes.utils.colors.orange (橙色)
-# gr.themes.utils.colors.amber (琥珀色)
-# gr.themes.utils.colors.yellow (黄色)
-# gr.themes.utils.colors.lime (酸橙色)
-# gr.themes.utils.colors.green (绿色)
-# gr.themes.utils.colors.emerald (祖母绿)
-# gr.themes.utils.colors.teal (青蓝色)
-# gr.themes.utils.colors.cyan (青色)
-# gr.themes.utils.colors.sky (天蓝色)
-# gr.themes.utils.colors.blue (蓝色)
-# gr.themes.utils.colors.indigo (靛蓝色)
-# gr.themes.utils.colors.violet (紫罗兰色)
-# gr.themes.utils.colors.purple (紫色)
-# gr.themes.utils.colors.fuchsia (洋红色)
-# gr.themes.utils.colors.pink (粉红色)
-# gr.themes.utils.colors.rose (玫瑰色)
-
-
-def adjust_theme():
- try:
- color_er = gr.themes.utils.colors.fuchsia
- set_theme = gr.themes.Default(
- primary_hue=gr.themes.utils.colors.orange,
- neutral_hue=gr.themes.utils.colors.gray,
- font=["sans-serif", "Microsoft YaHei", "ui-sans-serif", "system-ui",
- "sans-serif", gr.themes.utils.fonts.GoogleFont("Source Sans Pro")],
- font_mono=["ui-monospace", "Consolas", "monospace", gr.themes.utils.fonts.GoogleFont("IBM Plex Mono")])
- set_theme.set(
- # Colors
- input_background_fill_dark="*neutral_800",
- # Transition
- button_transition="none",
- # Shadows
- button_shadow="*shadow_drop",
- button_shadow_hover="*shadow_drop_lg",
- button_shadow_active="*shadow_inset",
- input_shadow="0 0 0 *shadow_spread transparent, *shadow_inset",
- input_shadow_focus="0 0 0 *shadow_spread *secondary_50, *shadow_inset",
- input_shadow_focus_dark="0 0 0 *shadow_spread *neutral_700, *shadow_inset",
- checkbox_label_shadow="*shadow_drop",
- block_shadow="*shadow_drop",
- form_gap_width="1px",
- # Button borders
- input_border_width="1px",
- input_background_fill="white",
- # Gradients
- stat_background_fill="linear-gradient(to right, *primary_400, *primary_200)",
- stat_background_fill_dark="linear-gradient(to right, *primary_400, *primary_600)",
- error_background_fill=f"linear-gradient(to right, {color_er.c100}, *background_fill_secondary)",
- error_background_fill_dark="*background_fill_primary",
- checkbox_label_background_fill="linear-gradient(to top, *neutral_50, white)",
- checkbox_label_background_fill_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
- checkbox_label_background_fill_hover="linear-gradient(to top, *neutral_100, white)",
- checkbox_label_background_fill_hover_dark="linear-gradient(to top, *neutral_900, *neutral_800)",
- button_primary_background_fill="linear-gradient(to bottom right, *primary_100, *primary_300)",
- button_primary_background_fill_dark="linear-gradient(to bottom right, *primary_500, *primary_600)",
- button_primary_background_fill_hover="linear-gradient(to bottom right, *primary_100, *primary_200)",
- button_primary_background_fill_hover_dark="linear-gradient(to bottom right, *primary_500, *primary_500)",
- button_primary_border_color_dark="*primary_500",
- button_secondary_background_fill="linear-gradient(to bottom right, *neutral_100, *neutral_200)",
- button_secondary_background_fill_dark="linear-gradient(to bottom right, *neutral_600, *neutral_700)",
- button_secondary_background_fill_hover="linear-gradient(to bottom right, *neutral_100, *neutral_100)",
- button_secondary_background_fill_hover_dark="linear-gradient(to bottom right, *neutral_600, *neutral_600)",
- button_cancel_background_fill=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c200})",
- button_cancel_background_fill_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c700})",
- button_cancel_background_fill_hover=f"linear-gradient(to bottom right, {color_er.c100}, {color_er.c100})",
- button_cancel_background_fill_hover_dark=f"linear-gradient(to bottom right, {color_er.c600}, {color_er.c600})",
- button_cancel_border_color=color_er.c200,
- button_cancel_border_color_dark=color_er.c600,
- button_cancel_text_color=color_er.c600,
- button_cancel_text_color_dark="white",
- )
- except:
- set_theme = None
- print('gradio版本较旧, 不能自定义字体和颜色')
- return set_theme
-
-
-advanced_css = """
-/* 设置表格的外边距为1em，内部单元格之间边框合并，空单元格显示. */
-.markdown-body table {
- margin: 1em 0;
- border-collapse: collapse;
- empty-cells: show;
-}
-
-/* 设置表格单元格的内边距为5px，边框粗细为1.2px，颜色为--border-color-primary. */
-.markdown-body th, .markdown-body td {
- border: 1.2px solid var(--border-color-primary);
- padding: 5px;
-}
-
-/* 设置表头背景颜色为rgba(175,184,193,0.2)，透明度为0.2. */
-.markdown-body thead {
- background-color: rgba(175,184,193,0.2);
-}
-
-/* 设置表头单元格的内边距为0.5em和0.2em. */
-.markdown-body thead th {
- padding: .5em .2em;
-}
-
-/* 去掉列表前缀的默认间距，使其与文本线对齐. */
-.markdown-body ol, .markdown-body ul {
- padding-inline-start: 2em !important;
-}
-
-/* 设定聊天气泡的样式，包括圆角、最大宽度和阴影等. */
-[class *= "message"] {
- border-radius: var(--radius-xl) !important;
- /* padding: var(--spacing-xl) !important; */
- /* font-size: var(--text-md) !important; */
- /* line-height: var(--line-md) !important; */
- /* min-height: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
- /* min-width: calc(var(--text-md)*var(--line-md) + 2*var(--spacing-xl)); */
-}
-[data-testid = "bot"] {
- max-width: 95%;
- /* width: auto !important; */
- border-bottom-left-radius: 0 !important;
-}
-[data-testid = "user"] {
- max-width: 100%;
- /* width: auto !important; */
- border-bottom-right-radius: 0 !important;
-}
-
-/* 行内代码的背景设为淡灰色，设定圆角和间距. */
-.markdown-body code {
- display: inline;
- white-space: break-spaces;
- border-radius: 6px;
- margin: 0 2px 0 2px;
- padding: .2em .4em .1em .4em;
- background-color: rgba(175,184,193,0.2);
-}
-/* 设定代码块的样式，包括背景颜色、内、外边距、圆角。 */
-.markdown-body pre code {
- display: block;
- overflow: auto;
- white-space: pre;
- background-color: rgba(175,184,193,0.2);
- border-radius: 10px;
- padding: 1em;
- margin: 1em 2em 1em 0.5em;
-}
-
-"""
-
-if CODE_HIGHLIGHT:
- advanced_css += """
-
-.hll { background-color: #ffffcc }
-.c { color: #3D7B7B; font-style: italic } /* Comment */
-.err { border: 1px solid #FF0000 } /* Error */
-.k { color: hsl(197, 94%, 51%); font-weight: bold } /* Keyword */
-.o { color: #666666 } /* Operator */
-.ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */
-.cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */
-.cp { color: #9C6500 } /* Comment.Preproc */
-.cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */
-.c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */
-.cs { color: #3D7B7B; font-style: italic } /* Comment.Special */
-.gd { color: #A00000 } /* Generic.Deleted */
-.ge { font-style: italic } /* Generic.Emph */
-.gr { color: #E40000 } /* Generic.Error */
-.gh { color: #000080; font-weight: bold } /* Generic.Heading */
-.gi { color: #008400 } /* Generic.Inserted */
-.go { color: #717171 } /* Generic.Output */
-.gp { color: #000080; font-weight: bold } /* Generic.Prompt */
-.gs { font-weight: bold } /* Generic.Strong */
-.gu { color: #800080; font-weight: bold } /* Generic.Subheading */
-.gt { color: #a9dd00 } /* Generic.Traceback */
-.kc { color: #008000; font-weight: bold } /* Keyword.Constant */
-.kd { color: #008000; font-weight: bold } /* Keyword.Declaration */
-.kn { color: #008000; font-weight: bold } /* Keyword.Namespace */
-.kp { color: #008000 } /* Keyword.Pseudo */
-.kr { color: #008000; font-weight: bold } /* Keyword.Reserved */
-.kt { color: #B00040 } /* Keyword.Type */
-.m { color: #666666 } /* Literal.Number */
-.s { color: #BA2121 } /* Literal.String */
-.na { color: #687822 } /* Name.Attribute */
-.nb { color: #e5f8c3 } /* Name.Builtin */
-.nc { color: #ffad65; font-weight: bold } /* Name.Class */
-.no { color: #880000 } /* Name.Constant */
-.nd { color: #AA22FF } /* Name.Decorator */
-.ni { color: #717171; font-weight: bold } /* Name.Entity */
-.ne { color: #CB3F38; font-weight: bold } /* Name.Exception */
-.nf { color: #f9f978 } /* Name.Function */
-.nl { color: #767600 } /* Name.Label */
-.nn { color: #0000FF; font-weight: bold } /* Name.Namespace */
-.nt { color: #008000; font-weight: bold } /* Name.Tag */
-.nv { color: #19177C } /* Name.Variable */
-.ow { color: #AA22FF; font-weight: bold } /* Operator.Word */
-.w { color: #bbbbbb } /* Text.Whitespace */
-.mb { color: #666666 } /* Literal.Number.Bin */
-.mf { color: #666666 } /* Literal.Number.Float */
-.mh { color: #666666 } /* Literal.Number.Hex */
-.mi { color: #666666 } /* Literal.Number.Integer */
-.mo { color: #666666 } /* Literal.Number.Oct */
-.sa { color: #BA2121 } /* Literal.String.Affix */
-.sb { color: #BA2121 } /* Literal.String.Backtick */
-.sc { color: #BA2121 } /* Literal.String.Char */
-.dl { color: #BA2121 } /* Literal.String.Delimiter */
-.sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */
-.s2 { color: #2bf840 } /* Literal.String.Double */
-.se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */
-.sh { color: #BA2121 } /* Literal.String.Heredoc */
-.si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */
-.sx { color: #008000 } /* Literal.String.Other */
-.sr { color: #A45A77 } /* Literal.String.Regex */
-.s1 { color: #BA2121 } /* Literal.String.Single */
-.ss { color: #19177C } /* Literal.String.Symbol */
-.bp { color: #008000 } /* Name.Builtin.Pseudo */
-.fm { color: #0000FF } /* Name.Function.Magic */
-.vc { color: #19177C } /* Name.Variable.Class */
-.vg { color: #19177C } /* Name.Variable.Global */
-.vi { color: #19177C } /* Name.Variable.Instance */
-.vm { color: #19177C } /* Name.Variable.Magic */
-.il { color: #666666 } /* Literal.Number.Integer.Long */
-"""
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/CRACK Passmark WirelessMon Pro V2.1.md b/spaces/quidiaMuxgu/Expedit-SAM/CRACK Passmark WirelessMon Pro V2.1.md
deleted file mode 100644
index b936ae671c60fc5b64aa29c890b566e572ef8233..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/CRACK Passmark WirelessMon Pro V2.1.md
+++ /dev/null
@@ -1,8 +0,0 @@
-wirelessmon has the ability to display intermittent and hidden access points - those with a mac address, but not a ssid. the access point connection window allows you to connect to an access point via a mac address.
- when you download files through wlan, a large number of files may be transferred and the data can be transferred to a client computer, so that the service user can see the file. wirelessmon serial number is a little piece of software that takes up less disc space than the average communication application. its popular in india, the united states, and indonesia. when requesting information from a network card, several improvements have been made to make the user interface more responsive. overall, this program offers a variety of network diagnostic capabilities in an easy-to-use interface that consumes very little system resources.
-CRACK Passmark WirelessMon Pro v2.1 Download File ↔ https://geags.com/2uCrRN
wirelessmon serial number is a little piece of software that takes up less disc space than the average communication application. its popular in india, the united states, and indonesia. when requesting information from a network card, several improvements have been made to make the user interface more responsive. overall, this program offers a variety of network diagnostic capabilities in an easy-to-use interface that consumes very little system resources.
- it is also a handy little utility that can be used to monitor the status of other computers on your network, wirelessmon serial number is a little piece of software that takes up less disc space than the average communication application. its popular in india, the united states, and indonesia. when requesting information from a network card, several improvements have been made to make the user interface more responsive. overall, this program offers a variety of network diagnostic capabilities in an easy-to-use interface that consumes very little system resources.
899543212bin general, the rejection of problematic data was necessary to ensure the reliability of the astrometric reductions. in gaia , individual transit data are automatically analysed, based on the information about the apparent brightness of the asteroid and the local sky background. the brightness range is taken into account as well as the brightness variation over the observation, as well as the full extent of the photometric errors. the main causes of rejection are listed below.
too faint apparent brightness. the ephemeris of the transit is used to estimate the apparent brightness of the asteroid. if the apparent brightness of the object is too low, the uncertainty associated with it will be very large, and therefore the transit cannot be well fitted. in this case, the position of the asteroid cannot be measured with the required precision.
-Elements Of Astro Mechanics Van De Kamp Pdf Download Download - https://geags.com/2uCrop
the position is not well defined. this problem occurs when the asteroid is so faint that its position cannot be well defined by the astrometric reduction. this problem is generally resolved by increasing the exposure time.
-the astrometric calibration module, which is activated by the appropriate telescope and is the only module that is specific to gaia , is the fundamental tool for the determination of the position of the ssos with respect to the ccds. the agiss provide the transformation between the focal plane and the sky coordinate systems, which are used to transform the raw data into the astrometric reference frame and to make a first clean cut through the observations. these transformations are stored in agiss that are specific to each telescope, and they are stored in the database in a form of a catalogue. this is the procedure described below in sect. 3.2.
899543212belf bowling hawaiian vacation crack download Download ⚹ https://geags.com/2uCsLn
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/Jdk 1.6 Free Download For Windows 7 64 Bit Cnet PATCHED.md b/spaces/quidiaMuxgu/Expedit-SAM/Jdk 1.6 Free Download For Windows 7 64 Bit Cnet PATCHED.md
deleted file mode 100644
index 9564b8d9e3d2485f8bc01070630080a9d5fe42af..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/Jdk 1.6 Free Download For Windows 7 64 Bit Cnet PATCHED.md
+++ /dev/null
@@ -1,6 +0,0 @@
-jdk 1.6 free download for windows 7 64 bit cnet Download ❤ https://geags.com/2uCqsc
diff --git a/spaces/quidiaMuxgu/Expedit-SAM/Magic Engine Fx V1.1.1 !!TOP!! Cracked Version.md b/spaces/quidiaMuxgu/Expedit-SAM/Magic Engine Fx V1.1.1 !!TOP!! Cracked Version.md
deleted file mode 100644
index 995966fa22477abe257fcf298222c8cecf7105c4..0000000000000000000000000000000000000000
--- a/spaces/quidiaMuxgu/Expedit-SAM/Magic Engine Fx V1.1.1 !!TOP!! Cracked Version.md
+++ /dev/null
@@ -1,6 +0,0 @@
-magic engine fx v1.1.1 cracked version Download ⚙ https://geags.com/2uCrmr
diff --git a/spaces/r3gm/Aesthetic_RVC_Inference_HF/lib/uvr5_pack/lib_v5/spec_utils.py b/spaces/r3gm/Aesthetic_RVC_Inference_HF/lib/uvr5_pack/lib_v5/spec_utils.py
deleted file mode 100644
index 062d9050d85c036f8ebafc9c64f1501cff747568..0000000000000000000000000000000000000000
--- a/spaces/r3gm/Aesthetic_RVC_Inference_HF/lib/uvr5_pack/lib_v5/spec_utils.py
+++ /dev/null
@@ -1,666 +0,0 @@
-import os, librosa
-import numpy as np
-import soundfile as sf
-from tqdm import tqdm
-import json, math, hashlib
-
-
-def crop_center(h1, h2):
- h1_shape = h1.size()
- h2_shape = h2.size()
-
- if h1_shape[3] == h2_shape[3]:
- return h1
- elif h1_shape[3] < h2_shape[3]:
- raise ValueError("h1_shape[3] must be greater than h2_shape[3]")
-
- # s_freq = (h2_shape[2] - h1_shape[2]) // 2
- # e_freq = s_freq + h1_shape[2]
- s_time = (h1_shape[3] - h2_shape[3]) // 2
- e_time = s_time + h2_shape[3]
- h1 = h1[:, :, :, s_time:e_time]
-
- return h1
-
-
-def wave_to_spectrogram(
- wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
-):
- if reverse:
- wave_left = np.flip(np.asfortranarray(wave[0]))
- wave_right = np.flip(np.asfortranarray(wave[1]))
- elif mid_side:
- wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
- elif mid_side_b2:
- wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
- else:
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
-
- spec_left = librosa.stft(wave_left, n_fft, hop_length=hop_length)
- spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
-
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def wave_to_spectrogram_mt(
- wave, hop_length, n_fft, mid_side=False, mid_side_b2=False, reverse=False
-):
- import threading
-
- if reverse:
- wave_left = np.flip(np.asfortranarray(wave[0]))
- wave_right = np.flip(np.asfortranarray(wave[1]))
- elif mid_side:
- wave_left = np.asfortranarray(np.add(wave[0], wave[1]) / 2)
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1]))
- elif mid_side_b2:
- wave_left = np.asfortranarray(np.add(wave[1], wave[0] * 0.5))
- wave_right = np.asfortranarray(np.subtract(wave[0], wave[1] * 0.5))
- else:
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
-
- def run_thread(**kwargs):
- global spec_left
- spec_left = librosa.stft(**kwargs)
-
- thread = threading.Thread(
- target=run_thread,
- kwargs={"y": wave_left, "n_fft": n_fft, "hop_length": hop_length},
- )
- thread.start()
- spec_right = librosa.stft(wave_right, n_fft, hop_length=hop_length)
- thread.join()
-
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def combine_spectrograms(specs, mp):
- l = min([specs[i].shape[2] for i in specs])
- spec_c = np.zeros(shape=(2, mp.param["bins"] + 1, l), dtype=np.complex64)
- offset = 0
- bands_n = len(mp.param["band"])
-
- for d in range(1, bands_n + 1):
- h = mp.param["band"][d]["crop_stop"] - mp.param["band"][d]["crop_start"]
- spec_c[:, offset : offset + h, :l] = specs[d][
- :, mp.param["band"][d]["crop_start"] : mp.param["band"][d]["crop_stop"], :l
- ]
- offset += h
-
- if offset > mp.param["bins"]:
- raise ValueError("Too much bins")
-
- # lowpass fiter
- if (
- mp.param["pre_filter_start"] > 0
- ): # and mp.param['band'][bands_n]['res_type'] in ['scipy', 'polyphase']:
- if bands_n == 1:
- spec_c = fft_lp_filter(
- spec_c, mp.param["pre_filter_start"], mp.param["pre_filter_stop"]
- )
- else:
- gp = 1
- for b in range(
- mp.param["pre_filter_start"] + 1, mp.param["pre_filter_stop"]
- ):
- g = math.pow(
- 10, -(b - mp.param["pre_filter_start"]) * (3.5 - gp) / 20.0
- )
- gp = g
- spec_c[:, b, :] *= g
-
- return np.asfortranarray(spec_c)
-
-
-def spectrogram_to_image(spec, mode="magnitude"):
- if mode == "magnitude":
- if np.iscomplexobj(spec):
- y = np.abs(spec)
- else:
- y = spec
- y = np.log10(y**2 + 1e-8)
- elif mode == "phase":
- if np.iscomplexobj(spec):
- y = np.angle(spec)
- else:
- y = spec
-
- y -= y.min()
- y *= 255 / y.max()
- img = np.uint8(y)
-
- if y.ndim == 3:
- img = img.transpose(1, 2, 0)
- img = np.concatenate([np.max(img, axis=2, keepdims=True), img], axis=2)
-
- return img
-
-
-def reduce_vocal_aggressively(X, y, softmask):
- v = X - y
- y_mag_tmp = np.abs(y)
- v_mag_tmp = np.abs(v)
-
- v_mask = v_mag_tmp > y_mag_tmp
- y_mag = np.clip(y_mag_tmp - v_mag_tmp * v_mask * softmask, 0, np.inf)
-
- return y_mag * np.exp(1.0j * np.angle(y))
-
-
-def mask_silence(mag, ref, thres=0.2, min_range=64, fade_size=32):
- if min_range < fade_size * 2:
- raise ValueError("min_range must be >= fade_area * 2")
-
- mag = mag.copy()
-
- idx = np.where(ref.mean(axis=(0, 1)) < thres)[0]
- starts = np.insert(idx[np.where(np.diff(idx) != 1)[0] + 1], 0, idx[0])
- ends = np.append(idx[np.where(np.diff(idx) != 1)[0]], idx[-1])
- uninformative = np.where(ends - starts > min_range)[0]
- if len(uninformative) > 0:
- starts = starts[uninformative]
- ends = ends[uninformative]
- old_e = None
- for s, e in zip(starts, ends):
- if old_e is not None and s - old_e < fade_size:
- s = old_e - fade_size * 2
-
- if s != 0:
- weight = np.linspace(0, 1, fade_size)
- mag[:, :, s : s + fade_size] += weight * ref[:, :, s : s + fade_size]
- else:
- s -= fade_size
-
- if e != mag.shape[2]:
- weight = np.linspace(1, 0, fade_size)
- mag[:, :, e - fade_size : e] += weight * ref[:, :, e - fade_size : e]
- else:
- e += fade_size
-
- mag[:, :, s + fade_size : e - fade_size] += ref[
- :, :, s + fade_size : e - fade_size
- ]
- old_e = e
-
- return mag
-
-
-def align_wave_head_and_tail(a, b):
- l = min([a[0].size, b[0].size])
-
- return a[:l, :l], b[:l, :l]
-
-
-def cache_or_load(mix_path, inst_path, mp):
- mix_basename = os.path.splitext(os.path.basename(mix_path))[0]
- inst_basename = os.path.splitext(os.path.basename(inst_path))[0]
-
- cache_dir = "mph{}".format(
- hashlib.sha1(json.dumps(mp.param, sort_keys=True).encode("utf-8")).hexdigest()
- )
- mix_cache_dir = os.path.join("cache", cache_dir)
- inst_cache_dir = os.path.join("cache", cache_dir)
-
- os.makedirs(mix_cache_dir, exist_ok=True)
- os.makedirs(inst_cache_dir, exist_ok=True)
-
- mix_cache_path = os.path.join(mix_cache_dir, mix_basename + ".npy")
- inst_cache_path = os.path.join(inst_cache_dir, inst_basename + ".npy")
-
- if os.path.exists(mix_cache_path) and os.path.exists(inst_cache_path):
- X_spec_m = np.load(mix_cache_path)
- y_spec_m = np.load(inst_cache_path)
- else:
- X_wave, y_wave, X_spec_s, y_spec_s = {}, {}, {}, {}
-
- for d in range(len(mp.param["band"]), 0, -1):
- bp = mp.param["band"][d]
-
- if d == len(mp.param["band"]): # high-end band
- X_wave[d], _ = librosa.load(
- mix_path, bp["sr"], False, dtype=np.float32, res_type=bp["res_type"]
- )
- y_wave[d], _ = librosa.load(
- inst_path,
- bp["sr"],
- False,
- dtype=np.float32,
- res_type=bp["res_type"],
- )
- else: # lower bands
- X_wave[d] = librosa.resample(
- X_wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
- y_wave[d] = librosa.resample(
- y_wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
-
- X_wave[d], y_wave[d] = align_wave_head_and_tail(X_wave[d], y_wave[d])
-
- X_spec_s[d] = wave_to_spectrogram(
- X_wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
- y_spec_s[d] = wave_to_spectrogram(
- y_wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
-
- del X_wave, y_wave
-
- X_spec_m = combine_spectrograms(X_spec_s, mp)
- y_spec_m = combine_spectrograms(y_spec_s, mp)
-
- if X_spec_m.shape != y_spec_m.shape:
- raise ValueError("The combined spectrograms are different: " + mix_path)
-
- _, ext = os.path.splitext(mix_path)
-
- np.save(mix_cache_path, X_spec_m)
- np.save(inst_cache_path, y_spec_m)
-
- return X_spec_m, y_spec_m
-
-
-def spectrogram_to_wave(spec, hop_length, mid_side, mid_side_b2, reverse):
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- wave_left = librosa.istft(spec_left, hop_length=hop_length)
- wave_right = librosa.istft(spec_right, hop_length=hop_length)
-
- if reverse:
- return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
- elif mid_side:
- return np.asfortranarray(
- [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
- )
- elif mid_side_b2:
- return np.asfortranarray(
- [
- np.add(wave_right / 1.25, 0.4 * wave_left),
- np.subtract(wave_left / 1.25, 0.4 * wave_right),
- ]
- )
- else:
- return np.asfortranarray([wave_left, wave_right])
-
-
-def spectrogram_to_wave_mt(spec, hop_length, mid_side, reverse, mid_side_b2):
- import threading
-
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- def run_thread(**kwargs):
- global wave_left
- wave_left = librosa.istft(**kwargs)
-
- thread = threading.Thread(
- target=run_thread, kwargs={"stft_matrix": spec_left, "hop_length": hop_length}
- )
- thread.start()
- wave_right = librosa.istft(spec_right, hop_length=hop_length)
- thread.join()
-
- if reverse:
- return np.asfortranarray([np.flip(wave_left), np.flip(wave_right)])
- elif mid_side:
- return np.asfortranarray(
- [np.add(wave_left, wave_right / 2), np.subtract(wave_left, wave_right / 2)]
- )
- elif mid_side_b2:
- return np.asfortranarray(
- [
- np.add(wave_right / 1.25, 0.4 * wave_left),
- np.subtract(wave_left / 1.25, 0.4 * wave_right),
- ]
- )
- else:
- return np.asfortranarray([wave_left, wave_right])
-
-
-def cmb_spectrogram_to_wave(spec_m, mp, extra_bins_h=None, extra_bins=None):
- wave_band = {}
- bands_n = len(mp.param["band"])
- offset = 0
-
- for d in range(1, bands_n + 1):
- bp = mp.param["band"][d]
- spec_s = np.ndarray(
- shape=(2, bp["n_fft"] // 2 + 1, spec_m.shape[2]), dtype=complex
- )
- h = bp["crop_stop"] - bp["crop_start"]
- spec_s[:, bp["crop_start"] : bp["crop_stop"], :] = spec_m[
- :, offset : offset + h, :
- ]
-
- offset += h
- if d == bands_n: # higher
- if extra_bins_h: # if --high_end_process bypass
- max_bin = bp["n_fft"] // 2
- spec_s[:, max_bin - extra_bins_h : max_bin, :] = extra_bins[
- :, :extra_bins_h, :
- ]
- if bp["hpf_start"] > 0:
- spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
- if bands_n == 1:
- wave = spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
- else:
- wave = np.add(
- wave,
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- )
- else:
- sr = mp.param["band"][d + 1]["sr"]
- if d == 1: # lower
- spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
- wave = librosa.resample(
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- bp["sr"],
- sr,
- res_type="sinc_fastest",
- )
- else: # mid
- spec_s = fft_hp_filter(spec_s, bp["hpf_start"], bp["hpf_stop"] - 1)
- spec_s = fft_lp_filter(spec_s, bp["lpf_start"], bp["lpf_stop"])
- wave2 = np.add(
- wave,
- spectrogram_to_wave(
- spec_s,
- bp["hl"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- ),
- )
- # wave = librosa.core.resample(wave2, bp['sr'], sr, res_type="sinc_fastest")
- wave = librosa.core.resample(wave2, bp["sr"], sr, res_type="scipy")
-
- return wave.T
-
-
-def fft_lp_filter(spec, bin_start, bin_stop):
- g = 1.0
- for b in range(bin_start, bin_stop):
- g -= 1 / (bin_stop - bin_start)
- spec[:, b, :] = g * spec[:, b, :]
-
- spec[:, bin_stop:, :] *= 0
-
- return spec
-
-
-def fft_hp_filter(spec, bin_start, bin_stop):
- g = 1.0
- for b in range(bin_start, bin_stop, -1):
- g -= 1 / (bin_start - bin_stop)
- spec[:, b, :] = g * spec[:, b, :]
-
- spec[:, 0 : bin_stop + 1, :] *= 0
-
- return spec
-
-
-def mirroring(a, spec_m, input_high_end, mp):
- if "mirroring" == a:
- mirror = np.flip(
- np.abs(
- spec_m[
- :,
- mp.param["pre_filter_start"]
- - 10
- - input_high_end.shape[1] : mp.param["pre_filter_start"]
- - 10,
- :,
- ]
- ),
- 1,
- )
- mirror = mirror * np.exp(1.0j * np.angle(input_high_end))
-
- return np.where(
- np.abs(input_high_end) <= np.abs(mirror), input_high_end, mirror
- )
-
- if "mirroring2" == a:
- mirror = np.flip(
- np.abs(
- spec_m[
- :,
- mp.param["pre_filter_start"]
- - 10
- - input_high_end.shape[1] : mp.param["pre_filter_start"]
- - 10,
- :,
- ]
- ),
- 1,
- )
- mi = np.multiply(mirror, input_high_end * 1.7)
-
- return np.where(np.abs(input_high_end) <= np.abs(mi), input_high_end, mi)
-
-
-def ensembling(a, specs):
- for i in range(1, len(specs)):
- if i == 1:
- spec = specs[0]
-
- ln = min([spec.shape[2], specs[i].shape[2]])
- spec = spec[:, :, :ln]
- specs[i] = specs[i][:, :, :ln]
-
- if "min_mag" == a:
- spec = np.where(np.abs(specs[i]) <= np.abs(spec), specs[i], spec)
- if "max_mag" == a:
- spec = np.where(np.abs(specs[i]) >= np.abs(spec), specs[i], spec)
-
- return spec
-
-
-def stft(wave, nfft, hl):
- wave_left = np.asfortranarray(wave[0])
- wave_right = np.asfortranarray(wave[1])
- spec_left = librosa.stft(wave_left, nfft, hop_length=hl)
- spec_right = librosa.stft(wave_right, nfft, hop_length=hl)
- spec = np.asfortranarray([spec_left, spec_right])
-
- return spec
-
-
-def istft(spec, hl):
- spec_left = np.asfortranarray(spec[0])
- spec_right = np.asfortranarray(spec[1])
-
- wave_left = librosa.istft(spec_left, hop_length=hl)
- wave_right = librosa.istft(spec_right, hop_length=hl)
- wave = np.asfortranarray([wave_left, wave_right])
-
-
-if __name__ == "__main__":
- import cv2
- import time
- import argparse
- from model_param_init import ModelParameters
-
- p = argparse.ArgumentParser()
- p.add_argument(
- "--algorithm",
- "-a",
- type=str,
- choices=["invert", "invert_p", "min_mag", "max_mag", "deep", "align"],
- default="min_mag",
- )
- p.add_argument(
- "--model_params",
- "-m",
- type=str,
- default=os.path.join("modelparams", "1band_sr44100_hl512.json"),
- )
- p.add_argument("--output_name", "-o", type=str, default="output")
- p.add_argument("--vocals_only", "-v", action="store_true")
- p.add_argument("input", nargs="+")
- args = p.parse_args()
-
- start_time = time.time()
-
- if args.algorithm.startswith("invert") and len(args.input) != 2:
- raise ValueError("There should be two input files.")
-
- if not args.algorithm.startswith("invert") and len(args.input) < 2:
- raise ValueError("There must be at least two input files.")
-
- wave, specs = {}, {}
- mp = ModelParameters(args.model_params)
-
- for i in range(len(args.input)):
- spec = {}
-
- for d in range(len(mp.param["band"]), 0, -1):
- bp = mp.param["band"][d]
-
- if d == len(mp.param["band"]): # high-end band
- wave[d], _ = librosa.load(
- args.input[i],
- bp["sr"],
- False,
- dtype=np.float32,
- res_type=bp["res_type"],
- )
-
- if len(wave[d].shape) == 1: # mono to stereo
- wave[d] = np.array([wave[d], wave[d]])
- else: # lower bands
- wave[d] = librosa.resample(
- wave[d + 1],
- mp.param["band"][d + 1]["sr"],
- bp["sr"],
- res_type=bp["res_type"],
- )
-
- spec[d] = wave_to_spectrogram(
- wave[d],
- bp["hl"],
- bp["n_fft"],
- mp.param["mid_side"],
- mp.param["mid_side_b2"],
- mp.param["reverse"],
- )
-
- specs[i] = combine_spectrograms(spec, mp)
-
- del wave
-
- if args.algorithm == "deep":
- d_spec = np.where(np.abs(specs[0]) <= np.abs(spec[1]), specs[0], spec[1])
- v_spec = d_spec - specs[1]
- sf.write(
- os.path.join("{}.wav".format(args.output_name)),
- cmb_spectrogram_to_wave(v_spec, mp),
- mp.param["sr"],
- )
-
- if args.algorithm.startswith("invert"):
- ln = min([specs[0].shape[2], specs[1].shape[2]])
- specs[0] = specs[0][:, :, :ln]
- specs[1] = specs[1][:, :, :ln]
-
- if "invert_p" == args.algorithm:
- X_mag = np.abs(specs[0])
- y_mag = np.abs(specs[1])
- max_mag = np.where(X_mag >= y_mag, X_mag, y_mag)
- v_spec = specs[1] - max_mag * np.exp(1.0j * np.angle(specs[0]))
- else:
- specs[1] = reduce_vocal_aggressively(specs[0], specs[1], 0.2)
- v_spec = specs[0] - specs[1]
-
- if not args.vocals_only:
- X_mag = np.abs(specs[0])
- y_mag = np.abs(specs[1])
- v_mag = np.abs(v_spec)
-
- X_image = spectrogram_to_image(X_mag)
- y_image = spectrogram_to_image(y_mag)
- v_image = spectrogram_to_image(v_mag)
-
- cv2.imwrite("{}_X.png".format(args.output_name), X_image)
- cv2.imwrite("{}_y.png".format(args.output_name), y_image)
- cv2.imwrite("{}_v.png".format(args.output_name), v_image)
-
- sf.write(
- "{}_X.wav".format(args.output_name),
- cmb_spectrogram_to_wave(specs[0], mp),
- mp.param["sr"],
- )
- sf.write(
- "{}_y.wav".format(args.output_name),
- cmb_spectrogram_to_wave(specs[1], mp),
- mp.param["sr"],
- )
-
- sf.write(
- "{}_v.wav".format(args.output_name),
- cmb_spectrogram_to_wave(v_spec, mp),
- mp.param["sr"],
- )
- else:
- if not args.algorithm == "deep":
- sf.write(
- os.path.join("ensembled", "{}.wav".format(args.output_name)),
- cmb_spectrogram_to_wave(ensembling(args.algorithm, specs), mp),
- mp.param["sr"],
- )
-
- if args.algorithm == "align":
- trackalignment = [
- {
- "file1": '"{}"'.format(args.input[0]),
- "file2": '"{}"'.format(args.input[1]),
- }
- ]
-
- for i, e in tqdm(enumerate(trackalignment), desc="Performing Alignment..."):
- os.system(f"python lib/align_tracks.py {e['file1']} {e['file2']}")
-
- # print('Total time: {0:.{1}f}s'.format(time.time() - start_time, 1))
diff --git a/spaces/rachana219/MODT2/utils/loss.py b/spaces/rachana219/MODT2/utils/loss.py
deleted file mode 100644
index bf7ab65a304b51b398d9877da0673d5c01e52081..0000000000000000000000000000000000000000
--- a/spaces/rachana219/MODT2/utils/loss.py
+++ /dev/null
@@ -1,1697 +0,0 @@
-# Loss functions
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from utils.general import bbox_iou, bbox_alpha_iou, box_iou, box_giou, box_diou, box_ciou, xywh2xyxy
-from utils.torch_utils import is_parallel
-
-
-def smooth_BCE(eps=0.1): # https://github.com/ultralytics/yolov3/issues/238#issuecomment-598028441
- # return positive, negative label smoothing BCE targets
- return 1.0 - 0.5 * eps, 0.5 * eps
-
-
-class BCEBlurWithLogitsLoss(nn.Module):
- # BCEwithLogitLoss() with reduced missing label effects.
- def __init__(self, alpha=0.05):
- super(BCEBlurWithLogitsLoss, self).__init__()
- self.loss_fcn = nn.BCEWithLogitsLoss(reduction='none') # must be nn.BCEWithLogitsLoss()
- self.alpha = alpha
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
- pred = torch.sigmoid(pred) # prob from logits
- dx = pred - true # reduce only missing label effects
- # dx = (pred - true).abs() # reduce missing label and false label effects
- alpha_factor = 1 - torch.exp((dx - 1) / (self.alpha + 1e-4))
- loss *= alpha_factor
- return loss.mean()
-
-
-class SigmoidBin(nn.Module):
- stride = None # strides computed during build
- export = False # onnx export
-
- def __init__(self, bin_count=10, min=0.0, max=1.0, reg_scale = 2.0, use_loss_regression=True, use_fw_regression=True, BCE_weight=1.0, smooth_eps=0.0):
- super(SigmoidBin, self).__init__()
-
- self.bin_count = bin_count
- self.length = bin_count + 1
- self.min = min
- self.max = max
- self.scale = float(max - min)
- self.shift = self.scale / 2.0
-
- self.use_loss_regression = use_loss_regression
- self.use_fw_regression = use_fw_regression
- self.reg_scale = reg_scale
- self.BCE_weight = BCE_weight
-
- start = min + (self.scale/2.0) / self.bin_count
- end = max - (self.scale/2.0) / self.bin_count
- step = self.scale / self.bin_count
- self.step = step
- #print(f" start = {start}, end = {end}, step = {step} ")
-
- bins = torch.range(start, end + 0.0001, step).float()
- self.register_buffer('bins', bins)
-
-
- self.cp = 1.0 - 0.5 * smooth_eps
- self.cn = 0.5 * smooth_eps
-
- self.BCEbins = nn.BCEWithLogitsLoss(pos_weight=torch.Tensor([BCE_weight]))
- self.MSELoss = nn.MSELoss()
-
- def get_length(self):
- return self.length
-
- def forward(self, pred):
- assert pred.shape[-1] == self.length, 'pred.shape[-1]=%d is not equal to self.length=%d' % (pred.shape[-1], self.length)
-
- pred_reg = (pred[..., 0] * self.reg_scale - self.reg_scale/2.0) * self.step
- pred_bin = pred[..., 1:(1+self.bin_count)]
-
- _, bin_idx = torch.max(pred_bin, dim=-1)
- bin_bias = self.bins[bin_idx]
-
- if self.use_fw_regression:
- result = pred_reg + bin_bias
- else:
- result = bin_bias
- result = result.clamp(min=self.min, max=self.max)
-
- return result
-
-
- def training_loss(self, pred, target):
- assert pred.shape[-1] == self.length, 'pred.shape[-1]=%d is not equal to self.length=%d' % (pred.shape[-1], self.length)
- assert pred.shape[0] == target.shape[0], 'pred.shape=%d is not equal to the target.shape=%d' % (pred.shape[0], target.shape[0])
- device = pred.device
-
- pred_reg = (pred[..., 0].sigmoid() * self.reg_scale - self.reg_scale/2.0) * self.step
- pred_bin = pred[..., 1:(1+self.bin_count)]
-
- diff_bin_target = torch.abs(target[..., None] - self.bins)
- _, bin_idx = torch.min(diff_bin_target, dim=-1)
-
- bin_bias = self.bins[bin_idx]
- bin_bias.requires_grad = False
- result = pred_reg + bin_bias
-
- target_bins = torch.full_like(pred_bin, self.cn, device=device) # targets
- n = pred.shape[0]
- target_bins[range(n), bin_idx] = self.cp
-
- loss_bin = self.BCEbins(pred_bin, target_bins) # BCE
-
- if self.use_loss_regression:
- loss_regression = self.MSELoss(result, target) # MSE
- loss = loss_bin + loss_regression
- else:
- loss = loss_bin
-
- out_result = result.clamp(min=self.min, max=self.max)
-
- return loss, out_result
-
-
-class FocalLoss(nn.Module):
- # Wraps focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
- def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
- super(FocalLoss, self).__init__()
- self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
- self.gamma = gamma
- self.alpha = alpha
- self.reduction = loss_fcn.reduction
- self.loss_fcn.reduction = 'none' # required to apply FL to each element
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
- # p_t = torch.exp(-loss)
- # loss *= self.alpha * (1.000001 - p_t) ** self.gamma # non-zero power for gradient stability
-
- # TF implementation https://github.com/tensorflow/addons/blob/v0.7.1/tensorflow_addons/losses/focal_loss.py
- pred_prob = torch.sigmoid(pred) # prob from logits
- p_t = true * pred_prob + (1 - true) * (1 - pred_prob)
- alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
- modulating_factor = (1.0 - p_t) ** self.gamma
- loss *= alpha_factor * modulating_factor
-
- if self.reduction == 'mean':
- return loss.mean()
- elif self.reduction == 'sum':
- return loss.sum()
- else: # 'none'
- return loss
-
-
-class QFocalLoss(nn.Module):
- # Wraps Quality focal loss around existing loss_fcn(), i.e. criteria = FocalLoss(nn.BCEWithLogitsLoss(), gamma=1.5)
- def __init__(self, loss_fcn, gamma=1.5, alpha=0.25):
- super(QFocalLoss, self).__init__()
- self.loss_fcn = loss_fcn # must be nn.BCEWithLogitsLoss()
- self.gamma = gamma
- self.alpha = alpha
- self.reduction = loss_fcn.reduction
- self.loss_fcn.reduction = 'none' # required to apply FL to each element
-
- def forward(self, pred, true):
- loss = self.loss_fcn(pred, true)
-
- pred_prob = torch.sigmoid(pred) # prob from logits
- alpha_factor = true * self.alpha + (1 - true) * (1 - self.alpha)
- modulating_factor = torch.abs(true - pred_prob) ** self.gamma
- loss *= alpha_factor * modulating_factor
-
- if self.reduction == 'mean':
- return loss.mean()
- elif self.reduction == 'sum':
- return loss.sum()
- else: # 'none'
- return loss
-
-class RankSort(torch.autograd.Function):
- @staticmethod
- def forward(ctx, logits, targets, delta_RS=0.50, eps=1e-10):
-
- classification_grads=torch.zeros(logits.shape).cuda()
-
- #Filter fg logits
- fg_labels = (targets > 0.)
- fg_logits = logits[fg_labels]
- fg_targets = targets[fg_labels]
- fg_num = len(fg_logits)
-
- #Do not use bg with scores less than minimum fg logit
- #since changing its score does not have an effect on precision
- threshold_logit = torch.min(fg_logits)-delta_RS
- relevant_bg_labels=((targets==0) & (logits>=threshold_logit))
-
- relevant_bg_logits = logits[relevant_bg_labels]
- relevant_bg_grad=torch.zeros(len(relevant_bg_logits)).cuda()
- sorting_error=torch.zeros(fg_num).cuda()
- ranking_error=torch.zeros(fg_num).cuda()
- fg_grad=torch.zeros(fg_num).cuda()
-
- #sort the fg logits
- order=torch.argsort(fg_logits)
- #Loops over each positive following the order
- for ii in order:
- # Difference Transforms (x_ij)
- fg_relations=fg_logits-fg_logits[ii]
- bg_relations=relevant_bg_logits-fg_logits[ii]
-
- if delta_RS > 0:
- fg_relations=torch.clamp(fg_relations/(2*delta_RS)+0.5,min=0,max=1)
- bg_relations=torch.clamp(bg_relations/(2*delta_RS)+0.5,min=0,max=1)
- else:
- fg_relations = (fg_relations >= 0).float()
- bg_relations = (bg_relations >= 0).float()
-
- # Rank of ii among pos and false positive number (bg with larger scores)
- rank_pos=torch.sum(fg_relations)
- FP_num=torch.sum(bg_relations)
-
- # Rank of ii among all examples
- rank=rank_pos+FP_num
-
- # Ranking error of example ii. target_ranking_error is always 0. (Eq. 7)
- ranking_error[ii]=FP_num/rank
-
- # Current sorting error of example ii. (Eq. 7)
- current_sorting_error = torch.sum(fg_relations*(1-fg_targets))/rank_pos
-
- #Find examples in the target sorted order for example ii
- iou_relations = (fg_targets >= fg_targets[ii])
- target_sorted_order = iou_relations * fg_relations
-
- #The rank of ii among positives in sorted order
- rank_pos_target = torch.sum(target_sorted_order)
-
- #Compute target sorting error. (Eq. 8)
- #Since target ranking error is 0, this is also total target error
- target_sorting_error= torch.sum(target_sorted_order*(1-fg_targets))/rank_pos_target
-
- #Compute sorting error on example ii
- sorting_error[ii] = current_sorting_error - target_sorting_error
-
- #Identity Update for Ranking Error
- if FP_num > eps:
- #For ii the update is the ranking error
- fg_grad[ii] -= ranking_error[ii]
- #For negatives, distribute error via ranking pmf (i.e. bg_relations/FP_num)
- relevant_bg_grad += (bg_relations*(ranking_error[ii]/FP_num))
-
- #Find the positives that are misranked (the cause of the error)
- #These are the ones with smaller IoU but larger logits
- missorted_examples = (~ iou_relations) * fg_relations
-
- #Denominotor of sorting pmf
- sorting_pmf_denom = torch.sum(missorted_examples)
-
- #Identity Update for Sorting Error
- if sorting_pmf_denom > eps:
- #For ii the update is the sorting error
- fg_grad[ii] -= sorting_error[ii]
- #For positives, distribute error via sorting pmf (i.e. missorted_examples/sorting_pmf_denom)
- fg_grad += (missorted_examples*(sorting_error[ii]/sorting_pmf_denom))
-
- #Normalize gradients by number of positives
- classification_grads[fg_labels]= (fg_grad/fg_num)
- classification_grads[relevant_bg_labels]= (relevant_bg_grad/fg_num)
-
- ctx.save_for_backward(classification_grads)
-
- return ranking_error.mean(), sorting_error.mean()
-
- @staticmethod
- def backward(ctx, out_grad1, out_grad2):
- g1, =ctx.saved_tensors
- return g1*out_grad1, None, None, None
-
-class aLRPLoss(torch.autograd.Function):
- @staticmethod
- def forward(ctx, logits, targets, regression_losses, delta=1., eps=1e-5):
- classification_grads=torch.zeros(logits.shape).cuda()
-
- #Filter fg logits
- fg_labels = (targets == 1)
- fg_logits = logits[fg_labels]
- fg_num = len(fg_logits)
-
- #Do not use bg with scores less than minimum fg logit
- #since changing its score does not have an effect on precision
- threshold_logit = torch.min(fg_logits)-delta
-
- #Get valid bg logits
- relevant_bg_labels=((targets==0)&(logits>=threshold_logit))
- relevant_bg_logits=logits[relevant_bg_labels]
- relevant_bg_grad=torch.zeros(len(relevant_bg_logits)).cuda()
- rank=torch.zeros(fg_num).cuda()
- prec=torch.zeros(fg_num).cuda()
- fg_grad=torch.zeros(fg_num).cuda()
-
- max_prec=0
- #sort the fg logits
- order=torch.argsort(fg_logits)
- #Loops over each positive following the order
- for ii in order:
- #x_ij s as score differences with fgs
- fg_relations=fg_logits-fg_logits[ii]
- #Apply piecewise linear function and determine relations with fgs
- fg_relations=torch.clamp(fg_relations/(2*delta)+0.5,min=0,max=1)
- #Discard i=j in the summation in rank_pos
- fg_relations[ii]=0
-
- #x_ij s as score differences with bgs
- bg_relations=relevant_bg_logits-fg_logits[ii]
- #Apply piecewise linear function and determine relations with bgs
- bg_relations=torch.clamp(bg_relations/(2*delta)+0.5,min=0,max=1)
-
- #Compute the rank of the example within fgs and number of bgs with larger scores
- rank_pos=1+torch.sum(fg_relations)
- FP_num=torch.sum(bg_relations)
- #Store the total since it is normalizer also for aLRP Regression error
- rank[ii]=rank_pos+FP_num
-
- #Compute precision for this example to compute classification loss
- prec[ii]=rank_pos/rank[ii]
- #For stability, set eps to a infinitesmall value (e.g. 1e-6), then compute grads
- if FP_num > eps:
- fg_grad[ii] = -(torch.sum(fg_relations*regression_losses)+FP_num)/rank[ii]
- relevant_bg_grad += (bg_relations*(-fg_grad[ii]/FP_num))
-
- #aLRP with grad formulation fg gradient
- classification_grads[fg_labels]= fg_grad
- #aLRP with grad formulation bg gradient
- classification_grads[relevant_bg_labels]= relevant_bg_grad
-
- classification_grads /= (fg_num)
-
- cls_loss=1-prec.mean()
- ctx.save_for_backward(classification_grads)
-
- return cls_loss, rank, order
-
- @staticmethod
- def backward(ctx, out_grad1, out_grad2, out_grad3):
- g1, =ctx.saved_tensors
- return g1*out_grad1, None, None, None, None
-
-
-class APLoss(torch.autograd.Function):
- @staticmethod
- def forward(ctx, logits, targets, delta=1.):
- classification_grads=torch.zeros(logits.shape).cuda()
-
- #Filter fg logits
- fg_labels = (targets == 1)
- fg_logits = logits[fg_labels]
- fg_num = len(fg_logits)
-
- #Do not use bg with scores less than minimum fg logit
- #since changing its score does not have an effect on precision
- threshold_logit = torch.min(fg_logits)-delta
-
- #Get valid bg logits
- relevant_bg_labels=((targets==0)&(logits>=threshold_logit))
- relevant_bg_logits=logits[relevant_bg_labels]
- relevant_bg_grad=torch.zeros(len(relevant_bg_logits)).cuda()
- rank=torch.zeros(fg_num).cuda()
- prec=torch.zeros(fg_num).cuda()
- fg_grad=torch.zeros(fg_num).cuda()
-
- max_prec=0
- #sort the fg logits
- order=torch.argsort(fg_logits)
- #Loops over each positive following the order
- for ii in order:
- #x_ij s as score differences with fgs
- fg_relations=fg_logits-fg_logits[ii]
- #Apply piecewise linear function and determine relations with fgs
- fg_relations=torch.clamp(fg_relations/(2*delta)+0.5,min=0,max=1)
- #Discard i=j in the summation in rank_pos
- fg_relations[ii]=0
-
- #x_ij s as score differences with bgs
- bg_relations=relevant_bg_logits-fg_logits[ii]
- #Apply piecewise linear function and determine relations with bgs
- bg_relations=torch.clamp(bg_relations/(2*delta)+0.5,min=0,max=1)
-
- #Compute the rank of the example within fgs and number of bgs with larger scores
- rank_pos=1+torch.sum(fg_relations)
- FP_num=torch.sum(bg_relations)
- #Store the total since it is normalizer also for aLRP Regression error
- rank[ii]=rank_pos+FP_num
-
- #Compute precision for this example
- current_prec=rank_pos/rank[ii]
-
- #Compute interpolated AP and store gradients for relevant bg examples
- if (max_prec<=current_prec):
- max_prec=current_prec
- relevant_bg_grad += (bg_relations/rank[ii])
- else:
- relevant_bg_grad += (bg_relations/rank[ii])*(((1-max_prec)/(1-current_prec)))
-
- #Store fg gradients
- fg_grad[ii]=-(1-max_prec)
- prec[ii]=max_prec
-
- #aLRP with grad formulation fg gradient
- classification_grads[fg_labels]= fg_grad
- #aLRP with grad formulation bg gradient
- classification_grads[relevant_bg_labels]= relevant_bg_grad
-
- classification_grads /= fg_num
-
- cls_loss=1-prec.mean()
- ctx.save_for_backward(classification_grads)
-
- return cls_loss
-
- @staticmethod
- def backward(ctx, out_grad1):
- g1, =ctx.saved_tensors
- return g1*out_grad1, None, None
-
-
-class ComputeLoss:
- # Compute losses
- def __init__(self, model, autobalance=False):
- super(ComputeLoss, self).__init__()
- device = next(model.parameters()).device # get model device
- h = model.hyp # hyperparameters
-
- # Define criteria
- BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
- BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
-
- # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
- self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
-
- # Focal loss
- g = h['fl_gamma'] # focal loss gamma
- if g > 0:
- BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
-
- det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module
- self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, .02]) # P3-P7
- #self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.1, .05]) # P3-P7
- #self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.5, 0.4, .1]) # P3-P7
- self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index
- self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, model.gr, h, autobalance
- for k in 'na', 'nc', 'nl', 'anchors':
- setattr(self, k, getattr(det, k))
-
- def __call__(self, p, targets): # predictions, targets, model
- device = targets.device
- lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device)
- tcls, tbox, indices, anchors = self.build_targets(p, targets) # targets
-
- # Losses
- for i, pi in enumerate(p): # layer index, layer predictions
- b, a, gj, gi = indices[i] # image, anchor, gridy, gridx
- tobj = torch.zeros_like(pi[..., 0], device=device) # target obj
-
- n = b.shape[0] # number of targets
- if n:
- ps = pi[b, a, gj, gi] # prediction subset corresponding to targets
-
- # Regression
- pxy = ps[:, :2].sigmoid() * 2. - 0.5
- pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]
- pbox = torch.cat((pxy, pwh), 1) # predicted box
- iou = bbox_iou(pbox.T, tbox[i], x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += (1.0 - iou).mean() # iou loss
-
- # Objectness
- tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * iou.detach().clamp(0).type(tobj.dtype) # iou ratio
-
- # Classification
- if self.nc > 1: # cls loss (only if multiple classes)
- t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets
- t[range(n), tcls[i]] = self.cp
- #t[t==self.cp] = iou.detach().clamp(0).type(t.dtype)
- lcls += self.BCEcls(ps[:, 5:], t) # BCE
-
- # Append targets to text file
- # with open('targets.txt', 'a') as file:
- # [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
-
- obji = self.BCEobj(pi[..., 4], tobj)
- lobj += obji * self.balance[i] # obj loss
- if self.autobalance:
- self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
-
- if self.autobalance:
- self.balance = [x / self.balance[self.ssi] for x in self.balance]
- lbox *= self.hyp['box']
- lobj *= self.hyp['obj']
- lcls *= self.hyp['cls']
- bs = tobj.shape[0] # batch size
-
- loss = lbox + lobj + lcls
- return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()
-
- def build_targets(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- tcls, tbox, indices, anch = [], [], [], []
- gain = torch.ones(7, device=targets.device).long() # normalized to gridspace gain
- ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 0.5 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=targets.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1. < g) & (gxy > 1.)).T
- l, m = ((gxi % 1. < g) & (gxi > 1.)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- b, c = t[:, :2].long().T # image, class
- gxy = t[:, 2:4] # grid xy
- gwh = t[:, 4:6] # grid wh
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid xy indices
-
- # Append
- a = t[:, 6].long() # anchor indices
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- tbox.append(torch.cat((gxy - gij, gwh), 1)) # box
- anch.append(anchors[a]) # anchors
- tcls.append(c) # class
-
- return tcls, tbox, indices, anch
-
-
-class ComputeLossOTA:
- # Compute losses
- def __init__(self, model, autobalance=False):
- super(ComputeLossOTA, self).__init__()
- device = next(model.parameters()).device # get model device
- h = model.hyp # hyperparameters
-
- # Define criteria
- BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
- BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
-
- # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
- self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
-
- # Focal loss
- g = h['fl_gamma'] # focal loss gamma
- if g > 0:
- BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
-
- det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module
- self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, .02]) # P3-P7
- self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index
- self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, model.gr, h, autobalance
- for k in 'na', 'nc', 'nl', 'anchors', 'stride':
- setattr(self, k, getattr(det, k))
-
- def __call__(self, p, targets, imgs): # predictions, targets, model
- device = targets.device
- lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device)
- bs, as_, gjs, gis, targets, anchors = self.build_targets(p, targets, imgs)
- pre_gen_gains = [torch.tensor(pp.shape, device=device)[[3, 2, 3, 2]] for pp in p]
-
-
- # Losses
- for i, pi in enumerate(p): # layer index, layer predictions
- b, a, gj, gi = bs[i], as_[i], gjs[i], gis[i] # image, anchor, gridy, gridx
- tobj = torch.zeros_like(pi[..., 0], device=device) # target obj
-
- n = b.shape[0] # number of targets
- if n:
- ps = pi[b, a, gj, gi] # prediction subset corresponding to targets
-
- # Regression
- grid = torch.stack([gi, gj], dim=1)
- pxy = ps[:, :2].sigmoid() * 2. - 0.5
- #pxy = ps[:, :2].sigmoid() * 3. - 1.
- pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]
- pbox = torch.cat((pxy, pwh), 1) # predicted box
- selected_tbox = targets[i][:, 2:6] * pre_gen_gains[i]
- selected_tbox[:, :2] -= grid
- iou = bbox_iou(pbox.T, selected_tbox, x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += (1.0 - iou).mean() # iou loss
-
- # Objectness
- tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * iou.detach().clamp(0).type(tobj.dtype) # iou ratio
-
- # Classification
- selected_tcls = targets[i][:, 1].long()
- if self.nc > 1: # cls loss (only if multiple classes)
- t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets
- t[range(n), selected_tcls] = self.cp
- lcls += self.BCEcls(ps[:, 5:], t) # BCE
-
- # Append targets to text file
- # with open('targets.txt', 'a') as file:
- # [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
-
- obji = self.BCEobj(pi[..., 4], tobj)
- lobj += obji * self.balance[i] # obj loss
- if self.autobalance:
- self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
-
- if self.autobalance:
- self.balance = [x / self.balance[self.ssi] for x in self.balance]
- lbox *= self.hyp['box']
- lobj *= self.hyp['obj']
- lcls *= self.hyp['cls']
- bs = tobj.shape[0] # batch size
-
- loss = lbox + lobj + lcls
- return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()
-
- def build_targets(self, p, targets, imgs):
-
- #indices, anch = self.find_positive(p, targets)
- indices, anch = self.find_3_positive(p, targets)
- #indices, anch = self.find_4_positive(p, targets)
- #indices, anch = self.find_5_positive(p, targets)
- #indices, anch = self.find_9_positive(p, targets)
-
- matching_bs = [[] for pp in p]
- matching_as = [[] for pp in p]
- matching_gjs = [[] for pp in p]
- matching_gis = [[] for pp in p]
- matching_targets = [[] for pp in p]
- matching_anchs = [[] for pp in p]
-
- nl = len(p)
-
- for batch_idx in range(p[0].shape[0]):
-
- b_idx = targets[:, 0]==batch_idx
- this_target = targets[b_idx]
- if this_target.shape[0] == 0:
- continue
-
- txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1]
- txyxy = xywh2xyxy(txywh)
-
- pxyxys = []
- p_cls = []
- p_obj = []
- from_which_layer = []
- all_b = []
- all_a = []
- all_gj = []
- all_gi = []
- all_anch = []
-
- for i, pi in enumerate(p):
-
- b, a, gj, gi = indices[i]
- idx = (b == batch_idx)
- b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]
- all_b.append(b)
- all_a.append(a)
- all_gj.append(gj)
- all_gi.append(gi)
- all_anch.append(anch[i][idx])
- from_which_layer.append(torch.ones(size=(len(b),)) * i)
-
- fg_pred = pi[b, a, gj, gi]
- p_obj.append(fg_pred[:, 4:5])
- p_cls.append(fg_pred[:, 5:])
-
- grid = torch.stack([gi, gj], dim=1)
- pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #/ 8.
- #pxy = (fg_pred[:, :2].sigmoid() * 3. - 1. + grid) * self.stride[i]
- pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8.
- pxywh = torch.cat([pxy, pwh], dim=-1)
- pxyxy = xywh2xyxy(pxywh)
- pxyxys.append(pxyxy)
-
- pxyxys = torch.cat(pxyxys, dim=0)
- if pxyxys.shape[0] == 0:
- continue
- p_obj = torch.cat(p_obj, dim=0)
- p_cls = torch.cat(p_cls, dim=0)
- from_which_layer = torch.cat(from_which_layer, dim=0)
- all_b = torch.cat(all_b, dim=0)
- all_a = torch.cat(all_a, dim=0)
- all_gj = torch.cat(all_gj, dim=0)
- all_gi = torch.cat(all_gi, dim=0)
- all_anch = torch.cat(all_anch, dim=0)
-
- pair_wise_iou = box_iou(txyxy, pxyxys)
-
- pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
-
- top_k, _ = torch.topk(pair_wise_iou, min(10, pair_wise_iou.shape[1]), dim=1)
- dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
-
- gt_cls_per_image = (
- F.one_hot(this_target[:, 1].to(torch.int64), self.nc)
- .float()
- .unsqueeze(1)
- .repeat(1, pxyxys.shape[0], 1)
- )
-
- num_gt = this_target.shape[0]
- cls_preds_ = (
- p_cls.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- * p_obj.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- )
-
- y = cls_preds_.sqrt_()
- pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
- torch.log(y/(1-y)) , gt_cls_per_image, reduction="none"
- ).sum(-1)
- del cls_preds_
-
- cost = (
- pair_wise_cls_loss
- + 3.0 * pair_wise_iou_loss
- )
-
- matching_matrix = torch.zeros_like(cost)
-
- for gt_idx in range(num_gt):
- _, pos_idx = torch.topk(
- cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
- )
- matching_matrix[gt_idx][pos_idx] = 1.0
-
- del top_k, dynamic_ks
- anchor_matching_gt = matching_matrix.sum(0)
- if (anchor_matching_gt > 1).sum() > 0:
- _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
- matching_matrix[:, anchor_matching_gt > 1] *= 0.0
- matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
- fg_mask_inboxes = matching_matrix.sum(0) > 0.0
- matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
-
- from_which_layer = from_which_layer[fg_mask_inboxes]
- all_b = all_b[fg_mask_inboxes]
- all_a = all_a[fg_mask_inboxes]
- all_gj = all_gj[fg_mask_inboxes]
- all_gi = all_gi[fg_mask_inboxes]
- all_anch = all_anch[fg_mask_inboxes]
-
- this_target = this_target[matched_gt_inds]
-
- for i in range(nl):
- layer_idx = from_which_layer == i
- matching_bs[i].append(all_b[layer_idx])
- matching_as[i].append(all_a[layer_idx])
- matching_gjs[i].append(all_gj[layer_idx])
- matching_gis[i].append(all_gi[layer_idx])
- matching_targets[i].append(this_target[layer_idx])
- matching_anchs[i].append(all_anch[layer_idx])
-
- for i in range(nl):
- if matching_targets[i] != []:
- matching_bs[i] = torch.cat(matching_bs[i], dim=0)
- matching_as[i] = torch.cat(matching_as[i], dim=0)
- matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
- matching_gis[i] = torch.cat(matching_gis[i], dim=0)
- matching_targets[i] = torch.cat(matching_targets[i], dim=0)
- matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
- else:
- matching_bs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_as[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gjs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gis[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_targets[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_anchs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
-
- return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs
-
- def find_3_positive(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- indices, anch = [], []
- gain = torch.ones(7, device=targets.device).long() # normalized to gridspace gain
- ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 0.5 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=targets.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1. < g) & (gxy > 1.)).T
- l, m = ((gxi % 1. < g) & (gxi > 1.)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- b, c = t[:, :2].long().T # image, class
- gxy = t[:, 2:4] # grid xy
- gwh = t[:, 4:6] # grid wh
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid xy indices
-
- # Append
- a = t[:, 6].long() # anchor indices
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- anch.append(anchors[a]) # anchors
-
- return indices, anch
-
-
-class ComputeLossBinOTA:
- # Compute losses
- def __init__(self, model, autobalance=False):
- super(ComputeLossBinOTA, self).__init__()
- device = next(model.parameters()).device # get model device
- h = model.hyp # hyperparameters
-
- # Define criteria
- BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
- BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
- #MSEangle = nn.MSELoss().to(device)
-
- # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
- self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
-
- # Focal loss
- g = h['fl_gamma'] # focal loss gamma
- if g > 0:
- BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
-
- det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module
- self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, .02]) # P3-P7
- self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index
- self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, model.gr, h, autobalance
- for k in 'na', 'nc', 'nl', 'anchors', 'stride', 'bin_count':
- setattr(self, k, getattr(det, k))
-
- #xy_bin_sigmoid = SigmoidBin(bin_count=11, min=-0.5, max=1.5, use_loss_regression=False).to(device)
- wh_bin_sigmoid = SigmoidBin(bin_count=self.bin_count, min=0.0, max=4.0, use_loss_regression=False).to(device)
- #angle_bin_sigmoid = SigmoidBin(bin_count=31, min=-1.1, max=1.1, use_loss_regression=False).to(device)
- self.wh_bin_sigmoid = wh_bin_sigmoid
-
- def __call__(self, p, targets, imgs): # predictions, targets, model
- device = targets.device
- lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device)
- bs, as_, gjs, gis, targets, anchors = self.build_targets(p, targets, imgs)
- pre_gen_gains = [torch.tensor(pp.shape, device=device)[[3, 2, 3, 2]] for pp in p]
-
-
- # Losses
- for i, pi in enumerate(p): # layer index, layer predictions
- b, a, gj, gi = bs[i], as_[i], gjs[i], gis[i] # image, anchor, gridy, gridx
- tobj = torch.zeros_like(pi[..., 0], device=device) # target obj
-
- obj_idx = self.wh_bin_sigmoid.get_length()*2 + 2 # x,y, w-bce, h-bce # xy_bin_sigmoid.get_length()*2
-
- n = b.shape[0] # number of targets
- if n:
- ps = pi[b, a, gj, gi] # prediction subset corresponding to targets
-
- # Regression
- grid = torch.stack([gi, gj], dim=1)
- selected_tbox = targets[i][:, 2:6] * pre_gen_gains[i]
- selected_tbox[:, :2] -= grid
-
- #pxy = ps[:, :2].sigmoid() * 2. - 0.5
- ##pxy = ps[:, :2].sigmoid() * 3. - 1.
- #pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]
- #pbox = torch.cat((pxy, pwh), 1) # predicted box
-
- #x_loss, px = xy_bin_sigmoid.training_loss(ps[..., 0:12], tbox[i][..., 0])
- #y_loss, py = xy_bin_sigmoid.training_loss(ps[..., 12:24], tbox[i][..., 1])
- w_loss, pw = self.wh_bin_sigmoid.training_loss(ps[..., 2:(3+self.bin_count)], selected_tbox[..., 2] / anchors[i][..., 0])
- h_loss, ph = self.wh_bin_sigmoid.training_loss(ps[..., (3+self.bin_count):obj_idx], selected_tbox[..., 3] / anchors[i][..., 1])
-
- pw *= anchors[i][..., 0]
- ph *= anchors[i][..., 1]
-
- px = ps[:, 0].sigmoid() * 2. - 0.5
- py = ps[:, 1].sigmoid() * 2. - 0.5
-
- lbox += w_loss + h_loss # + x_loss + y_loss
-
- #print(f"\n px = {px.shape}, py = {py.shape}, pw = {pw.shape}, ph = {ph.shape} \n")
-
- pbox = torch.cat((px.unsqueeze(1), py.unsqueeze(1), pw.unsqueeze(1), ph.unsqueeze(1)), 1).to(device) # predicted box
-
-
-
-
- iou = bbox_iou(pbox.T, selected_tbox, x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += (1.0 - iou).mean() # iou loss
-
- # Objectness
- tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * iou.detach().clamp(0).type(tobj.dtype) # iou ratio
-
- # Classification
- selected_tcls = targets[i][:, 1].long()
- if self.nc > 1: # cls loss (only if multiple classes)
- t = torch.full_like(ps[:, (1+obj_idx):], self.cn, device=device) # targets
- t[range(n), selected_tcls] = self.cp
- lcls += self.BCEcls(ps[:, (1+obj_idx):], t) # BCE
-
- # Append targets to text file
- # with open('targets.txt', 'a') as file:
- # [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
-
- obji = self.BCEobj(pi[..., obj_idx], tobj)
- lobj += obji * self.balance[i] # obj loss
- if self.autobalance:
- self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
-
- if self.autobalance:
- self.balance = [x / self.balance[self.ssi] for x in self.balance]
- lbox *= self.hyp['box']
- lobj *= self.hyp['obj']
- lcls *= self.hyp['cls']
- bs = tobj.shape[0] # batch size
-
- loss = lbox + lobj + lcls
- return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()
-
- def build_targets(self, p, targets, imgs):
-
- #indices, anch = self.find_positive(p, targets)
- indices, anch = self.find_3_positive(p, targets)
- #indices, anch = self.find_4_positive(p, targets)
- #indices, anch = self.find_5_positive(p, targets)
- #indices, anch = self.find_9_positive(p, targets)
-
- matching_bs = [[] for pp in p]
- matching_as = [[] for pp in p]
- matching_gjs = [[] for pp in p]
- matching_gis = [[] for pp in p]
- matching_targets = [[] for pp in p]
- matching_anchs = [[] for pp in p]
-
- nl = len(p)
-
- for batch_idx in range(p[0].shape[0]):
-
- b_idx = targets[:, 0]==batch_idx
- this_target = targets[b_idx]
- if this_target.shape[0] == 0:
- continue
-
- txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1]
- txyxy = xywh2xyxy(txywh)
-
- pxyxys = []
- p_cls = []
- p_obj = []
- from_which_layer = []
- all_b = []
- all_a = []
- all_gj = []
- all_gi = []
- all_anch = []
-
- for i, pi in enumerate(p):
-
- obj_idx = self.wh_bin_sigmoid.get_length()*2 + 2
-
- b, a, gj, gi = indices[i]
- idx = (b == batch_idx)
- b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]
- all_b.append(b)
- all_a.append(a)
- all_gj.append(gj)
- all_gi.append(gi)
- all_anch.append(anch[i][idx])
- from_which_layer.append(torch.ones(size=(len(b),)) * i)
-
- fg_pred = pi[b, a, gj, gi]
- p_obj.append(fg_pred[:, obj_idx:(obj_idx+1)])
- p_cls.append(fg_pred[:, (obj_idx+1):])
-
- grid = torch.stack([gi, gj], dim=1)
- pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #/ 8.
- #pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8.
- pw = self.wh_bin_sigmoid.forward(fg_pred[..., 2:(3+self.bin_count)].sigmoid()) * anch[i][idx][:, 0] * self.stride[i]
- ph = self.wh_bin_sigmoid.forward(fg_pred[..., (3+self.bin_count):obj_idx].sigmoid()) * anch[i][idx][:, 1] * self.stride[i]
-
- pxywh = torch.cat([pxy, pw.unsqueeze(1), ph.unsqueeze(1)], dim=-1)
- pxyxy = xywh2xyxy(pxywh)
- pxyxys.append(pxyxy)
-
- pxyxys = torch.cat(pxyxys, dim=0)
- if pxyxys.shape[0] == 0:
- continue
- p_obj = torch.cat(p_obj, dim=0)
- p_cls = torch.cat(p_cls, dim=0)
- from_which_layer = torch.cat(from_which_layer, dim=0)
- all_b = torch.cat(all_b, dim=0)
- all_a = torch.cat(all_a, dim=0)
- all_gj = torch.cat(all_gj, dim=0)
- all_gi = torch.cat(all_gi, dim=0)
- all_anch = torch.cat(all_anch, dim=0)
-
- pair_wise_iou = box_iou(txyxy, pxyxys)
-
- pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
-
- top_k, _ = torch.topk(pair_wise_iou, min(10, pair_wise_iou.shape[1]), dim=1)
- dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
-
- gt_cls_per_image = (
- F.one_hot(this_target[:, 1].to(torch.int64), self.nc)
- .float()
- .unsqueeze(1)
- .repeat(1, pxyxys.shape[0], 1)
- )
-
- num_gt = this_target.shape[0]
- cls_preds_ = (
- p_cls.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- * p_obj.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- )
-
- y = cls_preds_.sqrt_()
- pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
- torch.log(y/(1-y)) , gt_cls_per_image, reduction="none"
- ).sum(-1)
- del cls_preds_
-
- cost = (
- pair_wise_cls_loss
- + 3.0 * pair_wise_iou_loss
- )
-
- matching_matrix = torch.zeros_like(cost)
-
- for gt_idx in range(num_gt):
- _, pos_idx = torch.topk(
- cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
- )
- matching_matrix[gt_idx][pos_idx] = 1.0
-
- del top_k, dynamic_ks
- anchor_matching_gt = matching_matrix.sum(0)
- if (anchor_matching_gt > 1).sum() > 0:
- _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
- matching_matrix[:, anchor_matching_gt > 1] *= 0.0
- matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
- fg_mask_inboxes = matching_matrix.sum(0) > 0.0
- matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
-
- from_which_layer = from_which_layer[fg_mask_inboxes]
- all_b = all_b[fg_mask_inboxes]
- all_a = all_a[fg_mask_inboxes]
- all_gj = all_gj[fg_mask_inboxes]
- all_gi = all_gi[fg_mask_inboxes]
- all_anch = all_anch[fg_mask_inboxes]
-
- this_target = this_target[matched_gt_inds]
-
- for i in range(nl):
- layer_idx = from_which_layer == i
- matching_bs[i].append(all_b[layer_idx])
- matching_as[i].append(all_a[layer_idx])
- matching_gjs[i].append(all_gj[layer_idx])
- matching_gis[i].append(all_gi[layer_idx])
- matching_targets[i].append(this_target[layer_idx])
- matching_anchs[i].append(all_anch[layer_idx])
-
- for i in range(nl):
- if matching_targets[i] != []:
- matching_bs[i] = torch.cat(matching_bs[i], dim=0)
- matching_as[i] = torch.cat(matching_as[i], dim=0)
- matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
- matching_gis[i] = torch.cat(matching_gis[i], dim=0)
- matching_targets[i] = torch.cat(matching_targets[i], dim=0)
- matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
- else:
- matching_bs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_as[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gjs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gis[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_targets[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_anchs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
-
- return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs
-
- def find_3_positive(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- indices, anch = [], []
- gain = torch.ones(7, device=targets.device).long() # normalized to gridspace gain
- ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 0.5 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=targets.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1. < g) & (gxy > 1.)).T
- l, m = ((gxi % 1. < g) & (gxi > 1.)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- b, c = t[:, :2].long().T # image, class
- gxy = t[:, 2:4] # grid xy
- gwh = t[:, 4:6] # grid wh
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid xy indices
-
- # Append
- a = t[:, 6].long() # anchor indices
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- anch.append(anchors[a]) # anchors
-
- return indices, anch
-
-
-class ComputeLossAuxOTA:
- # Compute losses
- def __init__(self, model, autobalance=False):
- super(ComputeLossAuxOTA, self).__init__()
- device = next(model.parameters()).device # get model device
- h = model.hyp # hyperparameters
-
- # Define criteria
- BCEcls = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['cls_pw']], device=device))
- BCEobj = nn.BCEWithLogitsLoss(pos_weight=torch.tensor([h['obj_pw']], device=device))
-
- # Class label smoothing https://arxiv.org/pdf/1902.04103.pdf eqn 3
- self.cp, self.cn = smooth_BCE(eps=h.get('label_smoothing', 0.0)) # positive, negative BCE targets
-
- # Focal loss
- g = h['fl_gamma'] # focal loss gamma
- if g > 0:
- BCEcls, BCEobj = FocalLoss(BCEcls, g), FocalLoss(BCEobj, g)
-
- det = model.module.model[-1] if is_parallel(model) else model.model[-1] # Detect() module
- self.balance = {3: [4.0, 1.0, 0.4]}.get(det.nl, [4.0, 1.0, 0.25, 0.06, .02]) # P3-P7
- self.ssi = list(det.stride).index(16) if autobalance else 0 # stride 16 index
- self.BCEcls, self.BCEobj, self.gr, self.hyp, self.autobalance = BCEcls, BCEobj, model.gr, h, autobalance
- for k in 'na', 'nc', 'nl', 'anchors', 'stride':
- setattr(self, k, getattr(det, k))
-
- def __call__(self, p, targets, imgs): # predictions, targets, model
- device = targets.device
- lcls, lbox, lobj = torch.zeros(1, device=device), torch.zeros(1, device=device), torch.zeros(1, device=device)
- bs_aux, as_aux_, gjs_aux, gis_aux, targets_aux, anchors_aux = self.build_targets2(p[:self.nl], targets, imgs)
- bs, as_, gjs, gis, targets, anchors = self.build_targets(p[:self.nl], targets, imgs)
- pre_gen_gains_aux = [torch.tensor(pp.shape, device=device)[[3, 2, 3, 2]] for pp in p[:self.nl]]
- pre_gen_gains = [torch.tensor(pp.shape, device=device)[[3, 2, 3, 2]] for pp in p[:self.nl]]
-
-
- # Losses
- for i in range(self.nl): # layer index, layer predictions
- pi = p[i]
- pi_aux = p[i+self.nl]
- b, a, gj, gi = bs[i], as_[i], gjs[i], gis[i] # image, anchor, gridy, gridx
- b_aux, a_aux, gj_aux, gi_aux = bs_aux[i], as_aux_[i], gjs_aux[i], gis_aux[i] # image, anchor, gridy, gridx
- tobj = torch.zeros_like(pi[..., 0], device=device) # target obj
- tobj_aux = torch.zeros_like(pi_aux[..., 0], device=device) # target obj
-
- n = b.shape[0] # number of targets
- if n:
- ps = pi[b, a, gj, gi] # prediction subset corresponding to targets
-
- # Regression
- grid = torch.stack([gi, gj], dim=1)
- pxy = ps[:, :2].sigmoid() * 2. - 0.5
- pwh = (ps[:, 2:4].sigmoid() * 2) ** 2 * anchors[i]
- pbox = torch.cat((pxy, pwh), 1) # predicted box
- selected_tbox = targets[i][:, 2:6] * pre_gen_gains[i]
- selected_tbox[:, :2] -= grid
- iou = bbox_iou(pbox.T, selected_tbox, x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += (1.0 - iou).mean() # iou loss
-
- # Objectness
- tobj[b, a, gj, gi] = (1.0 - self.gr) + self.gr * iou.detach().clamp(0).type(tobj.dtype) # iou ratio
-
- # Classification
- selected_tcls = targets[i][:, 1].long()
- if self.nc > 1: # cls loss (only if multiple classes)
- t = torch.full_like(ps[:, 5:], self.cn, device=device) # targets
- t[range(n), selected_tcls] = self.cp
- lcls += self.BCEcls(ps[:, 5:], t) # BCE
-
- # Append targets to text file
- # with open('targets.txt', 'a') as file:
- # [file.write('%11.5g ' * 4 % tuple(x) + '\n') for x in torch.cat((txy[i], twh[i]), 1)]
-
- n_aux = b_aux.shape[0] # number of targets
- if n_aux:
- ps_aux = pi_aux[b_aux, a_aux, gj_aux, gi_aux] # prediction subset corresponding to targets
- grid_aux = torch.stack([gi_aux, gj_aux], dim=1)
- pxy_aux = ps_aux[:, :2].sigmoid() * 2. - 0.5
- #pxy_aux = ps_aux[:, :2].sigmoid() * 3. - 1.
- pwh_aux = (ps_aux[:, 2:4].sigmoid() * 2) ** 2 * anchors_aux[i]
- pbox_aux = torch.cat((pxy_aux, pwh_aux), 1) # predicted box
- selected_tbox_aux = targets_aux[i][:, 2:6] * pre_gen_gains_aux[i]
- selected_tbox_aux[:, :2] -= grid_aux
- iou_aux = bbox_iou(pbox_aux.T, selected_tbox_aux, x1y1x2y2=False, CIoU=True) # iou(prediction, target)
- lbox += 0.25 * (1.0 - iou_aux).mean() # iou loss
-
- # Objectness
- tobj_aux[b_aux, a_aux, gj_aux, gi_aux] = (1.0 - self.gr) + self.gr * iou_aux.detach().clamp(0).type(tobj_aux.dtype) # iou ratio
-
- # Classification
- selected_tcls_aux = targets_aux[i][:, 1].long()
- if self.nc > 1: # cls loss (only if multiple classes)
- t_aux = torch.full_like(ps_aux[:, 5:], self.cn, device=device) # targets
- t_aux[range(n_aux), selected_tcls_aux] = self.cp
- lcls += 0.25 * self.BCEcls(ps_aux[:, 5:], t_aux) # BCE
-
- obji = self.BCEobj(pi[..., 4], tobj)
- obji_aux = self.BCEobj(pi_aux[..., 4], tobj_aux)
- lobj += obji * self.balance[i] + 0.25 * obji_aux * self.balance[i] # obj loss
- if self.autobalance:
- self.balance[i] = self.balance[i] * 0.9999 + 0.0001 / obji.detach().item()
-
- if self.autobalance:
- self.balance = [x / self.balance[self.ssi] for x in self.balance]
- lbox *= self.hyp['box']
- lobj *= self.hyp['obj']
- lcls *= self.hyp['cls']
- bs = tobj.shape[0] # batch size
-
- loss = lbox + lobj + lcls
- return loss * bs, torch.cat((lbox, lobj, lcls, loss)).detach()
-
- def build_targets(self, p, targets, imgs):
-
- indices, anch = self.find_3_positive(p, targets)
-
- matching_bs = [[] for pp in p]
- matching_as = [[] for pp in p]
- matching_gjs = [[] for pp in p]
- matching_gis = [[] for pp in p]
- matching_targets = [[] for pp in p]
- matching_anchs = [[] for pp in p]
-
- nl = len(p)
-
- for batch_idx in range(p[0].shape[0]):
-
- b_idx = targets[:, 0]==batch_idx
- this_target = targets[b_idx]
- if this_target.shape[0] == 0:
- continue
-
- txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1]
- txyxy = xywh2xyxy(txywh)
-
- pxyxys = []
- p_cls = []
- p_obj = []
- from_which_layer = []
- all_b = []
- all_a = []
- all_gj = []
- all_gi = []
- all_anch = []
-
- for i, pi in enumerate(p):
-
- b, a, gj, gi = indices[i]
- idx = (b == batch_idx)
- b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]
- all_b.append(b)
- all_a.append(a)
- all_gj.append(gj)
- all_gi.append(gi)
- all_anch.append(anch[i][idx])
- from_which_layer.append(torch.ones(size=(len(b),)) * i)
-
- fg_pred = pi[b, a, gj, gi]
- p_obj.append(fg_pred[:, 4:5])
- p_cls.append(fg_pred[:, 5:])
-
- grid = torch.stack([gi, gj], dim=1)
- pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #/ 8.
- #pxy = (fg_pred[:, :2].sigmoid() * 3. - 1. + grid) * self.stride[i]
- pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8.
- pxywh = torch.cat([pxy, pwh], dim=-1)
- pxyxy = xywh2xyxy(pxywh)
- pxyxys.append(pxyxy)
-
- pxyxys = torch.cat(pxyxys, dim=0)
- if pxyxys.shape[0] == 0:
- continue
- p_obj = torch.cat(p_obj, dim=0)
- p_cls = torch.cat(p_cls, dim=0)
- from_which_layer = torch.cat(from_which_layer, dim=0)
- all_b = torch.cat(all_b, dim=0)
- all_a = torch.cat(all_a, dim=0)
- all_gj = torch.cat(all_gj, dim=0)
- all_gi = torch.cat(all_gi, dim=0)
- all_anch = torch.cat(all_anch, dim=0)
-
- pair_wise_iou = box_iou(txyxy, pxyxys)
-
- pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
-
- top_k, _ = torch.topk(pair_wise_iou, min(20, pair_wise_iou.shape[1]), dim=1)
- dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
-
- gt_cls_per_image = (
- F.one_hot(this_target[:, 1].to(torch.int64), self.nc)
- .float()
- .unsqueeze(1)
- .repeat(1, pxyxys.shape[0], 1)
- )
-
- num_gt = this_target.shape[0]
- cls_preds_ = (
- p_cls.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- * p_obj.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- )
-
- y = cls_preds_.sqrt_()
- pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
- torch.log(y/(1-y)) , gt_cls_per_image, reduction="none"
- ).sum(-1)
- del cls_preds_
-
- cost = (
- pair_wise_cls_loss
- + 3.0 * pair_wise_iou_loss
- )
-
- matching_matrix = torch.zeros_like(cost)
-
- for gt_idx in range(num_gt):
- _, pos_idx = torch.topk(
- cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
- )
- matching_matrix[gt_idx][pos_idx] = 1.0
-
- del top_k, dynamic_ks
- anchor_matching_gt = matching_matrix.sum(0)
- if (anchor_matching_gt > 1).sum() > 0:
- _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
- matching_matrix[:, anchor_matching_gt > 1] *= 0.0
- matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
- fg_mask_inboxes = matching_matrix.sum(0) > 0.0
- matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
-
- from_which_layer = from_which_layer[fg_mask_inboxes]
- all_b = all_b[fg_mask_inboxes]
- all_a = all_a[fg_mask_inboxes]
- all_gj = all_gj[fg_mask_inboxes]
- all_gi = all_gi[fg_mask_inboxes]
- all_anch = all_anch[fg_mask_inboxes]
-
- this_target = this_target[matched_gt_inds]
-
- for i in range(nl):
- layer_idx = from_which_layer == i
- matching_bs[i].append(all_b[layer_idx])
- matching_as[i].append(all_a[layer_idx])
- matching_gjs[i].append(all_gj[layer_idx])
- matching_gis[i].append(all_gi[layer_idx])
- matching_targets[i].append(this_target[layer_idx])
- matching_anchs[i].append(all_anch[layer_idx])
-
- for i in range(nl):
- if matching_targets[i] != []:
- matching_bs[i] = torch.cat(matching_bs[i], dim=0)
- matching_as[i] = torch.cat(matching_as[i], dim=0)
- matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
- matching_gis[i] = torch.cat(matching_gis[i], dim=0)
- matching_targets[i] = torch.cat(matching_targets[i], dim=0)
- matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
- else:
- matching_bs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_as[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gjs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gis[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_targets[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_anchs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
-
- return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs
-
- def build_targets2(self, p, targets, imgs):
-
- indices, anch = self.find_5_positive(p, targets)
-
- matching_bs = [[] for pp in p]
- matching_as = [[] for pp in p]
- matching_gjs = [[] for pp in p]
- matching_gis = [[] for pp in p]
- matching_targets = [[] for pp in p]
- matching_anchs = [[] for pp in p]
-
- nl = len(p)
-
- for batch_idx in range(p[0].shape[0]):
-
- b_idx = targets[:, 0]==batch_idx
- this_target = targets[b_idx]
- if this_target.shape[0] == 0:
- continue
-
- txywh = this_target[:, 2:6] * imgs[batch_idx].shape[1]
- txyxy = xywh2xyxy(txywh)
-
- pxyxys = []
- p_cls = []
- p_obj = []
- from_which_layer = []
- all_b = []
- all_a = []
- all_gj = []
- all_gi = []
- all_anch = []
-
- for i, pi in enumerate(p):
-
- b, a, gj, gi = indices[i]
- idx = (b == batch_idx)
- b, a, gj, gi = b[idx], a[idx], gj[idx], gi[idx]
- all_b.append(b)
- all_a.append(a)
- all_gj.append(gj)
- all_gi.append(gi)
- all_anch.append(anch[i][idx])
- from_which_layer.append(torch.ones(size=(len(b),)) * i)
-
- fg_pred = pi[b, a, gj, gi]
- p_obj.append(fg_pred[:, 4:5])
- p_cls.append(fg_pred[:, 5:])
-
- grid = torch.stack([gi, gj], dim=1)
- pxy = (fg_pred[:, :2].sigmoid() * 2. - 0.5 + grid) * self.stride[i] #/ 8.
- #pxy = (fg_pred[:, :2].sigmoid() * 3. - 1. + grid) * self.stride[i]
- pwh = (fg_pred[:, 2:4].sigmoid() * 2) ** 2 * anch[i][idx] * self.stride[i] #/ 8.
- pxywh = torch.cat([pxy, pwh], dim=-1)
- pxyxy = xywh2xyxy(pxywh)
- pxyxys.append(pxyxy)
-
- pxyxys = torch.cat(pxyxys, dim=0)
- if pxyxys.shape[0] == 0:
- continue
- p_obj = torch.cat(p_obj, dim=0)
- p_cls = torch.cat(p_cls, dim=0)
- from_which_layer = torch.cat(from_which_layer, dim=0)
- all_b = torch.cat(all_b, dim=0)
- all_a = torch.cat(all_a, dim=0)
- all_gj = torch.cat(all_gj, dim=0)
- all_gi = torch.cat(all_gi, dim=0)
- all_anch = torch.cat(all_anch, dim=0)
-
- pair_wise_iou = box_iou(txyxy, pxyxys)
-
- pair_wise_iou_loss = -torch.log(pair_wise_iou + 1e-8)
-
- top_k, _ = torch.topk(pair_wise_iou, min(20, pair_wise_iou.shape[1]), dim=1)
- dynamic_ks = torch.clamp(top_k.sum(1).int(), min=1)
-
- gt_cls_per_image = (
- F.one_hot(this_target[:, 1].to(torch.int64), self.nc)
- .float()
- .unsqueeze(1)
- .repeat(1, pxyxys.shape[0], 1)
- )
-
- num_gt = this_target.shape[0]
- cls_preds_ = (
- p_cls.float().unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- * p_obj.unsqueeze(0).repeat(num_gt, 1, 1).sigmoid_()
- )
-
- y = cls_preds_.sqrt_()
- pair_wise_cls_loss = F.binary_cross_entropy_with_logits(
- torch.log(y/(1-y)) , gt_cls_per_image, reduction="none"
- ).sum(-1)
- del cls_preds_
-
- cost = (
- pair_wise_cls_loss
- + 3.0 * pair_wise_iou_loss
- )
-
- matching_matrix = torch.zeros_like(cost)
-
- for gt_idx in range(num_gt):
- _, pos_idx = torch.topk(
- cost[gt_idx], k=dynamic_ks[gt_idx].item(), largest=False
- )
- matching_matrix[gt_idx][pos_idx] = 1.0
-
- del top_k, dynamic_ks
- anchor_matching_gt = matching_matrix.sum(0)
- if (anchor_matching_gt > 1).sum() > 0:
- _, cost_argmin = torch.min(cost[:, anchor_matching_gt > 1], dim=0)
- matching_matrix[:, anchor_matching_gt > 1] *= 0.0
- matching_matrix[cost_argmin, anchor_matching_gt > 1] = 1.0
- fg_mask_inboxes = matching_matrix.sum(0) > 0.0
- matched_gt_inds = matching_matrix[:, fg_mask_inboxes].argmax(0)
-
- from_which_layer = from_which_layer[fg_mask_inboxes]
- all_b = all_b[fg_mask_inboxes]
- all_a = all_a[fg_mask_inboxes]
- all_gj = all_gj[fg_mask_inboxes]
- all_gi = all_gi[fg_mask_inboxes]
- all_anch = all_anch[fg_mask_inboxes]
-
- this_target = this_target[matched_gt_inds]
-
- for i in range(nl):
- layer_idx = from_which_layer == i
- matching_bs[i].append(all_b[layer_idx])
- matching_as[i].append(all_a[layer_idx])
- matching_gjs[i].append(all_gj[layer_idx])
- matching_gis[i].append(all_gi[layer_idx])
- matching_targets[i].append(this_target[layer_idx])
- matching_anchs[i].append(all_anch[layer_idx])
-
- for i in range(nl):
- if matching_targets[i] != []:
- matching_bs[i] = torch.cat(matching_bs[i], dim=0)
- matching_as[i] = torch.cat(matching_as[i], dim=0)
- matching_gjs[i] = torch.cat(matching_gjs[i], dim=0)
- matching_gis[i] = torch.cat(matching_gis[i], dim=0)
- matching_targets[i] = torch.cat(matching_targets[i], dim=0)
- matching_anchs[i] = torch.cat(matching_anchs[i], dim=0)
- else:
- matching_bs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_as[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gjs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_gis[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_targets[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
- matching_anchs[i] = torch.tensor([], device='cuda:0', dtype=torch.int64)
-
- return matching_bs, matching_as, matching_gjs, matching_gis, matching_targets, matching_anchs
-
- def find_5_positive(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- indices, anch = [], []
- gain = torch.ones(7, device=targets.device).long() # normalized to gridspace gain
- ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 1.0 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=targets.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1. < g) & (gxy > 1.)).T
- l, m = ((gxi % 1. < g) & (gxi > 1.)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- b, c = t[:, :2].long().T # image, class
- gxy = t[:, 2:4] # grid xy
- gwh = t[:, 4:6] # grid wh
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid xy indices
-
- # Append
- a = t[:, 6].long() # anchor indices
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- anch.append(anchors[a]) # anchors
-
- return indices, anch
-
- def find_3_positive(self, p, targets):
- # Build targets for compute_loss(), input targets(image,class,x,y,w,h)
- na, nt = self.na, targets.shape[0] # number of anchors, targets
- indices, anch = [], []
- gain = torch.ones(7, device=targets.device).long() # normalized to gridspace gain
- ai = torch.arange(na, device=targets.device).float().view(na, 1).repeat(1, nt) # same as .repeat_interleave(nt)
- targets = torch.cat((targets.repeat(na, 1, 1), ai[:, :, None]), 2) # append anchor indices
-
- g = 0.5 # bias
- off = torch.tensor([[0, 0],
- [1, 0], [0, 1], [-1, 0], [0, -1], # j,k,l,m
- # [1, 1], [1, -1], [-1, 1], [-1, -1], # jk,jm,lk,lm
- ], device=targets.device).float() * g # offsets
-
- for i in range(self.nl):
- anchors = self.anchors[i]
- gain[2:6] = torch.tensor(p[i].shape)[[3, 2, 3, 2]] # xyxy gain
-
- # Match targets to anchors
- t = targets * gain
- if nt:
- # Matches
- r = t[:, :, 4:6] / anchors[:, None] # wh ratio
- j = torch.max(r, 1. / r).max(2)[0] < self.hyp['anchor_t'] # compare
- # j = wh_iou(anchors, t[:, 4:6]) > model.hyp['iou_t'] # iou(3,n)=wh_iou(anchors(3,2), gwh(n,2))
- t = t[j] # filter
-
- # Offsets
- gxy = t[:, 2:4] # grid xy
- gxi = gain[[2, 3]] - gxy # inverse
- j, k = ((gxy % 1. < g) & (gxy > 1.)).T
- l, m = ((gxi % 1. < g) & (gxi > 1.)).T
- j = torch.stack((torch.ones_like(j), j, k, l, m))
- t = t.repeat((5, 1, 1))[j]
- offsets = (torch.zeros_like(gxy)[None] + off[:, None])[j]
- else:
- t = targets[0]
- offsets = 0
-
- # Define
- b, c = t[:, :2].long().T # image, class
- gxy = t[:, 2:4] # grid xy
- gwh = t[:, 4:6] # grid wh
- gij = (gxy - offsets).long()
- gi, gj = gij.T # grid xy indices
-
- # Append
- a = t[:, 6].long() # anchor indices
- indices.append((b, a, gj.clamp_(0, gain[3] - 1), gi.clamp_(0, gain[2] - 1))) # image, anchor, grid indices
- anch.append(anchors[a]) # anchors
-
- return indices, anch
diff --git a/spaces/radames/Candle-T5-Generation-Wasm/build/m.d.ts b/spaces/radames/Candle-T5-Generation-Wasm/build/m.d.ts
deleted file mode 100644
index 21c078ca6d35d5432ad19ec8e4306c62e4072d9b..0000000000000000000000000000000000000000
--- a/spaces/radames/Candle-T5-Generation-Wasm/build/m.d.ts
+++ /dev/null
@@ -1,74 +0,0 @@
-/* tslint:disable */
-/* eslint-disable */
-/**
-*/
-export class ModelConditionalGeneration {
- free(): void;
-/**
-* @param {Uint8Array} weights
-* @param {Uint8Array} tokenizer
-* @param {Uint8Array} config
-*/
- constructor(weights: Uint8Array, tokenizer: Uint8Array, config: Uint8Array);
-/**
-* @param {any} input
-* @returns {any}
-*/
- decode(input: any): any;
-}
-/**
-*/
-export class ModelEncoder {
- free(): void;
-/**
-* @param {Uint8Array} weights
-* @param {Uint8Array} tokenizer
-* @param {Uint8Array} config
-*/
- constructor(weights: Uint8Array, tokenizer: Uint8Array, config: Uint8Array);
-/**
-* @param {any} input
-* @returns {any}
-*/
- decode(input: any): any;
-}
-
-export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
-
-export interface InitOutput {
- readonly memory: WebAssembly.Memory;
- readonly __wbg_modelencoder_free: (a: number) => void;
- readonly __wbg_modelconditionalgeneration_free: (a: number) => void;
- readonly modelconditionalgeneration_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
- readonly modelconditionalgeneration_decode: (a: number, b: number, c: number) => void;
- readonly modelencoder_load: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
- readonly modelencoder_decode: (a: number, b: number, c: number) => void;
- readonly main: (a: number, b: number) => number;
- readonly __wbindgen_malloc: (a: number, b: number) => number;
- readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
- readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
- readonly __wbindgen_free: (a: number, b: number, c: number) => void;
- readonly __wbindgen_exn_store: (a: number) => void;
- readonly __wbindgen_start: () => void;
-}
-
-export type SyncInitInput = BufferSource | WebAssembly.Module;
-/**
-* Instantiates the given `module`, which can either be bytes or
-* a precompiled `WebAssembly.Module`.
-*
-* @param {SyncInitInput} module
-*
-* @returns {InitOutput}
-*/
-export function initSync(module: SyncInitInput): InitOutput;
-
-/**
-* If `module_or_path` is {RequestInfo} or {URL}, makes a request and
-* for everything else, calls `WebAssembly.instantiate` directly.
-*
-* @param {InitInput | Promise} module_or_path
-*
-* @returns {Promise}
-*/
-export default function __wbg_init (module_or_path?: InitInput | Promise): Promise;
diff --git a/spaces/radames/SPIGA-face-alignment-headpose-estimator/SPIGA/spiga/models/cnn/transform_e2p.py b/spaces/radames/SPIGA-face-alignment-headpose-estimator/SPIGA/spiga/models/cnn/transform_e2p.py
deleted file mode 100644
index 14c42534bf5f608bd34f576c5ac1f6e8c0eb6167..0000000000000000000000000000000000000000
--- a/spaces/radames/SPIGA-face-alignment-headpose-estimator/SPIGA/spiga/models/cnn/transform_e2p.py
+++ /dev/null
@@ -1,257 +0,0 @@
-import torch
-from torch import nn
-
-
-class E2Ptransform(nn.Module):
- """Edge to Points trasnformation"""
- def __init__(self, points, edges, out_dim=64):
- super(E2Ptransform, self).__init__()
- self.ones = nn.parameter.Parameter(torch.ones((1, out_dim, out_dim)), requires_grad=False)
- edge_matrix = self._select_matrix(points, edges)
- self.edge2point = nn.parameter.Parameter(edge_matrix, requires_grad=False) # Npoint X Nedges+1
-
- def forward(self, edges):
- B, L, H, W = edges.shape
- edges_ext = torch.cat((edges, self.ones.repeat(B, 1, 1, 1)), 1)
- edges_mat = edges_ext.permute(0, 2, 3, 1).reshape(B, H, W, 1, L+1)
- edge2point = self.edge2point.transpose(-1, -2)
- point_edges = torch.matmul(edges_mat, edge2point)
- point_edges = point_edges.reshape(B, H, W, -1).permute(0, 3, 1, 2)
- point_edges[point_edges > 1] = 1.
- return point_edges
-
- def _select_matrix(self, points, edges):
-
- if points == 98 and edges == 15:
- return WFLW_98x15
- elif points == 68 and edges == 13:
- return W300_68x13
- elif points == 29 and edges == 13:
- return COFW_29x13
- elif points == 19 and edges == 6:
- return AFLW19_19x6
- else:
- raise ValueError("E2P matrix not implemented")
-
-
-# Database matrixE2P
-WFLW_98x15 = torch.Tensor([[1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
-
-
-W300_68x13 = torch.Tensor([ [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]])
-
-
-AFLW19_19x6 = torch.Tensor([[1, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 1]])
-
-
-COFW_29x13 = torch.Tensor([ [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
- [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
- [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]])
diff --git a/spaces/radames/sentence-embeddings-visualization/README.md b/spaces/radames/sentence-embeddings-visualization/README.md
deleted file mode 100644
index bc3a0b6593945dfadb8b0cce55106c94548a6473..0000000000000000000000000000000000000000
--- a/spaces/radames/sentence-embeddings-visualization/README.md
+++ /dev/null
@@ -1,26 +0,0 @@
----
-title: Sentence Embeddings Visualization
-emoji: 📈
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-# Hugging Face Spaces + Observable
-### Sentence Embeddings Visualization
-
-Recently I've been exploring [Hugging face Spaces](https://huggingface.co/spaces) and [sentence-transformers](https://huggingface.co/sentence-transformers) to build an application to generate text embeddings and clustering visualization.
-
-Currently, the quickest way to build interactive ML apps with Python (backend/frontend), afaik, is to use [Streamlit](https://streamlit.io/) or [Gradio](https://www.gradio.app/). To embed an Observable notebook on Streamlit, you can use this custom component [streamlit-observable](https://github.com/asg017/streamlit-observable)
-
-This [Observable notebook](https://observablehq.com/@radames/hugging-face-spaces-observable-sentence-embeddings) is the frontend application for this [Hugging Face Spaces](https://huggingface.co/spaces/radames/sentence-embeddings-visualization) app.
-
-This notebook explores another way to integrate Observable inside Hugging Face Spaces. Currently, [HF Spaces supports](https://huggingface.co/docs/hub/spaces#streamlit-and-gradio) Streamlit and Gradio or a simple static web page.
-
-The concept here is to use this entire notebook as the frontend and data visualization application for the [ML Flask/Python](https://huggingface.co/spaces/radames/sentence-embeddings-visualization/blob/main/app.py#L37-L75) backend.
-
-* The index route renders a [simple HTML template](https://huggingface.co/spaces/radames/sentence-embeddings-visualization/blob/main/templates/index.html) containing [Observable Runtime API code](https://observablehq.com/@observablehq/downloading-and-embedding-notebooks).
-* A single function, triggered by a POST request to \`run-umap\`, returns a low dimensional representation of the original sentence transformers embeddings using UMAP and cluster analysis with HDBSCAN.
-* All the visualization and interactive magic happen on the Javascript code inside the Observable Notebook.
diff --git a/spaces/raedeXanto/academic-chatgpt-beta/Adobe Illustrator CS6 V16.0.0 682 Portablel.md b/spaces/raedeXanto/academic-chatgpt-beta/Adobe Illustrator CS6 V16.0.0 682 Portablel.md
deleted file mode 100644
index cf27a27a71734e57a906c54cebf7383889aaba3b..0000000000000000000000000000000000000000
--- a/spaces/raedeXanto/academic-chatgpt-beta/Adobe Illustrator CS6 V16.0.0 682 Portablel.md
+++ /dev/null
@@ -1,36 +0,0 @@
-Adobe Illustrator CS6 V16.0.0 682 Portablel: What You Need to Know
-
-Adobe Illustrator CS6 is a powerful vector graphics software that allows you to create stunning logos, icons, illustrations, and more. But what if you want to use it on different devices without installing it? That's where Adobe Illustrator CS6 V16.0.0 682 Portablel comes in.
-Adobe Illustrator CS6 V16.0.0 682 Portablel Download Zip ❤❤❤ https://tinourl.com/2uL2Pm
Adobe Illustrator CS6 V16.0.0 682 Portablel is not an official Adobe product but a hacked version that can be run from a USB flash drive or any other portable device. It sounds convenient, but it also comes with many risks and disadvantages that you should be aware of before downloading it.
-
-The Risks of Using Adobe Illustrator CS6 V16.0.0 682 Portablel
-
-Here are some of the main reasons why you should avoid using Adobe Illustrator CS6 V16.0.0 682 Portablel:
-
-
-High risk of virus infection. Since this version is not authorized by Adobe, you cannot be sure that it has not been modified or infected with malware that can harm your computer or steal your personal information[^1^].Lack of updates and developer support. When you use Adobe Illustrator CS6 V16.0.0 682 Portablel, you will not receive any updates that fix bugs, improve performance, or add new features[^2^]. You will also not have access to Adobe's customer service or technical support in case you encounter any problems.Unstable and slow operation. Adobe Illustrator CS6 V16.0.0 682 Portablel is compressed and stripped of some functions to reduce its size and make it portable[^2^]. This means that it will run slower and crash more often than the original version.Violation of the law. Using Adobe Illustrator CS6 V16.0.0 682 Portablel is illegal and violates Adobe's intellectual property rights[^2^]. You could face fines or even jail time if you are caught using or distributing this software.
-
-The Benefits of Using Adobe Illustrator CS6 License
-
-If you want to enjoy the full potential of Adobe Illustrator CS6 without risking your security, performance, or legal status, you should buy a license from Adobe's official website. Here are some of the benefits of using a licensed version of Adobe Illustrator CS6:
-
-
-
-Flexible work with scale. You can save your AI files in any resolution you need without losing quality or detail[^2^]. You can also print your projects without any pixelation or distortion.Creative tools and features. You can access all the tools and features that Adobe Illustrator CS6 has to offer, such as gradients, patterns, brushes, symbols, effects, and more[^3^]. You can also use plugins and extensions to enhance your workflow and creativity.Integration with other Adobe products. You can easily import and export your files between Adobe Illustrator CS6 and other Adobe products, such as Photoshop, InDesign, After Effects, and more[^3^]. You can also use Adobe Creative Cloud to sync your files and settings across multiple devices.Security and reliability. You can be sure that your software is safe and free from viruses or malware[^1^]. You can also update your software regularly to get the latest improvements and fixes[^2^]. And if you ever need help, you can contact Adobe's customer service or technical support anytime[^2^].
-
-Conclusion
-
-Adobe Illustrator CS6 V16.0.0 682 Portablel may seem like a convenient way to use Adobe Illustrator CS6 on different devices without installing it, but it is actually a risky and illegal option that can compromise your security, performance, and legal status. If you want to use Adobe Illustrator CS6 safely and legally, you should buy a license from Adobe's official website and enjoy all the benefits of using a licensed version of this amazing software.
7b8c122e870.3 mega pixel fixed web camera drivers Download Zip >>>>> https://urlgoal.com/2uCLH8
diff --git a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Bazaraajarvisprogramacionlinealflujoredes.md b/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Bazaraajarvisprogramacionlinealflujoredes.md
deleted file mode 100644
index 585500c2f97d756ad854624a22e20cbd21b8dde9..0000000000000000000000000000000000000000
--- a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Bazaraajarvisprogramacionlinealflujoredes.md
+++ /dev/null
@@ -1,6 +0,0 @@
-bazaraajarvisprogramacionlinealflujoredes Download File >>>>> https://urlgoal.com/2uCJDc
diff --git a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Creative Es1373 Sound Card Driver Free Download For Windows 7 Free.md b/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Creative Es1373 Sound Card Driver Free Download For Windows 7 Free.md
deleted file mode 100644
index 6f993f9f42fa21de60f107186e67bdce0e7376d4..0000000000000000000000000000000000000000
--- a/spaces/recenWmenso/ChatGPT-with-Voice-Cloning-for-All/datasets/Creative Es1373 Sound Card Driver Free Download For Windows 7 Free.md
+++ /dev/null
@@ -1,50 +0,0 @@
-Creative Es1373 Sound Card Driver Free Download For Windows 7
-If you are looking for a high-quality sound card driver for your Windows 7 computer, you might want to consider the Creative Es1373 Sound Card Driver. This driver is compatible with the Ensoniq/Creative AudioPCI ES1373 sound card, which is a versatile and powerful device that can enhance your audio experience.
-The Creative Es1373 Sound Card Driver offers many features and benefits, such as:
-Creative Es1373 Sound Card Driver Free Download For Windows 7 Download Zip ○○○ https://urlgoal.com/2uCK4c
-Wavetable sound sets: You can choose from 2, 4, or 8 MB sets of 128 General MIDI wavetable instruments, 61 drum programs, 128 MT-32 instruments, and Roland GS Sound set in 4 & 8 MB sets.
-Synthesizer: You can enjoy up to 32 simultaneous voice polyphony and 16 MIDI channels with this driver.
-Digital effects: You can add reverb, chorus, and spatial enhancement to your sound with this driver.
-Digital audio: You can record and playback 16-bit audio at up to 48 kHz (mono/stereo) with this driver.
-A/D D/A codec: You can get the lowest noise possible with this driver, which has a signal-to-noise ratio of 90 dbr typical.
-Frequency response: You can hear every detail of your sound with this driver, which has a frequency response of 20Hz - 22kHz.
-Full duplex operation: You can record and playback sound simultaneously with this driver.
-S/PDIF and I²S output: You can connect your sound card to external devices with these outputs, which are available only for the ES1373 model.
-Supported standards: You can play various games and applications with this driver, which supports ENSONIQ Soundscape, Microsoft Direct Audio (DirectX), AdLib, OpenAL, Sound Blaster Pro (2.0), General MIDI, MT-32, FM (software emulation), MPC 1,2,3 standards.
-Drivers: You can install this driver on various operating systems, such as DOS, Windows (3.1, 9x, NT 4.x, 2000, XP), and FreeBSD.
-
-The Creative Es1373 Sound Card Driver is easy to download and install. You just need to follow these steps:
-
-Go to the official website of Creative and select your country/region.
-Click on the Support tab and then on Downloads.
-Type in Creative Es1373 Sound Card Driver in the search box and hit Enter.
-Select the appropriate driver for your operating system and click on Download.
-Save the file to your computer and run it as an administrator.
-Follow the instructions on the screen to complete the installation process.
-Restart your computer and enjoy your improved sound quality.
-
-The Creative Es1373 Sound Card Driver is a reliable and efficient driver that can make your sound card work better. It is free to download and use, and it can improve your audio performance and compatibility. If you have a Creative Es1373 Sound Card or a similar device, you should definitely try this driver today.
-Creative Es1373 Sound Card Driver Reviews
-Many users have tried the Creative Es1373 Sound Card Driver and have shared their opinions and experiences online. Here are some of the reviews that we have found:
-
-"I have been using this driver for a long time and I am very satisfied with it. It works perfectly with my Windows 7 system and my Creative ES1373 sound card. The sound quality is amazing and I can play all kinds of games and applications without any problems. I highly recommend this driver to anyone who has a Creative ES1373 sound card or a similar device."
-- John, from Treexy.com
-
-
-"This driver is very easy to download and install. It only took me a few minutes to get it up and running. It improved my sound performance and compatibility a lot. I can now enjoy my music and movies with better sound effects and clarity. This driver is a must-have for anyone who wants to upgrade their sound system."
-- Lisa, from Downloadsource.net
-
-
-"This driver is a lifesaver for me. I have an old computer with a Creative ES1373 sound card and I was having trouble finding a driver that works with Windows 7. I tried many other drivers but none of them worked. Then I found this driver and it solved all my problems. It supports all the features and standards that I need and it makes my sound card work like new."
-- Mike, from Oemdrivers.com
-
-
-"This driver is awesome. It has everything that I want from a sound card driver. It has wavetable sound sets, synthesizer, digital effects, digital audio, A/D D/A codec, frequency response, full duplex operation, S/PDIF and I²S output, supported standards, and drivers for various operating systems. It is very versatile and powerful. It is the best driver for my Creative ES1373 sound card."
-- Anna, from Cnet.com
-
-As you can see, most users are very happy with the Creative Es1373 Sound Card Driver and have given it positive feedback and ratings. They have praised its features, benefits, quality, performance, compatibility, ease of use, and reliability. They have also reported that it works well with Windows 7 and other operating systems.
-
3cee63e6c2{i.delete(s),i.size===0&&(o(),o=null)}}return{set:r,update:a,subscribe:l}}let u="",d="";function g(t){u=t.base,d=t.assets||u}export{d as a,u as b,g as s,_ as w};
diff --git a/spaces/rishikesh/365DataScience/app.py b/spaces/rishikesh/365DataScience/app.py
deleted file mode 100644
index c26fb29fc09d8c2a5a88bb4a1a674229f46d149b..0000000000000000000000000000000000000000
--- a/spaces/rishikesh/365DataScience/app.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import streamlit as st
-import pickle
-import numpy as np
-
-# Stores loaded model in cache so that we don't need to reload model repeatedly for each input
-@st.cache(allow_output_mutation=True)
-def load_model():
- model = pickle.load(open('random_forest_model.sav', 'rb'))
- country_dict = pickle.load(open('country_dict.pickle', 'rb'))
- scaler = pickle.load(open('standardScaler.pickle', 'rb'))
- return model, scaler, country_dict
-
-def featurize(time, country, scaler, country_dict):
- arr = np.array([country_dict[country], time]).reshape(1,-1)
- vector = scaler.transform(arr)
- return vector
-
-def main():
- model, scaler, country_dict = load_model()
- st.title("\'365 data science\' : free-to-paid user conversion predictor")
- list_of_countries = list(country_dict.keys())
- st.write("\'365 data science\' is a ed-tech company that creates data science courses comprising of video lectures and \
- exercises in the form of quizzes and exams. Some of the courses offered are free and majority of the other courses \
- need the user to buy paid subscription. Students mostly register on this platform as 'free-tier user' as the registration is free of cost. \
- They enroll for free courses and then if they like the content of the platform, they proceed to buy paid-subscription \
- which offers lot of perks as compared to free tier. Paid student get access to large library of courses along with certificates, \
- quizzes and exams.")
- st.write("This application predicts how likely the student is to buy the paid subscription based on the number of minutes \
- he spent engaging with the free course content and the country he comes from. In the exploratory data analysis done, it was found that \
- total time spent by user and nationality of user are two major and most significant factor for determining how likely the user is \
- to buy the course. Typical range for total time watched for students is mostly 0.1 to 100 minutes")
-
- with st.form("my_form"):
- total_time = st.number_input('Time spent on platform watching tutorials')
- student_country = st.selectbox('country', list_of_countries)
- st.write('Total time spent : ', total_time)
- st.write('Student country :', student_country)
-
- # Every form must have a submit button.
- submitted = st.form_submit_button("Submit")
-
- if submitted:
- vector = featurize(total_time, student_country, scaler, country_dict)
- prediction = model.predict(vector)[0]
- predicted_proba = model.predict_proba(vector)
- if prediction == 0 :
- st.write('Student is ', str(round(predicted_proba[0][0]*100)), '% likely to NOT buy the paid subscription')
- else :
- st.write('Student is ', str(round(predicted_proba[0][1]*100)), '% likely to buy the paid subscription')
-
-if __name__ == '__main__' :
- main()
\ No newline at end of file
diff --git a/spaces/riyueyiming/gpt/modules/pdf_func.py b/spaces/riyueyiming/gpt/modules/pdf_func.py
deleted file mode 100644
index 0aba6b7b891fc527c79b887256b0cbaa81ae5b3d..0000000000000000000000000000000000000000
--- a/spaces/riyueyiming/gpt/modules/pdf_func.py
+++ /dev/null
@@ -1,180 +0,0 @@
-from types import SimpleNamespace
-import pdfplumber
-import logging
-from llama_index import Document
-
-def prepare_table_config(crop_page):
- """Prepare table查找边界, 要求page为原始page
-
- From https://github.com/jsvine/pdfplumber/issues/242
- """
- page = crop_page.root_page # root/parent
- cs = page.curves + page.edges
- def curves_to_edges():
- """See https://github.com/jsvine/pdfplumber/issues/127"""
- edges = []
- for c in cs:
- edges += pdfplumber.utils.rect_to_edges(c)
- return edges
- edges = curves_to_edges()
- return {
- "vertical_strategy": "explicit",
- "horizontal_strategy": "explicit",
- "explicit_vertical_lines": edges,
- "explicit_horizontal_lines": edges,
- "intersection_y_tolerance": 10,
- }
-
-def get_text_outside_table(crop_page):
- ts = prepare_table_config(crop_page)
- if len(ts["explicit_vertical_lines"]) == 0 or len(ts["explicit_horizontal_lines"]) == 0:
- return crop_page
-
- ### Get the bounding boxes of the tables on the page.
- bboxes = [table.bbox for table in crop_page.root_page.find_tables(table_settings=ts)]
- def not_within_bboxes(obj):
- """Check if the object is in any of the table's bbox."""
- def obj_in_bbox(_bbox):
- """See https://github.com/jsvine/pdfplumber/blob/stable/pdfplumber/table.py#L404"""
- v_mid = (obj["top"] + obj["bottom"]) / 2
- h_mid = (obj["x0"] + obj["x1"]) / 2
- x0, top, x1, bottom = _bbox
- return (h_mid >= x0) and (h_mid < x1) and (v_mid >= top) and (v_mid < bottom)
- return not any(obj_in_bbox(__bbox) for __bbox in bboxes)
-
- return crop_page.filter(not_within_bboxes)
-# 请使用 LaTeX 表达公式，行内公式以 $ 包裹，行间公式以 $$ 包裹
-
-extract_words = lambda page: page.extract_words(keep_blank_chars=True, y_tolerance=0, x_tolerance=1, extra_attrs=["fontname", "size", "object_type"])
-# dict_keys(['text', 'x0', 'x1', 'top', 'doctop', 'bottom', 'upright', 'direction', 'fontname', 'size'])
-
-def get_title_with_cropped_page(first_page):
- title = [] # 处理标题
- x0,top,x1,bottom = first_page.bbox # 获取页面边框
-
- for word in extract_words(first_page):
- word = SimpleNamespace(**word)
-
- if word.size >= 14:
- title.append(word.text)
- title_bottom = word.bottom
- elif word.text == "Abstract": # 获取页面abstract
- top = word.top
-
- user_info = [i["text"] for i in extract_words(first_page.within_bbox((x0,title_bottom,x1,top)))]
- # 裁剪掉上半部分, within_bbox: full_included; crop: partial_included
- return title, user_info, first_page.within_bbox((x0,top,x1,bottom))
-
-def get_column_cropped_pages(pages, two_column=True):
- new_pages = []
- for page in pages:
- if two_column:
- left = page.within_bbox((0, 0, page.width/2, page.height),relative=True)
- right = page.within_bbox((page.width/2, 0, page.width, page.height), relative=True)
- new_pages.append(left)
- new_pages.append(right)
- else:
- new_pages.append(page)
-
- return new_pages
-
-def parse_pdf(filename, two_column = True):
- level = logging.getLogger().level
- if level == logging.getLevelName("DEBUG"):
- logging.getLogger().setLevel("INFO")
-
- with pdfplumber.open(filename) as pdf:
- title, user_info, first_page = get_title_with_cropped_page(pdf.pages[0])
- new_pages = get_column_cropped_pages([first_page] + pdf.pages[1:], two_column)
-
- chapters = []
- # tuple (chapter_name, [pageid] (start,stop), chapter_text)
- create_chapter = lambda page_start,name_top,name_bottom: SimpleNamespace(
- name=[],
- name_top=name_top,
- name_bottom=name_bottom,
- record_chapter_name = True,
-
- page_start=page_start,
- page_stop=None,
-
- text=[],
- )
- cur_chapter = None
-
- # 按页遍历PDF文档
- for idx, page in enumerate(new_pages):
- page = get_text_outside_table(page)
-
- # 按行遍历页面文本
- for word in extract_words(page):
- word = SimpleNamespace(**word)
-
- # 检查行文本是否以12号字体打印，如果是，则将其作为新章节开始
- if word.size >= 11: # 出现chapter name
- if cur_chapter is None:
- cur_chapter = create_chapter(page.page_number, word.top, word.bottom)
- elif not cur_chapter.record_chapter_name or (cur_chapter.name_bottom != cur_chapter.name_bottom and cur_chapter.name_top != cur_chapter.name_top):
- # 不再继续写chapter name
- cur_chapter.page_stop = page.page_number # stop id
- chapters.append(cur_chapter)
- # 重置当前chapter信息
- cur_chapter = create_chapter(page.page_number, word.top, word.bottom)
-
- # print(word.size, word.top, word.bottom, word.text)
- cur_chapter.name.append(word.text)
- else:
- cur_chapter.record_chapter_name = False # chapter name 结束
- cur_chapter.text.append(word.text)
- else:
- # 处理最后一个章节
- cur_chapter.page_stop = page.page_number # stop id
- chapters.append(cur_chapter)
-
- for i in chapters:
- logging.info(f"section: {i.name} pages:{i.page_start, i.page_stop} word-count:{len(i.text)}")
- logging.debug(" ".join(i.text))
-
- title = " ".join(title)
- user_info = " ".join(user_info)
- text = f"Article Title: {title}, Information:{user_info}\n"
- for idx, chapter in enumerate(chapters):
- chapter.name = " ".join(chapter.name)
- text += f"The {idx}th Chapter {chapter.name}: " + " ".join(chapter.text) + "\n"
-
- logging.getLogger().setLevel(level)
- return Document(text=text, extra_info={"title": title})
-
-BASE_POINTS = """
-1. Who are the authors?
-2. What is the process of the proposed method?
-3. What is the performance of the proposed method? Please note down its performance metrics.
-4. What are the baseline models and their performances? Please note down these baseline methods.
-5. What dataset did this paper use?
-"""
-
-READING_PROMPT = """
-You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
-Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
-When you are reading, You need to focus on these key points:{}
-"""
-
-READING_PROMT_V2 = """
-You are a researcher helper bot. You can help the user with research paper reading and summarizing. \n
-Now I am going to send you a paper. You need to read it and summarize it for me part by part. \n
-When you are reading, You need to focus on these key points:{},
-
-And You need to generate a brief but informative title for this part.
-Your return format:
-- title: '...'
-- summary: '...'
-"""
-
-SUMMARY_PROMPT = "You are a researcher helper bot. Now you need to read the summaries of a research paper."
-
-
-if __name__ == '__main__':
- # Test code
- z = parse_pdf("./build/test.pdf")
- print(z["user_info"])
- print(z["title"])
\ No newline at end of file
diff --git a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/datasets/samplers/distributed_sampler.py b/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/datasets/samplers/distributed_sampler.py
deleted file mode 100644
index 1bc8b7c3602cee288e4ab8d661819c0a2490d4ee..0000000000000000000000000000000000000000
--- a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/datasets/samplers/distributed_sampler.py
+++ /dev/null
@@ -1,54 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import math
-
-import torch
-from torch.utils.data import DistributedSampler as _DistributedSampler
-
-from mmdet.core.utils import sync_random_seed
-from mmdet.utils import get_device
-
-
-class DistributedSampler(_DistributedSampler):
-
- def __init__(self,
- dataset,
- num_replicas=None,
- rank=None,
- shuffle=True,
- seed=0):
- super().__init__(
- dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
-
- # In distributed sampling, different ranks should sample
- # non-overlapped data in the dataset. Therefore, this function
- # is used to make sure that each rank shuffles the data indices
- # in the same order based on the same seed. Then different ranks
- # could use different indices to select non-overlapped data from the
- # same data list.
- device = get_device()
- self.seed = sync_random_seed(seed, device)
-
- def __iter__(self):
- # deterministically shuffle based on epoch
- if self.shuffle:
- g = torch.Generator()
- # When :attr:`shuffle=True`, this ensures all replicas
- # use a different random ordering for each epoch.
- # Otherwise, the next iteration of this sampler will
- # yield the same ordering.
- g.manual_seed(self.epoch + self.seed)
- indices = torch.randperm(len(self.dataset), generator=g).tolist()
- else:
- indices = torch.arange(len(self.dataset)).tolist()
-
- # add extra samples to make it evenly divisible
- # in case that indices is shorter than half of total_size
- indices = (indices *
- math.ceil(self.total_size / len(indices)))[:self.total_size]
- assert len(indices) == self.total_size
-
- # subsample
- indices = indices[self.rank:self.total_size:self.num_replicas]
- assert len(indices) == self.num_samples
-
- return iter(indices)
diff --git a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/models/necks/yolo_neck.py b/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/models/necks/yolo_neck.py
deleted file mode 100644
index c8eeb5737cdf871fa415c1a207956ea7753c304e..0000000000000000000000000000000000000000
--- a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/mmdet/models/necks/yolo_neck.py
+++ /dev/null
@@ -1,140 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-# Copyright (c) 2019 Western Digital Corporation or its affiliates.
-
-import torch
-import torch.nn.functional as F
-from mmcv.cnn import ConvModule
-from mmcv.runner import BaseModule
-
-from ..builder import NECKS
-
-
-class DetectionBlock(BaseModule):
- """Detection block in YOLO neck.
-
- Let out_channels = n, the DetectionBlock contains:
- Six ConvLayers, 1 Conv2D Layer and 1 YoloLayer.
- The first 6 ConvLayers are formed the following way:
- 1x1xn, 3x3x2n, 1x1xn, 3x3x2n, 1x1xn, 3x3x2n.
- The Conv2D layer is 1x1x255.
- Some block will have branch after the fifth ConvLayer.
- The input channel is arbitrary (in_channels)
-
- Args:
- in_channels (int): The number of input channels.
- out_channels (int): The number of output channels.
- conv_cfg (dict): Config dict for convolution layer. Default: None.
- norm_cfg (dict): Dictionary to construct and config norm layer.
- Default: dict(type='BN', requires_grad=True)
- act_cfg (dict): Config dict for activation layer.
- Default: dict(type='LeakyReLU', negative_slope=0.1).
- init_cfg (dict or list[dict], optional): Initialization config dict.
- Default: None
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- conv_cfg=None,
- norm_cfg=dict(type='BN', requires_grad=True),
- act_cfg=dict(type='LeakyReLU', negative_slope=0.1),
- init_cfg=None):
- super(DetectionBlock, self).__init__(init_cfg)
- double_out_channels = out_channels * 2
-
- # shortcut
- cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
- self.conv1 = ConvModule(in_channels, out_channels, 1, **cfg)
- self.conv2 = ConvModule(
- out_channels, double_out_channels, 3, padding=1, **cfg)
- self.conv3 = ConvModule(double_out_channels, out_channels, 1, **cfg)
- self.conv4 = ConvModule(
- out_channels, double_out_channels, 3, padding=1, **cfg)
- self.conv5 = ConvModule(double_out_channels, out_channels, 1, **cfg)
-
- def forward(self, x):
- tmp = self.conv1(x)
- tmp = self.conv2(tmp)
- tmp = self.conv3(tmp)
- tmp = self.conv4(tmp)
- out = self.conv5(tmp)
- return out
-
-
-@NECKS.register_module()
-class YOLOV3Neck(BaseModule):
- """The neck of YOLOV3.
-
- It can be treated as a simplified version of FPN. It
- will take the result from Darknet backbone and do some upsampling and
- concatenation. It will finally output the detection result.
-
- Note:
- The input feats should be from top to bottom.
- i.e., from high-lvl to low-lvl
- But YOLOV3Neck will process them in reversed order.
- i.e., from bottom (high-lvl) to top (low-lvl)
-
- Args:
- num_scales (int): The number of scales / stages.
- in_channels (List[int]): The number of input channels per scale.
- out_channels (List[int]): The number of output channels per scale.
- conv_cfg (dict, optional): Config dict for convolution layer.
- Default: None.
- norm_cfg (dict, optional): Dictionary to construct and config norm
- layer. Default: dict(type='BN', requires_grad=True)
- act_cfg (dict, optional): Config dict for activation layer.
- Default: dict(type='LeakyReLU', negative_slope=0.1).
- init_cfg (dict or list[dict], optional): Initialization config dict.
- Default: None
- """
-
- def __init__(self,
- num_scales,
- in_channels,
- out_channels,
- conv_cfg=None,
- norm_cfg=dict(type='BN', requires_grad=True),
- act_cfg=dict(type='LeakyReLU', negative_slope=0.1),
- init_cfg=None):
- super(YOLOV3Neck, self).__init__(init_cfg)
- assert (num_scales == len(in_channels) == len(out_channels))
- self.num_scales = num_scales
- self.in_channels = in_channels
- self.out_channels = out_channels
-
- # shortcut
- cfg = dict(conv_cfg=conv_cfg, norm_cfg=norm_cfg, act_cfg=act_cfg)
-
- # To support arbitrary scales, the code looks awful, but it works.
- # Better solution is welcomed.
- self.detect1 = DetectionBlock(in_channels[0], out_channels[0], **cfg)
- for i in range(1, self.num_scales):
- in_c, out_c = self.in_channels[i], self.out_channels[i]
- inter_c = out_channels[i - 1]
- self.add_module(f'conv{i}', ConvModule(inter_c, out_c, 1, **cfg))
- # in_c + out_c : High-lvl feats will be cat with low-lvl feats
- self.add_module(f'detect{i+1}',
- DetectionBlock(in_c + out_c, out_c, **cfg))
-
- def forward(self, feats):
- assert len(feats) == self.num_scales
-
- # processed from bottom (high-lvl) to top (low-lvl)
- outs = []
- out = self.detect1(feats[-1])
- outs.append(out)
-
- for i, x in enumerate(reversed(feats[:-1])):
- conv = getattr(self, f'conv{i+1}')
- tmp = conv(out)
-
- # Cat with low-lvl feats
- tmp = F.interpolate(tmp, scale_factor=2)
- tmp = torch.cat((tmp, x), 1)
-
- detect = getattr(self, f'detect{i+2}')
- out = detect(tmp)
- outs.append(out)
-
- return tuple(outs)
diff --git a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/setup.py b/spaces/rockeycoss/Prompt-Segment-Anything-Demo/setup.py
deleted file mode 100644
index 535d90eff44ba6f68a8388e08dea8cb6487650ed..0000000000000000000000000000000000000000
--- a/spaces/rockeycoss/Prompt-Segment-Anything-Demo/setup.py
+++ /dev/null
@@ -1,220 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) OpenMMLab. All rights reserved.
-import os
-import os.path as osp
-import platform
-import shutil
-import sys
-import warnings
-from setuptools import find_packages, setup
-
-import torch
-from torch.utils.cpp_extension import (BuildExtension, CppExtension,
- CUDAExtension)
-
-
-def readme():
- with open('README.md', encoding='utf-8') as f:
- content = f.read()
- return content
-
-
-version_file = 'mmdet/version.py'
-
-
-def get_version():
- with open(version_file, 'r') as f:
- exec(compile(f.read(), version_file, 'exec'))
- return locals()['__version__']
-
-
-def make_cuda_ext(name, module, sources, sources_cuda=[]):
-
- define_macros = []
- extra_compile_args = {'cxx': []}
-
- if torch.cuda.is_available() or os.getenv('FORCE_CUDA', '0') == '1':
- define_macros += [('WITH_CUDA', None)]
- extension = CUDAExtension
- extra_compile_args['nvcc'] = [
- '-D__CUDA_NO_HALF_OPERATORS__',
- '-D__CUDA_NO_HALF_CONVERSIONS__',
- '-D__CUDA_NO_HALF2_OPERATORS__',
- ]
- sources += sources_cuda
- else:
- print(f'Compiling {name} without CUDA')
- extension = CppExtension
-
- return extension(
- name=f'{module}.{name}',
- sources=[os.path.join(*module.split('.'), p) for p in sources],
- define_macros=define_macros,
- extra_compile_args=extra_compile_args)
-
-
-def parse_requirements(fname='requirements.txt', with_version=True):
- """Parse the package dependencies listed in a requirements file but strips
- specific versioning information.
-
- Args:
- fname (str): path to requirements file
- with_version (bool, default=False): if True include version specs
-
- Returns:
- List[str]: list of requirements items
-
- CommandLine:
- python -c "import setup; print(setup.parse_requirements())"
- """
- import re
- import sys
- from os.path import exists
- require_fpath = fname
-
- def parse_line(line):
- """Parse information from a line in a requirements text file."""
- if line.startswith('-r '):
- # Allow specifying requirements in other files
- target = line.split(' ')[1]
- for info in parse_require_file(target):
- yield info
- else:
- info = {'line': line}
- if line.startswith('-e '):
- info['package'] = line.split('#egg=')[1]
- elif '@git+' in line:
- info['package'] = line
- else:
- # Remove versioning from the package
- pat = '(' + '|'.join(['>=', '==', '>']) + ')'
- parts = re.split(pat, line, maxsplit=1)
- parts = [p.strip() for p in parts]
-
- info['package'] = parts[0]
- if len(parts) > 1:
- op, rest = parts[1:]
- if ';' in rest:
- # Handle platform specific dependencies
- # http://setuptools.readthedocs.io/en/latest/setuptools.html#declaring-platform-specific-dependencies
- version, platform_deps = map(str.strip,
- rest.split(';'))
- info['platform_deps'] = platform_deps
- else:
- version = rest # NOQA
- info['version'] = (op, version)
- yield info
-
- def parse_require_file(fpath):
- with open(fpath, 'r') as f:
- for line in f.readlines():
- line = line.strip()
- if line and not line.startswith('#'):
- for info in parse_line(line):
- yield info
-
- def gen_packages_items():
- if exists(require_fpath):
- for info in parse_require_file(require_fpath):
- parts = [info['package']]
- if with_version and 'version' in info:
- parts.extend(info['version'])
- if not sys.version.startswith('3.4'):
- # apparently package_deps are broken in 3.4
- platform_deps = info.get('platform_deps')
- if platform_deps is not None:
- parts.append(';' + platform_deps)
- item = ''.join(parts)
- yield item
-
- packages = list(gen_packages_items())
- return packages
-
-
-def add_mim_extension():
- """Add extra files that are required to support MIM into the package.
-
- These files will be added by creating a symlink to the originals if the
- package is installed in `editable` mode (e.g. pip install -e .), or by
- copying from the originals otherwise.
- """
-
- # parse installment mode
- if 'develop' in sys.argv:
- # installed by `pip install -e .`
- if platform.system() == 'Windows':
- # set `copy` mode here since symlink fails on Windows.
- mode = 'copy'
- else:
- mode = 'symlink'
- elif 'sdist' in sys.argv or 'bdist_wheel' in sys.argv:
- # installed by `pip install .`
- # or create source distribution by `python setup.py sdist`
- mode = 'copy'
- else:
- return
-
- filenames = ['tools', 'configs', 'demo', 'model-index.yml']
- repo_path = osp.dirname(__file__)
- mim_path = osp.join(repo_path, 'mmdet', '.mim')
- os.makedirs(mim_path, exist_ok=True)
-
- for filename in filenames:
- if osp.exists(filename):
- src_path = osp.join(repo_path, filename)
- tar_path = osp.join(mim_path, filename)
-
- if osp.isfile(tar_path) or osp.islink(tar_path):
- os.remove(tar_path)
- elif osp.isdir(tar_path):
- shutil.rmtree(tar_path)
-
- if mode == 'symlink':
- src_relpath = osp.relpath(src_path, osp.dirname(tar_path))
- os.symlink(src_relpath, tar_path)
- elif mode == 'copy':
- if osp.isfile(src_path):
- shutil.copyfile(src_path, tar_path)
- elif osp.isdir(src_path):
- shutil.copytree(src_path, tar_path)
- else:
- warnings.warn(f'Cannot copy file {src_path}.')
- else:
- raise ValueError(f'Invalid mode {mode}')
-
-
-if __name__ == '__main__':
- add_mim_extension()
- setup(
- name='mmdet',
- version=get_version(),
- description='OpenMMLab Detection Toolbox and Benchmark',
- long_description=readme(),
- long_description_content_type='text/markdown',
- author='MMDetection Contributors',
- author_email='openmmlab@gmail.com',
- keywords='computer vision, object detection',
- url='https://github.com/open-mmlab/mmdetection',
- packages=find_packages(exclude=('configs', 'tools', 'demo')),
- include_package_data=True,
- classifiers=[
- 'Development Status :: 5 - Production/Stable',
- 'License :: OSI Approved :: Apache Software License',
- 'Operating System :: OS Independent',
- 'Programming Language :: Python :: 3',
- 'Programming Language :: Python :: 3.7',
- 'Programming Language :: Python :: 3.8',
- 'Programming Language :: Python :: 3.9',
- ],
- license='Apache License 2.0',
- install_requires=parse_requirements('requirements/runtime.txt'),
- extras_require={
- 'all': parse_requirements('requirements.txt'),
- 'tests': parse_requirements('requirements/tests.txt'),
- 'build': parse_requirements('requirements/build.txt'),
- 'optional': parse_requirements('requirements/optional.txt'),
- 'mim': parse_requirements('requirements/mminstall.txt'),
- },
- ext_modules=[],
- cmdclass={'build_ext': BuildExtension},
- zip_safe=False)
diff --git a/spaces/rorallitri/biomedical-language-models/logs/Angels Sing Christmas In Ireland Rar ((TOP)).md b/spaces/rorallitri/biomedical-language-models/logs/Angels Sing Christmas In Ireland Rar ((TOP)).md
deleted file mode 100644
index a3f85c092fd4598f13fb46831cadcd20e1cc342c..0000000000000000000000000000000000000000
--- a/spaces/rorallitri/biomedical-language-models/logs/Angels Sing Christmas In Ireland Rar ((TOP)).md
+++ /dev/null
@@ -1,109 +0,0 @@
-
-Angels Sing Christmas in Ireland: A Review of Libera's Holiday Album
-
-If you are looking for a unique and beautiful way to celebrate the festive season, you might want to check out Angels Sing Christmas in Ireland , a stunning album by Libera, the world-renowned boys choir from London.
-
-Libera is known for their angelic voices and ethereal sound, blending classical and contemporary music with a touch of mystery. They have performed all over the world, from the Vatican to the White House, and have collaborated with artists such as Enya, Brian Wilson, and Elton John.
-angels sing christmas in ireland rar Download Zip ✏ ✏ ✏ https://tinurll.com/2uzm7i
In 2013, they recorded their first Christmas album in the historic St Patrick's Cathedral in Armagh, Ireland. The album features 15 tracks of traditional and modern carols, sung in English, Latin, and Irish Gaelic. Some of the highlights include:
-
-
-Joy to the World : A joyful and upbeat rendition of the classic hymn, with a Celtic twist.God Rest You Merry Gentlemen : A haunting and harmonious version of the old English carol, with a solo by Daniel Fontannaz.The Wexford Carol : A beautiful and ancient Irish lullaby, sung by Isaac London.In Dulci Jubilo : A lively and festive medley of two medieval songs, one in Latin and one in German.Angels We Have Heard On High : A soaring and majestic arrangement of the French carol, with a solo by Cassius O'Connell-White.Sanctus : A sublime and serene piece composed by Libera's musical director Robert Prizeman, based on the Latin Mass.Danny Boy : A moving and emotional interpretation of the Irish folk song, sung by Tom Cully.Carol of the Bells : A thrilling and dynamic adaptation of the Ukrainian carol, with a solo by Alex Gula.O Holy Night : A powerful and passionate performance of the French song, sung by Joshua Madine.Still, Still, Still : A gentle and soothing lullaby from Austria, sung by Benedict Philipp.Gaudete : A cheerful and catchy song from the 16th century, sung in Latin.Away in a Manger : A simple and sweet rendition of the popular carol, sung by Ralph Skan.Have Yourself a Merry Little Christmas : A warm and cozy version of the American song, sung by Ciaran Bradbury-Hickey.Silent Night : A tender and touching finale of the most famous Christmas song, sung in English and Irish Gaelic.What Child Is This : A bonus track available only on the DVD version of the album, sung by Kavana Crossley.
-
-The album also comes with a DVD that features behind-the-scenes footage of the recording process, interviews with the choir members and staff, and a documentary about Libera's visit to Ireland. You can watch a preview of the DVD here:
-
-VIDEO
-
-If you want to download Angels Sing Christmas in Ireland by Libera (RAR file), you can do so from this link:
-
-https://bitbucket.org/psrsoft/tempo2/issues/259/angels-sing-christmas-in-ireland-rar
-
-Alternatively, you can stream or purchase the album from LINE MUSIC here:
-
-https://music.line.me/webapp/album/mb00000000000f5611
-
-Angels Sing Christmas in Ireland is a wonderful gift for yourself or your loved ones this holiday season. It will fill your home with joy and peace, and transport you to a magical place where angels sing.
-Angels Sing Christmas in Ireland: A Collection of NFTs
-
-If you are a fan of Libera and their album Angels Sing Christmas in Ireland , you might be interested in owning a piece of their history as a non-fungible token (NFT). NFTs are digital assets that represent unique and scarce items, such as art, music, or collectibles. They are stored on a blockchain, which ensures their authenticity and ownership.
-
-
-On OpenSea, the largest marketplace for NFTs, you can find a collection of Angels Sing Christmas in Ireland NFTs that feature images and audio clips from the album. You can bid on them using cryptocurrency, such as Ethereum or Dai. Some of the NFTs available include:
-
-
-Joy to the World : A festive image of Libera singing in front of a Christmas tree, with a 30-second audio clip of the song.God Rest You Merry Gentlemen : A mysterious image of Libera wearing cloaks and holding candles, with a 30-second audio clip of the song.The Wexford Carol : A beautiful image of Libera standing in front of a stained glass window, with a 30-second audio clip of the song.In Dulci Jubilo : A lively image of Libera playing instruments and dancing, with a 30-second audio clip of the song.Angels We Have Heard On High : A majestic image of Libera surrounded by angels, with a 30-second audio clip of the song.
-
-You can view and purchase the Angels Sing Christmas in Ireland NFTs from this link:
-
-https://opensea.io/collection/angels-sing-christmas-in-ireland-rar
-
-Angels Sing Christmas in Ireland: A Tribute to The Waterboys
-
-Another reason why Angels Sing Christmas in Ireland is a special album is that it pays tribute to one of Libera's musical influences: The Waterboys. The Waterboys are a British band founded in 1986 and currently one of the most popular bands in the UK. They are known for their eclectic and adventurous style, mixing rock, folk, Celtic, gospel, and soul music.
-
-Libera has expressed their admiration for The Waterboys on several occasions, and even performed with them at a concert in London in 2010. On their album Angels Sing Christmas in Ireland , Libera covers two songs by The Waterboys: Danny Boy and The Whole of the Moon . Both songs are sung with passion and grace by Libera, showing their respect and appreciation for The Waterboys.
-
-You can watch Libera's performance of The Whole of the Moon with The Waterboys here:
-
-VIDEO
-Angels Sing Christmas in Ireland: A Behind-the-Scenes Look
-
-If you are curious about how Libera made their album Angels Sing Christmas in Ireland , you might want to watch their DVD that comes with the album. The DVD features a behind-the-scenes look at the recording process, as well as interviews with the choir members and staff. You can see how Libera prepared for their trip to Ireland, how they rehearsed and recorded in the historic St Patrick's Cathedral in Armagh, and how they enjoyed their time in the Emerald Isle.
-
-The DVD also includes a documentary about Libera's visit to Ireland, where they explored the culture and history of the country. You can see them visiting places such as Belfast, Dublin, Newgrange, Giant's Causeway, and Glendalough. You can also see them meeting and interacting with local people, such as schoolchildren, musicians, and clergy. You can witness their curiosity and enthusiasm, as well as their respect and gratitude.
-
-The DVD gives you a glimpse into the lives and personalities of Libera's members, who are not only talented singers, but also ordinary boys who like to have fun and learn new things. You can see them playing games, telling jokes, making friends, and sharing their thoughts and feelings. You can also see them expressing their faith and devotion, as well as their love and appreciation for each other.
-
-Angels Sing Christmas in Ireland: A Testimonial from a Fan
-
-If you are still not convinced that Angels Sing Christmas in Ireland is a great album to listen to or to give as a gift, you might want to read this testimonial from a fan who bought it and loved it. Here is what she wrote:
-
-
-I have been a fan of Libera for many years, and I have all their albums. But I have to say that Angels Sing Christmas in Ireland is my favorite one so far. It is such a beautiful and uplifting album that captures the spirit of Christmas perfectly.
-
-I love how Libera sings both traditional and modern carols, as well as songs from different countries and languages. They have such amazing voices that sound like angels, but also like children who are happy and innocent. They sing with so much emotion and expression that they touch my heart every time.
-
-I also love how Libera pays tribute to The Waterboys, one of my favorite bands. I think it is very cool that they cover their songs Danny Boy and The Whole of the Moon , which are both very meaningful and powerful songs. I think Libera does a great job of interpreting them in their own way.
-
-I also love how Libera includes a DVD with their album, which shows how they made it and what they did in Ireland. It is very interesting and entertaining to watch them recording, traveling, and having fun. It makes me feel like I am part of their journey and their family.
-
-I highly recommend Angels Sing Christmas in Ireland to anyone who loves music, especially Christmas music. It is an album that will make you smile, cry, sing, and pray. It is an album that will make you feel the true meaning of Christmas.
-
-Angels Sing Christmas in Ireland: A Must-Have Album for the Holidays
-
-In conclusion, Angels Sing Christmas in Ireland is a must-have album for anyone who loves music and Christmas. It is an album that showcases the talent and charm of Libera, the world-renowned boys choir from London. It is an album that features a variety of songs that are both familiar and new, both cheerful and solemn, both sung and instrumental. It is an album that pays tribute to one of Libera's musical influences, The Waterboys, as well as to the culture and history of Ireland. It is an album that comes with a DVD that gives a behind-the-scenes look at the recording process and Libera's visit to Ireland. It is an album that has received rave reviews from fans and critics alike.
-
-Angels Sing Christmas in Ireland is an album that will fill your home with joy and peace, and transport you to a magical place where angels sing. It is an album that you will want to listen to over and over again, and share with your loved ones. It is an album that you will cherish for years to come.
-
-If you want to download Angels Sing Christmas in Ireland by Libera (RAR file), you can do so from this link:
-
-https://bitbucket.org/psrsoft/tempo2/issues/259/angels-sing-christmas-in-ireland-rar
-
-Alternatively, you can stream or purchase the album from LINE MUSIC here:
-
-https://music.line.me/webapp/album/mb00000000000f5611
-
-Don't miss this opportunity to get Angels Sing Christmas in Ireland , the amazing album by Libera. You won't regret it!
3cee63e6c2Hd Tamil Rustom 1080p Download Zip ✺✺✺ https://tinurll.com/2uzlK4
diff --git a/spaces/runa91/barc_gradio/src/smal_pytorch/smal_model/smal_basics.py b/spaces/runa91/barc_gradio/src/smal_pytorch/smal_model/smal_basics.py
deleted file mode 100644
index bd2e71ce5c5bd1d087041aed79a376eae749ad24..0000000000000000000000000000000000000000
--- a/spaces/runa91/barc_gradio/src/smal_pytorch/smal_model/smal_basics.py
+++ /dev/null
@@ -1,82 +0,0 @@
-'''
-Adjusted version of other PyTorch implementation of the SMAL/SMPL model
-see:
- 1.) https://github.com/silviazuffi/smalst/blob/master/smal_model/smal_torch.py
- 2.) https://github.com/benjiebob/SMALify/blob/master/smal_model/smal_torch.py
-'''
-
-import os
-import pickle as pkl
-import json
-import numpy as np
-import pickle as pkl
-
-import os
-import sys
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..'))
-from configs.SMAL_configs import SMAL_DATA_DIR, SYMMETRY_INDS_FILE
-
-# model_dir = 'smalst/smpl_models/'
-# FILE_DIR = os.path.dirname(os.path.realpath(__file__))
-model_dir = SMAL_DATA_DIR # os.path.join(FILE_DIR, '..', 'smpl_models/')
-symmetry_inds_file = SYMMETRY_INDS_FILE # os.path.join(FILE_DIR, '..', 'smpl_models/symmetry_inds.json')
-with open(symmetry_inds_file) as f:
- symmetry_inds_dict = json.load(f)
-LEFT_INDS = np.asarray(symmetry_inds_dict['left_inds'])
-RIGHT_INDS = np.asarray(symmetry_inds_dict['right_inds'])
-CENTER_INDS = np.asarray(symmetry_inds_dict['center_inds'])
-
-
-def get_symmetry_indices():
- sym_dict = {'left': LEFT_INDS,
- 'right': RIGHT_INDS,
- 'center': CENTER_INDS}
- return sym_dict
-
-def verify_symmetry(shapedirs, center_inds=CENTER_INDS, left_inds=LEFT_INDS, right_inds=RIGHT_INDS):
- # shapedirs: (3889, 3, n_sh)
- assert (shapedirs[center_inds, 1, :] == 0.0).all()
- assert (shapedirs[right_inds, 1, :] == -shapedirs[left_inds, 1, :]).all()
- return
-
-def from_shapedirs_to_shapedirs_half(shapedirs, center_inds=CENTER_INDS, left_inds=LEFT_INDS, right_inds=RIGHT_INDS, verify=False):
- # shapedirs: (3889, 3, n_sh)
- # shapedirs_half: (2012, 3, n_sh)
- selected_inds = np.concatenate((center_inds, left_inds), axis=0)
- shapedirs_half = shapedirs[selected_inds, :, :]
- if verify:
- verify_symmetry(shapedirs)
- else:
- shapedirs_half[:center_inds.shape[0], 1, :] = 0.0
- return shapedirs_half
-
-def from_shapedirs_half_to_shapedirs(shapedirs_half, center_inds=CENTER_INDS, left_inds=LEFT_INDS, right_inds=RIGHT_INDS):
- # shapedirs_half: (2012, 3, n_sh)
- # shapedirs: (3889, 3, n_sh)
- shapedirs = np.zeros((center_inds.shape[0] + 2*left_inds.shape[0], 3, shapedirs_half.shape[2]))
- shapedirs[center_inds, :, :] = shapedirs_half[:center_inds.shape[0], :, :]
- shapedirs[left_inds, :, :] = shapedirs_half[center_inds.shape[0]:, :, :]
- shapedirs[right_inds, :, :] = shapedirs_half[center_inds.shape[0]:, :, :]
- shapedirs[right_inds, 1, :] = - shapedirs_half[center_inds.shape[0]:, 1, :]
- return shapedirs
-
-def align_smal_template_to_symmetry_axis(v, subtract_mean=True):
- # These are the indexes of the points that are on the symmetry axis
- I = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 37, 55, 119, 120, 163, 209, 210, 211, 213, 216, 227, 326, 395, 452, 578, 910, 959, 964, 975, 976, 977, 1172, 1175, 1176, 1178, 1194, 1243, 1739, 1796, 1797, 1798, 1799, 1800, 1801, 1802, 1803, 1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 1842, 1843, 1844, 1845, 1846, 1847, 1848, 1849, 1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 1863, 1870, 1919, 1960, 1961, 1965, 1967, 2003]
- if subtract_mean:
- v = v - np.mean(v)
- y = np.mean(v[I,1])
- v[:,1] = v[:,1] - y
- v[I,1] = 0
- left_inds = LEFT_INDS
- right_inds = RIGHT_INDS
- center_inds = CENTER_INDS
- v[right_inds, :] = np.array([1,-1,1])*v[left_inds, :]
- try:
- assert(len(left_inds) == len(right_inds))
- except:
- import pdb; pdb.set_trace()
- return v, left_inds, right_inds, center_inds
-
-
-
diff --git a/spaces/sanchanhart/Warehouse_Apparel_Detection/metadata/dataset_utils/dataset_downloader.py b/spaces/sanchanhart/Warehouse_Apparel_Detection/metadata/dataset_utils/dataset_downloader.py
deleted file mode 100644
index 8731de62d79a4ef6ae2c181316806ffb1105379d..0000000000000000000000000000000000000000
--- a/spaces/sanchanhart/Warehouse_Apparel_Detection/metadata/dataset_utils/dataset_downloader.py
+++ /dev/null
@@ -1,21 +0,0 @@
-import gdown
-from zipfile import ZipFile
-
-# Original Link :- https://drive.google.com/file/d/14QoqoZQLYnUmZgYblmFZ2u2eHo9yv2aA/view?usp=sharing
-url = 'https://drive.google.com/uc?id=14QoqoZQLYnUmZgYblmFZ2u2eHo9yv2aA'
-output = 'Fire_smoke.zip'
-
-gdown.download(url, output, quiet=False)
-
-# specifying the zip file name
-file_name = output
-
-# opening the zip file in READ mode
-with ZipFile(file_name, 'r') as zip:
- # printing all the contents of the zip file
- zip.printdir()
-
- # extracting all the files
- print('Extracting all the files now...')
- zip.extractall()
- print('Done!')
diff --git a/spaces/scedlatioru/img-to-music/example/EASEUS Data Recovery Wizard Professional Edition V5.6.5 With Key Free Download ((NEW)).md b/spaces/scedlatioru/img-to-music/example/EASEUS Data Recovery Wizard Professional Edition V5.6.5 With Key Free Download ((NEW)).md
deleted file mode 100644
index 9e743a2919434235e61a91da297515f0a06994b1..0000000000000000000000000000000000000000
--- a/spaces/scedlatioru/img-to-music/example/EASEUS Data Recovery Wizard Professional Edition V5.6.5 With Key Free Download ((NEW)).md
+++ /dev/null
@@ -1,6 +0,0 @@
-EASEUS Data Recovery Wizard Professional Edition v5.6.5 with Key free download Download File 🗹 https://gohhs.com/2uEySs
diff --git a/spaces/scedlatioru/img-to-music/example/MorphVOX Pro 4.4.85 Crack With Patch 2020 [Latest] Free !!HOT!!.md b/spaces/scedlatioru/img-to-music/example/MorphVOX Pro 4.4.85 Crack With Patch 2020 [Latest] Free !!HOT!!.md
deleted file mode 100644
index 78e37a24e3b062d16b2643208ab86d281ab548ef..0000000000000000000000000000000000000000
--- a/spaces/scedlatioru/img-to-music/example/MorphVOX Pro 4.4.85 Crack With Patch 2020 [Latest] Free !!HOT!!.md
+++ /dev/null
@@ -1,6 +0,0 @@
-MorphVOX Pro 4.4.85 Crack With Patch 2020 [Latest] Free DOWNLOAD »»» https://gohhs.com/2uEzlE
diff --git a/spaces/scedlatioru/img-to-music/example/__HOT__ Xforce Keygen AutoCAD P ID 2010 64 Bit Windows 8.md b/spaces/scedlatioru/img-to-music/example/__HOT__ Xforce Keygen AutoCAD P ID 2010 64 Bit Windows 8.md
deleted file mode 100644
index 6d9b6266bbf105373aa64969556d8fe998675f4a..0000000000000000000000000000000000000000
--- a/spaces/scedlatioru/img-to-music/example/__HOT__ Xforce Keygen AutoCAD P ID 2010 64 Bit Windows 8.md
+++ /dev/null
@@ -1,30 +0,0 @@
-Xforce Keygen AutoCAD P ID 2010 64 Bit Windows 8 DOWNLOAD >>> https://gohhs.com/2uEyVd
diff --git a/spaces/sczhou/CodeFormer/CodeFormer/basicsr/data/__init__.py b/spaces/sczhou/CodeFormer/CodeFormer/basicsr/data/__init__.py
deleted file mode 100644
index c6adb4bb6a926af7a46aaec4794eee95fda02a33..0000000000000000000000000000000000000000
--- a/spaces/sczhou/CodeFormer/CodeFormer/basicsr/data/__init__.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import importlib
-import numpy as np
-import random
-import torch
-import torch.utils.data
-from copy import deepcopy
-from functools import partial
-from os import path as osp
-
-from basicsr.data.prefetch_dataloader import PrefetchDataLoader
-from basicsr.utils import get_root_logger, scandir
-from basicsr.utils.dist_util import get_dist_info
-from basicsr.utils.registry import DATASET_REGISTRY
-
-__all__ = ['build_dataset', 'build_dataloader']
-
-# automatically scan and import dataset modules for registry
-# scan all the files under the data folder with '_dataset' in file names
-data_folder = osp.dirname(osp.abspath(__file__))
-dataset_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(data_folder) if v.endswith('_dataset.py')]
-# import all the dataset modules
-_dataset_modules = [importlib.import_module(f'basicsr.data.{file_name}') for file_name in dataset_filenames]
-
-
-def build_dataset(dataset_opt):
- """Build dataset from options.
-
- Args:
- dataset_opt (dict): Configuration for dataset. It must constain:
- name (str): Dataset name.
- type (str): Dataset type.
- """
- dataset_opt = deepcopy(dataset_opt)
- dataset = DATASET_REGISTRY.get(dataset_opt['type'])(dataset_opt)
- logger = get_root_logger()
- logger.info(f'Dataset [{dataset.__class__.__name__}] - {dataset_opt["name"]} ' 'is built.')
- return dataset
-
-
-def build_dataloader(dataset, dataset_opt, num_gpu=1, dist=False, sampler=None, seed=None):
- """Build dataloader.
-
- Args:
- dataset (torch.utils.data.Dataset): Dataset.
- dataset_opt (dict): Dataset options. It contains the following keys:
- phase (str): 'train' or 'val'.
- num_worker_per_gpu (int): Number of workers for each GPU.
- batch_size_per_gpu (int): Training batch size for each GPU.
- num_gpu (int): Number of GPUs. Used only in the train phase.
- Default: 1.
- dist (bool): Whether in distributed training. Used only in the train
- phase. Default: False.
- sampler (torch.utils.data.sampler): Data sampler. Default: None.
- seed (int | None): Seed. Default: None
- """
- phase = dataset_opt['phase']
- rank, _ = get_dist_info()
- if phase == 'train':
- if dist: # distributed training
- batch_size = dataset_opt['batch_size_per_gpu']
- num_workers = dataset_opt['num_worker_per_gpu']
- else: # non-distributed training
- multiplier = 1 if num_gpu == 0 else num_gpu
- batch_size = dataset_opt['batch_size_per_gpu'] * multiplier
- num_workers = dataset_opt['num_worker_per_gpu'] * multiplier
- dataloader_args = dict(
- dataset=dataset,
- batch_size=batch_size,
- shuffle=False,
- num_workers=num_workers,
- sampler=sampler,
- drop_last=True)
- if sampler is None:
- dataloader_args['shuffle'] = True
- dataloader_args['worker_init_fn'] = partial(
- worker_init_fn, num_workers=num_workers, rank=rank, seed=seed) if seed is not None else None
- elif phase in ['val', 'test']: # validation
- dataloader_args = dict(dataset=dataset, batch_size=1, shuffle=False, num_workers=0)
- else:
- raise ValueError(f'Wrong dataset phase: {phase}. ' "Supported ones are 'train', 'val' and 'test'.")
-
- dataloader_args['pin_memory'] = dataset_opt.get('pin_memory', False)
-
- prefetch_mode = dataset_opt.get('prefetch_mode')
- if prefetch_mode == 'cpu': # CPUPrefetcher
- num_prefetch_queue = dataset_opt.get('num_prefetch_queue', 1)
- logger = get_root_logger()
- logger.info(f'Use {prefetch_mode} prefetch dataloader: ' f'num_prefetch_queue = {num_prefetch_queue}')
- return PrefetchDataLoader(num_prefetch_queue=num_prefetch_queue, **dataloader_args)
- else:
- # prefetch_mode=None: Normal dataloader
- # prefetch_mode='cuda': dataloader for CUDAPrefetcher
- return torch.utils.data.DataLoader(**dataloader_args)
-
-
-def worker_init_fn(worker_id, num_workers, rank, seed):
- # Set the worker seed to num_workers * rank + worker_id + seed
- worker_seed = num_workers * rank + worker_id + seed
- np.random.seed(worker_seed)
- random.seed(worker_seed)
diff --git a/spaces/segments-tobias/conex/espnet/lm/lm_utils.py b/spaces/segments-tobias/conex/espnet/lm/lm_utils.py
deleted file mode 100644
index bb43e5de0e7ac83cf889d5e536d51c853058013e..0000000000000000000000000000000000000000
--- a/spaces/segments-tobias/conex/espnet/lm/lm_utils.py
+++ /dev/null
@@ -1,293 +0,0 @@
-#!/usr/bin/env python3
-
-# Copyright 2017 Johns Hopkins University (Shinji Watanabe)
-# Apache 2.0 (http://www.apache.org/licenses/LICENSE-2.0)
-
-# This code is ported from the following implementation written in Torch.
-# https://github.com/chainer/chainer/blob/master/examples/ptb/train_ptb_custom_loop.py
-
-import chainer
-import h5py
-import logging
-import numpy as np
-import os
-import random
-import six
-from tqdm import tqdm
-
-from chainer.training import extension
-
-
-def load_dataset(path, label_dict, outdir=None):
- """Load and save HDF5 that contains a dataset and stats for LM
-
- Args:
- path (str): The path of an input text dataset file
- label_dict (dict[str, int]):
- dictionary that maps token label string to its ID number
- outdir (str): The path of an output dir
-
- Returns:
- tuple[list[np.ndarray], int, int]: Tuple of
- token IDs in np.int32 converted by `read_tokens`
- the number of tokens by `count_tokens`,
- and the number of OOVs by `count_tokens`
- """
- if outdir is not None:
- os.makedirs(outdir, exist_ok=True)
- filename = outdir + "/" + os.path.basename(path) + ".h5"
- if os.path.exists(filename):
- logging.info(f"loading binary dataset: {filename}")
- f = h5py.File(filename, "r")
- return f["data"][:], f["n_tokens"][()], f["n_oovs"][()]
- else:
- logging.info("skip dump/load HDF5 because the output dir is not specified")
- logging.info(f"reading text dataset: {path}")
- ret = read_tokens(path, label_dict)
- n_tokens, n_oovs = count_tokens(ret, label_dict[""])
- if outdir is not None:
- logging.info(f"saving binary dataset: {filename}")
- with h5py.File(filename, "w") as f:
- # http://docs.h5py.org/en/stable/special.html#arbitrary-vlen-data
- data = f.create_dataset(
- "data", (len(ret),), dtype=h5py.special_dtype(vlen=np.int32)
- )
- data[:] = ret
- f["n_tokens"] = n_tokens
- f["n_oovs"] = n_oovs
- return ret, n_tokens, n_oovs
-
-
-def read_tokens(filename, label_dict):
- """Read tokens as a sequence of sentences
-
- :param str filename : The name of the input file
- :param dict label_dict : dictionary that maps token label string to its ID number
- :return list of ID sequences
- :rtype list
- """
-
- data = []
- unk = label_dict[""]
- for ln in tqdm(open(filename, "r", encoding="utf-8")):
- data.append(
- np.array(
- [label_dict.get(label, unk) for label in ln.split()], dtype=np.int32
- )
- )
- return data
-
-
-def count_tokens(data, unk_id=None):
- """Count tokens and oovs in token ID sequences.
-
- Args:
- data (list[np.ndarray]): list of token ID sequences
- unk_id (int): ID of unknown token
-
- Returns:
- tuple: tuple of number of token occurrences and number of oov tokens
-
- """
-
- n_tokens = 0
- n_oovs = 0
- for sentence in data:
- n_tokens += len(sentence)
- if unk_id is not None:
- n_oovs += np.count_nonzero(sentence == unk_id)
- return n_tokens, n_oovs
-
-
-def compute_perplexity(result):
- """Computes and add the perplexity to the LogReport
-
- :param dict result: The current observations
- """
- # Routine to rewrite the result dictionary of LogReport to add perplexity values
- result["perplexity"] = np.exp(result["main/loss"] / result["main/count"])
- if "validation/main/loss" in result:
- result["val_perplexity"] = np.exp(result["validation/main/loss"])
-
-
-class ParallelSentenceIterator(chainer.dataset.Iterator):
- """Dataset iterator to create a batch of sentences.
-
- This iterator returns a pair of sentences, where one token is shifted
- between the sentences like ' w1 w2 w3' and 'w1 w2 w3 '
- Sentence batches are made in order of longer sentences, and then
- randomly shuffled.
- """
-
- def __init__(
- self, dataset, batch_size, max_length=0, sos=0, eos=0, repeat=True, shuffle=True
- ):
- self.dataset = dataset
- self.batch_size = batch_size # batch size
- # Number of completed sweeps over the dataset. In this case, it is
- # incremented if every word is visited at least once after the last
- # increment.
- self.epoch = 0
- # True if the epoch is incremented at the last iteration.
- self.is_new_epoch = False
- self.repeat = repeat
- length = len(dataset)
- self.batch_indices = []
- # make mini-batches
- if batch_size > 1:
- indices = sorted(range(len(dataset)), key=lambda i: -len(dataset[i]))
- bs = 0
- while bs < length:
- be = min(bs + batch_size, length)
- # batch size is automatically reduced if the sentence length
- # is larger than max_length
- if max_length > 0:
- sent_length = len(dataset[indices[bs]])
- be = min(
- be, bs + max(batch_size // (sent_length // max_length + 1), 1)
- )
- self.batch_indices.append(np.array(indices[bs:be]))
- bs = be
- if shuffle:
- # shuffle batches
- random.shuffle(self.batch_indices)
- else:
- self.batch_indices = [np.array([i]) for i in six.moves.range(length)]
-
- # NOTE: this is not a count of parameter updates. It is just a count of
- # calls of ``__next__``.
- self.iteration = 0
- self.sos = sos
- self.eos = eos
- # use -1 instead of None internally
- self._previous_epoch_detail = -1.0
-
- def __next__(self):
- # This iterator returns a list representing a mini-batch. Each item
- # indicates a sentence pair like ' w1 w2 w3' and 'w1 w2 w3 '
- # represented by token IDs.
- n_batches = len(self.batch_indices)
- if not self.repeat and self.iteration >= n_batches:
- # If not self.repeat, this iterator stops at the end of the first
- # epoch (i.e., when all words are visited once).
- raise StopIteration
-
- batch = []
- for idx in self.batch_indices[self.iteration % n_batches]:
- batch.append(
- (
- np.append([self.sos], self.dataset[idx]),
- np.append(self.dataset[idx], [self.eos]),
- )
- )
-
- self._previous_epoch_detail = self.epoch_detail
- self.iteration += 1
-
- epoch = self.iteration // n_batches
- self.is_new_epoch = self.epoch < epoch
- if self.is_new_epoch:
- self.epoch = epoch
-
- return batch
-
- def start_shuffle(self):
- random.shuffle(self.batch_indices)
-
- @property
- def epoch_detail(self):
- # Floating point version of epoch.
- return self.iteration / len(self.batch_indices)
-
- @property
- def previous_epoch_detail(self):
- if self._previous_epoch_detail < 0:
- return None
- return self._previous_epoch_detail
-
- def serialize(self, serializer):
- # It is important to serialize the state to be recovered on resume.
- self.iteration = serializer("iteration", self.iteration)
- self.epoch = serializer("epoch", self.epoch)
- try:
- self._previous_epoch_detail = serializer(
- "previous_epoch_detail", self._previous_epoch_detail
- )
- except KeyError:
- # guess previous_epoch_detail for older version
- self._previous_epoch_detail = self.epoch + (
- self.current_position - 1
- ) / len(self.batch_indices)
- if self.epoch_detail > 0:
- self._previous_epoch_detail = max(self._previous_epoch_detail, 0.0)
- else:
- self._previous_epoch_detail = -1.0
-
-
-class MakeSymlinkToBestModel(extension.Extension):
- """Extension that makes a symbolic link to the best model
-
- :param str key: Key of value
- :param str prefix: Prefix of model files and link target
- :param str suffix: Suffix of link target
- """
-
- def __init__(self, key, prefix="model", suffix="best"):
- super(MakeSymlinkToBestModel, self).__init__()
- self.best_model = -1
- self.min_loss = 0.0
- self.key = key
- self.prefix = prefix
- self.suffix = suffix
-
- def __call__(self, trainer):
- observation = trainer.observation
- if self.key in observation:
- loss = observation[self.key]
- if self.best_model == -1 or loss < self.min_loss:
- self.min_loss = loss
- self.best_model = trainer.updater.epoch
- src = "%s.%d" % (self.prefix, self.best_model)
- dest = os.path.join(trainer.out, "%s.%s" % (self.prefix, self.suffix))
- if os.path.lexists(dest):
- os.remove(dest)
- os.symlink(src, dest)
- logging.info("best model is " + src)
-
- def serialize(self, serializer):
- if isinstance(serializer, chainer.serializer.Serializer):
- serializer("_best_model", self.best_model)
- serializer("_min_loss", self.min_loss)
- serializer("_key", self.key)
- serializer("_prefix", self.prefix)
- serializer("_suffix", self.suffix)
- else:
- self.best_model = serializer("_best_model", -1)
- self.min_loss = serializer("_min_loss", 0.0)
- self.key = serializer("_key", "")
- self.prefix = serializer("_prefix", "model")
- self.suffix = serializer("_suffix", "best")
-
-
-# TODO(Hori): currently it only works with character-word level LM.
-# need to consider any types of subwords-to-word mapping.
-def make_lexical_tree(word_dict, subword_dict, word_unk):
- """Make a lexical tree to compute word-level probabilities"""
- # node [dict(subword_id -> node), word_id, word_set[start-1, end]]
- root = [{}, -1, None]
- for w, wid in word_dict.items():
- if wid > 0 and wid != word_unk: # skip and
- if True in [c not in subword_dict for c in w]: # skip unknown subword
- continue
- succ = root[0] # get successors from root node
- for i, c in enumerate(w):
- cid = subword_dict[c]
- if cid not in succ: # if next node does not exist, make a new node
- succ[cid] = [{}, -1, (wid - 1, wid)]
- else:
- prev = succ[cid][2]
- succ[cid][2] = (min(prev[0], wid - 1), max(prev[1], wid))
- if i == len(w) - 1: # if word end, set word id
- succ[cid][1] = wid
- succ = succ[cid][0] # move to the child successors
- return root
diff --git a/spaces/serdaryildiz/TRCaptionNet/Model/clip/__init__.py b/spaces/serdaryildiz/TRCaptionNet/Model/clip/__init__.py
deleted file mode 100644
index dcc5619538c0f7c782508bdbd9587259d805e0d9..0000000000000000000000000000000000000000
--- a/spaces/serdaryildiz/TRCaptionNet/Model/clip/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from .clip import *
diff --git a/spaces/shabnam91/Sanskrit-TTS/indic_nlp_library/indicnlp/langinfo.py b/spaces/shabnam91/Sanskrit-TTS/indic_nlp_library/indicnlp/langinfo.py
deleted file mode 100644
index efb7e372feeb67d7106eb5c443de2e14053fd204..0000000000000000000000000000000000000000
--- a/spaces/shabnam91/Sanskrit-TTS/indic_nlp_library/indicnlp/langinfo.py
+++ /dev/null
@@ -1,488 +0,0 @@
-#
-# Copyright (c) 2013-present, Anoop Kunchukuttan
-# All rights reserved.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-#
-
-## language codes
-LC_TA='ta'
-
-SCRIPT_RANGES={
- 'pa':[0x0a00,0x0a7f] ,
- 'gu':[0x0a80,0x0aff] ,
- 'or':[0x0b00,0x0b7f] ,
- 'ta':[0x0b80,0x0bff] ,
- 'te':[0x0c00,0x0c7f] ,
- 'kn':[0x0c80,0x0cff] ,
- 'ml':[0x0d00,0x0d7f] ,
- 'si':[0x0d80,0x0dff] ,
- 'hi':[0x0900,0x097f] ,
- 'mr':[0x0900,0x097f] ,
- 'kK':[0x0900,0x097f] ,
- 'sa':[0x0900,0x097f] ,
- 'ne':[0x0900,0x097f] ,
- 'sd':[0x0900,0x097f] ,
- 'bn':[0x0980,0x09ff] ,
- 'as':[0x0980,0x09ff] ,
- }
-
-DRAVIDIAN_LANGUAGES=['ta', 'te', 'kn', 'ml',]
-IE_LANGUAGES=['hi', 'mr', 'kK', 'sa', 'ne', 'sd', 'bn', 'as', 'pa', 'gu', 'or', 'si', ]
-DANDA_DELIM_LANGUAGES=['as','bn','hi','ne','or','pa','sa','sd']
-
-URDU_RANGES=[
- [0x0600,0x06ff],
- [0x0750,0x077f],
- [0xfb50,0xfdff],
- [0xfe70,0xfeff],
- ]
-
-COORDINATED_RANGE_START_INCLUSIVE=0
-COORDINATED_RANGE_END_INCLUSIVE=0x6f
-
-NUMERIC_OFFSET_START=0x66
-NUMERIC_OFFSET_END=0x6f
-
-HALANTA_OFFSET=0x4d
-AUM_OFFSET=0x50
-NUKTA_OFFSET=0x3c
-
-RUPEE_SIGN=0x20b9
-
-DANDA=0x0964
-DOUBLE_DANDA=0x0965
-
-#TODO: add missing fricatives and approximants
-VELAR_RANGE=[0x15,0x19]
-PALATAL_RANGE=[0x1a,0x1e]
-RETROFLEX_RANGE=[0x1f,0x23]
-DENTAL_RANGE=[0x24,0x29]
-LABIAL_RANGE=[0x2a,0x2e]
-
-# verify
-VOICED_LIST=[0x17,0x18,0x1c,0x1d,0x21,0x22,0x26,0x27,0x2c,0x2d]
-UNVOICED_LIST=[0x15,0x16,0x1a,0x1b,0x1f,0x20,0x24,0x25,0x2a,0x2b] #TODO: add sibilants/sonorants
-ASPIRATED_LIST=[0x16,0x18,0x1b,0x1d,0x20,0x22,0x25,0x27,0x2b,0x2d]
-UNASPIRATED_LIST=[0x15,0x17,0x1a,0x1c,0x1f,0x21,0x24,0x26,0x2a,0x2c]
-NASAL_LIST=[0x19,0x1e,0x23,0x28,0x29,0x2d]
-FRICATIVE_LIST=[0x36,0x37,0x38]
-APPROXIMANT_LIST=[0x2f,0x30,0x31,0x32,0x33,0x34,0x35]
-
-#TODO: ha has to be properly categorized
-
-def is_danda_delim(lang):
- """
- Returns True if danda/double danda is a possible delimiter for the language
- """
- return lang in DANDA_DELIM_LANGUAGES
-
-def get_offset(c,lang):
- """
- Applicable to Brahmi derived Indic scripts
- """
- return ord(c)-SCRIPT_RANGES[lang][0]
-
-def offset_to_char(c,lang):
- """
- Applicable to Brahmi derived Indic scripts
- """
- return chr(c+SCRIPT_RANGES[lang][0])
-
-def in_coordinated_range(c_offset):
- """
- Applicable to Brahmi derived Indic scripts
- """
- return (c_offset>=COORDINATED_RANGE_START_INCLUSIVE and c_offset<=COORDINATED_RANGE_END_INCLUSIVE)
-
-def is_indiclang_char(c,lang):
- """
- Applicable to Brahmi derived Indic scripts
- """
- o=get_offset(c,lang)
- return (o>=0 and o<=0x7f) or ord(c)==DANDA or ord(c)==DOUBLE_DANDA
-
-# def is_vowel(c,lang):
-# """
-# Is the character a vowel
-# """
-# o=get_offset(c,lang)
-# return (o>=0x04 and o<=0x14)
-
-# def is_vowel_sign(c,lang):
-# """
-# Is the character a vowel sign (maatraa)
-# """
-# o=get_offset(c,lang)
-# return (o>=0x3e and o<=0x4c)
-
-# def is_halanta(c,lang):
-# """
-# Is the character the halanta character
-# """
-# o=get_offset(c,lang)
-# return (o==HALANTA_OFFSET)
-
-# def is_nukta(c,lang):
-# """
-# Is the character the halanta character
-# """
-# o=get_offset(c,lang)
-# return (o==NUKTA_OFFSET)
-
-# def is_aum(c,lang):
-# """
-# Is the character a vowel sign (maatraa)
-# """
-# o=get_offset(c,lang)
-# return (o==AUM_OFFSET)
-
-# def is_consonant(c,lang):
-# """
-# Is the character a consonant
-# """
-# o=get_offset(c,lang)
-# return (o>=0x15 and o<=0x39)
-
-# def is_velar(c,lang):
-# """
-# Is the character a velar
-# """
-# o=get_offset(c,lang)
-# return (o>=VELAR_RANGE[0] and o<=VELAR_RANGE[1])
-
-# def is_palatal(c,lang):
-# """
-# Is the character a palatal
-# """
-# o=get_offset(c,lang)
-# return (o>=PALATAL_RANGE[0] and o<=PALATAL_RANGE[1])
-
-# def is_retroflex(c,lang):
-# """
-# Is the character a retroflex
-# """
-# o=get_offset(c,lang)
-# return (o>=RETROFLEX_RANGE[0] and o<=RETROFLEX_RANGE[1])
-
-# def is_dental(c,lang):
-# """
-# Is the character a dental
-# """
-# o=get_offset(c,lang)
-# return (o>=DENTAL_RANGE[0] and o<=DENTAL_RANGE[1])
-
-# def is_labial(c,lang):
-# """
-# Is the character a labial
-# """
-# o=get_offset(c,lang)
-# return (o>=LABIAL_RANGE[0] and o<=LABIAL_RANGE[1])
-
-# def is_voiced(c,lang):
-# """
-# Is the character a voiced consonant
-# """
-# o=get_offset(c,lang)
-# return o in VOICED_LIST
-
-# def is_unvoiced(c,lang):
-# """
-# Is the character a unvoiced consonant
-# """
-# o=get_offset(c,lang)
-# return o in UNVOICED_LIST
-
-# def is_aspirated(c,lang):
-# """
-# Is the character a aspirated consonant
-# """
-# o=get_offset(c,lang)
-# return o in ASPIRATED_LIST
-
-# def is_unaspirated(c,lang):
-# """
-# Is the character a unaspirated consonant
-# """
-# o=get_offset(c,lang)
-# return o in UNASPIRATED_LIST
-
-# def is_nasal(c,lang):
-# """
-# Is the character a nasal consonant
-# """
-# o=get_offset(c,lang)
-# return o in NASAL_LIST
-
-# def is_fricative(c,lang):
-# """
-# Is the character a fricative consonant
-# """
-# o=get_offset(c,lang)
-# return o in FRICATIVE_LIST
-
-# def is_approximant(c,lang):
-# """
-# Is the character an approximant consonant
-# """
-# o=get_offset(c,lang)
-# return o in APPROXIMANT_LIST
-
-# def is_number(c,lang):
-# """
-# Is the character a number
-# """
-# o=get_offset(c,lang)
-# return (o>=0x66 and o<=0x6f)
-
-
-def is_vowel(c,lang):
- """
- Is the character a vowel
- """
- o=get_offset(c,lang)
- return (o>=0x04 and o<=0x14)
-
-def is_vowel_sign(c,lang):
- """
- Is the character a vowel sign (maatraa)
- """
- o=get_offset(c,lang)
- return (o>=0x3e and o<=0x4c)
-
-def is_halanta(c,lang):
- """
- Is the character the halanta character
- """
- o=get_offset(c,lang)
- return (o==HALANTA_OFFSET)
-
-def is_nukta(c,lang):
- """
- Is the character the halanta character
- """
- o=get_offset(c,lang)
- return (o==NUKTA_OFFSET)
-
-def is_aum(c,lang):
- """
- Is the character a vowel sign (maatraa)
- """
- o=get_offset(c,lang)
- return (o==AUM_OFFSET)
-
-def is_consonant(c,lang):
- """
- Is the character a consonant
- """
- o=get_offset(c,lang)
- return (o>=0x15 and o<=0x39)
-
-def is_velar(c,lang):
- """
- Is the character a velar
- """
- o=get_offset(c,lang)
- return (o>=VELAR_RANGE[0] and o<=VELAR_RANGE[1])
-
-def is_palatal(c,lang):
- """
- Is the character a palatal
- """
- o=get_offset(c,lang)
- return (o>=PALATAL_RANGE[0] and o<=PALATAL_RANGE[1])
-
-def is_retroflex(c,lang):
- """
- Is the character a retroflex
- """
- o=get_offset(c,lang)
- return (o>=RETROFLEX_RANGE[0] and o<=RETROFLEX_RANGE[1])
-
-def is_dental(c,lang):
- """
- Is the character a dental
- """
- o=get_offset(c,lang)
- return (o>=DENTAL_RANGE[0] and o<=DENTAL_RANGE[1])
-
-def is_labial(c,lang):
- """
- Is the character a labial
- """
- o=get_offset(c,lang)
- return (o>=LABIAL_RANGE[0] and o<=LABIAL_RANGE[1])
-
-def is_voiced(c,lang):
- """
- Is the character a voiced consonant
- """
- o=get_offset(c,lang)
- return o in VOICED_LIST
-
-def is_unvoiced(c,lang):
- """
- Is the character a unvoiced consonant
- """
- o=get_offset(c,lang)
- return o in UNVOICED_LIST
-
-def is_aspirated(c,lang):
- """
- Is the character a aspirated consonant
- """
- o=get_offset(c,lang)
- return o in ASPIRATED_LIST
-
-def is_unaspirated(c,lang):
- """
- Is the character a unaspirated consonant
- """
- o=get_offset(c,lang)
- return o in UNASPIRATED_LIST
-
-def is_nasal(c,lang):
- """
- Is the character a nasal consonant
- """
- o=get_offset(c,lang)
- return o in NASAL_LIST
-
-def is_fricative(c,lang):
- """
- Is the character a fricative consonant
- """
- o=get_offset(c,lang)
- return o in FRICATIVE_LIST
-
-def is_approximant(c,lang):
- """
- Is the character an approximant consonant
- """
- o=get_offset(c,lang)
- return o in APPROXIMANT_LIST
-
-def is_number(c,lang):
- """
- Is the character a number
- """
- o=get_offset(c,lang)
- return (o>=0x66 and o<=0x6f)
-
-
-##################################################
-
-def is_vowel_offset(c_offset):
- """
- Is the offset a vowel
- """
- return (c_offset>=0x04 and c_offset<=0x14)
-
-def is_vowel_sign_offset(c_offset):
- """
- Is the offset a vowel sign (maatraa)
- """
- return (c_offset>=0x3e and c_offset<=0x4c)
-
-def is_halanta_offset(c_offset):
- """
- Is the offset the halanta offset
- """
- return (c_offset==HALANTA_OFFSET)
-
-def is_nukta_offset(c_offset):
- """
- Is the offset the halanta offset
- """
- return (c_offset==NUKTA_OFFSET)
-
-def is_aum_offset(c_offset):
- """
- Is the offset a vowel sign (maatraa)
- """
- return (c_offset==AUM_OFFSET)
-
-def is_consonant_offset(c_offset):
- """
- Is the offset a consonant
- """
- return (c_offset>=0x15 and c_offset<=0x39)
-
-def is_velar_offset(c_offset):
- """
- Is the offset a velar
- """
- return (c_offset>=VELAR_RANGE[0] and c_offset<=VELAR_RANGE[1])
-
-def is_palatal_offset(c_offset):
- """
- Is the offset a palatal
- """
- return (c_offset>=PALATAL_RANGE[0] and c_offset<=PALATAL_RANGE[1])
-
-def is_retroflex_offset(c_offset):
- """
- Is the offset a retroflex
- """
- return (c_offset>=RETROFLEX_RANGE[0] and c_offset<=RETROFLEX_RANGE[1])
-
-def is_dental_offset(c_offset):
- """
- Is the offset a dental
- """
- return (c_offset>=DENTAL_RANGE[0] and c_offset<=DENTAL_RANGE[1])
-
-def is_labial_offset(c_offset):
- """
- Is the offset a labial
- """
- return (c_offset>=LABIAL_RANGE[0] and c_offset<=LABIAL_RANGE[1])
-
-def is_voiced_offset(c_offset):
- """
- Is the offset a voiced consonant
- """
- return c_offset in VOICED_LIST
-
-def is_unvoiced_offset(c_offset):
- """
- Is the offset a unvoiced consonant
- """
- return c_offset in UNVOICED_LIST
-
-def is_aspirated_offset(c_offset):
- """
- Is the offset a aspirated consonant
- """
- return c_offset in ASPIRATED_LIST
-
-def is_unaspirated_offset(c_offset):
- """
- Is the offset a unaspirated consonant
- """
- return c_offset in UNASPIRATED_LIST
-
-def is_nasal_offset(c_offset):
- """
- Is the offset a nasal consonant
- """
- return c_offset in NASAL_LIST
-
-def is_fricative_offset(c_offset):
- """
- Is the offset a fricative consonant
- """
- return c_offset in FRICATIVE_LIST
-
-def is_approximant_offset(c_offset):
- """
- Is the offset an approximant consonant
- """
- return c_offset in APPROXIMANT_LIST
-
-def is_number_offset(c_offset):
- """
- Is the offset a number
- """
- return (c_offset>=0x66 and c_offset<=0x6f)
diff --git a/spaces/shamikbose89/title-generator-from-abstract/app.py b/spaces/shamikbose89/title-generator-from-abstract/app.py
deleted file mode 100644
index 1c41ca8e9747c840175b5b66e22d774026cf61aa..0000000000000000000000000000000000000000
--- a/spaces/shamikbose89/title-generator-from-abstract/app.py
+++ /dev/null
@@ -1,8 +0,0 @@
-import gradio as gr
-from gradio.mix import Parallel
-
-distilbart_model = "huggingface/sshleifer/distilbart-cnn-12-6"
-model_name = "huggingface/sshleifer/distill-pegasus-xsum-16-4"
-base_model = gr.Interface.load(distilbart_model)
-my_model = gr.Interface.load(model_name, title = "Finetuned model output", inputs = "text", outputs="text")
-Parallel(base_model, my_model)
\ No newline at end of file
diff --git a/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/controlnet_annotator/midas/midas/blocks.py b/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/controlnet_annotator/midas/midas/blocks.py
deleted file mode 100644
index 2145d18fa98060a618536d9a64fe6589e9be4f78..0000000000000000000000000000000000000000
--- a/spaces/shi-labs/Prompt-Free-Diffusion/lib/model_zoo/controlnet_annotator/midas/midas/blocks.py
+++ /dev/null
@@ -1,342 +0,0 @@
-import torch
-import torch.nn as nn
-
-from .vit import (
- _make_pretrained_vitb_rn50_384,
- _make_pretrained_vitl16_384,
- _make_pretrained_vitb16_384,
- forward_vit,
-)
-
-def _make_encoder(backbone, features, use_pretrained, groups=1, expand=False, exportable=True, hooks=None, use_vit_only=False, use_readout="ignore",):
- if backbone == "vitl16_384":
- pretrained = _make_pretrained_vitl16_384(
- use_pretrained, hooks=hooks, use_readout=use_readout
- )
- scratch = _make_scratch(
- [256, 512, 1024, 1024], features, groups=groups, expand=expand
- ) # ViT-L/16 - 85.0% Top1 (backbone)
- elif backbone == "vitb_rn50_384":
- pretrained = _make_pretrained_vitb_rn50_384(
- use_pretrained,
- hooks=hooks,
- use_vit_only=use_vit_only,
- use_readout=use_readout,
- )
- scratch = _make_scratch(
- [256, 512, 768, 768], features, groups=groups, expand=expand
- ) # ViT-H/16 - 85.0% Top1 (backbone)
- elif backbone == "vitb16_384":
- pretrained = _make_pretrained_vitb16_384(
- use_pretrained, hooks=hooks, use_readout=use_readout
- )
- scratch = _make_scratch(
- [96, 192, 384, 768], features, groups=groups, expand=expand
- ) # ViT-B/16 - 84.6% Top1 (backbone)
- elif backbone == "resnext101_wsl":
- pretrained = _make_pretrained_resnext101_wsl(use_pretrained)
- scratch = _make_scratch([256, 512, 1024, 2048], features, groups=groups, expand=expand) # efficientnet_lite3
- elif backbone == "efficientnet_lite3":
- pretrained = _make_pretrained_efficientnet_lite3(use_pretrained, exportable=exportable)
- scratch = _make_scratch([32, 48, 136, 384], features, groups=groups, expand=expand) # efficientnet_lite3
- else:
- print(f"Backbone '{backbone}' not implemented")
- assert False
-
- return pretrained, scratch
-
-
-def _make_scratch(in_shape, out_shape, groups=1, expand=False):
- scratch = nn.Module()
-
- out_shape1 = out_shape
- out_shape2 = out_shape
- out_shape3 = out_shape
- out_shape4 = out_shape
- if expand==True:
- out_shape1 = out_shape
- out_shape2 = out_shape*2
- out_shape3 = out_shape*4
- out_shape4 = out_shape*8
-
- scratch.layer1_rn = nn.Conv2d(
- in_shape[0], out_shape1, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
- )
- scratch.layer2_rn = nn.Conv2d(
- in_shape[1], out_shape2, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
- )
- scratch.layer3_rn = nn.Conv2d(
- in_shape[2], out_shape3, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
- )
- scratch.layer4_rn = nn.Conv2d(
- in_shape[3], out_shape4, kernel_size=3, stride=1, padding=1, bias=False, groups=groups
- )
-
- return scratch
-
-
-def _make_pretrained_efficientnet_lite3(use_pretrained, exportable=False):
- efficientnet = torch.hub.load(
- "rwightman/gen-efficientnet-pytorch",
- "tf_efficientnet_lite3",
- pretrained=use_pretrained,
- exportable=exportable
- )
- return _make_efficientnet_backbone(efficientnet)
-
-
-def _make_efficientnet_backbone(effnet):
- pretrained = nn.Module()
-
- pretrained.layer1 = nn.Sequential(
- effnet.conv_stem, effnet.bn1, effnet.act1, *effnet.blocks[0:2]
- )
- pretrained.layer2 = nn.Sequential(*effnet.blocks[2:3])
- pretrained.layer3 = nn.Sequential(*effnet.blocks[3:5])
- pretrained.layer4 = nn.Sequential(*effnet.blocks[5:9])
-
- return pretrained
-
-
-def _make_resnet_backbone(resnet):
- pretrained = nn.Module()
- pretrained.layer1 = nn.Sequential(
- resnet.conv1, resnet.bn1, resnet.relu, resnet.maxpool, resnet.layer1
- )
-
- pretrained.layer2 = resnet.layer2
- pretrained.layer3 = resnet.layer3
- pretrained.layer4 = resnet.layer4
-
- return pretrained
-
-
-def _make_pretrained_resnext101_wsl(use_pretrained):
- resnet = torch.hub.load("facebookresearch/WSL-Images", "resnext101_32x8d_wsl")
- return _make_resnet_backbone(resnet)
-
-
-
-class Interpolate(nn.Module):
- """Interpolation module.
- """
-
- def __init__(self, scale_factor, mode, align_corners=False):
- """Init.
-
- Args:
- scale_factor (float): scaling
- mode (str): interpolation mode
- """
- super(Interpolate, self).__init__()
-
- self.interp = nn.functional.interpolate
- self.scale_factor = scale_factor
- self.mode = mode
- self.align_corners = align_corners
-
- def forward(self, x):
- """Forward pass.
-
- Args:
- x (tensor): input
-
- Returns:
- tensor: interpolated data
- """
-
- x = self.interp(
- x, scale_factor=self.scale_factor, mode=self.mode, align_corners=self.align_corners
- )
-
- return x
-
-
-class ResidualConvUnit(nn.Module):
- """Residual convolution module.
- """
-
- def __init__(self, features):
- """Init.
-
- Args:
- features (int): number of features
- """
- super().__init__()
-
- self.conv1 = nn.Conv2d(
- features, features, kernel_size=3, stride=1, padding=1, bias=True
- )
-
- self.conv2 = nn.Conv2d(
- features, features, kernel_size=3, stride=1, padding=1, bias=True
- )
-
- self.relu = nn.ReLU(inplace=True)
-
- def forward(self, x):
- """Forward pass.
-
- Args:
- x (tensor): input
-
- Returns:
- tensor: output
- """
- out = self.relu(x)
- out = self.conv1(out)
- out = self.relu(out)
- out = self.conv2(out)
-
- return out + x
-
-
-class FeatureFusionBlock(nn.Module):
- """Feature fusion block.
- """
-
- def __init__(self, features):
- """Init.
-
- Args:
- features (int): number of features
- """
- super(FeatureFusionBlock, self).__init__()
-
- self.resConfUnit1 = ResidualConvUnit(features)
- self.resConfUnit2 = ResidualConvUnit(features)
-
- def forward(self, *xs):
- """Forward pass.
-
- Returns:
- tensor: output
- """
- output = xs[0]
-
- if len(xs) == 2:
- output += self.resConfUnit1(xs[1])
-
- output = self.resConfUnit2(output)
-
- output = nn.functional.interpolate(
- output, scale_factor=2, mode="bilinear", align_corners=True
- )
-
- return output
-
-
-
-
-class ResidualConvUnit_custom(nn.Module):
- """Residual convolution module.
- """
-
- def __init__(self, features, activation, bn):
- """Init.
-
- Args:
- features (int): number of features
- """
- super().__init__()
-
- self.bn = bn
-
- self.groups=1
-
- self.conv1 = nn.Conv2d(
- features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups
- )
-
- self.conv2 = nn.Conv2d(
- features, features, kernel_size=3, stride=1, padding=1, bias=True, groups=self.groups
- )
-
- if self.bn==True:
- self.bn1 = nn.BatchNorm2d(features)
- self.bn2 = nn.BatchNorm2d(features)
-
- self.activation = activation
-
- self.skip_add = nn.quantized.FloatFunctional()
-
- def forward(self, x):
- """Forward pass.
-
- Args:
- x (tensor): input
-
- Returns:
- tensor: output
- """
-
- out = self.activation(x)
- out = self.conv1(out)
- if self.bn==True:
- out = self.bn1(out)
-
- out = self.activation(out)
- out = self.conv2(out)
- if self.bn==True:
- out = self.bn2(out)
-
- if self.groups > 1:
- out = self.conv_merge(out)
-
- return self.skip_add.add(out, x)
-
- # return out + x
-
-
-class FeatureFusionBlock_custom(nn.Module):
- """Feature fusion block.
- """
-
- def __init__(self, features, activation, deconv=False, bn=False, expand=False, align_corners=True):
- """Init.
-
- Args:
- features (int): number of features
- """
- super(FeatureFusionBlock_custom, self).__init__()
-
- self.deconv = deconv
- self.align_corners = align_corners
-
- self.groups=1
-
- self.expand = expand
- out_features = features
- if self.expand==True:
- out_features = features//2
-
- self.out_conv = nn.Conv2d(features, out_features, kernel_size=1, stride=1, padding=0, bias=True, groups=1)
-
- self.resConfUnit1 = ResidualConvUnit_custom(features, activation, bn)
- self.resConfUnit2 = ResidualConvUnit_custom(features, activation, bn)
-
- self.skip_add = nn.quantized.FloatFunctional()
-
- def forward(self, *xs):
- """Forward pass.
-
- Returns:
- tensor: output
- """
- output = xs[0]
-
- if len(xs) == 2:
- res = self.resConfUnit1(xs[1])
- output = self.skip_add.add(output, res)
- # output += res
-
- output = self.resConfUnit2(output)
-
- output = nn.functional.interpolate(
- output, scale_factor=2, mode="bilinear", align_corners=self.align_corners
- )
-
- output = self.out_conv(output)
-
- return output
-
diff --git a/spaces/shj7972/gradiospace/app.py b/spaces/shj7972/gradiospace/app.py
deleted file mode 100644
index c457a71c5564407084bc14d1224c9423d1d53561..0000000000000000000000000000000000000000
--- a/spaces/shj7972/gradiospace/app.py
+++ /dev/null
@@ -1,29 +0,0 @@
-import gradio as gr
-#from transformers import pipeline
-#pipe = pipeline("translation", model="Helsinki-NLP/opus-mt-en-es")
-
-#def greet(name, is_morning, temperature):
-# salutation = "Good morning" if is_morning else "Good evening"
-# greeting = f"{salutation} {name}. It is {temperature} degrees today"
-# celsius = (temperature - 32) * 5 / 9
-# return greeting, round(celsius, 2)
-
-#demo = gr.Interface(
-# fn=greet,
-# inputs=["text", "checkbox", gr.Slider(0, 100)],
-# outputs=["text", "number"],
-#)
-import numpy as np
-
-def sepia(input_img):
- sepia_filter = np.array([
- [0.393, 0.769, 0.189],
- [0.349, 0.686, 0.168],
- [0.272, 0.534, 0.131]
- ])
- sepia_img = input_img.dot(sepia_filter.T)
- sepia_img /= sepia_img.max()
- return sepia_img
-
-demo = gr.Interface(sepia, gr.Image(shape=(200, 200)), "image")
-demo.launch()
\ No newline at end of file
diff --git a/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/quat_affine.py b/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/quat_affine.py
deleted file mode 100644
index 9ebcd20f3e2948c905242dc3e09df6684b99ace7..0000000000000000000000000000000000000000
--- a/spaces/simonduerr/ProteinMPNN/af_backprop/alphafold/model/quat_affine.py
+++ /dev/null
@@ -1,459 +0,0 @@
-# Copyright 2021 DeepMind Technologies Limited
-#
-# 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.
-
-"""Quaternion geometry modules.
-
-This introduces a representation of coordinate frames that is based around a
-‘QuatAffine’ object. This object describes an array of coordinate frames.
-It consists of vectors corresponding to the
-origin of the frames as well as orientations which are stored in two
-ways, as unit quaternions as well as a rotation matrices.
-The rotation matrices are derived from the unit quaternions and the two are kept
-in sync.
-For an explanation of the relation between unit quaternions and rotations see
-https://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation
-
-This representation is used in the model for the backbone frames.
-
-One important thing to note here, is that while we update both representations
-the jit compiler is going to ensure that only the parts that are
-actually used are executed.
-"""
-
-
-import functools
-from typing import Tuple
-
-import jax
-import jax.numpy as jnp
-import numpy as np
-
-# pylint: disable=bad-whitespace
-QUAT_TO_ROT = np.zeros((4, 4, 3, 3), dtype=np.float32)
-
-QUAT_TO_ROT[0, 0] = [[ 1, 0, 0], [ 0, 1, 0], [ 0, 0, 1]] # rr
-QUAT_TO_ROT[1, 1] = [[ 1, 0, 0], [ 0,-1, 0], [ 0, 0,-1]] # ii
-QUAT_TO_ROT[2, 2] = [[-1, 0, 0], [ 0, 1, 0], [ 0, 0,-1]] # jj
-QUAT_TO_ROT[3, 3] = [[-1, 0, 0], [ 0,-1, 0], [ 0, 0, 1]] # kk
-
-QUAT_TO_ROT[1, 2] = [[ 0, 2, 0], [ 2, 0, 0], [ 0, 0, 0]] # ij
-QUAT_TO_ROT[1, 3] = [[ 0, 0, 2], [ 0, 0, 0], [ 2, 0, 0]] # ik
-QUAT_TO_ROT[2, 3] = [[ 0, 0, 0], [ 0, 0, 2], [ 0, 2, 0]] # jk
-
-QUAT_TO_ROT[0, 1] = [[ 0, 0, 0], [ 0, 0,-2], [ 0, 2, 0]] # ir
-QUAT_TO_ROT[0, 2] = [[ 0, 0, 2], [ 0, 0, 0], [-2, 0, 0]] # jr
-QUAT_TO_ROT[0, 3] = [[ 0,-2, 0], [ 2, 0, 0], [ 0, 0, 0]] # kr
-
-QUAT_MULTIPLY = np.zeros((4, 4, 4), dtype=np.float32)
-QUAT_MULTIPLY[:, :, 0] = [[ 1, 0, 0, 0],
- [ 0,-1, 0, 0],
- [ 0, 0,-1, 0],
- [ 0, 0, 0,-1]]
-
-QUAT_MULTIPLY[:, :, 1] = [[ 0, 1, 0, 0],
- [ 1, 0, 0, 0],
- [ 0, 0, 0, 1],
- [ 0, 0,-1, 0]]
-
-QUAT_MULTIPLY[:, :, 2] = [[ 0, 0, 1, 0],
- [ 0, 0, 0,-1],
- [ 1, 0, 0, 0],
- [ 0, 1, 0, 0]]
-
-QUAT_MULTIPLY[:, :, 3] = [[ 0, 0, 0, 1],
- [ 0, 0, 1, 0],
- [ 0,-1, 0, 0],
- [ 1, 0, 0, 0]]
-
-QUAT_MULTIPLY_BY_VEC = QUAT_MULTIPLY[:, 1:, :]
-# pylint: enable=bad-whitespace
-
-
-def rot_to_quat(rot, unstack_inputs=False):
- """Convert rotation matrix to quaternion.
-
- Note that this function calls self_adjoint_eig which is extremely expensive on
- the GPU. If at all possible, this function should run on the CPU.
-
- Args:
- rot: rotation matrix (see below for format).
- unstack_inputs: If true, rotation matrix should be shape (..., 3, 3)
- otherwise the rotation matrix should be a list of lists of tensors.
-
- Returns:
- Quaternion as (..., 4) tensor.
- """
- if unstack_inputs:
- rot = [jnp.moveaxis(x, -1, 0) for x in jnp.moveaxis(rot, -2, 0)]
-
- [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = rot
-
- # pylint: disable=bad-whitespace
- k = [[ xx + yy + zz, zy - yz, xz - zx, yx - xy,],
- [ zy - yz, xx - yy - zz, xy + yx, xz + zx,],
- [ xz - zx, xy + yx, yy - xx - zz, yz + zy,],
- [ yx - xy, xz + zx, yz + zy, zz - xx - yy,]]
- # pylint: enable=bad-whitespace
-
- k = (1./3.) * jnp.stack([jnp.stack(x, axis=-1) for x in k],
- axis=-2)
-
- # Get eigenvalues in non-decreasing order and associated.
- _, qs = jnp.linalg.eigh(k)
- return qs[..., -1]
-
-
-def rot_list_to_tensor(rot_list):
- """Convert list of lists to rotation tensor."""
- return jnp.stack(
- [jnp.stack(rot_list[0], axis=-1),
- jnp.stack(rot_list[1], axis=-1),
- jnp.stack(rot_list[2], axis=-1)],
- axis=-2)
-
-
-def vec_list_to_tensor(vec_list):
- """Convert list to vector tensor."""
- return jnp.stack(vec_list, axis=-1)
-
-
-def quat_to_rot(normalized_quat):
- """Convert a normalized quaternion to a rotation matrix."""
- rot_tensor = jnp.sum(
- np.reshape(QUAT_TO_ROT, (4, 4, 9)) *
- normalized_quat[..., :, None, None] *
- normalized_quat[..., None, :, None],
- axis=(-3, -2))
- rot = jnp.moveaxis(rot_tensor, -1, 0) # Unstack.
- return [[rot[0], rot[1], rot[2]],
- [rot[3], rot[4], rot[5]],
- [rot[6], rot[7], rot[8]]]
-
-
-def quat_multiply_by_vec(quat, vec):
- """Multiply a quaternion by a pure-vector quaternion."""
- return jnp.sum(
- QUAT_MULTIPLY_BY_VEC *
- quat[..., :, None, None] *
- vec[..., None, :, None],
- axis=(-3, -2))
-
-
-def quat_multiply(quat1, quat2):
- """Multiply a quaternion by another quaternion."""
- return jnp.sum(
- QUAT_MULTIPLY *
- quat1[..., :, None, None] *
- quat2[..., None, :, None],
- axis=(-3, -2))
-
-
-def apply_rot_to_vec(rot, vec, unstack=False):
- """Multiply rotation matrix by a vector."""
- if unstack:
- x, y, z = [vec[:, i] for i in range(3)]
- else:
- x, y, z = vec
- return [rot[0][0] * x + rot[0][1] * y + rot[0][2] * z,
- rot[1][0] * x + rot[1][1] * y + rot[1][2] * z,
- rot[2][0] * x + rot[2][1] * y + rot[2][2] * z]
-
-
-def apply_inverse_rot_to_vec(rot, vec):
- """Multiply the inverse of a rotation matrix by a vector."""
- # Inverse rotation is just transpose
- return [rot[0][0] * vec[0] + rot[1][0] * vec[1] + rot[2][0] * vec[2],
- rot[0][1] * vec[0] + rot[1][1] * vec[1] + rot[2][1] * vec[2],
- rot[0][2] * vec[0] + rot[1][2] * vec[1] + rot[2][2] * vec[2]]
-
-
-class QuatAffine(object):
- """Affine transformation represented by quaternion and vector."""
-
- def __init__(self, quaternion, translation, rotation=None, normalize=True,
- unstack_inputs=False):
- """Initialize from quaternion and translation.
-
- Args:
- quaternion: Rotation represented by a quaternion, to be applied
- before translation. Must be a unit quaternion unless normalize==True.
- translation: Translation represented as a vector.
- rotation: Same rotation as the quaternion, represented as a (..., 3, 3)
- tensor. If None, rotation will be calculated from the quaternion.
- normalize: If True, l2 normalize the quaternion on input.
- unstack_inputs: If True, translation is a vector with last component 3
- """
-
- if quaternion is not None:
- assert quaternion.shape[-1] == 4
-
- if unstack_inputs:
- if rotation is not None:
- rotation = [jnp.moveaxis(x, -1, 0) # Unstack.
- for x in jnp.moveaxis(rotation, -2, 0)] # Unstack.
- translation = jnp.moveaxis(translation, -1, 0) # Unstack.
-
- if normalize and quaternion is not None:
- quaternion = quaternion / jnp.linalg.norm(quaternion, axis=-1,
- keepdims=True)
-
- if rotation is None:
- rotation = quat_to_rot(quaternion)
-
- self.quaternion = quaternion
- self.rotation = [list(row) for row in rotation]
- self.translation = list(translation)
-
- assert all(len(row) == 3 for row in self.rotation)
- assert len(self.translation) == 3
-
- def to_tensor(self):
- return jnp.concatenate(
- [self.quaternion] +
- [jnp.expand_dims(x, axis=-1) for x in self.translation],
- axis=-1)
-
- def apply_tensor_fn(self, tensor_fn):
- """Return a new QuatAffine with tensor_fn applied (e.g. stop_gradient)."""
- return QuatAffine(
- tensor_fn(self.quaternion),
- [tensor_fn(x) for x in self.translation],
- rotation=[[tensor_fn(x) for x in row] for row in self.rotation],
- normalize=False)
-
- def apply_rotation_tensor_fn(self, tensor_fn):
- """Return a new QuatAffine with tensor_fn applied to the rotation part."""
- return QuatAffine(
- tensor_fn(self.quaternion),
- [x for x in self.translation],
- rotation=[[tensor_fn(x) for x in row] for row in self.rotation],
- normalize=False)
-
- def scale_translation(self, position_scale):
- """Return a new quat affine with a different scale for translation."""
-
- return QuatAffine(
- self.quaternion,
- [x * position_scale for x in self.translation],
- rotation=[[x for x in row] for row in self.rotation],
- normalize=False)
-
- @classmethod
- def from_tensor(cls, tensor, normalize=False):
- quaternion, tx, ty, tz = jnp.split(tensor, [4, 5, 6], axis=-1)
- return cls(quaternion,
- [tx[..., 0], ty[..., 0], tz[..., 0]],
- normalize=normalize)
-
- def pre_compose(self, update):
- """Return a new QuatAffine which applies the transformation update first.
-
- Args:
- update: Length-6 vector. 3-vector of x, y, and z such that the quaternion
- update is (1, x, y, z) and zero for the 3-vector is the identity
- quaternion. 3-vector for translation concatenated.
-
- Returns:
- New QuatAffine object.
- """
- vector_quaternion_update, x, y, z = jnp.split(update, [3, 4, 5], axis=-1)
- trans_update = [jnp.squeeze(x, axis=-1),
- jnp.squeeze(y, axis=-1),
- jnp.squeeze(z, axis=-1)]
-
- new_quaternion = (self.quaternion +
- quat_multiply_by_vec(self.quaternion,
- vector_quaternion_update))
-
- trans_update = apply_rot_to_vec(self.rotation, trans_update)
- new_translation = [
- self.translation[0] + trans_update[0],
- self.translation[1] + trans_update[1],
- self.translation[2] + trans_update[2]]
-
- return QuatAffine(new_quaternion, new_translation)
-
- def apply_to_point(self, point, extra_dims=0):
- """Apply affine to a point.
-
- Args:
- point: List of 3 tensors to apply affine.
- extra_dims: Number of dimensions at the end of the transformed_point
- shape that are not present in the rotation and translation. The most
- common use is rotation N points at once with extra_dims=1 for use in a
- network.
-
- Returns:
- Transformed point after applying affine.
- """
- rotation = self.rotation
- translation = self.translation
- for _ in range(extra_dims):
- expand_fn = functools.partial(jnp.expand_dims, axis=-1)
- rotation = jax.tree_map(expand_fn, rotation)
- translation = jax.tree_map(expand_fn, translation)
-
- rot_point = apply_rot_to_vec(rotation, point)
- return [
- rot_point[0] + translation[0],
- rot_point[1] + translation[1],
- rot_point[2] + translation[2]]
-
- def invert_point(self, transformed_point, extra_dims=0):
- """Apply inverse of transformation to a point.
-
- Args:
- transformed_point: List of 3 tensors to apply affine
- extra_dims: Number of dimensions at the end of the transformed_point
- shape that are not present in the rotation and translation. The most
- common use is rotation N points at once with extra_dims=1 for use in a
- network.
-
- Returns:
- Transformed point after applying affine.
- """
- rotation = self.rotation
- translation = self.translation
- for _ in range(extra_dims):
- expand_fn = functools.partial(jnp.expand_dims, axis=-1)
- rotation = jax.tree_map(expand_fn, rotation)
- translation = jax.tree_map(expand_fn, translation)
-
- rot_point = [
- transformed_point[0] - translation[0],
- transformed_point[1] - translation[1],
- transformed_point[2] - translation[2]]
-
- return apply_inverse_rot_to_vec(rotation, rot_point)
-
- def __repr__(self):
- return 'QuatAffine(%r, %r)' % (self.quaternion, self.translation)
-
-
-def _multiply(a, b):
- return jnp.stack([
- jnp.array([a[0][0]*b[0][0] + a[0][1]*b[1][0] + a[0][2]*b[2][0],
- a[0][0]*b[0][1] + a[0][1]*b[1][1] + a[0][2]*b[2][1],
- a[0][0]*b[0][2] + a[0][1]*b[1][2] + a[0][2]*b[2][2]]),
-
- jnp.array([a[1][0]*b[0][0] + a[1][1]*b[1][0] + a[1][2]*b[2][0],
- a[1][0]*b[0][1] + a[1][1]*b[1][1] + a[1][2]*b[2][1],
- a[1][0]*b[0][2] + a[1][1]*b[1][2] + a[1][2]*b[2][2]]),
-
- jnp.array([a[2][0]*b[0][0] + a[2][1]*b[1][0] + a[2][2]*b[2][0],
- a[2][0]*b[0][1] + a[2][1]*b[1][1] + a[2][2]*b[2][1],
- a[2][0]*b[0][2] + a[2][1]*b[1][2] + a[2][2]*b[2][2]])])
-
-
-def make_canonical_transform(
- n_xyz: jnp.ndarray,
- ca_xyz: jnp.ndarray,
- c_xyz: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]:
- """Returns translation and rotation matrices to canonicalize residue atoms.
-
- Note that this method does not take care of symmetries. If you provide the
- atom positions in the non-standard way, the N atom will end up not at
- [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You
- need to take care of such cases in your code.
-
- Args:
- n_xyz: An array of shape [batch, 3] of nitrogen xyz coordinates.
- ca_xyz: An array of shape [batch, 3] of carbon alpha xyz coordinates.
- c_xyz: An array of shape [batch, 3] of carbon xyz coordinates.
-
- Returns:
- A tuple (translation, rotation) where:
- translation is an array of shape [batch, 3] defining the translation.
- rotation is an array of shape [batch, 3, 3] defining the rotation.
- After applying the translation and rotation to all atoms in a residue:
- * All atoms will be shifted so that CA is at the origin,
- * All atoms will be rotated so that C is at the x-axis,
- * All atoms will be shifted so that N is in the xy plane.
- """
- assert len(n_xyz.shape) == 2, n_xyz.shape
- assert n_xyz.shape[-1] == 3, n_xyz.shape
- assert n_xyz.shape == ca_xyz.shape == c_xyz.shape, (
- n_xyz.shape, ca_xyz.shape, c_xyz.shape)
-
- # Place CA at the origin.
- translation = -ca_xyz
- n_xyz = n_xyz + translation
- c_xyz = c_xyz + translation
-
- # Place C on the x-axis.
- c_x, c_y, c_z = [c_xyz[:, i] for i in range(3)]
- # Rotate by angle c1 in the x-y plane (around the z-axis).
- sin_c1 = -c_y / jnp.sqrt(1e-20 + c_x**2 + c_y**2)
- cos_c1 = c_x / jnp.sqrt(1e-20 + c_x**2 + c_y**2)
- zeros = jnp.zeros_like(sin_c1)
- ones = jnp.ones_like(sin_c1)
- # pylint: disable=bad-whitespace
- c1_rot_matrix = jnp.stack([jnp.array([cos_c1, -sin_c1, zeros]),
- jnp.array([sin_c1, cos_c1, zeros]),
- jnp.array([zeros, zeros, ones])])
-
- # Rotate by angle c2 in the x-z plane (around the y-axis).
- sin_c2 = c_z / jnp.sqrt(1e-20 + c_x**2 + c_y**2 + c_z**2)
- cos_c2 = jnp.sqrt(c_x**2 + c_y**2) / jnp.sqrt(
- 1e-20 + c_x**2 + c_y**2 + c_z**2)
- c2_rot_matrix = jnp.stack([jnp.array([cos_c2, zeros, sin_c2]),
- jnp.array([zeros, ones, zeros]),
- jnp.array([-sin_c2, zeros, cos_c2])])
-
- c_rot_matrix = _multiply(c2_rot_matrix, c1_rot_matrix)
- n_xyz = jnp.stack(apply_rot_to_vec(c_rot_matrix, n_xyz, unstack=True)).T
-
- # Place N in the x-y plane.
- _, n_y, n_z = [n_xyz[:, i] for i in range(3)]
- # Rotate by angle alpha in the y-z plane (around the x-axis).
- sin_n = -n_z / jnp.sqrt(1e-20 + n_y**2 + n_z**2)
- cos_n = n_y / jnp.sqrt(1e-20 + n_y**2 + n_z**2)
- n_rot_matrix = jnp.stack([jnp.array([ones, zeros, zeros]),
- jnp.array([zeros, cos_n, -sin_n]),
- jnp.array([zeros, sin_n, cos_n])])
- # pylint: enable=bad-whitespace
-
- return (translation,
- jnp.transpose(_multiply(n_rot_matrix, c_rot_matrix), [2, 0, 1]))
-
-
-def make_transform_from_reference(
- n_xyz: jnp.ndarray,
- ca_xyz: jnp.ndarray,
- c_xyz: jnp.ndarray) -> Tuple[jnp.ndarray, jnp.ndarray]:
- """Returns rotation and translation matrices to convert from reference.
-
- Note that this method does not take care of symmetries. If you provide the
- atom positions in the non-standard way, the N atom will end up not at
- [-0.527250, 1.359329, 0.0] but instead at [-0.527250, -1.359329, 0.0]. You
- need to take care of such cases in your code.
-
- Args:
- n_xyz: An array of shape [batch, 3] of nitrogen xyz coordinates.
- ca_xyz: An array of shape [batch, 3] of carbon alpha xyz coordinates.
- c_xyz: An array of shape [batch, 3] of carbon xyz coordinates.
-
- Returns:
- A tuple (rotation, translation) where:
- rotation is an array of shape [batch, 3, 3] defining the rotation.
- translation is an array of shape [batch, 3] defining the translation.
- After applying the translation and rotation to the reference backbone,
- the coordinates will approximately equal to the input coordinates.
-
- The order of translation and rotation differs from make_canonical_transform
- because the rotation from this function should be applied before the
- translation, unlike make_canonical_transform.
- """
- translation, rotation = make_canonical_transform(n_xyz, ca_xyz, c_xyz)
- return np.transpose(rotation, (0, 2, 1)), -translation
diff --git a/spaces/simonduerr/diffdock/models/score_model.py b/spaces/simonduerr/diffdock/models/score_model.py
deleted file mode 100644
index 60c64feabdb3d23096a61e4b5e77004b87d6febd..0000000000000000000000000000000000000000
--- a/spaces/simonduerr/diffdock/models/score_model.py
+++ /dev/null
@@ -1,442 +0,0 @@
-import math
-
-from e3nn import o3
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch_cluster import radius, radius_graph
-from torch_scatter import scatter, scatter_mean
-import numpy as np
-from e3nn.nn import BatchNorm
-
-from utils import so3, torus
-from datasets.process_mols import lig_feature_dims, rec_residue_feature_dims
-
-
-class AtomEncoder(torch.nn.Module):
-
- def __init__(self, emb_dim, feature_dims, sigma_embed_dim, lm_embedding_type= None):
- # first element of feature_dims tuple is a list with the lenght of each categorical feature and the second is the number of scalar features
- super(AtomEncoder, self).__init__()
- self.atom_embedding_list = torch.nn.ModuleList()
- self.num_categorical_features = len(feature_dims[0])
- self.num_scalar_features = feature_dims[1] + sigma_embed_dim
- self.lm_embedding_type = lm_embedding_type
- for i, dim in enumerate(feature_dims[0]):
- emb = torch.nn.Embedding(dim, emb_dim)
- torch.nn.init.xavier_uniform_(emb.weight.data)
- self.atom_embedding_list.append(emb)
-
- if self.num_scalar_features > 0:
- self.linear = torch.nn.Linear(self.num_scalar_features, emb_dim)
- if self.lm_embedding_type is not None:
- if self.lm_embedding_type == 'esm':
- self.lm_embedding_dim = 1280
- else: raise ValueError('LM Embedding type was not correctly determined. LM embedding type: ', self.lm_embedding_type)
- self.lm_embedding_layer = torch.nn.Linear(self.lm_embedding_dim + emb_dim, emb_dim)
-
- def forward(self, x):
- x_embedding = 0
- if self.lm_embedding_type is not None:
- assert x.shape[1] == self.num_categorical_features + self.num_scalar_features + self.lm_embedding_dim
- else:
- assert x.shape[1] == self.num_categorical_features + self.num_scalar_features
- for i in range(self.num_categorical_features):
- x_embedding += self.atom_embedding_list[i](x[:, i].long())
-
- if self.num_scalar_features > 0:
- x_embedding += self.linear(x[:, self.num_categorical_features:self.num_categorical_features + self.num_scalar_features])
- if self.lm_embedding_type is not None:
- x_embedding = self.lm_embedding_layer(torch.cat([x_embedding, x[:, -self.lm_embedding_dim:]], axis=1))
- return x_embedding
-
-
-class TensorProductConvLayer(torch.nn.Module):
- def __init__(self, in_irreps, sh_irreps, out_irreps, n_edge_features, residual=True, batch_norm=True, dropout=0.0,
- hidden_features=None):
- super(TensorProductConvLayer, self).__init__()
- self.in_irreps = in_irreps
- self.out_irreps = out_irreps
- self.sh_irreps = sh_irreps
- self.residual = residual
- if hidden_features is None:
- hidden_features = n_edge_features
-
- self.tp = tp = o3.FullyConnectedTensorProduct(in_irreps, sh_irreps, out_irreps, shared_weights=False)
-
- self.fc = nn.Sequential(
- nn.Linear(n_edge_features, hidden_features),
- nn.ReLU(),
- nn.Dropout(dropout),
- nn.Linear(hidden_features, tp.weight_numel)
- )
- self.batch_norm = BatchNorm(out_irreps) if batch_norm else None
-
- def forward(self, node_attr, edge_index, edge_attr, edge_sh, out_nodes=None, reduce='mean'):
-
- edge_src, edge_dst = edge_index
- tp = self.tp(node_attr[edge_dst], edge_sh, self.fc(edge_attr))
-
- out_nodes = out_nodes or node_attr.shape[0]
- out = scatter(tp, edge_src, dim=0, dim_size=out_nodes, reduce=reduce)
-
- if self.residual:
- padded = F.pad(node_attr, (0, out.shape[-1] - node_attr.shape[-1]))
- out = out + padded
-
- if self.batch_norm:
- out = self.batch_norm(out)
- return out
-
-
-class TensorProductScoreModel(torch.nn.Module):
- def __init__(self, t_to_sigma, device, timestep_emb_func, in_lig_edge_features=4, sigma_embed_dim=32, sh_lmax=2,
- ns=16, nv=4, num_conv_layers=2, lig_max_radius=5, rec_max_radius=30, cross_max_distance=250,
- center_max_distance=30, distance_embed_dim=32, cross_distance_embed_dim=32, no_torsion=False,
- scale_by_sigma=True, use_second_order_repr=False, batch_norm=True,
- dynamic_max_cross=False, dropout=0.0, lm_embedding_type=None, confidence_mode=False,
- confidence_dropout=0, confidence_no_batchnorm=False, num_confidence_outputs=1):
- super(TensorProductScoreModel, self).__init__()
- self.t_to_sigma = t_to_sigma
- self.in_lig_edge_features = in_lig_edge_features
- self.sigma_embed_dim = sigma_embed_dim
- self.lig_max_radius = lig_max_radius
- self.rec_max_radius = rec_max_radius
- self.cross_max_distance = cross_max_distance
- self.dynamic_max_cross = dynamic_max_cross
- self.center_max_distance = center_max_distance
- self.distance_embed_dim = distance_embed_dim
- self.cross_distance_embed_dim = cross_distance_embed_dim
- self.sh_irreps = o3.Irreps.spherical_harmonics(lmax=sh_lmax)
- self.ns, self.nv = ns, nv
- self.scale_by_sigma = scale_by_sigma
- self.device = device
- self.no_torsion = no_torsion
- self.timestep_emb_func = timestep_emb_func
- self.confidence_mode = confidence_mode
- self.num_conv_layers = num_conv_layers
-
- self.lig_node_embedding = AtomEncoder(emb_dim=ns, feature_dims=lig_feature_dims, sigma_embed_dim=sigma_embed_dim)
- self.lig_edge_embedding = nn.Sequential(nn.Linear(in_lig_edge_features + sigma_embed_dim + distance_embed_dim, ns),nn.ReLU(), nn.Dropout(dropout),nn.Linear(ns, ns))
-
- self.rec_node_embedding = AtomEncoder(emb_dim=ns, feature_dims=rec_residue_feature_dims, sigma_embed_dim=sigma_embed_dim, lm_embedding_type=lm_embedding_type)
- self.rec_edge_embedding = nn.Sequential(nn.Linear(sigma_embed_dim + distance_embed_dim, ns), nn.ReLU(), nn.Dropout(dropout),nn.Linear(ns, ns))
-
- self.cross_edge_embedding = nn.Sequential(nn.Linear(sigma_embed_dim + cross_distance_embed_dim, ns), nn.ReLU(), nn.Dropout(dropout),nn.Linear(ns, ns))
-
- self.lig_distance_expansion = GaussianSmearing(0.0, lig_max_radius, distance_embed_dim)
- self.rec_distance_expansion = GaussianSmearing(0.0, rec_max_radius, distance_embed_dim)
- self.cross_distance_expansion = GaussianSmearing(0.0, cross_max_distance, cross_distance_embed_dim)
-
- if use_second_order_repr:
- irrep_seq = [
- f'{ns}x0e',
- f'{ns}x0e + {nv}x1o + {nv}x2e',
- f'{ns}x0e + {nv}x1o + {nv}x2e + {nv}x1e + {nv}x2o',
- f'{ns}x0e + {nv}x1o + {nv}x2e + {nv}x1e + {nv}x2o + {ns}x0o'
- ]
- else:
- irrep_seq = [
- f'{ns}x0e',
- f'{ns}x0e + {nv}x1o',
- f'{ns}x0e + {nv}x1o + {nv}x1e',
- f'{ns}x0e + {nv}x1o + {nv}x1e + {ns}x0o'
- ]
-
- lig_conv_layers, rec_conv_layers, lig_to_rec_conv_layers, rec_to_lig_conv_layers = [], [], [], []
- for i in range(num_conv_layers):
- in_irreps = irrep_seq[min(i, len(irrep_seq) - 1)]
- out_irreps = irrep_seq[min(i + 1, len(irrep_seq) - 1)]
- parameters = {
- 'in_irreps': in_irreps,
- 'sh_irreps': self.sh_irreps,
- 'out_irreps': out_irreps,
- 'n_edge_features': 3 * ns,
- 'hidden_features': 3 * ns,
- 'residual': False,
- 'batch_norm': batch_norm,
- 'dropout': dropout
- }
-
- lig_layer = TensorProductConvLayer(**parameters)
- lig_conv_layers.append(lig_layer)
- rec_layer = TensorProductConvLayer(**parameters)
- rec_conv_layers.append(rec_layer)
- lig_to_rec_layer = TensorProductConvLayer(**parameters)
- lig_to_rec_conv_layers.append(lig_to_rec_layer)
- rec_to_lig_layer = TensorProductConvLayer(**parameters)
- rec_to_lig_conv_layers.append(rec_to_lig_layer)
-
- self.lig_conv_layers = nn.ModuleList(lig_conv_layers)
- self.rec_conv_layers = nn.ModuleList(rec_conv_layers)
- self.lig_to_rec_conv_layers = nn.ModuleList(lig_to_rec_conv_layers)
- self.rec_to_lig_conv_layers = nn.ModuleList(rec_to_lig_conv_layers)
-
- if self.confidence_mode:
- self.confidence_predictor = nn.Sequential(
- nn.Linear(2*self.ns if num_conv_layers >= 3 else self.ns,ns),
- nn.BatchNorm1d(ns) if not confidence_no_batchnorm else nn.Identity(),
- nn.ReLU(),
- nn.Dropout(confidence_dropout),
- nn.Linear(ns, ns),
- nn.BatchNorm1d(ns) if not confidence_no_batchnorm else nn.Identity(),
- nn.ReLU(),
- nn.Dropout(confidence_dropout),
- nn.Linear(ns, num_confidence_outputs)
- )
- else:
- # center of mass translation and rotation components
- self.center_distance_expansion = GaussianSmearing(0.0, center_max_distance, distance_embed_dim)
- self.center_edge_embedding = nn.Sequential(
- nn.Linear(distance_embed_dim + sigma_embed_dim, ns),
- nn.ReLU(),
- nn.Dropout(dropout),
- nn.Linear(ns, ns)
- )
-
- self.final_conv = TensorProductConvLayer(
- in_irreps=self.lig_conv_layers[-1].out_irreps,
- sh_irreps=self.sh_irreps,
- out_irreps=f'2x1o + 2x1e',
- n_edge_features=2 * ns,
- residual=False,
- dropout=dropout,
- batch_norm=batch_norm
- )
- self.tr_final_layer = nn.Sequential(nn.Linear(1 + sigma_embed_dim, ns),nn.Dropout(dropout), nn.ReLU(), nn.Linear(ns, 1))
- self.rot_final_layer = nn.Sequential(nn.Linear(1 + sigma_embed_dim, ns),nn.Dropout(dropout), nn.ReLU(), nn.Linear(ns, 1))
-
- if not no_torsion:
- # torsion angles components
- self.final_edge_embedding = nn.Sequential(
- nn.Linear(distance_embed_dim, ns),
- nn.ReLU(),
- nn.Dropout(dropout),
- nn.Linear(ns, ns)
- )
- self.final_tp_tor = o3.FullTensorProduct(self.sh_irreps, "2e")
- self.tor_bond_conv = TensorProductConvLayer(
- in_irreps=self.lig_conv_layers[-1].out_irreps,
- sh_irreps=self.final_tp_tor.irreps_out,
- out_irreps=f'{ns}x0o + {ns}x0e',
- n_edge_features=3 * ns,
- residual=False,
- dropout=dropout,
- batch_norm=batch_norm
- )
- self.tor_final_layer = nn.Sequential(
- nn.Linear(2 * ns, ns, bias=False),
- nn.Tanh(),
- nn.Dropout(dropout),
- nn.Linear(ns, 1, bias=False)
- )
-
- def forward(self, data):
- if not self.confidence_mode:
- tr_sigma, rot_sigma, tor_sigma = self.t_to_sigma(*[data.complex_t[noise_type] for noise_type in ['tr', 'rot', 'tor']])
- else:
- tr_sigma, rot_sigma, tor_sigma = [data.complex_t[noise_type] for noise_type in ['tr', 'rot', 'tor']]
-
- # build ligand graph
- lig_node_attr, lig_edge_index, lig_edge_attr, lig_edge_sh = self.build_lig_conv_graph(data)
- lig_src, lig_dst = lig_edge_index
- lig_node_attr = self.lig_node_embedding(lig_node_attr)
- lig_edge_attr = self.lig_edge_embedding(lig_edge_attr)
-
- # build receptor graph
- rec_node_attr, rec_edge_index, rec_edge_attr, rec_edge_sh = self.build_rec_conv_graph(data)
- rec_src, rec_dst = rec_edge_index
- rec_node_attr = self.rec_node_embedding(rec_node_attr)
- rec_edge_attr = self.rec_edge_embedding(rec_edge_attr)
-
- # build cross graph
- if self.dynamic_max_cross:
- cross_cutoff = (tr_sigma * 3 + 20).unsqueeze(1)
- else:
- cross_cutoff = self.cross_max_distance
- cross_edge_index, cross_edge_attr, cross_edge_sh = self.build_cross_conv_graph(data, cross_cutoff)
- cross_lig, cross_rec = cross_edge_index
- cross_edge_attr = self.cross_edge_embedding(cross_edge_attr)
-
- for l in range(len(self.lig_conv_layers)):
- # intra graph message passing
- lig_edge_attr_ = torch.cat([lig_edge_attr, lig_node_attr[lig_src, :self.ns], lig_node_attr[lig_dst, :self.ns]], -1)
- lig_intra_update = self.lig_conv_layers[l](lig_node_attr, lig_edge_index, lig_edge_attr_, lig_edge_sh)
-
- # inter graph message passing
- rec_to_lig_edge_attr_ = torch.cat([cross_edge_attr, lig_node_attr[cross_lig, :self.ns], rec_node_attr[cross_rec, :self.ns]], -1)
- lig_inter_update = self.rec_to_lig_conv_layers[l](rec_node_attr, cross_edge_index, rec_to_lig_edge_attr_, cross_edge_sh,
- out_nodes=lig_node_attr.shape[0])
-
- if l != len(self.lig_conv_layers) - 1:
- rec_edge_attr_ = torch.cat([rec_edge_attr, rec_node_attr[rec_src, :self.ns], rec_node_attr[rec_dst, :self.ns]], -1)
- rec_intra_update = self.rec_conv_layers[l](rec_node_attr, rec_edge_index, rec_edge_attr_, rec_edge_sh)
-
- lig_to_rec_edge_attr_ = torch.cat([cross_edge_attr, lig_node_attr[cross_lig, :self.ns], rec_node_attr[cross_rec, :self.ns]], -1)
- rec_inter_update = self.lig_to_rec_conv_layers[l](lig_node_attr, torch.flip(cross_edge_index, dims=[0]), lig_to_rec_edge_attr_,
- cross_edge_sh, out_nodes=rec_node_attr.shape[0])
-
- # padding original features
- lig_node_attr = F.pad(lig_node_attr, (0, lig_intra_update.shape[-1] - lig_node_attr.shape[-1]))
-
- # update features with residual updates
- lig_node_attr = lig_node_attr + lig_intra_update + lig_inter_update
-
- if l != len(self.lig_conv_layers) - 1:
- rec_node_attr = F.pad(rec_node_attr, (0, rec_intra_update.shape[-1] - rec_node_attr.shape[-1]))
- rec_node_attr = rec_node_attr + rec_intra_update + rec_inter_update
-
- # compute confidence score
- if self.confidence_mode:
- scalar_lig_attr = torch.cat([lig_node_attr[:,:self.ns],lig_node_attr[:,-self.ns:] ], dim=1) if self.num_conv_layers >= 3 else lig_node_attr[:,:self.ns]
- confidence = self.confidence_predictor(scatter_mean(scalar_lig_attr, data['ligand'].batch, dim=0)).squeeze(dim=-1)
- return confidence
-
- # compute translational and rotational score vectors
- center_edge_index, center_edge_attr, center_edge_sh = self.build_center_conv_graph(data)
- center_edge_attr = self.center_edge_embedding(center_edge_attr)
- center_edge_attr = torch.cat([center_edge_attr, lig_node_attr[center_edge_index[0], :self.ns]], -1)
- global_pred = self.final_conv(lig_node_attr, center_edge_index, center_edge_attr, center_edge_sh, out_nodes=data.num_graphs)
-
- tr_pred = global_pred[:, :3] + global_pred[:, 6:9]
- rot_pred = global_pred[:, 3:6] + global_pred[:, 9:]
- data.graph_sigma_emb = self.timestep_emb_func(data.complex_t['tr'])
-
- # fix the magnitude of translational and rotational score vectors
- tr_norm = torch.linalg.vector_norm(tr_pred, dim=1).unsqueeze(1)
- tr_pred = tr_pred / tr_norm * self.tr_final_layer(torch.cat([tr_norm, data.graph_sigma_emb], dim=1))
- rot_norm = torch.linalg.vector_norm(rot_pred, dim=1).unsqueeze(1)
- rot_pred = rot_pred / rot_norm * self.rot_final_layer(torch.cat([rot_norm, data.graph_sigma_emb], dim=1))
-
- if self.scale_by_sigma:
- tr_pred = tr_pred / tr_sigma.unsqueeze(1)
- rot_pred = rot_pred * so3.score_norm(rot_sigma.cpu()).unsqueeze(1).to(data['ligand'].x.device)
-
- if self.no_torsion or data['ligand'].edge_mask.sum() == 0: return tr_pred, rot_pred, torch.empty(0, device=self.device)
-
- # torsional components
- tor_bonds, tor_edge_index, tor_edge_attr, tor_edge_sh = self.build_bond_conv_graph(data)
- tor_bond_vec = data['ligand'].pos[tor_bonds[1]] - data['ligand'].pos[tor_bonds[0]]
- tor_bond_attr = lig_node_attr[tor_bonds[0]] + lig_node_attr[tor_bonds[1]]
-
- tor_bonds_sh = o3.spherical_harmonics("2e", tor_bond_vec, normalize=True, normalization='component')
- tor_edge_sh = self.final_tp_tor(tor_edge_sh, tor_bonds_sh[tor_edge_index[0]])
-
- tor_edge_attr = torch.cat([tor_edge_attr, lig_node_attr[tor_edge_index[1], :self.ns],
- tor_bond_attr[tor_edge_index[0], :self.ns]], -1)
- tor_pred = self.tor_bond_conv(lig_node_attr, tor_edge_index, tor_edge_attr, tor_edge_sh,
- out_nodes=data['ligand'].edge_mask.sum(), reduce='mean')
- tor_pred = self.tor_final_layer(tor_pred).squeeze(1)
- edge_sigma = tor_sigma[data['ligand'].batch][data['ligand', 'ligand'].edge_index[0]][data['ligand'].edge_mask]
-
- if self.scale_by_sigma:
- tor_pred = tor_pred * torch.sqrt(torch.tensor(torus.score_norm(edge_sigma.cpu().numpy())).float()
- .to(data['ligand'].x.device))
- return tr_pred, rot_pred, tor_pred
-
- def build_lig_conv_graph(self, data):
- # builds the ligand graph edges and initial node and edge features
- data['ligand'].node_sigma_emb = self.timestep_emb_func(data['ligand'].node_t['tr'])
-
- # compute edges
- radius_edges = radius_graph(data['ligand'].pos, self.lig_max_radius, data['ligand'].batch)
- edge_index = torch.cat([data['ligand', 'ligand'].edge_index, radius_edges], 1).long()
- edge_attr = torch.cat([
- data['ligand', 'ligand'].edge_attr,
- torch.zeros(radius_edges.shape[-1], self.in_lig_edge_features, device=data['ligand'].x.device)
- ], 0)
-
- # compute initial features
- edge_sigma_emb = data['ligand'].node_sigma_emb[edge_index[0].long()]
- edge_attr = torch.cat([edge_attr, edge_sigma_emb], 1)
- node_attr = torch.cat([data['ligand'].x, data['ligand'].node_sigma_emb], 1)
-
- src, dst = edge_index
- edge_vec = data['ligand'].pos[dst.long()] - data['ligand'].pos[src.long()]
- edge_length_emb = self.lig_distance_expansion(edge_vec.norm(dim=-1))
-
- edge_attr = torch.cat([edge_attr, edge_length_emb], 1)
- edge_sh = o3.spherical_harmonics(self.sh_irreps, edge_vec, normalize=True, normalization='component')
-
- return node_attr, edge_index, edge_attr, edge_sh
-
- def build_rec_conv_graph(self, data):
- # builds the receptor initial node and edge embeddings
- data['receptor'].node_sigma_emb = self.timestep_emb_func(data['receptor'].node_t['tr']) # tr rot and tor noise is all the same
- node_attr = torch.cat([data['receptor'].x, data['receptor'].node_sigma_emb], 1)
-
- # this assumes the edges were already created in preprocessing since protein's structure is fixed
- edge_index = data['receptor', 'receptor'].edge_index
- src, dst = edge_index
- edge_vec = data['receptor'].pos[dst.long()] - data['receptor'].pos[src.long()]
-
- edge_length_emb = self.rec_distance_expansion(edge_vec.norm(dim=-1))
- edge_sigma_emb = data['receptor'].node_sigma_emb[edge_index[0].long()]
- edge_attr = torch.cat([edge_sigma_emb, edge_length_emb], 1)
- edge_sh = o3.spherical_harmonics(self.sh_irreps, edge_vec, normalize=True, normalization='component')
-
- return node_attr, edge_index, edge_attr, edge_sh
-
- def build_cross_conv_graph(self, data, cross_distance_cutoff):
- # builds the cross edges between ligand and receptor
- if torch.is_tensor(cross_distance_cutoff):
- # different cutoff for every graph (depends on the diffusion time)
- edge_index = radius(data['receptor'].pos / cross_distance_cutoff[data['receptor'].batch],
- data['ligand'].pos / cross_distance_cutoff[data['ligand'].batch], 1,
- data['receptor'].batch, data['ligand'].batch, max_num_neighbors=10000)
- else:
- edge_index = radius(data['receptor'].pos, data['ligand'].pos, cross_distance_cutoff,
- data['receptor'].batch, data['ligand'].batch, max_num_neighbors=10000)
-
- src, dst = edge_index
- edge_vec = data['receptor'].pos[dst.long()] - data['ligand'].pos[src.long()]
-
- edge_length_emb = self.cross_distance_expansion(edge_vec.norm(dim=-1))
- edge_sigma_emb = data['ligand'].node_sigma_emb[src.long()]
- edge_attr = torch.cat([edge_sigma_emb, edge_length_emb], 1)
- edge_sh = o3.spherical_harmonics(self.sh_irreps, edge_vec, normalize=True, normalization='component')
-
- return edge_index, edge_attr, edge_sh
-
- def build_center_conv_graph(self, data):
- # builds the filter and edges for the convolution generating translational and rotational scores
- edge_index = torch.cat([data['ligand'].batch.unsqueeze(0), torch.arange(len(data['ligand'].batch)).to(data['ligand'].x.device).unsqueeze(0)], dim=0)
-
- center_pos, count = torch.zeros((data.num_graphs, 3)).to(data['ligand'].x.device), torch.zeros((data.num_graphs, 3)).to(data['ligand'].x.device)
- center_pos.index_add_(0, index=data['ligand'].batch, source=data['ligand'].pos)
- center_pos = center_pos / torch.bincount(data['ligand'].batch).unsqueeze(1)
-
- edge_vec = data['ligand'].pos[edge_index[1]] - center_pos[edge_index[0]]
- edge_attr = self.center_distance_expansion(edge_vec.norm(dim=-1))
- edge_sigma_emb = data['ligand'].node_sigma_emb[edge_index[1].long()]
- edge_attr = torch.cat([edge_attr, edge_sigma_emb], 1)
- edge_sh = o3.spherical_harmonics(self.sh_irreps, edge_vec, normalize=True, normalization='component')
- return edge_index, edge_attr, edge_sh
-
- def build_bond_conv_graph(self, data):
- # builds the graph for the convolution between the center of the rotatable bonds and the neighbouring nodes
- bonds = data['ligand', 'ligand'].edge_index[:, data['ligand'].edge_mask].long()
- bond_pos = (data['ligand'].pos[bonds[0]] + data['ligand'].pos[bonds[1]]) / 2
- bond_batch = data['ligand'].batch[bonds[0]]
- edge_index = radius(data['ligand'].pos, bond_pos, self.lig_max_radius, batch_x=data['ligand'].batch, batch_y=bond_batch)
-
- edge_vec = data['ligand'].pos[edge_index[1]] - bond_pos[edge_index[0]]
- edge_attr = self.lig_distance_expansion(edge_vec.norm(dim=-1))
-
- edge_attr = self.final_edge_embedding(edge_attr)
- edge_sh = o3.spherical_harmonics(self.sh_irreps, edge_vec, normalize=True, normalization='component')
-
- return bonds, edge_index, edge_attr, edge_sh
-
-
-class GaussianSmearing(torch.nn.Module):
- # used to embed the edge distances
- def __init__(self, start=0.0, stop=5.0, num_gaussians=50):
- super().__init__()
- offset = torch.linspace(start, stop, num_gaussians)
- self.coeff = -0.5 / (offset[1] - offset[0]).item() ** 2
- self.register_buffer('offset', offset)
-
- def forward(self, dist):
- dist = dist.view(-1, 1) - self.offset.view(1, -1)
- return torch.exp(self.coeff * torch.pow(dist, 2))
diff --git a/spaces/sino72/Passenger_Reconization/deep_sort/utils/asserts.py b/spaces/sino72/Passenger_Reconization/deep_sort/utils/asserts.py
deleted file mode 100644
index 59a73cc04025762d6490fcd2945a747d963def32..0000000000000000000000000000000000000000
--- a/spaces/sino72/Passenger_Reconization/deep_sort/utils/asserts.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from os import environ
-
-
-def assert_in(file, files_to_check):
- if file not in files_to_check:
- raise AssertionError("{} does not exist in the list".format(str(file)))
- return True
-
-
-def assert_in_env(check_list: list):
- for item in check_list:
- assert_in(item, environ.keys())
- return True
diff --git a/spaces/skf15963/summary/fengshen/examples/clue1.1/predict2submit/tnews_submit.py b/spaces/skf15963/summary/fengshen/examples/clue1.1/predict2submit/tnews_submit.py
deleted file mode 100644
index eada0476b270624af8c397afb7df70e4e24473b3..0000000000000000000000000000000000000000
--- a/spaces/skf15963/summary/fengshen/examples/clue1.1/predict2submit/tnews_submit.py
+++ /dev/null
@@ -1,47 +0,0 @@
-import json
-from tqdm import tqdm
-import argparse
-
-
-def save_data(data,file_path):
- with open(file_path, 'w', encoding='utf8') as f:
- for line in data:
- json_data=json.dumps(line,ensure_ascii=False)
- f.write(json_data+'\n')
-
-def submit(file_path):
- id2label={"故事": "100",
- "文化": "101",
- "娱乐": "102",
- "体育": "103",
- "财经": "104",
- "房产": "106",
- "汽车": "107",
- "教育": "108",
- "科技": "109",
- "军事": "110",
- "旅游": "112",
- "国际": "113",
- "股票": "114",
- "农业": "115",
- "电竞": "116"}
-
- with open(file_path, 'r', encoding='utf8') as f:
- lines = f.readlines()
- result=[]
- for line in tqdm(lines):
- data = json.loads(line)
- result.append({'id':data['id'],'label':id2label[data['choice'][data['label']]]})
- return result
-
-
-if __name__=="__main__":
- parser = argparse.ArgumentParser(description="train")
- parser.add_argument("--data_path", type=str,default="")
- parser.add_argument("--save_path", type=str,default="")
-
- args = parser.parse_args()
- save_data(submit(args.data_path), args.save_path)
-
-
-
\ No newline at end of file
diff --git a/spaces/skf15963/summary/fengshen/models/deltalm/tokenizer_deltalm.py b/spaces/skf15963/summary/fengshen/models/deltalm/tokenizer_deltalm.py
deleted file mode 100644
index dcc81acffeb15bea28c0dd5bb10287fc897cd55d..0000000000000000000000000000000000000000
--- a/spaces/skf15963/summary/fengshen/models/deltalm/tokenizer_deltalm.py
+++ /dev/null
@@ -1,323 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-import os
-import re
-import warnings
-from shutil import copyfile
-from typing import Any, Dict, List, Optional, Tuple
-
-import sentencepiece as spm
-
-from transformers.tokenization_utils import PreTrainedTokenizer
-from transformers.utils import logging
-
-
-SPIECE_UNDERLINE = "▁"
-
-VOCAB_FILES_NAMES = {"vocab_file": "spm.model"}
-
-PRETRAINED_VOCAB_FILES_MAP = {
- "vocab_file": {"IDEA-CCNL/deltalm": "https://huggingface.co/IDEA-CCNL/Randeng-Deltalm-362M-En-Zn/resolve/main/spm.model"}
-}
-
-PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES = {
- "IDEA-CCNL/deltalm": 512,
-}
-
-
-logger = logging.get_logger(__name__)
-
-
-class DeltalmTokenizer(PreTrainedTokenizer):
- """
- Construct a T5 tokenizer. Based on [SentencePiece](https://github.com/google/sentencepiece).
- This tokenizer inherits from [`PreTrainedTokenizer`] which contains most of the main methods. Users should refer to
- this superclass for more information regarding those methods.
- Args:
- vocab_file (`str`):
- [SentencePiece](https://github.com/google/sentencepiece) file (generally has a *.spm* extension) that
- contains the vocabulary necessary to instantiate a tokenizer.
- eos_token (`str`, *optional*, defaults to `""`):
- The end of sequence token.
-
- When building a sequence using special tokens, this is not the token that is used for the end of sequence.
- The token used is the `sep_token`.
-
- unk_token (`str`, *optional*, defaults to `""`):
- The unknown token. A token that is not in the vocabulary cannot be converted to an ID and is set to be this
- token instead.
- pad_token (`str`, *optional*, defaults to `" 
-
-
-
- 
-
-
diff --git a/spaces/Amrrs/DragGan-Inversion/PTI/configs/evaluation_config.py b/spaces/Amrrs/DragGan-Inversion/PTI/configs/evaluation_config.py
deleted file mode 100644
index 16b621d4a47df9e25828c4235cf1692899d14d50..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/PTI/configs/evaluation_config.py
+++ /dev/null
@@ -1 +0,0 @@
-evaluated_methods = ['e4e', 'SG2', 'SG2Plus']
\ No newline at end of file
diff --git a/spaces/Amrrs/DragGan-Inversion/training/__init__.py b/spaces/Amrrs/DragGan-Inversion/training/__init__.py
deleted file mode 100644
index 939e7c6c8f94c4ea1141885c3c3295fe083b06aa..0000000000000000000000000000000000000000
--- a/spaces/Amrrs/DragGan-Inversion/training/__init__.py
+++ /dev/null
@@ -1,9 +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.
-
-# empty
diff --git a/spaces/Andy1621/uniformer_image_detection/mmdet/models/utils/transformer.py b/spaces/Andy1621/uniformer_image_detection/mmdet/models/utils/transformer.py
deleted file mode 100644
index 83870eead42f4b0bf73c9e19248d5512d3d044c5..0000000000000000000000000000000000000000
--- a/spaces/Andy1621/uniformer_image_detection/mmdet/models/utils/transformer.py
+++ /dev/null
@@ -1,860 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import (Linear, build_activation_layer, build_norm_layer,
- xavier_init)
-
-from .builder import TRANSFORMER
-
-
-class MultiheadAttention(nn.Module):
- """A warpper for torch.nn.MultiheadAttention.
-
- This module implements MultiheadAttention with residual connection,
- and positional encoding used in DETR is also passed as input.
-
- Args:
- embed_dims (int): The embedding dimension.
- num_heads (int): Parallel attention heads. Same as
- `nn.MultiheadAttention`.
- dropout (float): A Dropout layer on attn_output_weights. Default 0.0.
- """
-
- def __init__(self, embed_dims, num_heads, dropout=0.0):
- super(MultiheadAttention, self).__init__()
- assert embed_dims % num_heads == 0, 'embed_dims must be ' \
- f'divisible by num_heads. got {embed_dims} and {num_heads}.'
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.dropout = dropout
- self.attn = nn.MultiheadAttention(embed_dims, num_heads, dropout)
- self.dropout = nn.Dropout(dropout)
-
- def forward(self,
- x,
- key=None,
- value=None,
- residual=None,
- query_pos=None,
- key_pos=None,
- attn_mask=None,
- key_padding_mask=None):
- """Forward function for `MultiheadAttention`.
-
- Args:
- x (Tensor): The input query with shape [num_query, bs,
- embed_dims]. Same in `nn.MultiheadAttention.forward`.
- key (Tensor): The key tensor with shape [num_key, bs,
- embed_dims]. Same in `nn.MultiheadAttention.forward`.
- Default None. If None, the `query` will be used.
- value (Tensor): The value tensor with same shape as `key`.
- Same in `nn.MultiheadAttention.forward`. Default None.
- If None, the `key` will be used.
- residual (Tensor): The tensor used for addition, with the
- same shape as `x`. Default None. If None, `x` will be used.
- query_pos (Tensor): The positional encoding for query, with
- the same shape as `x`. Default None. If not None, it will
- be added to `x` before forward function.
- key_pos (Tensor): The positional encoding for `key`, with the
- same shape as `key`. Default 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`.
- attn_mask (Tensor): ByteTensor mask with shape [num_query,
- num_key]. Same in `nn.MultiheadAttention.forward`.
- Default None.
- key_padding_mask (Tensor): ByteTensor with shape [bs, num_key].
- Same in `nn.MultiheadAttention.forward`. Default None.
-
- Returns:
- Tensor: forwarded results with shape [num_query, bs, embed_dims].
- """
- query = x
- if key is None:
- key = query
- if value is None:
- value = key
- if residual is None:
- residual = x
- if key_pos is None:
- if query_pos is not None and key is not None:
- if query_pos.shape == key.shape:
- key_pos = query_pos
- if query_pos is not None:
- query = query + query_pos
- if key_pos is not None:
- key = key + key_pos
- out = self.attn(
- query,
- key,
- value=value,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask)[0]
-
- return residual + self.dropout(out)
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(embed_dims={self.embed_dims}, '
- repr_str += f'num_heads={self.num_heads}, '
- repr_str += f'dropout={self.dropout})'
- return repr_str
-
-
-class FFN(nn.Module):
- """Implements feed-forward networks (FFNs) with residual connection.
-
- Args:
- embed_dims (int): The feature dimension. Same as
- `MultiheadAttention`.
- feedforward_channels (int): The hidden dimension of FFNs.
- num_fcs (int, optional): The number of fully-connected layers in
- FFNs. Defaults to 2.
- act_cfg (dict, optional): The activation config for FFNs.
- dropout (float, optional): Probability of an element to be
- zeroed. Default 0.0.
- add_residual (bool, optional): Add resudual connection.
- Defaults to True.
- """
-
- def __init__(self,
- embed_dims,
- feedforward_channels,
- num_fcs=2,
- act_cfg=dict(type='ReLU', inplace=True),
- dropout=0.0,
- add_residual=True):
- super(FFN, self).__init__()
- 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.dropout = dropout
- self.activate = build_activation_layer(act_cfg)
-
- layers = nn.ModuleList()
- in_channels = embed_dims
- for _ in range(num_fcs - 1):
- layers.append(
- nn.Sequential(
- Linear(in_channels, feedforward_channels), self.activate,
- nn.Dropout(dropout)))
- in_channels = feedforward_channels
- layers.append(Linear(feedforward_channels, embed_dims))
- self.layers = nn.Sequential(*layers)
- self.dropout = nn.Dropout(dropout)
- self.add_residual = add_residual
-
- def forward(self, x, residual=None):
- """Forward function for `FFN`."""
- out = self.layers(x)
- if not self.add_residual:
- return out
- if residual is None:
- residual = x
- return residual + self.dropout(out)
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(embed_dims={self.embed_dims}, '
- repr_str += f'feedforward_channels={self.feedforward_channels}, '
- repr_str += f'num_fcs={self.num_fcs}, '
- repr_str += f'act_cfg={self.act_cfg}, '
- repr_str += f'dropout={self.dropout}, '
- repr_str += f'add_residual={self.add_residual})'
- return repr_str
-
-
-class TransformerEncoderLayer(nn.Module):
- """Implements one encoder layer in DETR transformer.
-
- Args:
- embed_dims (int): The feature dimension. Same as `FFN`.
- num_heads (int): Parallel attention heads.
- feedforward_channels (int): The hidden dimension for FFNs.
- dropout (float): Probability of an element to be zeroed. Default 0.0.
- order (tuple[str]): The order for encoder layer. Valid examples are
- ('selfattn', 'norm', 'ffn', 'norm') and ('norm', 'selfattn',
- 'norm', 'ffn'). Default ('selfattn', 'norm', 'ffn', 'norm').
- act_cfg (dict): The activation config for FFNs. Default ReLU.
- norm_cfg (dict): Config dict for normalization layer. Default
- layer normalization.
- num_fcs (int): The number of fully-connected layers for FFNs.
- Default 2.
- """
-
- def __init__(self,
- embed_dims,
- num_heads,
- feedforward_channels,
- dropout=0.0,
- order=('selfattn', 'norm', 'ffn', 'norm'),
- act_cfg=dict(type='ReLU', inplace=True),
- norm_cfg=dict(type='LN'),
- num_fcs=2):
- super(TransformerEncoderLayer, self).__init__()
- assert isinstance(order, tuple) and len(order) == 4
- assert set(order) == set(['selfattn', 'norm', 'ffn'])
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.feedforward_channels = feedforward_channels
- self.dropout = dropout
- self.order = order
- self.act_cfg = act_cfg
- self.norm_cfg = norm_cfg
- self.num_fcs = num_fcs
- self.pre_norm = order[0] == 'norm'
- self.self_attn = MultiheadAttention(embed_dims, num_heads, dropout)
- self.ffn = FFN(embed_dims, feedforward_channels, num_fcs, act_cfg,
- dropout)
- self.norms = nn.ModuleList()
- self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
- self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
-
- def forward(self, x, pos=None, attn_mask=None, key_padding_mask=None):
- """Forward function for `TransformerEncoderLayer`.
-
- Args:
- x (Tensor): The input query with shape [num_key, bs,
- embed_dims]. Same in `MultiheadAttention.forward`.
- pos (Tensor): The positional encoding for query. Default None.
- Same as `query_pos` in `MultiheadAttention.forward`.
- attn_mask (Tensor): ByteTensor mask with shape [num_key,
- num_key]. Same in `MultiheadAttention.forward`. Default None.
- key_padding_mask (Tensor): ByteTensor with shape [bs, num_key].
- Same in `MultiheadAttention.forward`. Default None.
-
- Returns:
- Tensor: forwarded results with shape [num_key, bs, embed_dims].
- """
- norm_cnt = 0
- inp_residual = x
- for layer in self.order:
- if layer == 'selfattn':
- # self attention
- query = key = value = x
- x = self.self_attn(
- query,
- key,
- value,
- inp_residual if self.pre_norm else None,
- query_pos=pos,
- key_pos=pos,
- attn_mask=attn_mask,
- key_padding_mask=key_padding_mask)
- inp_residual = x
- elif layer == 'norm':
- x = self.norms[norm_cnt](x)
- norm_cnt += 1
- elif layer == 'ffn':
- x = self.ffn(x, inp_residual if self.pre_norm else None)
- return x
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(embed_dims={self.embed_dims}, '
- repr_str += f'num_heads={self.num_heads}, '
- repr_str += f'feedforward_channels={self.feedforward_channels}, '
- repr_str += f'dropout={self.dropout}, '
- repr_str += f'order={self.order}, '
- repr_str += f'act_cfg={self.act_cfg}, '
- repr_str += f'norm_cfg={self.norm_cfg}, '
- repr_str += f'num_fcs={self.num_fcs})'
- return repr_str
-
-
-class TransformerDecoderLayer(nn.Module):
- """Implements one decoder layer in DETR transformer.
-
- Args:
- embed_dims (int): The feature dimension. Same as
- `TransformerEncoderLayer`.
- num_heads (int): Parallel attention heads.
- feedforward_channels (int): Same as `TransformerEncoderLayer`.
- dropout (float): Same as `TransformerEncoderLayer`. Default 0.0.
- order (tuple[str]): The order for decoder layer. Valid examples are
- ('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn', 'norm') and
- ('norm', 'selfattn', 'norm', 'multiheadattn', 'norm', 'ffn').
- Default the former.
- act_cfg (dict): Same as `TransformerEncoderLayer`. Default ReLU.
- norm_cfg (dict): Config dict for normalization layer. Default
- layer normalization.
- num_fcs (int): The number of fully-connected layers in FFNs.
- """
-
- def __init__(self,
- embed_dims,
- num_heads,
- feedforward_channels,
- dropout=0.0,
- order=('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn',
- 'norm'),
- act_cfg=dict(type='ReLU', inplace=True),
- norm_cfg=dict(type='LN'),
- num_fcs=2):
- super(TransformerDecoderLayer, self).__init__()
- assert isinstance(order, tuple) and len(order) == 6
- assert set(order) == set(['selfattn', 'norm', 'multiheadattn', 'ffn'])
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.feedforward_channels = feedforward_channels
- self.dropout = dropout
- self.order = order
- self.act_cfg = act_cfg
- self.norm_cfg = norm_cfg
- self.num_fcs = num_fcs
- self.pre_norm = order[0] == 'norm'
- self.self_attn = MultiheadAttention(embed_dims, num_heads, dropout)
- self.multihead_attn = MultiheadAttention(embed_dims, num_heads,
- dropout)
- self.ffn = FFN(embed_dims, feedforward_channels, num_fcs, act_cfg,
- dropout)
- self.norms = nn.ModuleList()
- # 3 norm layers in official DETR's TransformerDecoderLayer
- for _ in range(3):
- self.norms.append(build_norm_layer(norm_cfg, embed_dims)[1])
-
- def forward(self,
- x,
- memory,
- memory_pos=None,
- query_pos=None,
- memory_attn_mask=None,
- target_attn_mask=None,
- memory_key_padding_mask=None,
- target_key_padding_mask=None):
- """Forward function for `TransformerDecoderLayer`.
-
- Args:
- x (Tensor): Input query with shape [num_query, bs, embed_dims].
- memory (Tensor): Tensor got from `TransformerEncoder`, with shape
- [num_key, bs, embed_dims].
- memory_pos (Tensor): The positional encoding for `memory`. Default
- None. Same as `key_pos` in `MultiheadAttention.forward`.
- query_pos (Tensor): The positional encoding for `query`. Default
- None. Same as `query_pos` in `MultiheadAttention.forward`.
- memory_attn_mask (Tensor): ByteTensor mask for `memory`, with
- shape [num_key, num_key]. Same as `attn_mask` in
- `MultiheadAttention.forward`. Default None.
- target_attn_mask (Tensor): ByteTensor mask for `x`, with shape
- [num_query, num_query]. Same as `attn_mask` in
- `MultiheadAttention.forward`. Default None.
- memory_key_padding_mask (Tensor): ByteTensor for `memory`, with
- shape [bs, num_key]. Same as `key_padding_mask` in
- `MultiheadAttention.forward`. Default None.
- target_key_padding_mask (Tensor): ByteTensor for `x`, with shape
- [bs, num_query]. Same as `key_padding_mask` in
- `MultiheadAttention.forward`. Default None.
-
- Returns:
- Tensor: forwarded results with shape [num_query, bs, embed_dims].
- """
- norm_cnt = 0
- inp_residual = x
- for layer in self.order:
- if layer == 'selfattn':
- query = key = value = x
- x = self.self_attn(
- query,
- key,
- value,
- inp_residual if self.pre_norm else None,
- query_pos,
- key_pos=query_pos,
- attn_mask=target_attn_mask,
- key_padding_mask=target_key_padding_mask)
- inp_residual = x
- elif layer == 'norm':
- x = self.norms[norm_cnt](x)
- norm_cnt += 1
- elif layer == 'multiheadattn':
- query = x
- key = value = memory
- x = self.multihead_attn(
- query,
- key,
- value,
- inp_residual if self.pre_norm else None,
- query_pos,
- key_pos=memory_pos,
- attn_mask=memory_attn_mask,
- key_padding_mask=memory_key_padding_mask)
- inp_residual = x
- elif layer == 'ffn':
- x = self.ffn(x, inp_residual if self.pre_norm else None)
- return x
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(embed_dims={self.embed_dims}, '
- repr_str += f'num_heads={self.num_heads}, '
- repr_str += f'feedforward_channels={self.feedforward_channels}, '
- repr_str += f'dropout={self.dropout}, '
- repr_str += f'order={self.order}, '
- repr_str += f'act_cfg={self.act_cfg}, '
- repr_str += f'norm_cfg={self.norm_cfg}, '
- repr_str += f'num_fcs={self.num_fcs})'
- return repr_str
-
-
-class TransformerEncoder(nn.Module):
- """Implements the encoder in DETR transformer.
-
- Args:
- num_layers (int): The number of `TransformerEncoderLayer`.
- embed_dims (int): Same as `TransformerEncoderLayer`.
- num_heads (int): Same as `TransformerEncoderLayer`.
- feedforward_channels (int): Same as `TransformerEncoderLayer`.
- dropout (float): Same as `TransformerEncoderLayer`. Default 0.0.
- order (tuple[str]): Same as `TransformerEncoderLayer`.
- act_cfg (dict): Same as `TransformerEncoderLayer`. Default ReLU.
- norm_cfg (dict): Same as `TransformerEncoderLayer`. Default
- layer normalization.
- num_fcs (int): Same as `TransformerEncoderLayer`. Default 2.
- """
-
- def __init__(self,
- num_layers,
- embed_dims,
- num_heads,
- feedforward_channels,
- dropout=0.0,
- order=('selfattn', 'norm', 'ffn', 'norm'),
- act_cfg=dict(type='ReLU', inplace=True),
- norm_cfg=dict(type='LN'),
- num_fcs=2):
- super(TransformerEncoder, self).__init__()
- assert isinstance(order, tuple) and len(order) == 4
- assert set(order) == set(['selfattn', 'norm', 'ffn'])
- self.num_layers = num_layers
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.feedforward_channels = feedforward_channels
- self.dropout = dropout
- self.order = order
- self.act_cfg = act_cfg
- self.norm_cfg = norm_cfg
- self.num_fcs = num_fcs
- self.pre_norm = order[0] == 'norm'
- self.layers = nn.ModuleList()
- for _ in range(num_layers):
- self.layers.append(
- TransformerEncoderLayer(embed_dims, num_heads,
- feedforward_channels, dropout, order,
- act_cfg, norm_cfg, num_fcs))
- self.norm = build_norm_layer(norm_cfg,
- embed_dims)[1] if self.pre_norm else None
-
- def forward(self, x, pos=None, attn_mask=None, key_padding_mask=None):
- """Forward function for `TransformerEncoder`.
-
- Args:
- x (Tensor): Input query. Same in `TransformerEncoderLayer.forward`.
- pos (Tensor): Positional encoding for query. Default None.
- Same in `TransformerEncoderLayer.forward`.
- attn_mask (Tensor): ByteTensor attention mask. Default None.
- Same in `TransformerEncoderLayer.forward`.
- key_padding_mask (Tensor): Same in
- `TransformerEncoderLayer.forward`. Default None.
-
- Returns:
- Tensor: Results with shape [num_key, bs, embed_dims].
- """
- for layer in self.layers:
- x = layer(x, pos, attn_mask, key_padding_mask)
- if self.norm is not None:
- x = self.norm(x)
- return x
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(num_layers={self.num_layers}, '
- repr_str += f'embed_dims={self.embed_dims}, '
- repr_str += f'num_heads={self.num_heads}, '
- repr_str += f'feedforward_channels={self.feedforward_channels}, '
- repr_str += f'dropout={self.dropout}, '
- repr_str += f'order={self.order}, '
- repr_str += f'act_cfg={self.act_cfg}, '
- repr_str += f'norm_cfg={self.norm_cfg}, '
- repr_str += f'num_fcs={self.num_fcs})'
- return repr_str
-
-
-class TransformerDecoder(nn.Module):
- """Implements the decoder in DETR transformer.
-
- Args:
- num_layers (int): The number of `TransformerDecoderLayer`.
- embed_dims (int): Same as `TransformerDecoderLayer`.
- num_heads (int): Same as `TransformerDecoderLayer`.
- feedforward_channels (int): Same as `TransformerDecoderLayer`.
- dropout (float): Same as `TransformerDecoderLayer`. Default 0.0.
- order (tuple[str]): Same as `TransformerDecoderLayer`.
- act_cfg (dict): Same as `TransformerDecoderLayer`. Default ReLU.
- norm_cfg (dict): Same as `TransformerDecoderLayer`. Default
- layer normalization.
- num_fcs (int): Same as `TransformerDecoderLayer`. Default 2.
- """
-
- def __init__(self,
- num_layers,
- embed_dims,
- num_heads,
- feedforward_channels,
- dropout=0.0,
- order=('selfattn', 'norm', 'multiheadattn', 'norm', 'ffn',
- 'norm'),
- act_cfg=dict(type='ReLU', inplace=True),
- norm_cfg=dict(type='LN'),
- num_fcs=2,
- return_intermediate=False):
- super(TransformerDecoder, self).__init__()
- assert isinstance(order, tuple) and len(order) == 6
- assert set(order) == set(['selfattn', 'norm', 'multiheadattn', 'ffn'])
- self.num_layers = num_layers
- self.embed_dims = embed_dims
- self.num_heads = num_heads
- self.feedforward_channels = feedforward_channels
- self.dropout = dropout
- self.order = order
- self.act_cfg = act_cfg
- self.norm_cfg = norm_cfg
- self.num_fcs = num_fcs
- self.return_intermediate = return_intermediate
- self.layers = nn.ModuleList()
- for _ in range(num_layers):
- self.layers.append(
- TransformerDecoderLayer(embed_dims, num_heads,
- feedforward_channels, dropout, order,
- act_cfg, norm_cfg, num_fcs))
- self.norm = build_norm_layer(norm_cfg, embed_dims)[1]
-
- def forward(self,
- x,
- memory,
- memory_pos=None,
- query_pos=None,
- memory_attn_mask=None,
- target_attn_mask=None,
- memory_key_padding_mask=None,
- target_key_padding_mask=None):
- """Forward function for `TransformerDecoder`.
-
- Args:
- x (Tensor): Input query. Same in `TransformerDecoderLayer.forward`.
- memory (Tensor): Same in `TransformerDecoderLayer.forward`.
- memory_pos (Tensor): Same in `TransformerDecoderLayer.forward`.
- Default None.
- query_pos (Tensor): Same in `TransformerDecoderLayer.forward`.
- Default None.
- memory_attn_mask (Tensor): Same in
- `TransformerDecoderLayer.forward`. Default None.
- target_attn_mask (Tensor): Same in
- `TransformerDecoderLayer.forward`. Default None.
- memory_key_padding_mask (Tensor): Same in
- `TransformerDecoderLayer.forward`. Default None.
- target_key_padding_mask (Tensor): Same in
- `TransformerDecoderLayer.forward`. Default None.
-
- Returns:
- Tensor: Results with shape [num_query, bs, embed_dims].
- """
- intermediate = []
- for layer in self.layers:
- x = layer(x, memory, memory_pos, query_pos, memory_attn_mask,
- target_attn_mask, memory_key_padding_mask,
- target_key_padding_mask)
- if self.return_intermediate:
- intermediate.append(self.norm(x))
- if self.norm is not None:
- x = self.norm(x)
- if self.return_intermediate:
- intermediate.pop()
- intermediate.append(x)
- if self.return_intermediate:
- return torch.stack(intermediate)
- return x.unsqueeze(0)
-
- def __repr__(self):
- """str: a string that describes the module"""
- repr_str = self.__class__.__name__
- repr_str += f'(num_layers={self.num_layers}, '
- repr_str += f'embed_dims={self.embed_dims}, '
- repr_str += f'num_heads={self.num_heads}, '
- repr_str += f'feedforward_channels={self.feedforward_channels}, '
- repr_str += f'dropout={self.dropout}, '
- repr_str += f'order={self.order}, '
- repr_str += f'act_cfg={self.act_cfg}, '
- repr_str += f'norm_cfg={self.norm_cfg}, '
- repr_str += f'num_fcs={self.num_fcs}, '
- repr_str += f'return_intermediate={self.return_intermediate})'
- return repr_str
-
-
-@TRANSFORMER.register_module()
-class Transformer(nn.Module):
- """Implements the DETR transformer.
-
- Following the official DETR implementation, this module copy-paste
- from torch.nn.Transformer with modifications:
-
- * positional encodings are passed in MultiheadAttention
- * extra LN at the end of encoder is removed
- * decoder returns a stack of activations from all decoding layers
-
- See `paper: End-to-End Object Detection with Transformers
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
- 
-
-
-
-
-
-## 
-
-## 
- 
- 
-
-
-