Update parquet files (step 29 of 249)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download DIGSI 5 Today and Discover the Benefits of the Versatile Engineering Tool for SIPROTEC 5 Devices.md

@@ -1,28 +0,0 @@
-<br />
-<h1>How to Download and Install DIGSI 5 - The Engineering Software for SIPROTEC 5 Protection Relays</h1>
-<p>DIGSI 5 is a versatile engineering tool for parameterizing, commissioning and operating all SIPROTEC 5 protection devices. It has an innovative user interface that includes context-sensitive user instructions and a simple connection to the device via USB. In this article, we will show you how to download and install DIGSI 5 on your computer.</p>
-<h2>digsi 5 download</h2><br /><p><b><b>Download Zip</b> &#9193; <a href="https://byltly.com/2uKuUI">https://byltly.com/2uKuUI</a></b></p><br /><br />
-<h2>Step 1: Download DIGSI 5</h2>
-<p>You can download the latest version of DIGSI 5 from the Siemens website . There are three options available:</p>
-<ul>
-<li>Trial version: This is a free version of DIGSI 5 Premium that can be used for 30 days without functional restrictions. It includes the latest versions of IEC 61850 System Configurator and SIGRA.</li>
-<li>Update version: This is a software update for existing users of DIGSI 5 who want to upgrade to the latest version. It requires a valid license key.</li>
-<li>Full version: This is a complete installation package for new users of DIGSI 5 who want to install it on a clean system. It also includes a trial version of DIGSI 5 Premium, usable for 30 days without functional restrictions.</li>
-</ul>
-<p>To download DIGSI 5, you need to register or log in with your Siemens account and accept the terms of use. You can also find the product information, manuals, readme files and hotfixes for DIGSI 5 on the same page.</p>
-<h2>Step 2: Install DIGSI 5</h2>
-<p>After downloading the DIGSI 5 package, you need to unzip it and run the setup.exe file. Follow the instructions on the screen to complete the installation process. You may need to restart your computer after the installation.</p>
-<p>If you are installing DIGSI 5 for the first time, you will need to activate it with a license key. You can request a license key from Siemens or use the trial version for 30 days. If you are updating from an earlier version of DIGSI 5, you can use your existing license key.</p>
-<h2>Step 3: Connect and Configure SIPROTEC 5 Devices</h2>
-<p>Once you have installed and activated DIGSI 5, you can connect your SIPROTEC 5 devices to your computer via USB or Ethernet. You can use DIGSI 5 to parameterize, commission and operate your devices easily and efficiently. You can also use the IEC 61850 System Configurator and SIGRA tools to configure and analyze communication networks and data.</p>
-<p>For more information on how to use DIGSI 5, please refer to the manuals  and online help available in the software.</p>
-<p></p><h2>Step 4: Test and Troubleshoot SIPROTEC 5 Devices</h2>
-<p>After configuring your SIPROTEC 5 devices, you can test and troubleshoot them using DIGSI 5. You can use the following features to ensure the proper functioning of your devices:</p>
-<ul>
-<li>Device test: This feature allows you to perform various tests on your devices, such as output test, input test, LED test, display test and communication test. You can also run predefined test cases or create your own test cases.</li>
-<li>Device diagnosis: This feature allows you to monitor the status and performance of your devices, such as voltage, current, power, frequency, temperature and memory usage. You can also view the event logs, fault records and disturbance records of your devices.</li>
-<li>Device simulation: This feature allows you to simulate the behavior of your devices in different scenarios, such as normal operation, fault occurrence and protection tripping. You can also use the SIPROTEC Digital Twin plugin to connect your devices to a virtual power system model and simulate realistic scenarios.</li>
-</ul>
-<p>For more information on how to test and troubleshoot SIPROTEC 5 devices, please refer to the manuals  and online help available in the software.</p> ddb901b051<br />
-<br />
-<br />

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download WinRAR 64 Bit Free Crack and Unleash the Power of RAR.md

@@ -1,25 +0,0 @@
-<br />
-<h1>How to Download WinRAR 64 Bit Free Crack and Use It on Your PC</h1>
-<p>WinRAR is a popular and powerful file compression and archiving software. It can create and extract RAR, ZIP, and other archive formats. It can also split large files into smaller volumes, encrypt and password-protect archives, repair damaged files, and more. WinRAR is widely used by millions of users around the world for various purposes.</p>
-<h2>winrar 64 bit free download with crack</h2><br /><p><b><b>Download File</b> &bull;&bull;&bull; <a href="https://byltly.com/2uKzCf">https://byltly.com/2uKzCf</a></b></p><br /><br />
-<p>However, WinRAR is not a free software. You need to buy a license to use it legally on your PC. The official price of WinRAR is $29 for a single-user license or $21 per user for a multi-user license. These prices can be too high for some users who just want to use WinRAR occasionally or for personal purposes.</p>
-<p>That's why some people look for ways to download WinRAR 64 bit free crack and use it without paying anything. A crack is a software tool that modifies or bypasses the original code of a program to make it work without a license or activation. By using a crack, you can get access to the full features of WinRAR without paying anything.</p>
-<p>But is it safe and legal to download WinRAR 64 bit free crack? How can you do it and what are the risks involved? In this article, we will answer these questions and show you how to download WinRAR 64 bit free crack and use it on your PC.</p>
-<h2>Is It Safe and Legal to Download WinRAR 64 Bit Free Crack?</h2>
-<p>The short answer is no. Downloading WinRAR 64 bit free crack is neither safe nor legal. Here are some reasons why:</p>
-<ul>
-<li>Downloading WinRAR 64 bit free crack is illegal because it violates the terms and conditions of WinRAR. You are not allowed to use WinRAR without a valid license. If you do so, you are committing software piracy, which is a crime that can result in fines or even jail time.</li>
-<li>Downloading WinRAR 64 bit free crack is unsafe because it can expose your PC to malware and viruses. Cracks are often distributed by hackers or malicious websites that can infect your PC with malware and viruses. These can damage your files, steal your personal information, or even take control of your PC.</li>
-<li>Downloading WinRAR 64 bit free crack is unreliable because it can cause errors and glitches. Cracks are not official updates or patches from WinRAR. They are often outdated or incompatible with the latest versions of WinRAR or Windows. This can cause errors and glitches that can affect the performance and functionality of WinRAR.</li>
-<li>Downloading WinRAR 64 bit free crack is unethical because it harms the developers and creators of WinRAR. WinRAR invests a lot of time, money, and resources to develop and improve WinRAR. By using a crack, you are depriving them of their rightful income and recognition.</li>
-</ul>
-<p>Therefore, we do not recommend downloading WinRAR 64 bit free crack and using it on your PC. It is not worth the risk and hassle. Instead, we suggest using one of the legal and safe alternatives that we will discuss in the next section.</p>
-<p></p>
-<h2>How to Download WinRAR 64 Bit Free Crack and Use It on Your PC</h2>
-<p>If you still want to download WinRAR 64 bit free crack and use it on your PC, despite the risks and consequences involved, here are the steps you need to follow:</p>
-<ol>
-<li>Go to a website that offers cracks for WinRAR or other software. There are many websites that claim to offer cracks for WinRAR or other software, but most of them are fake or malicious. You need to be careful and do some research before downloading anything from these websites. Some examples of websites that offer cracks for WinRAR are Yasir252 , Techworm , WizCase , etc.</li>
-<li>Select the version of WinRAR that you want to download. Depending on the website you choose, you may find different versions of WinRAR available for download. For example, you may find WinRAR 6.21, 6.11, 6.02, etc., for Windows 11, 10, 8.1, 8, 7, etc., in both 32 bit and 64 bit versions. Choose the version that suits your needs and preferences.</li>
-<li>Download</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Dispensary Management Software Free Download [PORTABLE].md

@@ -1,6 +0,0 @@
-<h2>dispensary management software free download</h2><br /><p><b><b>Download Zip</b> >>> <a href="https://imgfil.com/2uy1Bz">https://imgfil.com/2uy1Bz</a></b></p><br /><br />
-<br />
-If an application is rejected for failure to provide required information, ... Our technology serves as an elegant retail marijuana POS with powerful dispensary management tools. We can ... Download the report template from the OMMA website. 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/Download Real Car Parking 3D and Become a Parking Master.md

@@ -1,124 +0,0 @@
-
-<h1>Real Car Parking and Driving Simulator 3D Download: A Review</h1>
-<p>Do you love driving cars and parking them in realistic scenarios? Do you want to test your skills and have fun at the same time? If you answered yes, then you should download real car parking and driving simulator 3d, one of the best car simulation games available on the market. In this article, we will review the features, benefits, and tips of this amazing game, and show you how to download it on your device. Let's get started!</p>
- <h2>Features of Real Car Parking and Driving Simulator 3D</h2>
-<p>Real car parking and driving simulator 3d is a game that offers you a realistic and immersive driving experience. Here are some of the features that make this game stand out:</p>
-<h2>real car parking and driving simulator 3d download</h2><br /><p><b><b>Download File</b> &#10038;&#10038;&#10038; <a href="https://jinyurl.com/2uNMPa">https://jinyurl.com/2uNMPa</a></b></p><br /><br />
-<ul>
-<li><b>Realistic cars and physics:</b> You can choose from a variety of cars, from sports cars to SUVs, each with its own characteristics and performance. The game also uses realistic physics to simulate the car's movement, weight, speed, and braking.</li>
-<li><b>Challenging parking courses and levels:</b> You can test your parking skills in different environments, such as city streets, parking lots, airports, docks, factories, and more. Each level has its own objectives, obstacles, and time limits. You can earn stars based on your performance and unlock new levels.</li>
-<li><b>Amazing graphics and sound effects:</b> The game has stunning 3D graphics that create a lifelike atmosphere. You can also enjoy the realistic sound effects of the engine, horn, brakes, tires, and collisions.</li>
-<li><b>Customizable controls and camera angles:</b> You can adjust the controls according to your preference, whether you want to use buttons, steering wheel, or tilt. You can also switch between different camera views, such as top-down, rear-view, or cockpit.</li>
-<li><b>Offline and online modes:</b> You can play the game offline without an internet connection, or you can play online with other players from around the world. You can compete in multiplayer races, join clans, chat with friends, and rank on the leaderboard.</li>
-</ul>
- <h2>How to Download Real Car Parking and Driving Simulator 3D</h2>
-<p>The game is available for free on various platforms. Here is how to download it on your device:</p>
-<h3>For Android devices</h3>
-<p>You can download the game from the Google Play Store by following these steps:</p>
-<ol>
-<li>Open the Google Play Store app on your device.</li>
-<li>Search for "real car parking 3d" or click [here](^1^).</li>
-<li>Select the game from the list of results.</li>
-<li>Tap on "Install" and wait for the download to finish.</li>
-<li>Tap on "Open" to launch the game.</li>
-</ol>
- <h3>For iOS devices</h3>
-<p>You can download the game from the App Store by following these steps:</p>
-<ol>
-<li>Open the App Store app on your device.</li>
-<li>Search for "real car parking 3d" or click [here](^2^).</li>
-<li>Select the game from the list of results.</li>
-<li>Tap on "Get" and enter your Apple ID password if prompted.</li>
-<li>Wait for the download to finish.</li>
-<li>Tap on the game icon to launch the game.</li>
-</ol>
- <h3>For Windows devices</h3>
-<p>You can download the game from the Microsoft Store by following these steps:</p>
-<ol>
-<li>Open the Microsoft Store app on your device.</li>
-<li>Search for "real car parking 3d" or click [here].</li>
-<li>Select the game from the list of results.</li>
-<li>Click on "Get" and sign in with your Microsoft account if prompted.</li>
-<li>Wait for the download to finish.</li>
-<li>Click on "Play" to launch the game.</li>
-</ol>
- <h2>Tips and Tricks for Playing Real Car Parking and Driving Simulator 3D</h2>
-<p>Now that you have downloaded the game, you might be wondering how to play it and improve your skills. Here are some tips and tricks that will help you master the game:</p>
-<h3>Practice your parking skills in free mode</h3>
-<p>The game has a free mode where you can drive around without any time limit or objectives. This is a great way to get familiar with the controls, the car's behavior, and the environment. You can also practice parking in different spots and angles, and learn from your mistakes.</p>
- <h3>Use the brake and steering buttons wisely</h3>
-<p>The game has two buttons for braking and steering, which are located on the bottom left and right corners of the screen. You can use them to control the speed and direction of your car. However, you should not overuse them or press them too hard, as this might cause your car to skid, spin, or crash. You should also release them when you are not using them, as this will save your fuel and prevent overheating.</p>
- <h3>Follow the arrows and avoid obstacles</h3>
-<p>The game has arrows that guide you to your parking spot. You should follow them carefully and pay attention to the distance indicator, which shows how far you are from your destination. You should also avoid hitting any obstacles, such as cones, barriers, walls, or other cars, as this will damage your car and reduce your score. You can use the mini-map on the top right corner of the screen to see your surroundings and plan your route.</p>
-<p>real car parking 3d simulator app<br />
-real car parking and driving simulator 3d game<br />
-real car parking and racing simulator 3d<br />
-real car parking and drifting simulator 3d<br />
-real car parking and driving school simulator 3d<br />
-real car parking and driving test simulator 3d<br />
-real car parking and driving challenge simulator 3d<br />
-real car parking and driving skills simulator 3d<br />
-real car parking and driving adventure simulator 3d<br />
-real car parking and driving extreme simulator 3d<br />
-real car parking and driving city simulator 3d<br />
-real car parking and driving offroad simulator 3d<br />
-real car parking and driving highway simulator 3d<br />
-real car parking and driving airport simulator 3d<br />
-real car parking and driving police simulator 3d<br />
-real car parking and driving taxi simulator 3d<br />
-real car parking and driving truck simulator 3d<br />
-real car parking and driving bus simulator 3d<br />
-real car parking and driving suv simulator 3d<br />
-real car parking and driving sports car simulator 3d<br />
-real car parking and driving classic car simulator 3d<br />
-real car parking and driving luxury car simulator 3d<br />
-real car parking and driving muscle car simulator 3d<br />
-real car parking and driving supercar simulator 3d<br />
-real car parking and driving hypercar simulator 3d<br />
-real car parking and driving electric car simulator 3d<br />
-real car parking and driving hybrid car simulator 3d<br />
-real car parking and driving smart car simulator 3d<br />
-real car parking and driving mini car simulator 3d<br />
-real car parking and driving monster truck simulator 3d<br />
-real car parking and driving tractor simulator 3d<br />
-real car parking and driving loader simulator 3d<br />
-real car parking and driving forklift simulator 3d<br />
-real car parking and driving crane simulator 3d<br />
-real car parking and driving tow truck simulator 3d<br />
-real car parking and driving fire truck simulator 3d<br />
-real car parking and driving ambulance simulator 3d<br />
-real car parking and driving limo simulator 3d<br />
-real car parking and driving jeep simulator 3d<br />
-real car parking and driving pickup truck simulator 3d<br />
-download free real car parking and driving simulator 3d for android <br />
-download free real car parking and driving simulator 3d for ios <br />
-download free real car parking and driving simulator 3d for pc <br />
-download free real car parking and driving simulator 3d for windows <br />
-download free real car parking and driving simulator 3d for mac <br />
-download free real car parking and driving simulator 3d for linux <br />
-download free real car parking and driving simulator 3d apk <br />
-download free real car parking and driving simulator 3d mod apk <br />
-download free real car parking and driving simulator 3d hack apk <br />
-download free real car parking and driving simulator 3d unlimited money apk</p>
- <h3>Collect coins and gems to unlock new cars</h3>
-<p>The game has coins and gems that you can collect by driving around or completing levels. You can use them to buy new cars or upgrade your existing ones. Each car has its own stats, such as speed, acceleration, handling, and braking. You should try different cars and find the one that suits your style and preference.</p>
- <h3>Try different camera views to find the best angle</h3>
-<p>The game has four camera views that you can switch between by tapping on the camera icon on the top left corner of the screen. They are: top-down, rear-view, cockpit, and side-view. Each view has its own advantages and disadvantages, depending on the situation and your preference. You should experiment with different views and find the one that gives you the best visibility and comfort.</p>
- <h2>Conclusion</h2>
-<p>Real car parking and driving simulator 3d is a game that will challenge your driving and parking skills in a realistic and fun way. It has many features that make it stand out from other car simulation games, such as realistic cars and physics, challenging parking courses and levels, amazing graphics and sound effects, customizable controls and camera angles, offline and online modes, and more. You can download it for free on various platforms, such as Android, iOS, and Windows devices. If you are looking for a game that will keep you entertained for hours, then you should definitely give real car parking and driving simulator 3d a try!</p>
- <p>If you liked this article, please share it with your friends and leave a comment below. We would love to hear your feedback and suggestions. Also, if you have any questions about the game or need more tips and tricks, feel free to ask us. We will be happy to help you!</p>
- <h2>Frequently Asked Questions</h2>
-<ul>
-<li><b>Q: How do I change the language of the game?</b></li>
-<li>A: You can change the language of the game by tapping on the settings icon on the main menu screen. Then, select "Language" from the list of options. You can choose from English, Spanish, French, German, Italian, Portuguese, Russian, Turkish, Arabic, Chinese, Japanese, Korean, Hindi, Indonesian, or Vietnamese.</li>
-<li><b>Q: How do I save my progress in the game?</b></li>
-<li>A: The game automatically saves your progress every time you complete a level or exit the game. You can also manually save your progress by tapping on the settings icon on the main menu screen. Then, select "Save Game" from the list of options. You can also load your saved game by selecting "Load Game" from the same menu.</li>
-<li><b>Q: How do I reset my progress in the game?</b></li>
-<li>A: You can reset your progress in the game by tapping on the settings icon on the main menu screen. Then, select "Reset Game" from the list of options. This will erase all your data and start the game from scratch. Be careful, as this action cannot be undone.</li>
-<li><b>Q: How do I contact the developers of the game?</b></li>
-<li>A: You can contact the developers of the game by tapping on the settings icon on the main menu screen. Then, select "Contact Us" from the list of options. You can send them an email with your feedback, suggestions, or issues. You can also follow them on their social media accounts, such as Facebook, Twitter, Instagram, or YouTube.</li>
-<li><b>Q: How do I rate and review the game?</b></li>
-<li>A: You can rate and review the game by tapping on the settings icon on the main menu screen. Then, select "Rate Us" from the list of options. This will redirect you to the store page of the game, where you can give it a star rating and write a comment. Your feedback is very important for us and helps us improve the game.</li>
-</ul></p> 401be4b1e0<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/commands/env.py

@@ -1,67 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import platform
-from argparse import ArgumentParser
-
-from .. import __version__ as version
-from ..utils import is_paddle_available, is_paddlenlp_available
-from . import BasePPDiffusersCLICommand
-
-
-def info_command_factory(_):
-    return EnvironmentCommand()
-
-
-class EnvironmentCommand(BasePPDiffusersCLICommand):
-    @staticmethod
-    def register_subcommand(parser: ArgumentParser):
-        download_parser = parser.add_parser("env")
-        download_parser.set_defaults(func=info_command_factory)
-
-    def run(self):
-
-        pd_version = "not installed"
-        pd_cuda_available = "NA"
-        if is_paddle_available():
-            import paddle
-
-            pd_version = paddle.__version__
-            pd_cuda_available = paddle.device.is_compiled_with_cuda()
-
-        paddlenlp_version = "not installed"
-        if is_paddlenlp_available:
-            import paddlenlp
-
-            paddlenlp_version = paddlenlp.__version__
-
-        info = {
-            "`ppdiffusers` version": version,
-            "Platform": platform.platform(),
-            "Python version": platform.python_version(),
-            "Paddle version (GPU?)": f"{pd_version} ({pd_cuda_available})",
-            "PaddleNLP version": paddlenlp_version,
-            "Using GPU in script?": "<fill in>",
-            "Using distributed or parallel set-up in script?": "<fill in>",
-        }
-
-        print("\nCopy-and-paste the text below in your GitHub issue and FILL OUT the two last points.\n")
-        print(self.format_dict(info))
-
-        return info
-
-    @staticmethod
-    def format_dict(d):
-        return "\n".join([f"- {prop}: {val}" for prop, val in d.items()]) + "\n"

spaces/232labs/VToonify/vtoonify/model/stylegan/prepare_data.py

@@ -1,105 +0,0 @@
-import argparse
-from io import BytesIO
-import multiprocessing
-from functools import partial
-
-import os
-from PIL import Image
-import lmdb
-from tqdm import tqdm
-from torchvision import datasets
-from torchvision.transforms import functional as trans_fn
-
-
-def resize_and_convert(img, size, resample, quality=100):
-    img = trans_fn.resize(img, size, resample)
-    img = trans_fn.center_crop(img, size)
-    buffer = BytesIO()
-    img.save(buffer, format="jpeg", quality=quality)
-    val = buffer.getvalue()
-
-    return val
-
-
-def resize_multiple(
-    img, sizes=(128, 256, 512, 1024), resample=Image.LANCZOS, quality=100
-):
-    imgs = []
-
-    for size in sizes:
-        imgs.append(resize_and_convert(img, size, resample, quality))
-
-    return imgs
-
-
-def resize_worker(img_file, sizes, resample):
-    i, file = img_file
-    img = Image.open(file)
-    img = img.convert("RGB")
-    out = resize_multiple(img, sizes=sizes, resample=resample)
-
-    return i, out
-
-
-def prepare(
-    env, dataset, n_worker, sizes=(128, 256, 512, 1024), resample=Image.LANCZOS
-):
-    resize_fn = partial(resize_worker, sizes=sizes, resample=resample)
-
-    files = sorted(dataset.imgs, key=lambda x: x[0])
-    files = [(i, file) for i, (file, label) in enumerate(files)]
-    total = 0
-
-    with multiprocessing.Pool(n_worker) as pool:
-        for i, imgs in tqdm(pool.imap_unordered(resize_fn, files)):
-            for size, img in zip(sizes, imgs):
-                key = f"{size}-{str(i).zfill(5)}".encode("utf-8")
-
-                with env.begin(write=True) as txn:
-                    txn.put(key, img)
-
-            total += 1
-
-        with env.begin(write=True) as txn:
-            txn.put("length".encode("utf-8"), str(total).encode("utf-8"))
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Preprocess images for model training")
-    parser.add_argument("--out", type=str, help="filename of the result lmdb dataset")
-    parser.add_argument(
-        "--size",
-        type=str,
-        default="128,256,512,1024",
-        help="resolutions of images for the dataset",
-    )
-    parser.add_argument(
-        "--n_worker",
-        type=int,
-        default=8,
-        help="number of workers for preparing dataset",
-    )
-    parser.add_argument(
-        "--resample",
-        type=str,
-        default="lanczos",
-        help="resampling methods for resizing images",
-    )
-    parser.add_argument("path", type=str, help="path to the image dataset")
-
-    args = parser.parse_args()
-
-    if not os.path.exists(args.out):
-        os.makedirs(args.out)
-     
-    resample_map = {"lanczos": Image.LANCZOS, "bilinear": Image.BILINEAR}
-    resample = resample_map[args.resample]
-
-    sizes = [int(s.strip()) for s in args.size.split(",")]
-
-    print(f"Make dataset of image sizes:", ", ".join(str(s) for s in sizes))
-
-    imgset = datasets.ImageFolder(args.path)
-
-    with lmdb.open(args.out, map_size=1024 ** 4, readahead=False) as env:
-        prepare(env, imgset, args.n_worker, sizes=sizes, resample=resample)

spaces/52Hz/CMFNet_deraindrop/main_test_CMFNet.py

@@ -1,98 +0,0 @@
-import argparse
-import cv2
-import glob
-import numpy as np
-from collections import OrderedDict
-from skimage import img_as_ubyte
-import os
-import torch
-import requests
-from PIL import Image
-import torchvision.transforms.functional as TF
-import torch.nn.functional as F
-from natsort import natsorted
-from model.CMFNet import CMFNet
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Demo Image Deraindrop')
-    parser.add_argument('--input_dir', default='test/', type=str, help='Input images')
-    parser.add_argument('--result_dir', default='results/', type=str, help='Directory for results')
-    parser.add_argument('--weights',
-                        default='experiments/pretrained_models/deraindrop_model.pth', type=str,
-                        help='Path to weights')
-
-    args = parser.parse_args()
-
-    inp_dir = args.input_dir
-    out_dir = args.result_dir
-
-    os.makedirs(out_dir, exist_ok=True)
-
-    files = natsorted(glob.glob(os.path.join(inp_dir, '*')))
-
-    if len(files) == 0:
-        raise Exception(f"No files found at {inp_dir}")
-
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-    # Load corresponding models architecture and weights
-    model = CMFNet()
-    model = model.to(device)
-    model.eval()
-    load_checkpoint(model, args.weights)
-    
-
-    mul = 8
-    for file_ in files:
-        img = Image.open(file_).convert('RGB')
-        input_ = TF.to_tensor(img).unsqueeze(0).to(device)
-
-        # Pad the input if not_multiple_of 8
-        h, w = input_.shape[2], input_.shape[3]
-        H, W = ((h + mul) // mul) * mul, ((w + mul) // mul) * mul
-        padh = H - h if h % mul != 0 else 0
-        padw = W - w if w % mul != 0 else 0
-        input_ = F.pad(input_, (0, padw, 0, padh), 'reflect')
-        
-        with torch.no_grad():
-            restored = model(input_)
-            
-        restored = torch.clamp(restored, 0, 1)
-        restored = restored[:, :, :h, :w]
-        restored = restored.permute(0, 2, 3, 1).cpu().detach().numpy()
-        restored = img_as_ubyte(restored[0])
-
-        f = os.path.splitext(os.path.split(file_)[-1])[0]
-        save_img((os.path.join(out_dir, f + '.png')), restored)
-
-
-def save_img(filepath, img):
-    cv2.imwrite(filepath, cv2.cvtColor(img, cv2.COLOR_RGB2BGR))
-
-
-def load_checkpoint(model, weights):
-    checkpoint = torch.load(weights, map_location=torch.device('cpu'))
-    try:
-        model.load_state_dict(checkpoint["state_dict"])
-    except:
-        state_dict = checkpoint["state_dict"]
-        new_state_dict = OrderedDict()
-        for k, v in state_dict.items():
-            name = k[7:]  # remove `module.`
-            new_state_dict[name] = v
-        model.load_state_dict(new_state_dict)
-        
-def clean_folder(folder):
-    for filename in os.listdir(folder):
-        file_path = os.path.join(folder, filename)
-        try:
-            if os.path.isfile(file_path) or os.path.islink(file_path):
-                os.unlink(file_path)
-            elif os.path.isdir(file_path):
-                shutil.rmtree(file_path)
-        except Exception as e:
-            print('Failed to delete %s. Reason: %s' % (file_path, e))
-
-if __name__ == '__main__':
-    main()

spaces/7hao/bingo/src/lib/hooks/use-enter-submit.tsx

@@ -1,23 +0,0 @@
-import { useRef, type RefObject } from 'react'
-
-export function useEnterSubmit(): {
-  formRef: RefObject<HTMLFormElement>
-  onKeyDown: (event: React.KeyboardEvent<HTMLTextAreaElement>) => void
-} {
-  const formRef = useRef<HTMLFormElement>(null)
-
-  const handleKeyDown = (
-    event: React.KeyboardEvent<HTMLTextAreaElement>
-  ): void => {
-    if (
-      event.key === 'Enter' &&
-      !event.shiftKey &&
-      !event.nativeEvent.isComposing
-    ) {
-      formRef.current?.requestSubmit()
-      event.preventDefault()
-    }
-  }
-
-  return { formRef, onKeyDown: handleKeyDown }
-}

spaces/AIConsultant/MusicGen/audiocraft/losses/balancer.py

@@ -1,136 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import typing as tp
-
-import flashy
-import torch
-from torch import autograd
-
-
-class Balancer:
-    """Loss balancer.
-
-    The loss balancer combines losses together to compute gradients for the backward.
-    Given `y = f(...)`, and a number of losses `l1(y, ...)`, `l2(y, ...)`, with `...`
-    not having any dependence on `f`, the balancer can efficiently normalize the partial gradients
-    `d l1 / d y`, `d l2 / dy` before summing them in order to achieve a desired ratio between
-    the losses. For instance if `weights = {'l1': 2, 'l2': 1}`, 66% of the gradient
-    going into `f(...)` will come from `l1` on average, and 33% from `l2`. This allows for an easy
-    interpration of the weights even if the intrisic scale of `l1`, `l2` ... is unknown.
-
-    Noting `g1 = d l1 / dy`, etc., the balanced gradient `G` will be
-    (with `avg` an exponential moving average over the updates),
-
-        G = sum_i total_norm * g_i / avg(||g_i||) * w_i / sum(w_i)
-
-    If `balance_grads` is False, this is deactivated, and instead the gradient will just be the
-    standard sum of the partial gradients with the given weights.
-
-    A call to the backward method of the balancer will compute the the partial gradients,
-    combining all the losses and potentially rescaling the gradients,
-    which can help stabilize the training and reason about multiple losses with varying scales.
-    The obtained gradient with respect to `y` is then back-propagated to `f(...)`.
-
-    Expected usage:
-
-        weights = {'loss_a': 1, 'loss_b': 4}
-        balancer = Balancer(weights, ...)
-        losses: dict = {}
-        losses['loss_a'] = compute_loss_a(x, y)
-        losses['loss_b'] = compute_loss_b(x, y)
-        if model.training():
-            effective_loss = balancer.backward(losses, x)
-
-    Args:
-        weights (dict[str, float]): Weight coefficient for each loss. The balancer expect the losses keys
-            from the backward method to match the weights keys to assign weight to each of the provided loss.
-        balance_grads (bool): Whether to rescale gradients so that weights reflect the fraction of the
-            overall gradient, rather than a constant multiplier.
-        total_norm (float): Reference norm when rescaling gradients, ignored otherwise.
-        emay_decay (float): EMA decay for averaging the norms.
-        per_batch_item (bool): Whether to compute the averaged norm per batch item or not. This only holds
-            when rescaling the gradients.
-        epsilon (float): Epsilon value for numerical stability.
-        monitor (bool): If True, stores in `self.metrics` the relative ratio between the norm of the gradients
-            coming from each loss, when calling `backward()`.
-    """
-    def __init__(self, weights: tp.Dict[str, float], balance_grads: bool = True, total_norm: float = 1.,
-                 ema_decay: float = 0.999, per_batch_item: bool = True, epsilon: float = 1e-12,
-                 monitor: bool = False):
-        self.weights = weights
-        self.per_batch_item = per_batch_item
-        self.total_norm = total_norm or 1.
-        self.averager = flashy.averager(ema_decay or 1.)
-        self.epsilon = epsilon
-        self.monitor = monitor
-        self.balance_grads = balance_grads
-        self._metrics: tp.Dict[str, tp.Any] = {}
-
-    @property
-    def metrics(self):
-        return self._metrics
-
-    def backward(self, losses: tp.Dict[str, torch.Tensor], input: torch.Tensor) -> torch.Tensor:
-        """Compute the backward and return the effective train loss, e.g. the loss obtained from
-        computing the effective weights. If `balance_grads` is True, the effective weights
-        are the one that needs to be applied to each gradient to respect the desired relative
-        scale of gradients coming from each loss.
-
-        Args:
-            losses (Dict[str, torch.Tensor]): dictionary with the same keys as `self.weights`.
-            input (torch.Tensor): the input of the losses, typically the output of the model.
-                This should be the single point of dependence between the losses
-                and the model being trained.
-        """
-        norms = {}
-        grads = {}
-        for name, loss in losses.items():
-            # Compute partial derivative of the less with respect to the input.
-            grad, = autograd.grad(loss, [input], retain_graph=True)
-            if self.per_batch_item:
-                # We do not average the gradient over the batch dimension.
-                dims = tuple(range(1, grad.dim()))
-                norm = grad.norm(dim=dims, p=2).mean()
-            else:
-                norm = grad.norm(p=2)
-            norms[name] = norm
-            grads[name] = grad
-
-        count = 1
-        if self.per_batch_item:
-            count = len(grad)
-        # Average norms across workers. Theoretically we should average the
-        # squared norm, then take the sqrt, but it worked fine like that.
-        avg_norms = flashy.distrib.average_metrics(self.averager(norms), count)
-        # We approximate the total norm of the gradient as the sums of the norms.
-        # Obviously this can be very incorrect if all gradients are aligned, but it works fine.
-        total = sum(avg_norms.values())
-
-        self._metrics = {}
-        if self.monitor:
-            # Store the ratio of the total gradient represented by each loss.
-            for k, v in avg_norms.items():
-                self._metrics[f'ratio_{k}'] = v / total
-
-        total_weights = sum([self.weights[k] for k in avg_norms])
-        assert total_weights > 0.
-        desired_ratios = {k: w / total_weights for k, w in self.weights.items()}
-
-        out_grad = torch.zeros_like(input)
-        effective_loss = torch.tensor(0., device=input.device, dtype=input.dtype)
-        for name, avg_norm in avg_norms.items():
-            if self.balance_grads:
-                # g_balanced = g / avg(||g||) * total_norm * desired_ratio
-                scale = desired_ratios[name] * self.total_norm / (self.epsilon + avg_norm)
-            else:
-                # We just do regular weighted sum of the gradients.
-                scale = self.weights[name]
-            out_grad.add_(grads[name], alpha=scale)
-            effective_loss += scale * losses[name].detach()
-        # Send the computed partial derivative with respect to the output of the model to the model.
-        input.backward(out_grad)
-        return effective_loss

spaces/AIConsultant/MusicGen/audiocraft/train.py

@@ -1,157 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Entry point for dora to launch solvers for running training loops.
-See more info on how to use dora: https://github.com/facebookresearch/dora
-"""
-
-import logging
-import multiprocessing
-import os
-import sys
-import typing as tp
-
-from dora import git_save, hydra_main, XP
-import flashy
-import hydra
-import omegaconf
-
-from .environment import AudioCraftEnvironment
-from .utils.cluster import get_slurm_parameters
-
-logger = logging.getLogger(__name__)
-
-
-def resolve_config_dset_paths(cfg):
-    """Enable Dora to load manifest from git clone repository."""
-    # manifest files for the different splits
-    for key, value in cfg.datasource.items():
-        if isinstance(value, str):
-            cfg.datasource[key] = git_save.to_absolute_path(value)
-
-
-def get_solver(cfg):
-    from . import solvers
-    # Convert batch size to batch size for each GPU
-    assert cfg.dataset.batch_size % flashy.distrib.world_size() == 0
-    cfg.dataset.batch_size //= flashy.distrib.world_size()
-    for split in ['train', 'valid', 'evaluate', 'generate']:
-        if hasattr(cfg.dataset, split) and hasattr(cfg.dataset[split], 'batch_size'):
-            assert cfg.dataset[split].batch_size % flashy.distrib.world_size() == 0
-            cfg.dataset[split].batch_size //= flashy.distrib.world_size()
-    resolve_config_dset_paths(cfg)
-    solver = solvers.get_solver(cfg)
-    return solver
-
-
-def get_solver_from_xp(xp: XP, override_cfg: tp.Optional[tp.Union[dict, omegaconf.DictConfig]] = None,
-                       restore: bool = True, load_best: bool = True,
-                       ignore_state_keys: tp.List[str] = [], disable_fsdp: bool = True):
-    """Given a XP, return the Solver object.
-
-    Args:
-        xp (XP): Dora experiment for which to retrieve the solver.
-        override_cfg (dict or None): If not None, should be a dict used to
-            override some values in the config of `xp`. This will not impact
-            the XP signature or folder. The format is different
-            than the one used in Dora grids, nested keys should actually be nested dicts,
-            not flattened, e.g. `{'optim': {'batch_size': 32}}`.
-        restore (bool): If `True` (the default), restore state from the last checkpoint.
-        load_best (bool): If `True` (the default), load the best state from the checkpoint.
-        ignore_state_keys (list[str]): List of sources to ignore when loading the state, e.g. `optimizer`.
-        disable_fsdp (bool): if True, disables FSDP entirely. This will
-            also automatically skip loading the EMA. For solver specific
-            state sources, like the optimizer, you might want to
-            use along `ignore_state_keys=['optimizer']`. Must be used with `load_best=True`.
-    """
-    logger.info(f"Loading solver from XP {xp.sig}. "
-                f"Overrides used: {xp.argv}")
-    cfg = xp.cfg
-    if override_cfg is not None:
-        cfg = omegaconf.OmegaConf.merge(cfg, omegaconf.DictConfig(override_cfg))
-    if disable_fsdp and cfg.fsdp.use:
-        cfg.fsdp.use = False
-        assert load_best is True
-        # ignoring some keys that were FSDP sharded like model, ema, and best_state.
-        # fsdp_best_state will be used in that case. When using a specific solver,
-        # one is responsible for adding the relevant keys, e.g. 'optimizer'.
-        # We could make something to automatically register those inside the solver, but that
-        # seem overkill at this point.
-        ignore_state_keys = ignore_state_keys + ['model', 'ema', 'best_state']
-
-    try:
-        with xp.enter():
-            solver = get_solver(cfg)
-            if restore:
-                solver.restore(load_best=load_best, ignore_state_keys=ignore_state_keys)
-        return solver
-    finally:
-        hydra.core.global_hydra.GlobalHydra.instance().clear()
-
-
-def get_solver_from_sig(sig: str, *args, **kwargs):
-    """Return Solver object from Dora signature, i.e. to play with it from a notebook.
-    See `get_solver_from_xp` for more information.
-    """
-    xp = main.get_xp_from_sig(sig)
-    return get_solver_from_xp(xp, *args, **kwargs)
-
-
-def init_seed_and_system(cfg):
-    import numpy as np
-    import torch
-    import random
-    from audiocraft.modules.transformer import set_efficient_attention_backend
-
-    multiprocessing.set_start_method(cfg.mp_start_method)
-    logger.debug('Setting mp start method to %s', cfg.mp_start_method)
-    random.seed(cfg.seed)
-    np.random.seed(cfg.seed)
-    # torch also initialize cuda seed if available
-    torch.manual_seed(cfg.seed)
-    torch.set_num_threads(cfg.num_threads)
-    os.environ['MKL_NUM_THREADS'] = str(cfg.num_threads)
-    os.environ['OMP_NUM_THREADS'] = str(cfg.num_threads)
-    logger.debug('Setting num threads to %d', cfg.num_threads)
-    set_efficient_attention_backend(cfg.efficient_attention_backend)
-    logger.debug('Setting efficient attention backend to %s', cfg.efficient_attention_backend)
-
-
-@hydra_main(config_path='../config', config_name='config', version_base='1.1')
-def main(cfg):
-    init_seed_and_system(cfg)
-
-    # Setup logging both to XP specific folder, and to stderr.
-    log_name = '%s.log.{rank}' % cfg.execute_only if cfg.execute_only else 'solver.log.{rank}'
-    flashy.setup_logging(level=str(cfg.logging.level).upper(), log_name=log_name)
-    # Initialize distributed training, no need to specify anything when using Dora.
-    flashy.distrib.init()
-    solver = get_solver(cfg)
-    if cfg.show:
-        solver.show()
-        return
-
-    if cfg.execute_only:
-        assert cfg.execute_inplace or cfg.continue_from is not None, \
-            "Please explicitly specify the checkpoint to continue from with continue_from=<sig_or_path> " + \
-            "when running with execute_only or set execute_inplace to True."
-        solver.restore(replay_metrics=False)  # load checkpoint
-        solver.run_one_stage(cfg.execute_only)
-        return
-
-    return solver.run()
-
-
-main.dora.dir = AudioCraftEnvironment.get_dora_dir()
-main._base_cfg.slurm = get_slurm_parameters(main._base_cfg.slurm)
-
-if main.dora.shared is not None and not os.access(main.dora.shared, os.R_OK):
-    print("No read permission on dora.shared folder, ignoring it.", file=sys.stderr)
-    main.dora.shared = None
-
-if __name__ == '__main__':
-    main()

spaces/AIZero2Hero4Health/5-QuantumStreamlitAIDashboard-SL/app.py

@@ -1,57 +0,0 @@
-import streamlit as st      
-import gradio as gr
-import IPython
-import streamlit as st
-import streamlit.components.v1 as components
-from IPython.display import IFrame
-
-#quantum imports:
-import qiskit
-from qiskit import QuantumCircuit, QuantumRegister, execute
-
-src=''   # URL parameter to change the iframe url
-
-def SetIframeURL(option_selected):
-    if (option_selected=='QCEngine'):
-        src='https://oreilly-qc.github.io?p=2-1'
-    if (option_selected=='Grok'):
-        src='https://javafxpert.github.io/grok-bloch/'
-    if (option_selected=='Playground'):
-        src='https://davidbkemp.github.io/quantum-gate-playground/'
-    if (option_selected=='Circuit'):
-        src='https://algassert.com/quirk#circuit={%22cols%22:[[%22H%22],[%22Bloch%22],[%22Measure%22]]}'
-    
-    # Render iframe contents
-    #st.set_page_config(layout="wide")
-    width = st.sidebar.slider("Width", 200, 1500, 800, 100)
-    height = st.sidebar.slider("Height", 200, 1500, 900, 100)
-    st.components.v1.iframe(src, width, height, scrolling=True)
-
-# query params exist
-try:
-    options = ['QCEngine', 'Grok', 'Playground', 'Circuit']
-    query_params = st.experimental_get_query_params()
-    query_option = query_params['option'][0] #throws an exception when visiting http://host:port
-    option_selected = st.sidebar.selectbox('Pick option', options, index=options.index(query_option))
-    if option_selected:
-        st.experimental_set_query_params(option=option_selected)
-        SetIframeURL(option_selected)
-
-# run when query params don't exist. e.g on first launch
-except: # catch exception and set query param to predefined value
-    options = ['QCEngine', 'Grok', 'Playground', 'Circuit']
-    st.experimental_set_query_params(option=options[1]) # defaults to dog
-    query_params = st.experimental_get_query_params()
-    query_option = query_params['option'][0]
-    option_selected = st.sidebar.selectbox('Pick option', options, index=options.index(query_option))
-    if option_selected:
-        st.experimental_set_query_params(option=option_selected)
-        SetIframeURL(option_selected)
-
-def LoadGradioAIModels():
-    title = "AI Quantum - QGAN and QCEngine"
-    description = "Using Superposition Advantage from Quantum for QGAN AI."
-    article = "<p style='text-align: center'></p>"
-
-    examples = [
-    ["Scientific breakthroughs in treatment of HIV/AIDS may be solved in our lifetime using a procedure called [MASK] modulation which strengthens the immune system to fight the disease."],["A disease called [MASK] disease involves progressive memory loss and has new treatments to improve memory and delay progression of the disease."],["[MASK] refers to the uncontrolled growth of abnormal cells in the body.  With chemotherapy and radiation therapy have improvements and replacements that destroy cancer cells before they become resistant to current treatment methods."],["The hereditary disease [MASK] is caused by mucus abnormally thick preventing lungs and pancreas from doing their jobs correctly."],["[MASK] or atherosclerosis is the buildup of cholesterol, fatty cells, and inflammatory deposits in the arteries.  Stem cells, mechanical devices, and lowering cholesterol and blood pressure levels are helping prevention."]]

spaces/Abdullah-Habib/Text_to_Speech_Urdu/app.py

@@ -1,127 +0,0 @@
-import torch
-from transformers import SpeechT5ForTextToSpeech, SpeechT5Processor, SpeechT5HifiGan
-import soundfile as sf
-import gradio as gr
-import scipy.io.wavfile as wav
-import numpy as np
-import wave
-from datasets import load_dataset, Audio, config
-from IPython.display import Audio
-
-# Load the TTS model from the Hugging Face Hub
-checkpoint = "Abdullah-Habib/urdu_speech_tt"  # Replace with your actual model name
-processor = SpeechT5Processor.from_pretrained(checkpoint)
-model = SpeechT5ForTextToSpeech.from_pretrained(checkpoint)
-tokenizer = processor.tokenizer
-vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
-
-
-# Buckwalter to Unicode mapping
-buck2uni = {
-            u"\u0627":"a",
-            u"\u0627":"a",
-            u"\u0675":"a",
-            u"\u0673":"a",
-            u"\u0630":"a",
-            u"\u0622":"aa",
-            u"\u0628":"b",
-            u"\u067E":"p",
-            u"\u062A":"t",
-            u"\u0637":"t",
-            u"\u0679":"t",
-            u"\u062C":"j",
-            u"\u0633":"s",
-            u"\u062B":"s",
-            u"\u0635":"s",
-            u"\u0686":"ch",
-            u"\u062D":"h",
-            u"\u0647":"h",
-            u"\u0629":"h",
-            u"\u06DF":"h",
-            u"\u062E":"kh",
-            u"\u062F":"d",
-            u"\u0688":"d",
-            u"\u0630":"z",
-            u"\u0632":"z",
-            u"\u0636":"z",
-            u"\u0638":"z",
-            u"\u068E":"z",
-            u"\u0631":"r",
-            u"\u0691":"r",
-            u"\u0634":"sh",
-            u"\u063A":"gh",
-            u"\u0641":"f",
-            u"\u06A9":"k",
-            u"\u0642":"k",
-            u"\u06AF":"g",
-            u"\u0644":"l",
-            u"\u0645":"m",
-            u"\u0646":"n",
-            u"\u06BA":"n",
-            u"\u0648":"o",
-            u"\u0649":"y",
-            u"\u0626":"y",
-            u"\u06CC":"y",
-            u"\u06D2":"e",
-            u"\u06C1":"h",
-            u"\u064A":"e"  ,
-            u"\u06C2":"ah"  ,
-            u"\u06BE":"h"  ,
-            u"\u0639":"a"  ,
-            u"\u0643":"k" ,
-            u"\u0621":"a",
-            u"\u0624":"o",
-            u"\u060C":"" #seperator ulta comma
-        }
-def transString(string, reverse=0):
-    """Given a Unicode string, transliterate into Buckwalter. To go from
-    Buckwalter back to Unicode, set reverse=1"""
-    for k, v in buck2uni.items():
-        if not reverse:
-            string = string.replace(k, v)
-        else:
-            string = string.replace(v, k)
-    return string
-
-
-def generate_audio(text):
-    # Convert input text to Roman Urdu
-    roman_urdu = transString(text)
-
-    # Tokenize the input text
-    inputs = processor(text=roman_urdu, return_tensors="pt", type = "numpy")
-
-    # Generate audio from the SpeechT5 model
-
-
-    
-    # speaker_embeddings = torch.tensor(np.load("speaker_embeddings.npy"))
-
-    speaker_embeddings = torch.load("speaker_embeddings_29.pt")
-    # speaker_embeddings= torch.tensor([[-0.0917, -0.0461,  0.0347,  0.0341,  0.0197, -0.0438, -0.0377, -0.0212, 0.0361,  0.0220, -0.0676, -0.0731,  0.0827,  0.0132,  0.0187,  0.0577, -0.0026,  0.0618,  0.0088,  0.0159,  0.0344,  0.0243, -0.0164, -0.0430, -0.0556, -0.0044, -0.0413, -0.0003,  0.0310,  0.0369, -0.0034,  0.0424, 0.0474,  0.0102,  0.0392, -0.0611,  0.0405,  0.0652, -0.0386, -0.0638,   0.0255, -0.0411,  0.0398,  0.0490,  0.0297, -0.1218, -0.0206,  0.0146,-0.0649,  0.0550,  0.0177,  0.0407,  0.0017, -0.0113, -0.0990, -0.0015,0.0158,  0.0481,  0.0286,  0.0300,  0.0346, -0.0104, -0.0142, -0.0005,0.0264,  0.0412,  0.0227, -0.0389, -0.0489, -0.0750,  0.0238,  0.0101,0.0171,  0.0141,  0.0224,  0.0344,  0.0402,  0.0336, -0.0641, -0.0818, -0.0731, -0.0470, -0.0512, -0.0602, -0.0344, -0.0442, -0.0541,  0.0097, 0.0198,  0.0482,  0.0323, -0.0885,  0.0210, -0.0798,  0.0417, -0.0436, 0.0402,  0.0256, -0.0641, -0.0668, -0.0023, -0.0706, -0.0928,  0.0121, 0.0355, -0.0376,  0.0522,  0.0482,  0.0200,  0.0290, -0.0698, -0.0232, 0.0878,  0.0044,  0.0559,  0.0581, -0.0718,  0.0095, -0.0538,  0.0125, 0.0023, -0.0562,  0.0424,  0.0261, -0.0498,  0.0255, -0.0840,  0.0331, 0.0406,  0.0162, -0.0522,  0.0218,  0.0323,  0.0359,  0.0128, -0.0891, -0.0569,  0.0031, -0.0694, -0.0102,  0.0118,  0.0033,  0.0127,  0.0589, -0.0783,  0.0179,  0.0200, -0.0371,  0.0325, -0.1033,  0.0483, -0.0343, -0.0714,  0.0102,  0.0665,  0.0278,  0.0285, -0.0653, -0.0834,  0.0196, 0.0399,  0.0085,  0.0246, -0.0400,  0.0215,  0.0083,  0.0302,  0.0204, 0.0360,  0.0309, -0.0306, -0.0828,  0.0142, -0.0614, -0.0103,  0.0372, -0.0456,  0.0291,  0.0565, -0.0271,  0.0518, -0.0671,  0.0012, -0.0048, -0.0565, -0.0092,  0.0336,  0.0476, -0.0351, -0.0698,  0.0487,  0.0313, -0.0491,  0.0401,  0.0246,  0.0178,  0.0405,  0.0012,  0.0311, -0.0041, 0.0367,  0.0330, -0.0609,  0.0099, -0.0097,  0.0173,  0.0494, -0.0305, 0.0272, -0.0349,  0.0025, -0.0697, -0.0414,  0.0604, -0.0707,  0.0420, 0.0380, -0.0731,  0.0546,  0.0339, -0.0758,  0.0365, -0.0712, -0.0140, 0.0365,  0.0477,  0.0796,  0.0572,  0.0212,  0.0098,  0.0133,  0.0261, 0.0329, -0.0269,  0.0437, -0.0359,  0.0296,  0.0180, -0.0008,  0.0668, -0.0448,  0.0269, -0.0734,  0.0194, -0.0494,  0.0432,  0.0449,  0.0442, 0.0389,  0.0530,  0.0420,  0.0021,  0.0084, -0.0820, -0.0081,  0.0326, 0.0265,  0.0536, -0.0714,  0.0188,  0.0298, -0.0737,  0.0110,  0.0340, 0.0016,  0.0262,  0.0179,  0.0109,  0.0426, -0.0538,  0.0649,  0.0160, 0.0146, -0.0419, -0.0851,  0.0138,  0.0399,  0.0445, -0.0849, -0.0425, 0.0293,  0.0477,  0.0108, -0.0941, -0.0386,  0.0600,  0.0089,  0.0557,-0.0892,  0.0026,  0.0192,  0.0136, -0.0207, -0.0023,  0.0163,  0.0263, -0.0112,  0.0245,  0.0411,  0.0285,  0.0267,  0.0297,  0.0213, -0.0577, 0.0169,  0.0592,  0.0227,  0.0290,  0.0074,  0.0197,  0.0282,  0.0368,0.0064,  0.0092, -0.0896, -0.0693, -0.0295,  0.0316, -0.0674,  0.0645,-0.0655,  0.0355, -0.0389,  0.0134,  0.0299, -0.0534,  0.0537,  0.0900, -0.0770, -0.0666, -0.0600, -0.0019,  0.0276,  0.0590, -0.0705,  0.0222, 0.0517, -0.0089,  0.0063, -0.0270,  0.0185, -0.0626, -0.0065,  0.0187,-0.0670,  0.0216,  0.0356,  0.0384, -0.0268, -0.0628, -0.0443, -0.0195, -0.0495,  0.1405,  0.0274, -0.0455, -0.0068,  0.0686, -0.0756, -0.0073, -0.0981,  0.0025,  0.0383,  0.0157,  0.0651,  0.0252, -0.0665,  0.0054, 0.0223,  0.0509,  0.0101,  0.0454, -0.0527,  0.0252, -0.0157, -0.0022, 0.0526,  0.0224,  0.0494,  0.0293, -0.0808, -0.1220,  0.0196,  0.0135, 0.0303, -0.0467,  0.0411, -0.0639,  0.0358,  0.0499,  0.0425,  0.0169, -0.0579,  0.0388,  0.0414, -0.0101,  0.0490, -0.0773,  0.0478, -0.0238, -0.0142, -0.0508,  0.0018, -0.0085,  0.0198,  0.0126,  0.0133, -0.0554, -0.0583, -0.0699, -0.0167,  0.0131,  0.0288, -0.0132,  0.0343, -0.0476, -0.0039, -0.0825, -0.1180, -0.0570, -0.0590,  0.0233,  0.0500, -0.0328, -0.0426,  0.0241,  0.0441,  0.0372,  0.0488, -0.0366, -0.0233, -0.0118, -0.0256,  0.0254,  0.0041,  0.0119,  0.0423,  0.0178, -0.0245, -0.0769, 0.0056,  0.0428,  0.0341, -0.0009, -0.0197,  0.0395,  0.0247,  0.0090, 0.0098, -0.0083,  0.0346,  0.0411,  0.0416,  0.0413,  0.0312,  0.0054, 0.0390, -0.0571, -0.0403,  0.0441, -0.0132,  0.0117,  0.0467,  0.0516,-0.0639,  0.0296,  0.0337, -0.0557,  0.0110,  0.0277, -0.0026,  0.0347, 0.0301,  0.0056, -0.0572, -0.0663,  0.0124, -0.0065,  0.0222,  0.0441,-0.0570, -0.0519,  0.0132,  0.0323,  0.0401,  0.0357, -0.0555,  0.0310,0.0028, -0.0102, -0.0598,  0.0153, -0.0438,  0.0268, -0.0097,  0.0388,-0.0330, -0.0277, -0.0581, -0.0389,  0.0099,  0.0371, -0.0455,  0.0553, 0.0753, -0.0154, -0.0385,  0.0359,  0.0403,  0.0464,  0.0499, -0.0365]])
-
-
-
-    speech = model.generate_speech(inputs["input_ids"], speaker_embeddings, vocoder=vocoder)
-
-    return speech
-
-def text_to_speech(text):
-    # Generate audio
-    audio_output = generate_audio(text)
-
-    output_path = "output.wav"
-    sf.write(output_path, audio_output.numpy(), 16000, "PCM_16")
-
-    return output_path
-
-
-examples = [
-    ['اگر رشتے داری ہے تو پیسے کی'],
-    ['میری تعلیم جیکی کی ہے۔']
-]
-
-
-interface = gr.Interface(fn=text_to_speech, inputs="text", outputs="audio", verbose = True, title="Urdu TTS", 
-                         description = "A simple Urdu Text to Speech Application. It is not by any means perfect and will not work for all text. You can sometimes expect it to generate random noise on an input of your choice. Right now it works successfully on very basic urdu text, such the ones in the example.", examples = examples)
-interface.launch()

spaces/AchyuthGamer/OpenGPT/g4f/Provider/DfeHub.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-import json
-import re
-import time
-
-import requests
-
-from ..typing import Any, CreateResult
-from .base_provider import BaseProvider
-
-
-class DfeHub(BaseProvider):
-    url                   = "https://chat.dfehub.com/"
-    supports_stream       = True
-    supports_gpt_35_turbo = True
-
-    @staticmethod
-    def create_completion(
-        model: str,
-        messages: list[dict[str, str]],
-        stream: bool, **kwargs: Any) -> CreateResult:
-        
-        headers = {
-            "authority"         : "chat.dfehub.com",
-            "accept"            : "*/*",
-            "accept-language"   : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
-            "content-type"      : "application/json",
-            "origin"            : "https://chat.dfehub.com",
-            "referer"           : "https://chat.dfehub.com/",
-            "sec-ch-ua"         : '"Not.A/Brand";v="8", "Chromium";v="114", "Google Chrome";v="114"',
-            "sec-ch-ua-mobile"  : "?0",
-            "sec-ch-ua-platform": '"macOS"',
-            "sec-fetch-dest"    : "empty",
-            "sec-fetch-mode"    : "cors",
-            "sec-fetch-site"    : "same-origin",
-            "user-agent"        : "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36",
-            "x-requested-with"  : "XMLHttpRequest",
-        }
-
-        json_data = {
-            "messages"          : messages,
-            "model"             : "gpt-3.5-turbo",
-            "temperature"       : kwargs.get("temperature", 0.5),
-            "presence_penalty"  : kwargs.get("presence_penalty", 0),
-            "frequency_penalty" : kwargs.get("frequency_penalty", 0),
-            "top_p"             : kwargs.get("top_p", 1),
-            "stream"            : True
-        }
-        
-        response = requests.post("https://chat.dfehub.com/api/openai/v1/chat/completions",
-            headers=headers, json=json_data, timeout=3)
-
-        for chunk in response.iter_lines():
-            if b"detail" in chunk:
-                delay = re.findall(r"\d+\.\d+", chunk.decode())
-                delay = float(delay[-1])
-                time.sleep(delay)
-                yield from DfeHub.create_completion(model, messages, stream, **kwargs)
-            if b"content" in chunk:
-                data = json.loads(chunk.decode().split("data: ")[1])
-                yield (data["choices"][0]["delta"]["content"])
-
-    @classmethod
-    @property
-    def params(cls):
-        params = [
-            ("model", "str"),
-            ("messages", "list[dict[str, str]]"),
-            ("stream", "bool"),
-            ("temperature", "float"),
-            ("presence_penalty", "int"),
-            ("frequency_penalty", "int"),
-            ("top_p", "int"),
-        ]
-        param = ", ".join([": ".join(p) for p in params])
-        return f"g4f.provider.{cls.__name__} supports: ({param})"

spaces/Adapter/T2I-Adapter/ldm/modules/extra_condition/midas/midas/dpt_depth.py

@@ -1,109 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from .base_model import BaseModel
-from .blocks import (
-    FeatureFusionBlock,
-    FeatureFusionBlock_custom,
-    Interpolate,
-    _make_encoder,
-    forward_vit,
-)
-
-
-def _make_fusion_block(features, use_bn):
-    return FeatureFusionBlock_custom(
-        features,
-        nn.ReLU(False),
-        deconv=False,
-        bn=use_bn,
-        expand=False,
-        align_corners=True,
-    )
-
-
-class DPT(BaseModel):
-    def __init__(
-        self,
-        head,
-        features=256,
-        backbone="vitb_rn50_384",
-        readout="project",
-        channels_last=False,
-        use_bn=False,
-    ):
-
-        super(DPT, self).__init__()
-
-        self.channels_last = channels_last
-
-        hooks = {
-            "vitb_rn50_384": [0, 1, 8, 11],
-            "vitb16_384": [2, 5, 8, 11],
-            "vitl16_384": [5, 11, 17, 23],
-        }
-
-        # Instantiate backbone and reassemble blocks
-        self.pretrained, self.scratch = _make_encoder(
-            backbone,
-            features,
-            False, # Set to true of you want to train from scratch, uses ImageNet weights
-            groups=1,
-            expand=False,
-            exportable=False,
-            hooks=hooks[backbone],
-            use_readout=readout,
-        )
-
-        self.scratch.refinenet1 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet2 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet3 = _make_fusion_block(features, use_bn)
-        self.scratch.refinenet4 = _make_fusion_block(features, use_bn)
-
-        self.scratch.output_conv = head
-
-
-    def forward(self, x):
-        if self.channels_last == True:
-            x.contiguous(memory_format=torch.channels_last)
-
-        layer_1, layer_2, layer_3, layer_4 = forward_vit(self.pretrained, x)
-
-        layer_1_rn = self.scratch.layer1_rn(layer_1)
-        layer_2_rn = self.scratch.layer2_rn(layer_2)
-        layer_3_rn = self.scratch.layer3_rn(layer_3)
-        layer_4_rn = self.scratch.layer4_rn(layer_4)
-
-        path_4 = self.scratch.refinenet4(layer_4_rn)
-        path_3 = self.scratch.refinenet3(path_4, layer_3_rn)
-        path_2 = self.scratch.refinenet2(path_3, layer_2_rn)
-        path_1 = self.scratch.refinenet1(path_2, layer_1_rn)
-
-        out = self.scratch.output_conv(path_1)
-
-        return out
-
-
-class DPTDepthModel(DPT):
-    def __init__(self, path=None, non_negative=True, **kwargs):
-        features = kwargs["features"] if "features" in kwargs else 256
-
-        head = nn.Sequential(
-            nn.Conv2d(features, features // 2, kernel_size=3, stride=1, padding=1),
-            Interpolate(scale_factor=2, mode="bilinear", align_corners=True),
-            nn.Conv2d(features // 2, 32, kernel_size=3, stride=1, padding=1),
-            nn.ReLU(True),
-            nn.Conv2d(32, 1, kernel_size=1, stride=1, padding=0),
-            nn.ReLU(True) if non_negative else nn.Identity(),
-            nn.Identity(),
-        )
-
-        super().__init__(head, **kwargs)
-
-        if path is not None:
-           self.load(path)
-
-    def forward(self, x):
-        return super().forward(x).squeeze(dim=1)
-

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/swipe/Swipe.d.ts

@@ -1,2 +0,0 @@
-import { Swipe } from '../../../plugins/gestures';
-export default Swipe;

spaces/AlanMars/QYL-AI-Space/assets/custom.js

@@ -1,607 +0,0 @@
-
-// custom javascript here
-
-const MAX_HISTORY_LENGTH = 32;
-
-var key_down_history = [];
-var currentIndex = -1;
-var user_input_ta;
-
-var gradioContainer = null;
-var user_input_ta = null;
-var user_input_tb = null;
-var userInfoDiv = null;
-var appTitleDiv = null;
-var chatbot = null;
-var chatbotWrap = null;
-var apSwitch = null;
-var empty_botton = null;
-var messageBotDivs = null;
-// var renderLatex = null;
-var loginUserForm = null;
-var logginUser = null;
-
-var userLogged = false;
-var usernameGotten = false;
-var shouldRenderLatex = false;
-var historyLoaded = false;
-
-var ga = document.getElementsByTagName("gradio-app");
-var targetNode = ga[0];
-var isInIframe = (window.self !== window.top);
-var language = navigator.language.slice(0,2);
-
-var forView_i18n = {
-    'zh': "仅供查看",
-    'en': "For viewing only",
-    'ja': "閲覧専用",
-    'fr': "Pour consultation seulement",
-    'es': "Solo para visualización",
-};
-
-// gradio 页面加载好了么??? 我能动你的元素了么??
-function gradioLoaded(mutations) {
-    for (var i = 0; i < mutations.length; i++) {
-        if (mutations[i].addedNodes.length) {
-            loginUserForm = document.querySelector(".gradio-container > .main > .wrap > .panel > .form")
-            gradioContainer = document.querySelector(".gradio-container");
-            user_input_tb = document.getElementById('user_input_tb');
-            userInfoDiv = document.getElementById("user_info");
-            appTitleDiv = document.getElementById("app_title");
-            chatbot = document.querySelector('#chuanhu_chatbot');
-            chatbotWrap = document.querySelector('#chuanhu_chatbot > .wrap');
-            apSwitch = document.querySelector('.apSwitch input[type="checkbox"]');
-            // renderLatex = document.querySelector("#render_latex_checkbox > label > input");
-            empty_botton = document.getElementById("empty_btn")
-
-            if (loginUserForm) {
-                localStorage.setItem("userLogged", true);
-                userLogged = true;
-            }
-
-            if (gradioContainer && apSwitch) {  // gradioCainter 加载出来了没?
-                adjustDarkMode();
-            }
-            if (user_input_tb) {  // user_input_tb 加载出来了没?
-                selectHistory();
-            }
-            if (userInfoDiv && appTitleDiv) {  // userInfoDiv 和 appTitleDiv 加载出来了没?
-                if (!usernameGotten) {
-                    getUserInfo();
-                }
-                setTimeout(showOrHideUserInfo(), 2000);
-            }
-            if (chatbot) {  // chatbot 加载出来了没?
-                setChatbotHeight();
-            }
-            if (chatbotWrap) {
-                if (!historyLoaded) {
-                    loadHistoryHtml();
-                }
-                setChatbotScroll();
-            }
-            // if (renderLatex) {  // renderLatex 加载出来了没?
-            //     shouldRenderLatex = renderLatex.checked;
-            //     updateMathJax();
-            // }
-            if (empty_botton) {
-                emptyHistory();
-            }
-        }
-    }
-}
-
-function webLocale() {
-    console.log("webLocale", language);
-    if (forView_i18n.hasOwnProperty(language)) {
-        var forView = forView_i18n[language];
-        var forViewStyle = document.createElement('style');
-        forViewStyle.innerHTML = '.wrap>.history-message>:last-child::after { content: "' + forView + '"!important; }';
-        document.head.appendChild(forViewStyle);
-        // console.log("added forViewStyle", forView);
-    }
-}
-
-function selectHistory() {
-    user_input_ta = user_input_tb.querySelector("textarea");
-    if (user_input_ta) {
-        observer.disconnect(); // 停止监听
-        // 在 textarea 上监听 keydown 事件
-        user_input_ta.addEventListener("keydown", function (event) {
-            var value = user_input_ta.value.trim();
-            // 判断按下的是否为方向键
-            if (event.code === 'ArrowUp' || event.code === 'ArrowDown') {
-                // 如果按下的是方向键，且输入框中有内容，且历史记录中没有该内容，则不执行操作
-                if (value && key_down_history.indexOf(value) === -1)
-                    return;
-                // 对于需要响应的动作，阻止默认行为。
-                event.preventDefault();
-                var length = key_down_history.length;
-                if (length === 0) {
-                    currentIndex = -1; // 如果历史记录为空，直接将当前选中的记录重置
-                    return;
-                }
-                if (currentIndex === -1) {
-                    currentIndex = length;
-                }
-                if (event.code === 'ArrowUp' && currentIndex > 0) {
-                    currentIndex--;
-                    user_input_ta.value = key_down_history[currentIndex];
-                } else if (event.code === 'ArrowDown' && currentIndex < length - 1) {
-                    currentIndex++;
-                    user_input_ta.value = key_down_history[currentIndex];
-                }
-                user_input_ta.selectionStart = user_input_ta.value.length;
-                user_input_ta.selectionEnd = user_input_ta.value.length;
-                const input_event = new InputEvent("input", { bubbles: true, cancelable: true });
-                user_input_ta.dispatchEvent(input_event);
-            } else if (event.code === "Enter") {
-                if (value) {
-                    currentIndex = -1;
-                    if (key_down_history.indexOf(value) === -1) {
-                        key_down_history.push(value);
-                        if (key_down_history.length > MAX_HISTORY_LENGTH) {
-                            key_down_history.shift();
-                        }
-                    }
-                }
-            }
-        });
-    }
-}
-
-var username = null;
-function getUserInfo() {
-    if (usernameGotten) {
-        return;
-    }
-    userLogged = localStorage.getItem('userLogged');
-    if (userLogged) {
-        username = userInfoDiv.innerText;
-        if (username) {
-            if (username.includes("getting user info…")) {
-                setTimeout(getUserInfo, 500);
-                return;
-            } else if (username === " ") {
-                localStorage.removeItem("username");
-                localStorage.removeItem("userLogged")
-                userLogged = false;
-                usernameGotten = true;
-                return;
-            } else {
-                username = username.match(/User:\s*(.*)/)[1] || username;
-                localStorage.setItem("username", username);
-                usernameGotten = true;
-                clearHistoryHtml();
-            }
-        }
-    }
-}
-
-function toggleUserInfoVisibility(shouldHide) {
-    if (userInfoDiv) {
-        if (shouldHide) {
-            userInfoDiv.classList.add("hideK");
-        } else {
-            userInfoDiv.classList.remove("hideK");
-        }
-    }
-}
-function showOrHideUserInfo() {
-    var sendBtn = document.getElementById("submit_btn");
-
-    // Bind mouse/touch events to show/hide user info
-    appTitleDiv.addEventListener("mouseenter", function () {
-        toggleUserInfoVisibility(false);
-    });
-    userInfoDiv.addEventListener("mouseenter", function () {
-        toggleUserInfoVisibility(false);
-    });
-    sendBtn.addEventListener("mouseenter", function () {
-        toggleUserInfoVisibility(false);
-    });
-
-    appTitleDiv.addEventListener("mouseleave", function () {
-        toggleUserInfoVisibility(true);
-    });
-    userInfoDiv.addEventListener("mouseleave", function () {
-        toggleUserInfoVisibility(true);
-    });
-    sendBtn.addEventListener("mouseleave", function () {
-        toggleUserInfoVisibility(true);
-    });
-
-    appTitleDiv.ontouchstart = function () {
-        toggleUserInfoVisibility(false);
-    };
-    userInfoDiv.ontouchstart = function () {
-        toggleUserInfoVisibility(false);
-    };
-    sendBtn.ontouchstart = function () {
-        toggleUserInfoVisibility(false);
-    };
-
-    appTitleDiv.ontouchend = function () {
-        setTimeout(function () {
-            toggleUserInfoVisibility(true);
-        }, 3000);
-    };
-    userInfoDiv.ontouchend = function () {
-        setTimeout(function () {
-            toggleUserInfoVisibility(true);
-        }, 3000);
-    };
-    sendBtn.ontouchend = function () {
-        setTimeout(function () {
-            toggleUserInfoVisibility(true);
-        }, 3000); // Delay 1 second to hide user info
-    };
-
-    // Hide user info after 2 second
-    setTimeout(function () {
-        toggleUserInfoVisibility(true);
-    }, 2000);
-}
-
-function toggleDarkMode(isEnabled) {
-    if (isEnabled) {
-        gradioContainer.classList.add("dark");
-        document.body.style.setProperty("background-color", "var(--neutral-950)", "important");
-    } else {
-        gradioContainer.classList.remove("dark");
-        document.body.style.backgroundColor = "";
-    }
-}
-function adjustDarkMode() {
-    const darkModeQuery = window.matchMedia("(prefers-color-scheme: dark)");
-
-    // 根据当前颜色模式设置初始状态
-    apSwitch.checked = darkModeQuery.matches;
-    toggleDarkMode(darkModeQuery.matches);
-    // 监听颜色模式变化
-    darkModeQuery.addEventListener("change", (e) => {
-        apSwitch.checked = e.matches;
-        toggleDarkMode(e.matches);
-    });
-    // apSwitch = document.querySelector('.apSwitch input[type="checkbox"]');
-    apSwitch.addEventListener("change", (e) => {
-        toggleDarkMode(e.target.checked);
-    });
-}
-
-function setChatbotHeight() {
-    const screenWidth = window.innerWidth;
-    const statusDisplay = document.querySelector('#status_display');
-    const statusDisplayHeight = statusDisplay ? statusDisplay.offsetHeight : 0;
-    const wrap = chatbot.querySelector('.wrap');
-    const vh = window.innerHeight * 0.01;
-    document.documentElement.style.setProperty('--vh', `${vh}px`);
-    if (isInIframe) {
-        chatbot.style.height = `520px`;
-        wrap.style.maxHeight = `calc(520px - var(--line-sm) * 1rem - 2 * var(--block-label-margin))`
-    } else {
-        if (screenWidth <= 320) {
-            chatbot.style.height = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 150}px)`;
-            wrap.style.maxHeight = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 150}px - var(--line-sm) * 1rem - 2 * var(--block-label-margin))`;
-        } else if (screenWidth <= 499) {
-            chatbot.style.height = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 100}px)`;
-            wrap.style.maxHeight = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 100}px - var(--line-sm) * 1rem - 2 * var(--block-label-margin))`;
-        } else {
-            chatbot.style.height = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 160}px)`;
-            wrap.style.maxHeight = `calc(var(--vh, 1vh) * 100 - ${statusDisplayHeight + 160}px - var(--line-sm) * 1rem - 2 * var(--block-label-margin))`;
-        }
-    }
-}
-function setChatbotScroll() {
-    var scrollHeight = chatbotWrap.scrollHeight;
-    chatbotWrap.scrollTo(0,scrollHeight)
-}
-var rangeInputs = null;
-var numberInputs = null;
-function setSlider() {
-    rangeInputs = document.querySelectorAll('input[type="range"]');
-    numberInputs = document.querySelectorAll('input[type="number"]')
-    setSliderRange();
-    rangeInputs.forEach(rangeInput => {
-        rangeInput.addEventListener('input', setSliderRange);
-    });
-    numberInputs.forEach(numberInput => {
-        numberInput.addEventListener('input', setSliderRange);
-    })
-}
-function setSliderRange() {
-    var range = document.querySelectorAll('input[type="range"]');
-    range.forEach(range => {
-        range.style.backgroundSize = (range.value - range.min) / (range.max - range.min) * 100 + '% 100%';
-    });
-}
-
-function addChuanhuButton(botElement) {
-    var rawMessage = null;
-    var mdMessage = null;
-    rawMessage = botElement.querySelector('.raw-message');
-    mdMessage = botElement.querySelector('.md-message');
-    if (!rawMessage) {
-        var buttons = botElement.querySelectorAll('button.chuanhu-btn');
-        for (var i = 0; i < buttons.length; i++) {
-            buttons[i].parentNode.removeChild(buttons[i]);
-        }
-        return;
-    }
-    var copyButton = null;
-    var toggleButton = null;
-    copyButton = botElement.querySelector('button.copy-bot-btn');
-    toggleButton = botElement.querySelector('button.toggle-md-btn');
-    if (copyButton) copyButton.remove();
-    if (toggleButton) toggleButton.remove();
-
-    // Copy bot button
-    var copyButton = document.createElement('button');
-    copyButton.classList.add('chuanhu-btn');
-    copyButton.classList.add('copy-bot-btn');
-    copyButton.setAttribute('aria-label', 'Copy');
-    copyButton.innerHTML = copyIcon;
-    copyButton.addEventListener('click', () => {
-        const textToCopy = rawMessage.innerText;
-        navigator.clipboard
-            .writeText(textToCopy)
-            .then(() => {
-                copyButton.innerHTML = copiedIcon;
-                setTimeout(() => {
-                    copyButton.innerHTML = copyIcon;
-                }, 1500);
-            })
-            .catch(() => {
-                console.error("copy failed");
-            });
-    });
-    botElement.appendChild(copyButton);
-
-    // Toggle button
-    var toggleButton = document.createElement('button');
-    toggleButton.classList.add('chuanhu-btn');
-    toggleButton.classList.add('toggle-md-btn');
-    toggleButton.setAttribute('aria-label', 'Toggle');
-    var renderMarkdown = mdMessage.classList.contains('hideM');
-    toggleButton.innerHTML = renderMarkdown ? mdIcon : rawIcon;
-    toggleButton.addEventListener('click', () => {
-        renderMarkdown = mdMessage.classList.contains('hideM');
-        if (renderMarkdown){
-            renderMarkdownText(botElement);
-            toggleButton.innerHTML=rawIcon;
-        } else {
-            removeMarkdownText(botElement);
-            toggleButton.innerHTML=mdIcon;
-        }
-    });
-    botElement.insertBefore(toggleButton, copyButton);
-}
-
-function addCopyCodeButton(pre) {
-    var code = null;
-    var firstChild = null;
-    code = pre.querySelector('code');
-    if (!code) return;
-    firstChild = code.querySelector('div');
-    if (!firstChild) return;
-    var oldCopyButton = null;
-    oldCopyButton = code.querySelector('button.copy-code-btn');
-    // if (oldCopyButton) oldCopyButton.remove();
-    if (oldCopyButton) return; // 没太有用，新生成的对话中始终会被pre覆盖，导致按钮消失，这段代码不启用……
-    var codeButton = document.createElement('button');
-    codeButton.classList.add('copy-code-btn');
-    codeButton.textContent = '\uD83D\uDCCE';
-
-    code.insertBefore(codeButton, firstChild);
-    codeButton.addEventListener('click', function () {
-        var range = document.createRange();
-        range.selectNodeContents(code);
-        range.setStartBefore(firstChild);
-        navigator.clipboard
-            .writeText(range.toString())
-            .then(() => {
-                codeButton.textContent = '\u2714';
-                setTimeout(function () {
-                    codeButton.textContent = '\uD83D\uDCCE';
-                }, 2000);
-            })
-            .catch(e => {
-                console.error(e);
-                codeButton.textContent = '\u2716';
-            });
-    });
-}
-
-function renderMarkdownText(message) {
-    var mdDiv = message.querySelector('.md-message');
-    if (mdDiv) mdDiv.classList.remove('hideM');
-    var rawDiv = message.querySelector('.raw-message');
-    if (rawDiv) rawDiv.classList.add('hideM');
-}
-function removeMarkdownText(message) {
-    var rawDiv = message.querySelector('.raw-message');
-    if (rawDiv) rawDiv.classList.remove('hideM');
-    var mdDiv = message.querySelector('.md-message');
-    if (mdDiv) mdDiv.classList.add('hideM');
-}
-
-var rendertime = 0; // for debugging
-var mathjaxUpdated = false;
-
-function renderMathJax() {
-    messageBotDivs = document.querySelectorAll('.message.bot .md-message');
-    for (var i = 0; i < messageBotDivs.length; i++) {
-        var mathJaxSpan = messageBotDivs[i].querySelector('.MathJax_Preview');
-        if (!mathJaxSpan && shouldRenderLatex && !mathjaxUpdated) {
-            MathJax.Hub.Queue(["Typeset", MathJax.Hub, messageBotDivs[i]]);
-            rendertime +=1; // for debugging
-            // console.log("renderingMathJax", i)
-        }
-    }
-    mathjaxUpdated = true;
-    // console.log("MathJax Rendered")
-}
-
-function removeMathjax() {
-    // var jax = MathJax.Hub.getAllJax();
-    // for (var i = 0; i < jax.length; i++) {
-    //     // MathJax.typesetClear(jax[i]);
-    //     jax[i].Text(newmath)
-    //     jax[i].Reprocess()
-    // }
-    // 我真的不会了啊啊啊，mathjax并没有提供转换为原先文本的办法。
-    mathjaxUpdated = true;
-    // console.log("MathJax removed!");
-}
-
-function updateMathJax() {
-    // renderLatex.addEventListener("change", function() {
-    //     shouldRenderLatex = renderLatex.checked;
-    //     if (!mathjaxUpdated) {
-    //         if (shouldRenderLatex) {
-    //             renderMathJax();
-    //         } else {
-    //             console.log("MathJax Disabled")
-    //             removeMathjax();
-    //         }
-    //     } else {
-    //         if (!shouldRenderLatex) {
-    //             mathjaxUpdated = false; // reset
-    //         }
-    //     }
-    // });
-    if (shouldRenderLatex && !mathjaxUpdated) {
-        renderMathJax();
-    }
-    mathjaxUpdated = false;
-}
-
-let timeoutId;
-let isThrottled = false;
-var mmutation
-// 监听所有元素中 bot message 的变化，用来查找需要渲染的mathjax, 并为 bot 消息添加复制按钮。
-var mObserver = new MutationObserver(function (mutationsList) {
-    for (mmutation of mutationsList) {
-        if (mmutation.type === 'childList') {
-            for (var node of mmutation.addedNodes) {
-                if (node.nodeType === 1 && node.classList.contains('message') && node.getAttribute('data-testid') === 'bot') {
-                    if (shouldRenderLatex) {
-                        renderMathJax();
-                        mathjaxUpdated = false;
-                    }
-                    saveHistoryHtml();
-                    document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot').forEach(addChuanhuButton);
-                    document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot pre').forEach(addCopyCodeButton);
-                }
-                if (node.tagName === 'INPUT' && node.getAttribute('type') === 'range') {
-                    setSlider();
-                }
-            }
-            for (var node of mmutation.removedNodes) {
-                if (node.nodeType === 1 && node.classList.contains('message') && node.getAttribute('data-testid') === 'bot') {
-                    if (shouldRenderLatex) {
-                        renderMathJax();
-                        mathjaxUpdated = false;
-                    }
-                    saveHistoryHtml();
-                    document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot').forEach(addChuanhuButton);
-                    document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot pre').forEach(addCopyCodeButton);
-                }
-            }
-        } else if (mmutation.type === 'attributes') {
-            if (mmutation.target.nodeType === 1 && mmutation.target.classList.contains('message') && mmutation.target.getAttribute('data-testid') === 'bot') {
-                document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot pre').forEach(addCopyCodeButton); // 目前写的是有点问题的，会导致加button次数过多，但是bot对话内容生成时又是不断覆盖pre的……
-                if (isThrottled) break; // 为了防止重复不断疯狂渲染，加上等待_(:з」∠)_
-                isThrottled = true;
-                clearTimeout(timeoutId);
-                timeoutId = setTimeout(() => {
-                    isThrottled = false;
-                    if (shouldRenderLatex) {
-                        renderMathJax();
-                        mathjaxUpdated = false;
-                    }
-                    document.querySelectorAll('#chuanhu_chatbot>.wrap>.message-wrap .message.bot').forEach(addChuanhuButton);
-                    saveHistoryHtml();
-                }, 500);
-            }
-        }
-    }
-});
-mObserver.observe(document.documentElement, { attributes: true, childList: true, subtree: true });
-
-var loadhistorytime = 0; // for debugging
-function saveHistoryHtml() {
-    var historyHtml = document.querySelector('#chuanhu_chatbot > .wrap');
-    localStorage.setItem('chatHistory', historyHtml.innerHTML);
-    // console.log("History Saved")
-    historyLoaded = false;
-}
-function loadHistoryHtml() {
-    var historyHtml = localStorage.getItem('chatHistory');
-    if (!historyHtml) {
-        historyLoaded = true;
-        return; // no history, do nothing
-    }
-    userLogged = localStorage.getItem('userLogged');
-    if (userLogged){
-        historyLoaded = true;
-        return; // logged in, do nothing
-    }
-    if (!historyLoaded) {
-        var tempDiv = document.createElement('div');
-        tempDiv.innerHTML = historyHtml;
-        var buttons = tempDiv.querySelectorAll('button.chuanhu-btn');
-        for (var i = 0; i < buttons.length; i++) {
-            buttons[i].parentNode.removeChild(buttons[i]);
-        }
-        var fakeHistory = document.createElement('div');
-        fakeHistory.classList.add('history-message');
-        fakeHistory.innerHTML = tempDiv.innerHTML;
-        webLocale();
-        chatbotWrap.insertBefore(fakeHistory, chatbotWrap.firstChild);
-        // var fakeHistory = document.createElement('div');
-        // fakeHistory.classList.add('history-message');
-        // fakeHistory.innerHTML = historyHtml;
-        // chatbotWrap.insertBefore(fakeHistory, chatbotWrap.firstChild);
-        historyLoaded = true;
-        console.log("History Loaded");
-        loadhistorytime += 1; // for debugging
-    } else {
-        historyLoaded = false;
-    }
-}
-function clearHistoryHtml() {
-    localStorage.removeItem("chatHistory");
-    historyMessages = chatbotWrap.querySelector('.history-message');
-    if (historyMessages) {
-        chatbotWrap.removeChild(historyMessages);
-        console.log("History Cleared");
-    }
-}
-function emptyHistory() {
-    empty_botton.addEventListener("click", function () {
-        clearHistoryHtml();
-    });
-}
-
-// 监视页面内部 DOM 变动
-var observer = new MutationObserver(function (mutations) {
-    gradioLoaded(mutations);
-});
-observer.observe(targetNode, { childList: true, subtree: true });
-
-// 监视页面变化
-window.addEventListener("DOMContentLoaded", function () {
-    isInIframe = (window.self !== window.top);
-    historyLoaded = false;
-    shouldRenderLatex = !!document.querySelector('script[src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML"]');
-});
-window.addEventListener('resize', setChatbotHeight);
-window.addEventListener('scroll', setChatbotHeight);
-window.matchMedia("(prefers-color-scheme: dark)").addEventListener("change", adjustDarkMode);
-
-// button svg code
-const copyIcon   = '<span><svg stroke="currentColor" fill="none" stroke-width="2" viewBox="0 0 24 24" stroke-linecap="round" stroke-linejoin="round" height=".8em" width=".8em" xmlns="http://www.w3.org/2000/svg"><rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect><path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path></svg></span>';
-const copiedIcon = '<span><svg stroke="currentColor" fill="none" stroke-width="2" viewBox="0 0 24 24" stroke-linecap="round" stroke-linejoin="round" height=".8em" width=".8em" xmlns="http://www.w3.org/2000/svg"><polyline points="20 6 9 17 4 12"></polyline></svg></span>';
-const mdIcon     = '<span><svg stroke="currentColor" fill="none" stroke-width="1" viewBox="0 0 14 18" stroke-linecap="round" stroke-linejoin="round" height=".8em" width=".8em" xmlns="http://www.w3.org/2000/svg"><g transform-origin="center" transform="scale(0.85)"><path d="M1.5,0 L12.5,0 C13.3284271,-1.52179594e-16 14,0.671572875 14,1.5 L14,16.5 C14,17.3284271 13.3284271,18 12.5,18 L1.5,18 C0.671572875,18 1.01453063e-16,17.3284271 0,16.5 L0,1.5 C-1.01453063e-16,0.671572875 0.671572875,1.52179594e-16 1.5,0 Z" stroke-width="1.8"></path><line x1="3.5" y1="3.5" x2="10.5" y2="3.5"></line><line x1="3.5" y1="6.5" x2="8" y2="6.5"></line></g><path d="M4,9 L10,9 C10.5522847,9 11,9.44771525 11,10 L11,13.5 C11,14.0522847 10.5522847,14.5 10,14.5 L4,14.5 C3.44771525,14.5 3,14.0522847 3,13.5 L3,10 C3,9.44771525 3.44771525,9 4,9 Z" stroke="none" fill="currentColor"></path></svg></span>';
-const rawIcon    = '<span><svg stroke="currentColor" fill="none" stroke-width="1.8" viewBox="0 0 18 14" stroke-linecap="round" stroke-linejoin="round" height=".8em" width=".8em" xmlns="http://www.w3.org/2000/svg"><g transform-origin="center" transform="scale(0.85)"><polyline points="4 3 0 7 4 11"></polyline><polyline points="14 3 18 7 14 11"></polyline><line x1="12" y1="0" x2="6" y2="14"></line></g></svg></span>';

spaces/AlexWang/lama/saicinpainting/evaluation/masks/countless/test.py

@@ -1,195 +0,0 @@
-from copy import deepcopy
-
-import numpy as np
-
-import countless2d
-import countless3d
-
-def test_countless2d():
-  def test_all_cases(fn, test_zero):
-    case1 = np.array([ [ 1, 2 ], [ 3, 4 ] ]).reshape((2,2,1,1)) # all different
-    case2 = np.array([ [ 1, 1 ], [ 2, 3 ] ]).reshape((2,2,1,1)) # two are same
-    case1z = np.array([ [ 0, 1 ], [ 2, 3 ] ]).reshape((2,2,1,1)) # all different
-    case2z = np.array([ [ 0, 0 ], [ 2, 3 ] ]).reshape((2,2,1,1)) # two are same
-    case3 = np.array([ [ 1, 1 ], [ 2, 2 ] ]).reshape((2,2,1,1)) # two groups are same
-    case4 = np.array([ [ 1, 2 ], [ 2, 2 ] ]).reshape((2,2,1,1)) # 3 are the same
-    case5 = np.array([ [ 5, 5 ], [ 5, 5 ] ]).reshape((2,2,1,1)) # all are the same
-
-    is_255_handled = np.array([ [ 255, 255 ], [ 1, 2 ] ], dtype=np.uint8).reshape((2,2,1,1))
-
-    test = lambda case: fn(case)
-
-    if test_zero:
-      assert test(case1z) == [[[[3]]]] # d
-      assert test(case2z) == [[[[0]]]] # a==b
-    else:
-      assert test(case1) == [[[[4]]]] # d
-      assert test(case2) == [[[[1]]]] # a==b
-
-    assert test(case3) == [[[[1]]]] # a==b
-    assert test(case4) == [[[[2]]]] # b==c
-    assert test(case5) == [[[[5]]]] # a==b
-    
-    assert test(is_255_handled) == [[[[255]]]] 
-
-    assert fn(case1).dtype == case1.dtype
-
-  test_all_cases(countless2d.simplest_countless, False)
-  test_all_cases(countless2d.quick_countless, False)
-  test_all_cases(countless2d.quickest_countless, False)
-  test_all_cases(countless2d.stippled_countless, False)
-
-
-
-  methods = [
-    countless2d.zero_corrected_countless,
-    countless2d.countless,
-    countless2d.countless_if,
-    # countless2d.counting, # counting doesn't respect order so harder to write a test
-  ]
-
-  for fn in methods:
-    print(fn.__name__)
-    test_all_cases(fn, True)
-
-def test_stippled_countless2d():
-  a = np.array([ [ 1, 2 ], [ 3, 4 ] ]).reshape((2,2,1,1)) 
-  b = np.array([ [ 0, 2 ], [ 3, 4 ] ]).reshape((2,2,1,1)) 
-  c = np.array([ [ 1, 0 ], [ 3, 4 ] ]).reshape((2,2,1,1)) 
-  d = np.array([ [ 1, 2 ], [ 0, 4 ] ]).reshape((2,2,1,1)) 
-  e = np.array([ [ 1, 2 ], [ 3, 0 ] ]).reshape((2,2,1,1)) 
-  f = np.array([ [ 0, 0 ], [ 3, 4 ] ]).reshape((2,2,1,1)) 
-  g = np.array([ [ 0, 2 ], [ 0, 4 ] ]).reshape((2,2,1,1)) 
-  h = np.array([ [ 0, 2 ], [ 3, 0 ] ]).reshape((2,2,1,1)) 
-  i = np.array([ [ 1, 0 ], [ 0, 4 ] ]).reshape((2,2,1,1)) 
-  j = np.array([ [ 1, 2 ], [ 0, 0 ] ]).reshape((2,2,1,1)) 
-  k = np.array([ [ 1, 0 ], [ 3, 0 ] ]).reshape((2,2,1,1)) 
-  l = np.array([ [ 1, 0 ], [ 0, 0 ] ]).reshape((2,2,1,1)) 
-  m = np.array([ [ 0, 2 ], [ 0, 0 ] ]).reshape((2,2,1,1)) 
-  n = np.array([ [ 0, 0 ], [ 3, 0 ] ]).reshape((2,2,1,1)) 
-  o = np.array([ [ 0, 0 ], [ 0, 4 ] ]).reshape((2,2,1,1)) 
-  z = np.array([ [ 0, 0 ], [ 0, 0 ] ]).reshape((2,2,1,1)) 
-
-  test = countless2d.stippled_countless
-
-  # Note: We only tested non-matching cases above,
-  # cases f,g,h,i,j,k prove their duals work as well
-  # b/c if two pixels are black, either one can be chosen
-  # if they are different or the same.
-
-  assert test(a) == [[[[4]]]] 
-  assert test(b) == [[[[4]]]] 
-  assert test(c) == [[[[4]]]] 
-  assert test(d) == [[[[4]]]] 
-  assert test(e) == [[[[1]]]] 
-  assert test(f) == [[[[4]]]]  
-  assert test(g) == [[[[4]]]]  
-  assert test(h) == [[[[2]]]]  
-  assert test(i) == [[[[4]]]] 
-  assert test(j) == [[[[1]]]]  
-  assert test(k) == [[[[1]]]]  
-  assert test(l) == [[[[1]]]]  
-  assert test(m) == [[[[2]]]]  
-  assert test(n) == [[[[3]]]]  
-  assert test(o) == [[[[4]]]]  
-  assert test(z) == [[[[0]]]]  
-
-  bc = np.array([ [ 0, 2 ], [ 2, 4 ] ]).reshape((2,2,1,1)) 
-  bd = np.array([ [ 0, 2 ], [ 3, 2 ] ]).reshape((2,2,1,1)) 
-  cd = np.array([ [ 0, 2 ], [ 3, 3 ] ]).reshape((2,2,1,1)) 
-  
-  assert test(bc) == [[[[2]]]]
-  assert test(bd) == [[[[2]]]]
-  assert test(cd) == [[[[3]]]]
-
-  ab = np.array([ [ 1, 1 ], [ 0, 4 ] ]).reshape((2,2,1,1)) 
-  ac = np.array([ [ 1, 2 ], [ 1, 0 ] ]).reshape((2,2,1,1)) 
-  ad = np.array([ [ 1, 0 ], [ 3, 1 ] ]).reshape((2,2,1,1)) 
-
-  assert test(ab) == [[[[1]]]]
-  assert test(ac) == [[[[1]]]]
-  assert test(ad) == [[[[1]]]]
-    
-def test_countless3d():
-  def test_all_cases(fn):
-    alldifferent = [
-      [
-        [1,2],
-        [3,4],
-      ],
-      [
-        [5,6],
-        [7,8]
-      ]
-    ]
-    allsame = [
-      [
-        [1,1],
-        [1,1],
-      ],
-      [
-        [1,1],
-        [1,1]
-      ]
-    ]
-
-    assert fn(np.array(alldifferent)) == [[[8]]]
-    assert fn(np.array(allsame)) == [[[1]]]
-
-    twosame = deepcopy(alldifferent)
-    twosame[1][1][0] = 2
-
-    assert fn(np.array(twosame)) == [[[2]]]
-
-    threemixed = [
-      [
-        [3,3],
-        [1,2],
-      ],
-      [
-        [2,4],
-        [4,3]
-      ]
-    ]
-    assert fn(np.array(threemixed)) == [[[3]]]
-
-    foursame = [
-      [
-        [4,4],
-        [1,2],
-      ],
-      [
-        [2,4],
-        [4,3]
-      ]
-    ]
-
-    assert fn(np.array(foursame)) == [[[4]]]
-
-    fivesame = [
-      [
-        [5,4],
-        [5,5],
-      ],
-      [
-        [2,4],
-        [5,5]
-      ]
-    ]
-
-    assert fn(np.array(fivesame)) == [[[5]]]
-
-  def countless3d_generalized(img):
-    return countless3d.countless_generalized(img, (2,2,2))
-  def countless3d_dynamic_generalized(img):
-    return countless3d.dynamic_countless_generalized(img, (2,2,2))
-
-  methods = [
-    countless3d.countless3d,
-    countless3d.dynamic_countless3d,
-    countless3d_generalized,
-    countless3d_dynamic_generalized,
-  ]
-
-  for fn in methods:
-    test_all_cases(fn)

spaces/Aloento/9Nine-PITS/text/symbols.py

@@ -1,14 +0,0 @@
-"""
-Defines the set of symbols used in text input to the model.
-"""
-
-_pad = '_'
-_punctuation = ',.!?-~…'
-_letters = 'NQabdefghijklmnopstuvwxyzɑæʃʑçɯɪɔɛɹðəɫɥɸʊɾʒθβŋɦ⁼ʰ`^#*=ˈˌ→↓↑ '
-
-_extra = "ˌ%$"
-# Export all symbols:
-symbols = [_pad] + list(_punctuation) + list(_letters) + list(_extra)
-
-# Special symbol ids
-SPACE_ID = symbols.index(" ")

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/research_projects/mulit_token_textual_inversion/multi_token_clip.py

@@ -1,103 +0,0 @@
-"""
-The main idea for this code is to provide a way for users to not need to bother with the hassle of multiple tokens for a concept by typing
-a photo of <concept>_0 <concept>_1 ... and so on
-and instead just do
-a photo of <concept>
-which gets translated to the above. This needs to work for both inference and training.
-For inference,
-the tokenizer encodes the text. So, we would want logic for our tokenizer to replace the placeholder token with
-it's underlying vectors
-For training,
-we would want to abstract away some logic like
-1. Adding tokens
-2. Updating gradient mask
-3. Saving embeddings
-to our Util class here.
-so
-TODO:
-1. have tokenizer keep track of concept, multiconcept pairs and replace during encode call x
-2. have mechanism for adding tokens x
-3. have mech for saving emebeddings x
-4. get mask to update x
-5. Loading tokens from embedding x
-6. Integrate to training x
-7. Test
-"""
-import copy
-import random
-
-from transformers import CLIPTokenizer
-
-
-class MultiTokenCLIPTokenizer(CLIPTokenizer):
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        self.token_map = {}
-
-    def try_adding_tokens(self, placeholder_token, *args, **kwargs):
-        num_added_tokens = super().add_tokens(placeholder_token, *args, **kwargs)
-        if num_added_tokens == 0:
-            raise ValueError(
-                f"The tokenizer already contains the token {placeholder_token}. Please pass a different"
-                " `placeholder_token` that is not already in the tokenizer."
-            )
-
-    def add_placeholder_tokens(self, placeholder_token, *args, num_vec_per_token=1, **kwargs):
-        output = []
-        if num_vec_per_token == 1:
-            self.try_adding_tokens(placeholder_token, *args, **kwargs)
-            output.append(placeholder_token)
-        else:
-            output = []
-            for i in range(num_vec_per_token):
-                ith_token = placeholder_token + f"_{i}"
-                self.try_adding_tokens(ith_token, *args, **kwargs)
-                output.append(ith_token)
-        # handle cases where there is a new placeholder token that contains the current placeholder token but is larger
-        for token in self.token_map:
-            if token in placeholder_token:
-                raise ValueError(
-                    f"The tokenizer already has placeholder token {token} that can get confused with"
-                    f" {placeholder_token}keep placeholder tokens independent"
-                )
-        self.token_map[placeholder_token] = output
-
-    def replace_placeholder_tokens_in_text(self, text, vector_shuffle=False, prop_tokens_to_load=1.0):
-        """
-        Here, we replace the placeholder tokens in text recorded in token_map so that the text_encoder
-        can encode them
-        vector_shuffle was inspired by https://github.com/rinongal/textual_inversion/pull/119
-        where shuffling tokens were found to force the model to learn the concepts more descriptively.
-        """
-        if isinstance(text, list):
-            output = []
-            for i in range(len(text)):
-                output.append(self.replace_placeholder_tokens_in_text(text[i], vector_shuffle=vector_shuffle))
-            return output
-        for placeholder_token in self.token_map:
-            if placeholder_token in text:
-                tokens = self.token_map[placeholder_token]
-                tokens = tokens[: 1 + int(len(tokens) * prop_tokens_to_load)]
-                if vector_shuffle:
-                    tokens = copy.copy(tokens)
-                    random.shuffle(tokens)
-                text = text.replace(placeholder_token, " ".join(tokens))
-        return text
-
-    def __call__(self, text, *args, vector_shuffle=False, prop_tokens_to_load=1.0, **kwargs):
-        return super().__call__(
-            self.replace_placeholder_tokens_in_text(
-                text, vector_shuffle=vector_shuffle, prop_tokens_to_load=prop_tokens_to_load
-            ),
-            *args,
-            **kwargs,
-        )
-
-    def encode(self, text, *args, vector_shuffle=False, prop_tokens_to_load=1.0, **kwargs):
-        return super().encode(
-            self.replace_placeholder_tokens_in_text(
-                text, vector_shuffle=vector_shuffle, prop_tokens_to_load=prop_tokens_to_load
-            ),
-            *args,
-            **kwargs,
-        )

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/pipelines/shap_e/camera.py

@@ -1,147 +0,0 @@
-# Copyright 2023 Open AI and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-from dataclasses import dataclass
-from typing import Tuple
-
-import numpy as np
-import torch
-
-
-@dataclass
-class DifferentiableProjectiveCamera:
-    """
-    Implements a batch, differentiable, standard pinhole camera
-    """
-
-    origin: torch.Tensor  # [batch_size x 3]
-    x: torch.Tensor  # [batch_size x 3]
-    y: torch.Tensor  # [batch_size x 3]
-    z: torch.Tensor  # [batch_size x 3]
-    width: int
-    height: int
-    x_fov: float
-    y_fov: float
-    shape: Tuple[int]
-
-    def __post_init__(self):
-        assert self.x.shape[0] == self.y.shape[0] == self.z.shape[0] == self.origin.shape[0]
-        assert self.x.shape[1] == self.y.shape[1] == self.z.shape[1] == self.origin.shape[1] == 3
-        assert len(self.x.shape) == len(self.y.shape) == len(self.z.shape) == len(self.origin.shape) == 2
-
-    def resolution(self):
-        return torch.from_numpy(np.array([self.width, self.height], dtype=np.float32))
-
-    def fov(self):
-        return torch.from_numpy(np.array([self.x_fov, self.y_fov], dtype=np.float32))
-
-    def get_image_coords(self) -> torch.Tensor:
-        """
-        :return: coords of shape (width * height, 2)
-        """
-        pixel_indices = torch.arange(self.height * self.width)
-        coords = torch.stack(
-            [
-                pixel_indices % self.width,
-                torch.div(pixel_indices, self.width, rounding_mode="trunc"),
-            ],
-            axis=1,
-        )
-        return coords
-
-    @property
-    def camera_rays(self):
-        batch_size, *inner_shape = self.shape
-        inner_batch_size = int(np.prod(inner_shape))
-
-        coords = self.get_image_coords()
-        coords = torch.broadcast_to(coords.unsqueeze(0), [batch_size * inner_batch_size, *coords.shape])
-        rays = self.get_camera_rays(coords)
-
-        rays = rays.view(batch_size, inner_batch_size * self.height * self.width, 2, 3)
-
-        return rays
-
-    def get_camera_rays(self, coords: torch.Tensor) -> torch.Tensor:
-        batch_size, *shape, n_coords = coords.shape
-        assert n_coords == 2
-        assert batch_size == self.origin.shape[0]
-
-        flat = coords.view(batch_size, -1, 2)
-
-        res = self.resolution()
-        fov = self.fov()
-
-        fracs = (flat.float() / (res - 1)) * 2 - 1
-        fracs = fracs * torch.tan(fov / 2)
-
-        fracs = fracs.view(batch_size, -1, 2)
-        directions = (
-            self.z.view(batch_size, 1, 3)
-            + self.x.view(batch_size, 1, 3) * fracs[:, :, :1]
-            + self.y.view(batch_size, 1, 3) * fracs[:, :, 1:]
-        )
-        directions = directions / directions.norm(dim=-1, keepdim=True)
-        rays = torch.stack(
-            [
-                torch.broadcast_to(self.origin.view(batch_size, 1, 3), [batch_size, directions.shape[1], 3]),
-                directions,
-            ],
-            dim=2,
-        )
-        return rays.view(batch_size, *shape, 2, 3)
-
-    def resize_image(self, width: int, height: int) -> "DifferentiableProjectiveCamera":
-        """
-        Creates a new camera for the resized view assuming the aspect ratio does not change.
-        """
-        assert width * self.height == height * self.width, "The aspect ratio should not change."
-        return DifferentiableProjectiveCamera(
-            origin=self.origin,
-            x=self.x,
-            y=self.y,
-            z=self.z,
-            width=width,
-            height=height,
-            x_fov=self.x_fov,
-            y_fov=self.y_fov,
-        )
-
-
-def create_pan_cameras(size: int) -> DifferentiableProjectiveCamera:
-    origins = []
-    xs = []
-    ys = []
-    zs = []
-    for theta in np.linspace(0, 2 * np.pi, num=20):
-        z = np.array([np.sin(theta), np.cos(theta), -0.5])
-        z /= np.sqrt(np.sum(z**2))
-        origin = -z * 4
-        x = np.array([np.cos(theta), -np.sin(theta), 0.0])
-        y = np.cross(z, x)
-        origins.append(origin)
-        xs.append(x)
-        ys.append(y)
-        zs.append(z)
-    return DifferentiableProjectiveCamera(
-        origin=torch.from_numpy(np.stack(origins, axis=0)).float(),
-        x=torch.from_numpy(np.stack(xs, axis=0)).float(),
-        y=torch.from_numpy(np.stack(ys, axis=0)).float(),
-        z=torch.from_numpy(np.stack(zs, axis=0)).float(),
-        width=size,
-        height=size,
-        x_fov=0.7,
-        y_fov=0.7,
-        shape=(1, len(xs)),
-    )

spaces/Andy1621/uniformer_image_detection/configs/htc/htc_x101_32x4d_fpn_16x1_20e_coco.py

@@ -1,18 +0,0 @@
-_base_ = './htc_r50_fpn_1x_coco.py'
-model = dict(
-    pretrained='open-mmlab://resnext101_32x4d',
-    backbone=dict(
-        type='ResNeXt',
-        depth=101,
-        groups=32,
-        base_width=4,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        norm_eval=True,
-        style='pytorch'))
-data = dict(samples_per_gpu=1, workers_per_gpu=1)
-# learning policy
-lr_config = dict(step=[16, 19])
-runner = dict(type='EpochBasedRunner', max_epochs=20)

spaces/Andy1621/uniformer_image_detection/mmdet/models/necks/fpn_carafe.py

@@ -1,267 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, build_upsample_layer, xavier_init
-from mmcv.ops.carafe import CARAFEPack
-
-from ..builder import NECKS
-
-
-@NECKS.register_module()
-class FPN_CARAFE(nn.Module):
-    """FPN_CARAFE is a more flexible implementation of FPN. It allows more
-    choice for upsample methods during the top-down pathway.
-
-    It can reproduce the performance of ICCV 2019 paper
-    CARAFE: Content-Aware ReAssembly of FEatures
-    Please refer to https://arxiv.org/abs/1905.02188 for more details.
-
-    Args:
-        in_channels (list[int]): Number of channels for each input feature map.
-        out_channels (int): Output channels of feature pyramids.
-        num_outs (int): Number of output stages.
-        start_level (int): Start level of feature pyramids.
-            (Default: 0)
-        end_level (int): End level of feature pyramids.
-            (Default: -1 indicates the last level).
-        norm_cfg (dict): Dictionary to construct and config norm layer.
-        activate (str): Type of activation function in ConvModule
-            (Default: None indicates w/o activation).
-        order (dict): Order of components in ConvModule.
-        upsample (str): Type of upsample layer.
-        upsample_cfg (dict): Dictionary to construct and config upsample layer.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 num_outs,
-                 start_level=0,
-                 end_level=-1,
-                 norm_cfg=None,
-                 act_cfg=None,
-                 order=('conv', 'norm', 'act'),
-                 upsample_cfg=dict(
-                     type='carafe',
-                     up_kernel=5,
-                     up_group=1,
-                     encoder_kernel=3,
-                     encoder_dilation=1)):
-        super(FPN_CARAFE, self).__init__()
-        assert isinstance(in_channels, list)
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.num_ins = len(in_channels)
-        self.num_outs = num_outs
-        self.norm_cfg = norm_cfg
-        self.act_cfg = act_cfg
-        self.with_bias = norm_cfg is None
-        self.upsample_cfg = upsample_cfg.copy()
-        self.upsample = self.upsample_cfg.get('type')
-        self.relu = nn.ReLU(inplace=False)
-
-        self.order = order
-        assert order in [('conv', 'norm', 'act'), ('act', 'conv', 'norm')]
-
-        assert self.upsample in [
-            'nearest', 'bilinear', 'deconv', 'pixel_shuffle', 'carafe', None
-        ]
-        if self.upsample in ['deconv', 'pixel_shuffle']:
-            assert hasattr(
-                self.upsample_cfg,
-                'upsample_kernel') and self.upsample_cfg.upsample_kernel > 0
-            self.upsample_kernel = self.upsample_cfg.pop('upsample_kernel')
-
-        if end_level == -1:
-            self.backbone_end_level = self.num_ins
-            assert num_outs >= self.num_ins - start_level
-        else:
-            # if end_level < inputs, no extra level is allowed
-            self.backbone_end_level = end_level
-            assert end_level <= len(in_channels)
-            assert num_outs == end_level - start_level
-        self.start_level = start_level
-        self.end_level = end_level
-
-        self.lateral_convs = nn.ModuleList()
-        self.fpn_convs = nn.ModuleList()
-        self.upsample_modules = nn.ModuleList()
-
-        for i in range(self.start_level, self.backbone_end_level):
-            l_conv = ConvModule(
-                in_channels[i],
-                out_channels,
-                1,
-                norm_cfg=norm_cfg,
-                bias=self.with_bias,
-                act_cfg=act_cfg,
-                inplace=False,
-                order=self.order)
-            fpn_conv = ConvModule(
-                out_channels,
-                out_channels,
-                3,
-                padding=1,
-                norm_cfg=self.norm_cfg,
-                bias=self.with_bias,
-                act_cfg=act_cfg,
-                inplace=False,
-                order=self.order)
-            if i != self.backbone_end_level - 1:
-                upsample_cfg_ = self.upsample_cfg.copy()
-                if self.upsample == 'deconv':
-                    upsample_cfg_.update(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        kernel_size=self.upsample_kernel,
-                        stride=2,
-                        padding=(self.upsample_kernel - 1) // 2,
-                        output_padding=(self.upsample_kernel - 1) // 2)
-                elif self.upsample == 'pixel_shuffle':
-                    upsample_cfg_.update(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        scale_factor=2,
-                        upsample_kernel=self.upsample_kernel)
-                elif self.upsample == 'carafe':
-                    upsample_cfg_.update(channels=out_channels, scale_factor=2)
-                else:
-                    # suppress warnings
-                    align_corners = (None
-                                     if self.upsample == 'nearest' else False)
-                    upsample_cfg_.update(
-                        scale_factor=2,
-                        mode=self.upsample,
-                        align_corners=align_corners)
-                upsample_module = build_upsample_layer(upsample_cfg_)
-                self.upsample_modules.append(upsample_module)
-            self.lateral_convs.append(l_conv)
-            self.fpn_convs.append(fpn_conv)
-
-        # add extra conv layers (e.g., RetinaNet)
-        extra_out_levels = (
-            num_outs - self.backbone_end_level + self.start_level)
-        if extra_out_levels >= 1:
-            for i in range(extra_out_levels):
-                in_channels = (
-                    self.in_channels[self.backbone_end_level -
-                                     1] if i == 0 else out_channels)
-                extra_l_conv = ConvModule(
-                    in_channels,
-                    out_channels,
-                    3,
-                    stride=2,
-                    padding=1,
-                    norm_cfg=norm_cfg,
-                    bias=self.with_bias,
-                    act_cfg=act_cfg,
-                    inplace=False,
-                    order=self.order)
-                if self.upsample == 'deconv':
-                    upsampler_cfg_ = dict(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        kernel_size=self.upsample_kernel,
-                        stride=2,
-                        padding=(self.upsample_kernel - 1) // 2,
-                        output_padding=(self.upsample_kernel - 1) // 2)
-                elif self.upsample == 'pixel_shuffle':
-                    upsampler_cfg_ = dict(
-                        in_channels=out_channels,
-                        out_channels=out_channels,
-                        scale_factor=2,
-                        upsample_kernel=self.upsample_kernel)
-                elif self.upsample == 'carafe':
-                    upsampler_cfg_ = dict(
-                        channels=out_channels,
-                        scale_factor=2,
-                        **self.upsample_cfg)
-                else:
-                    # suppress warnings
-                    align_corners = (None
-                                     if self.upsample == 'nearest' else False)
-                    upsampler_cfg_ = dict(
-                        scale_factor=2,
-                        mode=self.upsample,
-                        align_corners=align_corners)
-                upsampler_cfg_['type'] = self.upsample
-                upsample_module = build_upsample_layer(upsampler_cfg_)
-                extra_fpn_conv = ConvModule(
-                    out_channels,
-                    out_channels,
-                    3,
-                    padding=1,
-                    norm_cfg=self.norm_cfg,
-                    bias=self.with_bias,
-                    act_cfg=act_cfg,
-                    inplace=False,
-                    order=self.order)
-                self.upsample_modules.append(upsample_module)
-                self.fpn_convs.append(extra_fpn_conv)
-                self.lateral_convs.append(extra_l_conv)
-
-    # default init_weights for conv(msra) and norm in ConvModule
-    def init_weights(self):
-        """Initialize the weights of module."""
-        for m in self.modules():
-            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
-                xavier_init(m, distribution='uniform')
-        for m in self.modules():
-            if isinstance(m, CARAFEPack):
-                m.init_weights()
-
-    def slice_as(self, src, dst):
-        """Slice ``src`` as ``dst``
-
-        Note:
-            ``src`` should have the same or larger size than ``dst``.
-
-        Args:
-            src (torch.Tensor): Tensors to be sliced.
-            dst (torch.Tensor): ``src`` will be sliced to have the same
-                size as ``dst``.
-
-        Returns:
-            torch.Tensor: Sliced tensor.
-        """
-        assert (src.size(2) >= dst.size(2)) and (src.size(3) >= dst.size(3))
-        if src.size(2) == dst.size(2) and src.size(3) == dst.size(3):
-            return src
-        else:
-            return src[:, :, :dst.size(2), :dst.size(3)]
-
-    def tensor_add(self, a, b):
-        """Add tensors ``a`` and ``b`` that might have different sizes."""
-        if a.size() == b.size():
-            c = a + b
-        else:
-            c = a + self.slice_as(b, a)
-        return c
-
-    def forward(self, inputs):
-        """Forward function."""
-        assert len(inputs) == len(self.in_channels)
-
-        # build laterals
-        laterals = []
-        for i, lateral_conv in enumerate(self.lateral_convs):
-            if i <= self.backbone_end_level - self.start_level:
-                input = inputs[min(i + self.start_level, len(inputs) - 1)]
-            else:
-                input = laterals[-1]
-            lateral = lateral_conv(input)
-            laterals.append(lateral)
-
-        # build top-down path
-        for i in range(len(laterals) - 1, 0, -1):
-            if self.upsample is not None:
-                upsample_feat = self.upsample_modules[i - 1](laterals[i])
-            else:
-                upsample_feat = laterals[i]
-            laterals[i - 1] = self.tensor_add(laterals[i - 1], upsample_feat)
-
-        # build outputs
-        num_conv_outs = len(self.fpn_convs)
-        outs = []
-        for i in range(num_conv_outs):
-            out = self.fpn_convs[i](laterals[i])
-            outs.append(out)
-        return tuple(outs)

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/openai/images.py

@@ -1,68 +0,0 @@
-import os
-import time
-
-import requests
-from extensions.openai.errors import ServiceUnavailableError
-
-
-def generations(prompt: str, size: str, response_format: str, n: int):
-    # Stable Diffusion callout wrapper for txt2img
-    # Low effort implementation for compatibility. With only "prompt" being passed and assuming DALL-E
-    # the results will be limited and likely poor. SD has hundreds of models and dozens of settings.
-    # If you want high quality tailored results you should just use the Stable Diffusion API directly.
-    # it's too general an API to try and shape the result with specific tags like negative prompts
-    # or "masterpiece", etc. SD configuration is beyond the scope of this API.
-    # At this point I will not add the edits and variations endpoints (ie. img2img) because they
-    # require changing the form data handling to accept multipart form data, also to properly support
-    # url return types will require file management and a web serving files... Perhaps later!
-    base_model_size = 512 if 'SD_BASE_MODEL_SIZE' not in os.environ else int(os.environ.get('SD_BASE_MODEL_SIZE', 512))
-    sd_defaults = {
-        'sampler_name': 'DPM++ 2M Karras',  # vast improvement
-        'steps': 30,
-    }
-
-    width, height = [int(x) for x in size.split('x')]  # ignore the restrictions on size
-
-    # to hack on better generation, edit default payload.
-    payload = {
-        'prompt': prompt,  # ignore prompt limit of 1000 characters
-        'width': width,
-        'height': height,
-        'batch_size': n,
-    }
-    payload.update(sd_defaults)
-
-    scale = min(width, height) / base_model_size
-    if scale >= 1.2:
-        # for better performance with the default size (1024), and larger res.
-        scaler = {
-            'width': width // scale,
-            'height': height // scale,
-            'hr_scale': scale,
-            'enable_hr': True,
-            'hr_upscaler': 'Latent',
-            'denoising_strength': 0.68,
-        }
-        payload.update(scaler)
-
-    resp = {
-        'created': int(time.time()),
-        'data': []
-    }
-    from extensions.openai.script import params
-    # TODO: support SD_WEBUI_AUTH username:password pair.
-    sd_url = f"{os.environ.get('SD_WEBUI_URL', params.get('sd_webui_url', ''))}/sdapi/v1/txt2img"
-
-    response = requests.post(url=sd_url, json=payload)
-    r = response.json()
-    if response.status_code != 200 or 'images' not in r:
-        print(r)
-        raise ServiceUnavailableError(r.get('error', 'Unknown error calling Stable Diffusion'), code=response.status_code, internal_message=r.get('errors', None))
-    # r['parameters']...
-    for b64_json in r['images']:
-        if response_format == 'b64_json':
-            resp['data'].extend([{'b64_json': b64_json}])
-        else:
-            resp['data'].extend([{'url': f'data:image/png;base64,{b64_json}'}])  # yeah it's lazy. requests.get() will not work with this
-
-    return resp

spaces/Anonymous-sub/Rerender/README.md

@@ -1,12 +0,0 @@
----
-title: Rerender
-emoji: ⚡
-colorFrom: green
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.44.4
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Asifpa6/emotion-analyzer-app/emotion_analysis.py

@@ -1,17 +0,0 @@
-
-from transformers import RobertaTokenizerFast, TFRobertaForSequenceClassification, pipeline
-
-tokenizer = RobertaTokenizerFast.from_pretrained("arpanghoshal/EmoRoBERTa")
-model = TFRobertaForSequenceClassification.from_pretrained("arpanghoshal/EmoRoBERTa")
-
-emotion = pipeline('sentiment-analysis', 
-                    model='arpanghoshal/EmoRoBERTa')
-
-
-def get_emotion(text):
-    emotion_labels = emotion(text)
-    emotion_detail = [item['label'] for item in emotion_labels]
-    print("The detected emotion is:", emotion_detail)
-    confidence_score = str(round([item['score'] for item in emotion_labels][0]*100, 2)) + "%"
-    print("The confidence score is:", confidence_score)
-    return emotion_detail, confidence_score

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_internal/utils/wheel.py

@@ -1,136 +0,0 @@
-"""Support functions for working with wheel files.
-"""
-
-import logging
-from email.message import Message
-from email.parser import Parser
-from typing import Tuple
-from zipfile import BadZipFile, ZipFile
-
-from pip._vendor.packaging.utils import canonicalize_name
-
-from pip._internal.exceptions import UnsupportedWheel
-
-VERSION_COMPATIBLE = (1, 0)
-
-
-logger = logging.getLogger(__name__)
-
-
-def parse_wheel(wheel_zip: ZipFile, name: str) -> Tuple[str, Message]:
-    """Extract information from the provided wheel, ensuring it meets basic
-    standards.
-
-    Returns the name of the .dist-info directory and the parsed WHEEL metadata.
-    """
-    try:
-        info_dir = wheel_dist_info_dir(wheel_zip, name)
-        metadata = wheel_metadata(wheel_zip, info_dir)
-        version = wheel_version(metadata)
-    except UnsupportedWheel as e:
-        raise UnsupportedWheel("{} has an invalid wheel, {}".format(name, str(e)))
-
-    check_compatibility(version, name)
-
-    return info_dir, metadata
-
-
-def wheel_dist_info_dir(source: ZipFile, name: str) -> str:
-    """Returns the name of the contained .dist-info directory.
-
-    Raises AssertionError or UnsupportedWheel if not found, >1 found, or
-    it doesn't match the provided name.
-    """
-    # Zip file path separators must be /
-    subdirs = {p.split("/", 1)[0] for p in source.namelist()}
-
-    info_dirs = [s for s in subdirs if s.endswith(".dist-info")]
-
-    if not info_dirs:
-        raise UnsupportedWheel(".dist-info directory not found")
-
-    if len(info_dirs) > 1:
-        raise UnsupportedWheel(
-            "multiple .dist-info directories found: {}".format(", ".join(info_dirs))
-        )
-
-    info_dir = info_dirs[0]
-
-    info_dir_name = canonicalize_name(info_dir)
-    canonical_name = canonicalize_name(name)
-    if not info_dir_name.startswith(canonical_name):
-        raise UnsupportedWheel(
-            ".dist-info directory {!r} does not start with {!r}".format(
-                info_dir, canonical_name
-            )
-        )
-
-    return info_dir
-
-
-def read_wheel_metadata_file(source: ZipFile, path: str) -> bytes:
-    try:
-        return source.read(path)
-        # BadZipFile for general corruption, KeyError for missing entry,
-        # and RuntimeError for password-protected files
-    except (BadZipFile, KeyError, RuntimeError) as e:
-        raise UnsupportedWheel(f"could not read {path!r} file: {e!r}")
-
-
-def wheel_metadata(source: ZipFile, dist_info_dir: str) -> Message:
-    """Return the WHEEL metadata of an extracted wheel, if possible.
-    Otherwise, raise UnsupportedWheel.
-    """
-    path = f"{dist_info_dir}/WHEEL"
-    # Zip file path separators must be /
-    wheel_contents = read_wheel_metadata_file(source, path)
-
-    try:
-        wheel_text = wheel_contents.decode()
-    except UnicodeDecodeError as e:
-        raise UnsupportedWheel(f"error decoding {path!r}: {e!r}")
-
-    # FeedParser (used by Parser) does not raise any exceptions. The returned
-    # message may have .defects populated, but for backwards-compatibility we
-    # currently ignore them.
-    return Parser().parsestr(wheel_text)
-
-
-def wheel_version(wheel_data: Message) -> Tuple[int, ...]:
-    """Given WHEEL metadata, return the parsed Wheel-Version.
-    Otherwise, raise UnsupportedWheel.
-    """
-    version_text = wheel_data["Wheel-Version"]
-    if version_text is None:
-        raise UnsupportedWheel("WHEEL is missing Wheel-Version")
-
-    version = version_text.strip()
-
-    try:
-        return tuple(map(int, version.split(".")))
-    except ValueError:
-        raise UnsupportedWheel(f"invalid Wheel-Version: {version!r}")
-
-
-def check_compatibility(version: Tuple[int, ...], name: str) -> None:
-    """Raises errors or warns if called with an incompatible Wheel-Version.
-
-    pip should refuse to install a Wheel-Version that's a major series
-    ahead of what it's compatible with (e.g 2.0 > 1.1); and warn when
-    installing a version only minor version ahead (e.g 1.2 > 1.1).
-
-    version: a 2-tuple representing a Wheel-Version (Major, Minor)
-    name: name of wheel or package to raise exception about
-
-    :raises UnsupportedWheel: when an incompatible Wheel-Version is given
-    """
-    if version[0] > VERSION_COMPATIBLE[0]:
-        raise UnsupportedWheel(
-            "{}'s Wheel-Version ({}) is not compatible with this version "
-            "of pip".format(name, ".".join(map(str, version)))
-        )
-    elif version > VERSION_COMPATIBLE:
-        logger.warning(
-            "Installing from a newer Wheel-Version (%s)",
-            ".".join(map(str, version)),
-        )

spaces/Ayaka2022/anime-aesthetic-predict/README.md

@@ -1,14 +0,0 @@
----
-title: Anime Aesthetic Predict
-emoji: ❤️🖼️
-colorFrom: purple
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.16.1
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: skytnt/anime-aesthetic-predict
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pygments/lexers/__init__.py

@@ -1,334 +0,0 @@
-"""
-    pygments.lexers
-    ~~~~~~~~~~~~~~~
-
-    Pygments lexers.
-
-    :copyright: Copyright 2006-2022 by the Pygments team, see AUTHORS.
-    :license: BSD, see LICENSE for details.
-"""
-
-import sys
-import types
-from fnmatch import fnmatch
-from os.path import basename
-
-from pip._vendor.pygments.lexers._mapping import LEXERS
-from pip._vendor.pygments.modeline import get_filetype_from_buffer
-from pip._vendor.pygments.plugin import find_plugin_lexers
-from pip._vendor.pygments.util import ClassNotFound, guess_decode
-
-COMPAT = {
-    'Python3Lexer': 'PythonLexer',
-    'Python3TracebackLexer': 'PythonTracebackLexer',
-}
-
-__all__ = ['get_lexer_by_name', 'get_lexer_for_filename', 'find_lexer_class',
-           'guess_lexer', 'load_lexer_from_file'] + list(LEXERS) + list(COMPAT)
-
-_lexer_cache = {}
-
-def _load_lexers(module_name):
-    """Load a lexer (and all others in the module too)."""
-    mod = __import__(module_name, None, None, ['__all__'])
-    for lexer_name in mod.__all__:
-        cls = getattr(mod, lexer_name)
-        _lexer_cache[cls.name] = cls
-
-
-def get_all_lexers(plugins=True):
-    """Return a generator of tuples in the form ``(name, aliases,
-    filenames, mimetypes)`` of all know lexers.
-
-    If *plugins* is true (the default), plugin lexers supplied by entrypoints
-    are also returned.  Otherwise, only builtin ones are considered.
-    """
-    for item in LEXERS.values():
-        yield item[1:]
-    if plugins:
-        for lexer in find_plugin_lexers():
-            yield lexer.name, lexer.aliases, lexer.filenames, lexer.mimetypes
-
-
-def find_lexer_class(name):
-    """Lookup a lexer class by name.
-
-    Return None if not found.
-    """
-    if name in _lexer_cache:
-        return _lexer_cache[name]
-    # lookup builtin lexers
-    for module_name, lname, aliases, _, _ in LEXERS.values():
-        if name == lname:
-            _load_lexers(module_name)
-            return _lexer_cache[name]
-    # continue with lexers from setuptools entrypoints
-    for cls in find_plugin_lexers():
-        if cls.name == name:
-            return cls
-
-
-def find_lexer_class_by_name(_alias):
-    """Lookup a lexer class by alias.
-
-    Like `get_lexer_by_name`, but does not instantiate the class.
-
-    .. versionadded:: 2.2
-    """
-    if not _alias:
-        raise ClassNotFound('no lexer for alias %r found' % _alias)
-    # lookup builtin lexers
-    for module_name, name, aliases, _, _ in LEXERS.values():
-        if _alias.lower() in aliases:
-            if name not in _lexer_cache:
-                _load_lexers(module_name)
-            return _lexer_cache[name]
-    # continue with lexers from setuptools entrypoints
-    for cls in find_plugin_lexers():
-        if _alias.lower() in cls.aliases:
-            return cls
-    raise ClassNotFound('no lexer for alias %r found' % _alias)
-
-
-def get_lexer_by_name(_alias, **options):
-    """Get a lexer by an alias.
-
-    Raises ClassNotFound if not found.
-    """
-    if not _alias:
-        raise ClassNotFound('no lexer for alias %r found' % _alias)
-
-    # lookup builtin lexers
-    for module_name, name, aliases, _, _ in LEXERS.values():
-        if _alias.lower() in aliases:
-            if name not in _lexer_cache:
-                _load_lexers(module_name)
-            return _lexer_cache[name](**options)
-    # continue with lexers from setuptools entrypoints
-    for cls in find_plugin_lexers():
-        if _alias.lower() in cls.aliases:
-            return cls(**options)
-    raise ClassNotFound('no lexer for alias %r found' % _alias)
-
-
-def load_lexer_from_file(filename, lexername="CustomLexer", **options):
-    """Load a lexer from a file.
-
-    This method expects a file located relative to the current working
-    directory, which contains a Lexer class. By default, it expects the
-    Lexer to be name CustomLexer; you can specify your own class name
-    as the second argument to this function.
-
-    Users should be very careful with the input, because this method
-    is equivalent to running eval on the input file.
-
-    Raises ClassNotFound if there are any problems importing the Lexer.
-
-    .. versionadded:: 2.2
-    """
-    try:
-        # This empty dict will contain the namespace for the exec'd file
-        custom_namespace = {}
-        with open(filename, 'rb') as f:
-            exec(f.read(), custom_namespace)
-        # Retrieve the class `lexername` from that namespace
-        if lexername not in custom_namespace:
-            raise ClassNotFound('no valid %s class found in %s' %
-                                (lexername, filename))
-        lexer_class = custom_namespace[lexername]
-        # And finally instantiate it with the options
-        return lexer_class(**options)
-    except OSError as err:
-        raise ClassNotFound('cannot read %s: %s' % (filename, err))
-    except ClassNotFound:
-        raise
-    except Exception as err:
-        raise ClassNotFound('error when loading custom lexer: %s' % err)
-
-
-def find_lexer_class_for_filename(_fn, code=None):
-    """Get a lexer for a filename.
-
-    If multiple lexers match the filename pattern, use ``analyse_text()`` to
-    figure out which one is more appropriate.
-
-    Returns None if not found.
-    """
-    matches = []
-    fn = basename(_fn)
-    for modname, name, _, filenames, _ in LEXERS.values():
-        for filename in filenames:
-            if fnmatch(fn, filename):
-                if name not in _lexer_cache:
-                    _load_lexers(modname)
-                matches.append((_lexer_cache[name], filename))
-    for cls in find_plugin_lexers():
-        for filename in cls.filenames:
-            if fnmatch(fn, filename):
-                matches.append((cls, filename))
-
-    if isinstance(code, bytes):
-        # decode it, since all analyse_text functions expect unicode
-        code = guess_decode(code)
-
-    def get_rating(info):
-        cls, filename = info
-        # explicit patterns get a bonus
-        bonus = '*' not in filename and 0.5 or 0
-        # The class _always_ defines analyse_text because it's included in
-        # the Lexer class.  The default implementation returns None which
-        # gets turned into 0.0.  Run scripts/detect_missing_analyse_text.py
-        # to find lexers which need it overridden.
-        if code:
-            return cls.analyse_text(code) + bonus, cls.__name__
-        return cls.priority + bonus, cls.__name__
-
-    if matches:
-        matches.sort(key=get_rating)
-        # print "Possible lexers, after sort:", matches
-        return matches[-1][0]
-
-
-def get_lexer_for_filename(_fn, code=None, **options):
-    """Get a lexer for a filename.
-
-    If multiple lexers match the filename pattern, use ``analyse_text()`` to
-    figure out which one is more appropriate.
-
-    Raises ClassNotFound if not found.
-    """
-    res = find_lexer_class_for_filename(_fn, code)
-    if not res:
-        raise ClassNotFound('no lexer for filename %r found' % _fn)
-    return res(**options)
-
-
-def get_lexer_for_mimetype(_mime, **options):
-    """Get a lexer for a mimetype.
-
-    Raises ClassNotFound if not found.
-    """
-    for modname, name, _, _, mimetypes in LEXERS.values():
-        if _mime in mimetypes:
-            if name not in _lexer_cache:
-                _load_lexers(modname)
-            return _lexer_cache[name](**options)
-    for cls in find_plugin_lexers():
-        if _mime in cls.mimetypes:
-            return cls(**options)
-    raise ClassNotFound('no lexer for mimetype %r found' % _mime)
-
-
-def _iter_lexerclasses(plugins=True):
-    """Return an iterator over all lexer classes."""
-    for key in sorted(LEXERS):
-        module_name, name = LEXERS[key][:2]
-        if name not in _lexer_cache:
-            _load_lexers(module_name)
-        yield _lexer_cache[name]
-    if plugins:
-        yield from find_plugin_lexers()
-
-
-def guess_lexer_for_filename(_fn, _text, **options):
-    """
-    Lookup all lexers that handle those filenames primary (``filenames``)
-    or secondary (``alias_filenames``). Then run a text analysis for those
-    lexers and choose the best result.
-
-    usage::
-
-        >>> from pygments.lexers import guess_lexer_for_filename
-        >>> guess_lexer_for_filename('hello.html', '<%= @foo %>')
-        <pygments.lexers.templates.RhtmlLexer object at 0xb7d2f32c>
-        >>> guess_lexer_for_filename('hello.html', '<h1>{{ title|e }}</h1>')
-        <pygments.lexers.templates.HtmlDjangoLexer object at 0xb7d2f2ac>
-        >>> guess_lexer_for_filename('style.css', 'a { color: <?= $link ?> }')
-        <pygments.lexers.templates.CssPhpLexer object at 0xb7ba518c>
-    """
-    fn = basename(_fn)
-    primary = {}
-    matching_lexers = set()
-    for lexer in _iter_lexerclasses():
-        for filename in lexer.filenames:
-            if fnmatch(fn, filename):
-                matching_lexers.add(lexer)
-                primary[lexer] = True
-        for filename in lexer.alias_filenames:
-            if fnmatch(fn, filename):
-                matching_lexers.add(lexer)
-                primary[lexer] = False
-    if not matching_lexers:
-        raise ClassNotFound('no lexer for filename %r found' % fn)
-    if len(matching_lexers) == 1:
-        return matching_lexers.pop()(**options)
-    result = []
-    for lexer in matching_lexers:
-        rv = lexer.analyse_text(_text)
-        if rv == 1.0:
-            return lexer(**options)
-        result.append((rv, lexer))
-
-    def type_sort(t):
-        # sort by:
-        # - analyse score
-        # - is primary filename pattern?
-        # - priority
-        # - last resort: class name
-        return (t[0], primary[t[1]], t[1].priority, t[1].__name__)
-    result.sort(key=type_sort)
-
-    return result[-1][1](**options)
-
-
-def guess_lexer(_text, **options):
-    """Guess a lexer by strong distinctions in the text (eg, shebang)."""
-
-    if not isinstance(_text, str):
-        inencoding = options.get('inencoding', options.get('encoding'))
-        if inencoding:
-            _text = _text.decode(inencoding or 'utf8')
-        else:
-            _text, _ = guess_decode(_text)
-
-    # try to get a vim modeline first
-    ft = get_filetype_from_buffer(_text)
-
-    if ft is not None:
-        try:
-            return get_lexer_by_name(ft, **options)
-        except ClassNotFound:
-            pass
-
-    best_lexer = [0.0, None]
-    for lexer in _iter_lexerclasses():
-        rv = lexer.analyse_text(_text)
-        if rv == 1.0:
-            return lexer(**options)
-        if rv > best_lexer[0]:
-            best_lexer[:] = (rv, lexer)
-    if not best_lexer[0] or best_lexer[1] is None:
-        raise ClassNotFound('no lexer matching the text found')
-    return best_lexer[1](**options)
-
-
-class _automodule(types.ModuleType):
-    """Automatically import lexers."""
-
-    def __getattr__(self, name):
-        info = LEXERS.get(name)
-        if info:
-            _load_lexers(info[0])
-            cls = _lexer_cache[info[1]]
-            setattr(self, name, cls)
-            return cls
-        if name in COMPAT:
-            return getattr(self, COMPAT[name])
-        raise AttributeError(name)
-
-
-oldmod = sys.modules[__name__]
-newmod = _automodule(__name__)
-newmod.__dict__.update(oldmod.__dict__)
-sys.modules[__name__] = newmod
-del newmod.newmod, newmod.oldmod, newmod.sys, newmod.types

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_vendor/pyparsing/diagram/__init__.py

@@ -1,642 +0,0 @@
-import railroad
-from pip._vendor import pyparsing
-import typing
-from typing import (
-    List,
-    NamedTuple,
-    Generic,
-    TypeVar,
-    Dict,
-    Callable,
-    Set,
-    Iterable,
-)
-from jinja2 import Template
-from io import StringIO
-import inspect
-
-
-jinja2_template_source = """\
-<!DOCTYPE html>
-<html>
-<head>
-    {% if not head %}
-        <style type="text/css">
-            .railroad-heading {
-                font-family: monospace;
-            }
-        </style>
-    {% else %}
-        {{ head | safe }}
-    {% endif %}
-</head>
-<body>
-{{ body | safe }}
-{% for diagram in diagrams %}
-    <div class="railroad-group">
-        <h1 class="railroad-heading">{{ diagram.title }}</h1>
-        <div class="railroad-description">{{ diagram.text }}</div>
-        <div class="railroad-svg">
-            {{ diagram.svg }}
-        </div>
-    </div>
-{% endfor %}
-</body>
-</html>
-"""
-
-template = Template(jinja2_template_source)
-
-# Note: ideally this would be a dataclass, but we're supporting Python 3.5+ so we can't do this yet
-NamedDiagram = NamedTuple(
-    "NamedDiagram",
-    [("name", str), ("diagram", typing.Optional[railroad.DiagramItem]), ("index", int)],
-)
-"""
-A simple structure for associating a name with a railroad diagram
-"""
-
-T = TypeVar("T")
-
-
-class EachItem(railroad.Group):
-    """
-    Custom railroad item to compose a:
-    - Group containing a
-      - OneOrMore containing a
-        - Choice of the elements in the Each
-    with the group label indicating that all must be matched
-    """
-
-    all_label = "[ALL]"
-
-    def __init__(self, *items):
-        choice_item = railroad.Choice(len(items) - 1, *items)
-        one_or_more_item = railroad.OneOrMore(item=choice_item)
-        super().__init__(one_or_more_item, label=self.all_label)
-
-
-class AnnotatedItem(railroad.Group):
-    """
-    Simple subclass of Group that creates an annotation label
-    """
-
-    def __init__(self, label: str, item):
-        super().__init__(item=item, label="[{}]".format(label) if label else label)
-
-
-class EditablePartial(Generic[T]):
-    """
-    Acts like a functools.partial, but can be edited. In other words, it represents a type that hasn't yet been
-    constructed.
-    """
-
-    # We need this here because the railroad constructors actually transform the data, so can't be called until the
-    # entire tree is assembled
-
-    def __init__(self, func: Callable[..., T], args: list, kwargs: dict):
-        self.func = func
-        self.args = args
-        self.kwargs = kwargs
-
-    @classmethod
-    def from_call(cls, func: Callable[..., T], *args, **kwargs) -> "EditablePartial[T]":
-        """
-        If you call this function in the same way that you would call the constructor, it will store the arguments
-        as you expect. For example EditablePartial.from_call(Fraction, 1, 3)() == Fraction(1, 3)
-        """
-        return EditablePartial(func=func, args=list(args), kwargs=kwargs)
-
-    @property
-    def name(self):
-        return self.kwargs["name"]
-
-    def __call__(self) -> T:
-        """
-        Evaluate the partial and return the result
-        """
-        args = self.args.copy()
-        kwargs = self.kwargs.copy()
-
-        # This is a helpful hack to allow you to specify varargs parameters (e.g. *args) as keyword args (e.g.
-        # args=['list', 'of', 'things'])
-        arg_spec = inspect.getfullargspec(self.func)
-        if arg_spec.varargs in self.kwargs:
-            args += kwargs.pop(arg_spec.varargs)
-
-        return self.func(*args, **kwargs)
-
-
-def railroad_to_html(diagrams: List[NamedDiagram], **kwargs) -> str:
-    """
-    Given a list of NamedDiagram, produce a single HTML string that visualises those diagrams
-    :params kwargs: kwargs to be passed in to the template
-    """
-    data = []
-    for diagram in diagrams:
-        if diagram.diagram is None:
-            continue
-        io = StringIO()
-        diagram.diagram.writeSvg(io.write)
-        title = diagram.name
-        if diagram.index == 0:
-            title += " (root)"
-        data.append({"title": title, "text": "", "svg": io.getvalue()})
-
-    return template.render(diagrams=data, **kwargs)
-
-
-def resolve_partial(partial: "EditablePartial[T]") -> T:
-    """
-    Recursively resolves a collection of Partials into whatever type they are
-    """
-    if isinstance(partial, EditablePartial):
-        partial.args = resolve_partial(partial.args)
-        partial.kwargs = resolve_partial(partial.kwargs)
-        return partial()
-    elif isinstance(partial, list):
-        return [resolve_partial(x) for x in partial]
-    elif isinstance(partial, dict):
-        return {key: resolve_partial(x) for key, x in partial.items()}
-    else:
-        return partial
-
-
-def to_railroad(
-    element: pyparsing.ParserElement,
-    diagram_kwargs: typing.Optional[dict] = None,
-    vertical: int = 3,
-    show_results_names: bool = False,
-    show_groups: bool = False,
-) -> List[NamedDiagram]:
-    """
-    Convert a pyparsing element tree into a list of diagrams. This is the recommended entrypoint to diagram
-    creation if you want to access the Railroad tree before it is converted to HTML
-    :param element: base element of the parser being diagrammed
-    :param diagram_kwargs: kwargs to pass to the Diagram() constructor
-    :param vertical: (optional) - int - limit at which number of alternatives should be
-       shown vertically instead of horizontally
-    :param show_results_names - bool to indicate whether results name annotations should be
-       included in the diagram
-    :param show_groups - bool to indicate whether groups should be highlighted with an unlabeled
-       surrounding box
-    """
-    # Convert the whole tree underneath the root
-    lookup = ConverterState(diagram_kwargs=diagram_kwargs or {})
-    _to_diagram_element(
-        element,
-        lookup=lookup,
-        parent=None,
-        vertical=vertical,
-        show_results_names=show_results_names,
-        show_groups=show_groups,
-    )
-
-    root_id = id(element)
-    # Convert the root if it hasn't been already
-    if root_id in lookup:
-        if not element.customName:
-            lookup[root_id].name = ""
-        lookup[root_id].mark_for_extraction(root_id, lookup, force=True)
-
-    # Now that we're finished, we can convert from intermediate structures into Railroad elements
-    diags = list(lookup.diagrams.values())
-    if len(diags) > 1:
-        # collapse out duplicate diags with the same name
-        seen = set()
-        deduped_diags = []
-        for d in diags:
-            # don't extract SkipTo elements, they are uninformative as subdiagrams
-            if d.name == "...":
-                continue
-            if d.name is not None and d.name not in seen:
-                seen.add(d.name)
-                deduped_diags.append(d)
-        resolved = [resolve_partial(partial) for partial in deduped_diags]
-    else:
-        # special case - if just one diagram, always display it, even if
-        # it has no name
-        resolved = [resolve_partial(partial) for partial in diags]
-    return sorted(resolved, key=lambda diag: diag.index)
-
-
-def _should_vertical(
-    specification: int, exprs: Iterable[pyparsing.ParserElement]
-) -> bool:
-    """
-    Returns true if we should return a vertical list of elements
-    """
-    if specification is None:
-        return False
-    else:
-        return len(_visible_exprs(exprs)) >= specification
-
-
-class ElementState:
-    """
-    State recorded for an individual pyparsing Element
-    """
-
-    # Note: this should be a dataclass, but we have to support Python 3.5
-    def __init__(
-        self,
-        element: pyparsing.ParserElement,
-        converted: EditablePartial,
-        parent: EditablePartial,
-        number: int,
-        name: str = None,
-        parent_index: typing.Optional[int] = None,
-    ):
-        #: The pyparsing element that this represents
-        self.element: pyparsing.ParserElement = element
-        #: The name of the element
-        self.name: typing.Optional[str] = name
-        #: The output Railroad element in an unconverted state
-        self.converted: EditablePartial = converted
-        #: The parent Railroad element, which we store so that we can extract this if it's duplicated
-        self.parent: EditablePartial = parent
-        #: The order in which we found this element, used for sorting diagrams if this is extracted into a diagram
-        self.number: int = number
-        #: The index of this inside its parent
-        self.parent_index: typing.Optional[int] = parent_index
-        #: If true, we should extract this out into a subdiagram
-        self.extract: bool = False
-        #: If true, all of this element's children have been filled out
-        self.complete: bool = False
-
-    def mark_for_extraction(
-        self, el_id: int, state: "ConverterState", name: str = None, force: bool = False
-    ):
-        """
-        Called when this instance has been seen twice, and thus should eventually be extracted into a sub-diagram
-        :param el_id: id of the element
-        :param state: element/diagram state tracker
-        :param name: name to use for this element's text
-        :param force: If true, force extraction now, regardless of the state of this. Only useful for extracting the
-        root element when we know we're finished
-        """
-        self.extract = True
-
-        # Set the name
-        if not self.name:
-            if name:
-                # Allow forcing a custom name
-                self.name = name
-            elif self.element.customName:
-                self.name = self.element.customName
-            else:
-                self.name = ""
-
-        # Just because this is marked for extraction doesn't mean we can do it yet. We may have to wait for children
-        # to be added
-        # Also, if this is just a string literal etc, don't bother extracting it
-        if force or (self.complete and _worth_extracting(self.element)):
-            state.extract_into_diagram(el_id)
-
-
-class ConverterState:
-    """
-    Stores some state that persists between recursions into the element tree
-    """
-
-    def __init__(self, diagram_kwargs: typing.Optional[dict] = None):
-        #: A dictionary mapping ParserElements to state relating to them
-        self._element_diagram_states: Dict[int, ElementState] = {}
-        #: A dictionary mapping ParserElement IDs to subdiagrams generated from them
-        self.diagrams: Dict[int, EditablePartial[NamedDiagram]] = {}
-        #: The index of the next unnamed element
-        self.unnamed_index: int = 1
-        #: The index of the next element. This is used for sorting
-        self.index: int = 0
-        #: Shared kwargs that are used to customize the construction of diagrams
-        self.diagram_kwargs: dict = diagram_kwargs or {}
-        self.extracted_diagram_names: Set[str] = set()
-
-    def __setitem__(self, key: int, value: ElementState):
-        self._element_diagram_states[key] = value
-
-    def __getitem__(self, key: int) -> ElementState:
-        return self._element_diagram_states[key]
-
-    def __delitem__(self, key: int):
-        del self._element_diagram_states[key]
-
-    def __contains__(self, key: int):
-        return key in self._element_diagram_states
-
-    def generate_unnamed(self) -> int:
-        """
-        Generate a number used in the name of an otherwise unnamed diagram
-        """
-        self.unnamed_index += 1
-        return self.unnamed_index
-
-    def generate_index(self) -> int:
-        """
-        Generate a number used to index a diagram
-        """
-        self.index += 1
-        return self.index
-
-    def extract_into_diagram(self, el_id: int):
-        """
-        Used when we encounter the same token twice in the same tree. When this
-        happens, we replace all instances of that token with a terminal, and
-        create a new subdiagram for the token
-        """
-        position = self[el_id]
-
-        # Replace the original definition of this element with a regular block
-        if position.parent:
-            ret = EditablePartial.from_call(railroad.NonTerminal, text=position.name)
-            if "item" in position.parent.kwargs:
-                position.parent.kwargs["item"] = ret
-            elif "items" in position.parent.kwargs:
-                position.parent.kwargs["items"][position.parent_index] = ret
-
-        # If the element we're extracting is a group, skip to its content but keep the title
-        if position.converted.func == railroad.Group:
-            content = position.converted.kwargs["item"]
-        else:
-            content = position.converted
-
-        self.diagrams[el_id] = EditablePartial.from_call(
-            NamedDiagram,
-            name=position.name,
-            diagram=EditablePartial.from_call(
-                railroad.Diagram, content, **self.diagram_kwargs
-            ),
-            index=position.number,
-        )
-
-        del self[el_id]
-
-
-def _worth_extracting(element: pyparsing.ParserElement) -> bool:
-    """
-    Returns true if this element is worth having its own sub-diagram. Simply, if any of its children
-    themselves have children, then its complex enough to extract
-    """
-    children = element.recurse()
-    return any(child.recurse() for child in children)
-
-
-def _apply_diagram_item_enhancements(fn):
-    """
-    decorator to ensure enhancements to a diagram item (such as results name annotations)
-    get applied on return from _to_diagram_element (we do this since there are several
-    returns in _to_diagram_element)
-    """
-
-    def _inner(
-        element: pyparsing.ParserElement,
-        parent: typing.Optional[EditablePartial],
-        lookup: ConverterState = None,
-        vertical: int = None,
-        index: int = 0,
-        name_hint: str = None,
-        show_results_names: bool = False,
-        show_groups: bool = False,
-    ) -> typing.Optional[EditablePartial]:
-
-        ret = fn(
-            element,
-            parent,
-            lookup,
-            vertical,
-            index,
-            name_hint,
-            show_results_names,
-            show_groups,
-        )
-
-        # apply annotation for results name, if present
-        if show_results_names and ret is not None:
-            element_results_name = element.resultsName
-            if element_results_name:
-                # add "*" to indicate if this is a "list all results" name
-                element_results_name += "" if element.modalResults else "*"
-                ret = EditablePartial.from_call(
-                    railroad.Group, item=ret, label=element_results_name
-                )
-
-        return ret
-
-    return _inner
-
-
-def _visible_exprs(exprs: Iterable[pyparsing.ParserElement]):
-    non_diagramming_exprs = (
-        pyparsing.ParseElementEnhance,
-        pyparsing.PositionToken,
-        pyparsing.And._ErrorStop,
-    )
-    return [
-        e
-        for e in exprs
-        if not (e.customName or e.resultsName or isinstance(e, non_diagramming_exprs))
-    ]
-
-
-@_apply_diagram_item_enhancements
-def _to_diagram_element(
-    element: pyparsing.ParserElement,
-    parent: typing.Optional[EditablePartial],
-    lookup: ConverterState = None,
-    vertical: int = None,
-    index: int = 0,
-    name_hint: str = None,
-    show_results_names: bool = False,
-    show_groups: bool = False,
-) -> typing.Optional[EditablePartial]:
-    """
-    Recursively converts a PyParsing Element to a railroad Element
-    :param lookup: The shared converter state that keeps track of useful things
-    :param index: The index of this element within the parent
-    :param parent: The parent of this element in the output tree
-    :param vertical: Controls at what point we make a list of elements vertical. If this is an integer (the default),
-    it sets the threshold of the number of items before we go vertical. If True, always go vertical, if False, never
-    do so
-    :param name_hint: If provided, this will override the generated name
-    :param show_results_names: bool flag indicating whether to add annotations for results names
-    :returns: The converted version of the input element, but as a Partial that hasn't yet been constructed
-    :param show_groups: bool flag indicating whether to show groups using bounding box
-    """
-    exprs = element.recurse()
-    name = name_hint or element.customName or element.__class__.__name__
-
-    # Python's id() is used to provide a unique identifier for elements
-    el_id = id(element)
-
-    element_results_name = element.resultsName
-
-    # Here we basically bypass processing certain wrapper elements if they contribute nothing to the diagram
-    if not element.customName:
-        if isinstance(
-            element,
-            (
-                # pyparsing.TokenConverter,
-                # pyparsing.Forward,
-                pyparsing.Located,
-            ),
-        ):
-            # However, if this element has a useful custom name, and its child does not, we can pass it on to the child
-            if exprs:
-                if not exprs[0].customName:
-                    propagated_name = name
-                else:
-                    propagated_name = None
-
-                return _to_diagram_element(
-                    element.expr,
-                    parent=parent,
-                    lookup=lookup,
-                    vertical=vertical,
-                    index=index,
-                    name_hint=propagated_name,
-                    show_results_names=show_results_names,
-                    show_groups=show_groups,
-                )
-
-    # If the element isn't worth extracting, we always treat it as the first time we say it
-    if _worth_extracting(element):
-        if el_id in lookup:
-            # If we've seen this element exactly once before, we are only just now finding out that it's a duplicate,
-            # so we have to extract it into a new diagram.
-            looked_up = lookup[el_id]
-            looked_up.mark_for_extraction(el_id, lookup, name=name_hint)
-            ret = EditablePartial.from_call(railroad.NonTerminal, text=looked_up.name)
-            return ret
-
-        elif el_id in lookup.diagrams:
-            # If we have seen the element at least twice before, and have already extracted it into a subdiagram, we
-            # just put in a marker element that refers to the sub-diagram
-            ret = EditablePartial.from_call(
-                railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
-            )
-            return ret
-
-    # Recursively convert child elements
-    # Here we find the most relevant Railroad element for matching pyparsing Element
-    # We use ``items=[]`` here to hold the place for where the child elements will go once created
-    if isinstance(element, pyparsing.And):
-        # detect And's created with ``expr*N`` notation - for these use a OneOrMore with a repeat
-        # (all will have the same name, and resultsName)
-        if not exprs:
-            return None
-        if len(set((e.name, e.resultsName) for e in exprs)) == 1:
-            ret = EditablePartial.from_call(
-                railroad.OneOrMore, item="", repeat=str(len(exprs))
-            )
-        elif _should_vertical(vertical, exprs):
-            ret = EditablePartial.from_call(railroad.Stack, items=[])
-        else:
-            ret = EditablePartial.from_call(railroad.Sequence, items=[])
-    elif isinstance(element, (pyparsing.Or, pyparsing.MatchFirst)):
-        if not exprs:
-            return None
-        if _should_vertical(vertical, exprs):
-            ret = EditablePartial.from_call(railroad.Choice, 0, items=[])
-        else:
-            ret = EditablePartial.from_call(railroad.HorizontalChoice, items=[])
-    elif isinstance(element, pyparsing.Each):
-        if not exprs:
-            return None
-        ret = EditablePartial.from_call(EachItem, items=[])
-    elif isinstance(element, pyparsing.NotAny):
-        ret = EditablePartial.from_call(AnnotatedItem, label="NOT", item="")
-    elif isinstance(element, pyparsing.FollowedBy):
-        ret = EditablePartial.from_call(AnnotatedItem, label="LOOKAHEAD", item="")
-    elif isinstance(element, pyparsing.PrecededBy):
-        ret = EditablePartial.from_call(AnnotatedItem, label="LOOKBEHIND", item="")
-    elif isinstance(element, pyparsing.Group):
-        if show_groups:
-            ret = EditablePartial.from_call(AnnotatedItem, label="", item="")
-        else:
-            ret = EditablePartial.from_call(railroad.Group, label="", item="")
-    elif isinstance(element, pyparsing.TokenConverter):
-        ret = EditablePartial.from_call(
-            AnnotatedItem, label=type(element).__name__.lower(), item=""
-        )
-    elif isinstance(element, pyparsing.Opt):
-        ret = EditablePartial.from_call(railroad.Optional, item="")
-    elif isinstance(element, pyparsing.OneOrMore):
-        ret = EditablePartial.from_call(railroad.OneOrMore, item="")
-    elif isinstance(element, pyparsing.ZeroOrMore):
-        ret = EditablePartial.from_call(railroad.ZeroOrMore, item="")
-    elif isinstance(element, pyparsing.Group):
-        ret = EditablePartial.from_call(
-            railroad.Group, item=None, label=element_results_name
-        )
-    elif isinstance(element, pyparsing.Empty) and not element.customName:
-        # Skip unnamed "Empty" elements
-        ret = None
-    elif len(exprs) > 1:
-        ret = EditablePartial.from_call(railroad.Sequence, items=[])
-    elif len(exprs) > 0 and not element_results_name:
-        ret = EditablePartial.from_call(railroad.Group, item="", label=name)
-    else:
-        terminal = EditablePartial.from_call(railroad.Terminal, element.defaultName)
-        ret = terminal
-
-    if ret is None:
-        return
-
-    # Indicate this element's position in the tree so we can extract it if necessary
-    lookup[el_id] = ElementState(
-        element=element,
-        converted=ret,
-        parent=parent,
-        parent_index=index,
-        number=lookup.generate_index(),
-    )
-    if element.customName:
-        lookup[el_id].mark_for_extraction(el_id, lookup, element.customName)
-
-    i = 0
-    for expr in exprs:
-        # Add a placeholder index in case we have to extract the child before we even add it to the parent
-        if "items" in ret.kwargs:
-            ret.kwargs["items"].insert(i, None)
-
-        item = _to_diagram_element(
-            expr,
-            parent=ret,
-            lookup=lookup,
-            vertical=vertical,
-            index=i,
-            show_results_names=show_results_names,
-            show_groups=show_groups,
-        )
-
-        # Some elements don't need to be shown in the diagram
-        if item is not None:
-            if "item" in ret.kwargs:
-                ret.kwargs["item"] = item
-            elif "items" in ret.kwargs:
-                # If we've already extracted the child, don't touch this index, since it's occupied by a nonterminal
-                ret.kwargs["items"][i] = item
-                i += 1
-        elif "items" in ret.kwargs:
-            # If we're supposed to skip this element, remove it from the parent
-            del ret.kwargs["items"][i]
-
-    # If all this items children are none, skip this item
-    if ret and (
-        ("items" in ret.kwargs and len(ret.kwargs["items"]) == 0)
-        or ("item" in ret.kwargs and ret.kwargs["item"] is None)
-    ):
-        ret = EditablePartial.from_call(railroad.Terminal, name)
-
-    # Mark this element as "complete", ie it has all of its children
-    if el_id in lookup:
-        lookup[el_id].complete = True
-
-    if el_id in lookup and lookup[el_id].extract and lookup[el_id].complete:
-        lookup.extract_into_diagram(el_id)
-        if ret is not None:
-            ret = EditablePartial.from_call(
-                railroad.NonTerminal, text=lookup.diagrams[el_id].kwargs["name"]
-            )
-
-    return ret

spaces/Blessin/yes-and-improv-game/app.py

@@ -1,50 +0,0 @@
-import gradio as gr
-import openai
-
-# Function to extract the last statement from the input
-def extract_last_statement(input_text):
-    lines = input_text.strip().split('\n')
-    last_line = lines[-1]
-    last_statement = last_line.split(':')[-1].strip() if ':' in last_line else last_line
-    return last_statement
-
-def yes_and_game(api_key, user_input):
-    # Initialize OpenAI API client
-    openai.api_key = api_key
-
-    # Extract the last statement from the user input
-    last_statement = extract_last_statement(user_input)
-
-    # Create the prompt for GPT
-    gpt_prompt = (f"Play the Yes, And improv game. "
-                  f"You will start your response with 'Yes, and'. "
-                  f"Keep your responses short. Not more than one statement. Responses can be funny or absurd. "
-                  f"The input statement can be a single line or a multi line statement.\n"
-                  f"Yes, And {last_statement}\n"
-                  f"Yes, And ")
-
-    # Generate GPT response
-    gpt_response = openai.Completion.create(
-        engine="text-davinci-002",
-        prompt=gpt_prompt,
-        max_tokens=20,  
-        temperature=0.9  # Increased temperature for more randomness
-    )['choices'][0]['text'].strip()
-
-    # Format and return the result
-    result = f"{last_statement}\nYes, And {gpt_response}"
-    return result
-
-iface = gr.Interface(
-    fn=yes_and_game,
-    inputs=[
-        gr.Textbox(label="OpenAI API Key", type="password"),
-        gr.Textbox(lines=5, label="Statement"),
-    ],
-    outputs=gr.Textbox(label="Game Transcript", live=True, flagging=True),  # Setting live=True for real-time updates, flagging=True to allow copying
-    title="The Yes, And Game"  # Adding title here
-)
-
-
-# This will create a link to host your model on Hugging Face Spaces when executed
-iface.launch(share=True)

spaces/CM-15/NLP-demo/README.md

@@ -1,12 +0,0 @@
----
-title: NLP Demo
-emoji: 😻
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CVPR/CVPR2022_papers/style.css

@@ -1,22 +0,0 @@
-h1 {
-  text-align: center;
-}
-table a {
-  background-color: transparent;
-  color: #58a6ff;
-  text-decoration: none;
-}
-a:active,
-a:hover {
-  outline-width: 0;
-}
-a:hover {
-  text-decoration: underline;
-}
-table, th, td {
-  border: 1px solid;
-}
-img#visitor-badge {
-  display: block;
-  margin: auto;
-}

spaces/CVPR/Dual-Key_Backdoor_Attacks/openvqa/openvqa/models/mmnasnet/adapter.py

@@ -1,120 +0,0 @@
-# --------------------------------------------------------
-# OpenVQA
-# Written by Zhenwei Shao https://github.com/ParadoxZW
-# --------------------------------------------------------
-
-import torch.nn as nn
-import torch
-from openvqa.core.base_dataset import BaseAdapter
-from openvqa.utils.make_mask import make_mask
-
-
-class Adapter(BaseAdapter):
-    def __init__(self, __C):
-        super(Adapter, self).__init__(__C)
-        self.__C = __C
-
-    
-    def relation_embedding(self, f_g):
-        x_min, y_min, x_max, y_max = torch.chunk(f_g, 4, dim=2)  # [bs, n_obj, 1]
-
-        cx = (x_min + x_max) * 0.5  # [bs, n_obj, 1]
-        cy = (y_min + y_max) * 0.5  # [bs, n_obj, 1]
-        w = (x_max - x_min) + 1.  # [bs, n_obj, 1]
-        h = (y_max - y_min) + 1.  # [bs, n_obj, 1]
-
-        delta_x = cx - cx.transpose(-1, -2)
-        delta_x = torch.clamp(torch.abs(delta_x / w), min=1e-3)
-        delta_x = torch.log(delta_x)  # [bs, n_obj, n_obj]
-
-        delta_y = cy - cy.transpose(-1, -2)
-        delta_y = torch.clamp(torch.abs(delta_y / h), min=1e-3)
-        delta_y = torch.log(delta_y)  # [bs, n_obj, n_obj]
-
-        delta_w = torch.log(w / w.transpose(-1, -2))  # [bs, n_obj, n_obj]
-        delta_h = torch.log(h / h.transpose(-1, -2))  # [bs, n_obj, n_obj]
-        size = delta_h.size()
-
-        delta_x = delta_x.view(size[0], size[1], size[2], 1)
-        delta_y = delta_y.view(size[0], size[1], size[2], 1)
-        delta_w = delta_w.view(size[0], size[1], size[2], 1)
-        delta_h = delta_h.view(size[0], size[1], size[2], 1)  # [bs, n_obj, n_obj, 1]
-        position_mat = torch.cat(
-            (delta_x, delta_y, delta_w, delta_h), -1)  # [bs, n_obj, n_obj, 4]
-
-        return position_mat
-
-    def vqa_init(self, __C):
-        imgfeat_linear_size = __C.FEAT_SIZE['vqa']['FRCN_FEAT_SIZE'][1]
-        if __C.USE_BBOX_FEAT:
-            self.bbox_linear = nn.Linear(5, __C.BBOXFEAT_EMB_SIZE)
-            imgfeat_linear_size += __C.BBOXFEAT_EMB_SIZE
-        self.frcn_linear = nn.Linear(imgfeat_linear_size, __C.HIDDEN_SIZE)
-
-
-    def gqa_init(self, __C):
-        imgfeat_linear_size = __C.FEAT_SIZE['gqa']['FRCN_FEAT_SIZE'][1]
-        if __C.USE_BBOX_FEAT:
-            self.bbox_linear = nn.Linear(5, __C.BBOXFEAT_EMB_SIZE)
-            imgfeat_linear_size += __C.BBOXFEAT_EMB_SIZE
-        self.frcn_linear = nn.Linear(imgfeat_linear_size, __C.HIDDEN_SIZE)
-
-        if __C.USE_AUX_FEAT:
-            self.grid_linear = nn.Linear(__C.FEAT_SIZE['gqa']['GRID_FEAT_SIZE'][1], __C.HIDDEN_SIZE)
-
-
-    def clevr_init(self, __C):
-        self.grid_linear = nn.Linear(__C.FEAT_SIZE['clevr']['GRID_FEAT_SIZE'][1], __C.HIDDEN_SIZE)
-
-
-    def vqa_forward(self, feat_dict):
-        frcn_feat = feat_dict['FRCN_FEAT']
-        bbox_feat = feat_dict['BBOX_FEAT']
-
-        img_feat_mask = make_mask(frcn_feat)
-
-        if self.__C.USE_BBOX_FEAT:
-            bbox_feat = self.bbox_proc(bbox_feat)
-            bbox_feat = self.bbox_linear(bbox_feat)
-            frcn_feat = torch.cat((frcn_feat, bbox_feat), dim=-1)
-        img_feat = self.frcn_linear(frcn_feat)
-        rel_embed = self.relation_embedding(bbox_feat)
-
-        return img_feat, rel_embed, img_feat_mask
-
-
-    def gqa_forward(self, feat_dict):
-        frcn_feat = feat_dict['FRCN_FEAT']
-        bbox_feat = feat_dict['BBOX_FEAT']
-        grid_feat = feat_dict['GRID_FEAT']
-
-        img_feat_mask = make_mask(frcn_feat)
-
-        if self.__C.USE_BBOX_FEAT:
-            bbox_feat = self.bbox_linear(bbox_feat)
-            frcn_feat = torch.cat((frcn_feat, bbox_feat), dim=-1)
-        img_feat = self.frcn_linear(frcn_feat)
-
-        if self.__C.USE_AUX_FEAT:
-            grid_feat_mask = make_mask(grid_feat)
-            img_feat_mask = torch.cat((img_feat_mask, grid_feat_mask), dim=-1)
-            grid_feat = self.grid_linear(grid_feat)
-            img_feat = torch.cat((img_feat, grid_feat), dim=1)
-
-        rel_embed = self.relation_embedding(bbox_feat)
-
-        return img_feat, rel_embed, img_feat_mask
-
-
-    def clevr_forward(self, feat_dict):
-        grid_feat = feat_dict['GRID_FEAT']
-
-        img_feat_mask = make_mask(grid_feat)
-        img_feat = self.grid_linear(grid_feat)
-
-        rel_embed = self.relation_embedding(bbox_feat)
-
-        return img_feat, rel_embed, img_feat_mask
-
-
-

spaces/CVPR/LIVE/pybind11/tests/test_modules.py

@@ -1,73 +0,0 @@
-# -*- coding: utf-8 -*-
-from pybind11_tests import modules as m
-from pybind11_tests.modules import subsubmodule as ms
-from pybind11_tests import ConstructorStats
-
-
-def test_nested_modules():
-    import pybind11_tests
-    assert pybind11_tests.__name__ == "pybind11_tests"
-    assert pybind11_tests.modules.__name__ == "pybind11_tests.modules"
-    assert pybind11_tests.modules.subsubmodule.__name__ == "pybind11_tests.modules.subsubmodule"
-    assert m.__name__ == "pybind11_tests.modules"
-    assert ms.__name__ == "pybind11_tests.modules.subsubmodule"
-
-    assert ms.submodule_func() == "submodule_func()"
-
-
-def test_reference_internal():
-    b = ms.B()
-    assert str(b.get_a1()) == "A[1]"
-    assert str(b.a1) == "A[1]"
-    assert str(b.get_a2()) == "A[2]"
-    assert str(b.a2) == "A[2]"
-
-    b.a1 = ms.A(42)
-    b.a2 = ms.A(43)
-    assert str(b.get_a1()) == "A[42]"
-    assert str(b.a1) == "A[42]"
-    assert str(b.get_a2()) == "A[43]"
-    assert str(b.a2) == "A[43]"
-
-    astats, bstats = ConstructorStats.get(ms.A), ConstructorStats.get(ms.B)
-    assert astats.alive() == 2
-    assert bstats.alive() == 1
-    del b
-    assert astats.alive() == 0
-    assert bstats.alive() == 0
-    assert astats.values() == ['1', '2', '42', '43']
-    assert bstats.values() == []
-    assert astats.default_constructions == 0
-    assert bstats.default_constructions == 1
-    assert astats.copy_constructions == 0
-    assert bstats.copy_constructions == 0
-    # assert astats.move_constructions >= 0  # Don't invoke any
-    # assert bstats.move_constructions >= 0  # Don't invoke any
-    assert astats.copy_assignments == 2
-    assert bstats.copy_assignments == 0
-    assert astats.move_assignments == 0
-    assert bstats.move_assignments == 0
-
-
-def test_importing():
-    from pybind11_tests.modules import OD
-    from collections import OrderedDict
-
-    assert OD is OrderedDict
-    assert str(OD([(1, 'a'), (2, 'b')])) == "OrderedDict([(1, 'a'), (2, 'b')])"
-
-
-def test_pydoc():
-    """Pydoc needs to be able to provide help() for everything inside a pybind11 module"""
-    import pybind11_tests
-    import pydoc
-
-    assert pybind11_tests.__name__ == "pybind11_tests"
-    assert pybind11_tests.__doc__ == "pybind11 test module"
-    assert pydoc.text.docmodule(pybind11_tests)
-
-
-def test_duplicate_registration():
-    """Registering two things with the same name"""
-
-    assert m.duplicate_registration() == []

spaces/CVPR/WALT/mmdet/datasets/samplers/distributed_sampler.py

@@ -1,39 +0,0 @@
-import math
-
-import torch
-from torch.utils.data import DistributedSampler as _DistributedSampler
-
-
-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)
-        # for the compatibility from PyTorch 1.3+
-        self.seed = seed if seed is not None else 0
-
-    def __iter__(self):
-        # deterministically shuffle based on epoch
-        if self.shuffle:
-            g = torch.Generator()
-            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)

spaces/Candyraider/Proxy4/README.md

@@ -1,10 +0,0 @@
----
-title: Proxy4
-emoji: 🏢
-colorFrom: purple
-colorTo: purple
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/Chris4K/llms_compare/Antares Mic Mod Efx Mac ~UPD~ Crack Torrent.md

@@ -1,84 +0,0 @@
-## Antares Mic Mod Efx Mac Crack Torrent
-
-
-
- 
-
-  
-
- 
-
-**CLICK HERE ->>> [https://www.google.com/url?q=https%3A%2F%2Furlca.com%2F2txP1A&sa=D&sntz=1&usg=AOvVaw2UH1YkG1xYBKItn2Gwxll7](https://www.google.com/url?q=https%3A%2F%2Furlca.com%2F2txP1A&sa=D&sntz=1&usg=AOvVaw2UH1YkG1xYBKItn2Gwxll7)**
-
-
-
- 
-
- 
-
- 
-
- 
-
- 
-
-# How to Get Antares Mic Mod Efx Mac Crack Torrent for Free
-
- 
-
-Antares Mic Mod Efx is a popular plugin that allows you to emulate the sound of hundreds of different microphones with your existing mic. Whether you want to record vocals, guitars, drums, or any other instrument, you can use Mic Mod Efx to change the tone and character of your sound. But how can you get this plugin for free without paying the hefty price tag?
-
- 
-
-One way is to download a cracked version of Antares Mic Mod Efx Mac from a torrent site. A torrent is a file that contains information about other files that are distributed across a network of computers. By using a torrent client, you can download the files you want from other users who have them. However, this method is not recommended for several reasons.
-
- 
-
-First of all, downloading cracked software is illegal and unethical. You are violating the copyright and license agreement of the software developer, and you are depriving them of their rightful income. Secondly, downloading cracked software is risky and unsafe. You never know what kind of malware or viruses might be hidden in the files you download. You could end up infecting your computer or compromising your personal data. Thirdly, downloading cracked software is unreliable and unstable. You might encounter errors, bugs, or compatibility issues that could affect your performance or quality of your recordings.
-
- 
-
-So what is the best way to get Antares Mic Mod Efx Mac for free? The answer is simple: use a trial version. Antares offers a free 14-day trial of Mic Mod Efx on their website. You can download and install the plugin on your Mac and use it for two weeks without any limitations or restrictions. You can try out all the features and functions of the plugin and see how it works for you. You can also compare the sound of different microphones and find the ones that suit your style and preference.
-
- 
-
-After the trial period is over, you can decide whether you want to buy the full version of Antares Mic Mod Efx Mac or not. The full version costs $129 and comes with lifetime updates and support. You can also get it as part of the Antares AVOX bundle, which includes other vocal processing plugins such as Auto-Tune, Harmony Engine, Articulator, and more.
-
- 
-
-If you are serious about your music production and want to get the best sound possible, then investing in Antares Mic Mod Efx Mac is worth it. You will get access to a huge collection of microphone models that will enhance your recordings and give you more creative options. You will also get a legal and safe software that will work smoothly and reliably on your Mac.
-
- 
-
-So don't waste your time and risk your security by downloading Antares Mic Mod Efx Mac crack torrent from shady sites. Instead, go to the official Antares website and download the free trial version of Mic Mod Efx today. You will be amazed by what this plugin can do for your sound.
-
-
-
-## What Users Say About Antares Mic Mod Efx Mac
-
- 
-
-If you are still not convinced by the benefits of Antares Mic Mod Efx Mac, you might want to hear what other users have to say about it. Many users have shared their positive experiences and reviews of this plugin on various platforms and websites. Here are some of the testimonials from real users who have tried Antares Mic Mod Efx Mac:
-
- 
-
-- "I was just recording on the Sony C800g not too long ago and when I use this plugin at home (with my ml 770) and hear myself it sounds like I'm on the Sony. Blown away by how good this plugin is." - Michael from Newport Beach, CA[^1^]
-
-- "This tool is just that... A tool. I used it alongside my 1977 U87 and my U87ai. I was unable to tell the difference between my Ai and my Vintage U87 when I used this plugin to turn one into the other. Like a few others have stated... I'm shocked this tool doesn't get more exposure." - CC from Colorado[^1^]
-
-- "I'm using this plug-in with a Manley ref cad, I have no clie what the actual version of most of these mics are really suppose to sound like. All I know is they sound great!!" - Rony from Philadelphia[^1^]
-
-- "I'm astounded at the lack of credit MIc Mod has gotten. This software is really easy to use and also sounds extremely convincing to my ear. By no means does it sound like my own mic being EQ'ed. What I hear is dynamic frequency response change and saturation as well." - Anthony Lowery from Manteca, CA[^1^]
-
-- "This is clearly not something you could do in the real world, but if it creates a sound that works then it's more than justified. The mic models themselves are stored as separate files which, in the case of Mac users, are located within the Preferences folder in the System folder." - Paul White from Sound On Sound[^3^]
-
-
-
-As you can see, Antares Mic Mod Efx Mac has received rave reviews from users who have tried it and loved it. They have praised its ease of use, its realism, its versatility, and its quality. They have also compared it favorably to some of the most expensive and sought-after microphones in the world.
-
- dfd1c89656
-
- 
-
- 
-

spaces/ChrisPreston/diff-svc_minato_aqua/modules/commons/ssim.py

@@ -1,84 +0,0 @@
-"""
-Adapted from https://github.com/Po-Hsun-Su/pytorch-ssim
-"""
-
-from math import exp
-
-import torch
-import torch.nn.functional as F
-from torch.autograd import Variable
-
-
-def gaussian(window_size, sigma):
-    gauss = torch.Tensor([exp(-(x - window_size // 2) ** 2 / float(2 * sigma ** 2)) for x in range(window_size)])
-    return gauss / gauss.sum()
-
-
-def create_window(window_size, channel):
-    _1D_window = gaussian(window_size, 1.5).unsqueeze(1)
-    _2D_window = _1D_window.mm(_1D_window.t()).float().unsqueeze(0).unsqueeze(0)
-    window = Variable(_2D_window.expand(channel, 1, window_size, window_size).contiguous())
-    return window
-
-
-def _ssim(img1, img2, window, window_size, channel, size_average=True):
-    mu1 = F.conv2d(img1, window, padding=window_size // 2, groups=channel)
-    mu2 = F.conv2d(img2, window, padding=window_size // 2, groups=channel)
-
-    mu1_sq = mu1.pow(2)
-    mu2_sq = mu2.pow(2)
-    mu1_mu2 = mu1 * mu2
-
-    sigma1_sq = F.conv2d(img1 * img1, window, padding=window_size // 2, groups=channel) - mu1_sq
-    sigma2_sq = F.conv2d(img2 * img2, window, padding=window_size // 2, groups=channel) - mu2_sq
-    sigma12 = F.conv2d(img1 * img2, window, padding=window_size // 2, groups=channel) - mu1_mu2
-
-    C1 = 0.01 ** 2
-    C2 = 0.03 ** 2
-
-    ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) * (sigma1_sq + sigma2_sq + C2))
-
-    if size_average:
-        return ssim_map.mean()
-    else:
-        return ssim_map.mean(1)
-
-
-class SSIM(torch.nn.Module):
-    def __init__(self, window_size=11, size_average=True):
-        super(SSIM, self).__init__()
-        self.window_size = window_size
-        self.size_average = size_average
-        self.channel = 1
-        self.window = create_window(window_size, self.channel)
-
-    def forward(self, img1, img2):
-        (_, channel, _, _) = img1.size()
-
-        if channel == self.channel and self.window.data.type() == img1.data.type():
-            window = self.window
-        else:
-            window = create_window(self.window_size, channel)
-
-            if img1.is_cuda:
-                window = window.cuda(img1.get_device())
-            window = window.type_as(img1)
-
-            self.window = window
-            self.channel = channel
-
-        return _ssim(img1, img2, window, self.window_size, channel, self.size_average)
-
-
-window = None
-
-
-def ssim(img1, img2, window_size=11, size_average=True):
-    (_, channel, _, _) = img1.size()
-    global window
-    if window is None:
-        window = create_window(window_size, channel)
-        if img1.is_cuda:
-            window = window.cuda(img1.get_device())
-        window = window.type_as(img1)
-    return _ssim(img1, img2, window, window_size, channel, size_average)

spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/structures/segmentation_mask.py

@@ -1,535 +0,0 @@
-import cv2
-import copy
-import torch
-import numpy as np
-from maskrcnn_benchmark.layers.misc import interpolate
-
-import pycocotools.mask as mask_utils
-
-# transpose
-FLIP_LEFT_RIGHT = 0
-FLIP_TOP_BOTTOM = 1
-
-
-""" ABSTRACT
-Segmentations come in either:
-1) Binary masks
-2) Polygons
-
-Binary masks can be represented in a contiguous array
-and operations can be carried out more efficiently,
-therefore BinaryMaskList handles them together.
-
-Polygons are handled separately for each instance,
-by PolygonInstance and instances are handled by
-PolygonList.
-
-SegmentationList is supposed to represent both,
-therefore it wraps the functions of BinaryMaskList
-and PolygonList to make it transparent.
-"""
-
-
-class BinaryMaskList(object):
-    """
-    This class handles binary masks for all objects in the image
-    """
-
-    def __init__(self, masks, size):
-        """
-            Arguments:
-                masks: Either torch.tensor of [num_instances, H, W]
-                    or list of torch.tensors of [H, W] with num_instances elems,
-                    or RLE (Run Length Encoding) - interpreted as list of dicts,
-                    or BinaryMaskList.
-                size: absolute image size, width first
-
-            After initialization, a hard copy will be made, to leave the
-            initializing source data intact.
-        """
-
-        if isinstance(masks, torch.Tensor):
-            # The raw data representation is passed as argument
-            masks = masks.clone()
-        elif isinstance(masks, (list, tuple)):
-            if isinstance(masks[0], torch.Tensor):
-                masks = torch.stack(masks, dim=2).clone()
-            elif isinstance(masks[0], dict) and "count" in masks[0]:
-                # RLE interpretation
-
-                masks = mask_utils
-            else:
-                RuntimeError(
-                    "Type of `masks[0]` could not be interpreted: %s" % type(masks)
-                )
-        elif isinstance(masks, BinaryMaskList):
-            # just hard copy the BinaryMaskList instance's underlying data
-            masks = masks.masks.clone()
-        else:
-            RuntimeError(
-                "Type of `masks` argument could not be interpreted:%s" % type(masks)
-            )
-
-        if len(masks.shape) == 2:
-            # if only a single instance mask is passed
-            masks = masks[None]
-
-        assert len(masks.shape) == 3
-        assert masks.shape[1] == size[1], "%s != %s" % (masks.shape[1], size[1])
-        assert masks.shape[2] == size[0], "%s != %s" % (masks.shape[2], size[0])
-
-        self.masks = masks
-        self.size = tuple(size)
-
-    def transpose(self, method):
-        dim = 1 if method == FLIP_TOP_BOTTOM else 2
-        flipped_masks = self.masks.flip(dim)
-        return BinaryMaskList(flipped_masks, self.size)
-
-    def crop(self, box):
-        assert isinstance(box, (list, tuple, torch.Tensor)), str(type(box))
-        # box is assumed to be xyxy
-        current_width, current_height = self.size
-        xmin, ymin, xmax, ymax = [round(float(b)) for b in box]
-
-        assert xmin <= xmax and ymin <= ymax, str(box)
-        xmin = min(max(xmin, 0), current_width - 1)
-        ymin = min(max(ymin, 0), current_height - 1)
-
-        xmax = min(max(xmax, 0), current_width)
-        ymax = min(max(ymax, 0), current_height)
-
-        xmax = max(xmax, xmin + 1)
-        ymax = max(ymax, ymin + 1)
-
-        width, height = xmax - xmin, ymax - ymin
-        cropped_masks = self.masks[:, ymin:ymax, xmin:xmax]
-        cropped_size = width, height
-        return BinaryMaskList(cropped_masks, cropped_size)
-
-    def resize(self, size):
-        try:
-            iter(size)
-        except TypeError:
-            assert isinstance(size, (int, float))
-            size = size, size
-        width, height = map(int, size)
-
-        assert width > 0
-        assert height > 0
-
-        # Height comes first here!
-        resized_masks = torch.nn.functional.interpolate(
-            input=self.masks[None].float(),
-            size=(height, width),
-            mode="bilinear",
-            align_corners=False,
-        )[0].type_as(self.masks)
-        resized_size = width, height
-        return BinaryMaskList(resized_masks, resized_size)
-
-    def convert_to_polygon(self):
-        contours = self._findContours()
-        return PolygonList(contours, self.size)
-
-    def to(self, *args, **kwargs):
-        return self
-
-    def _findContours(self):
-        contours = []
-        masks = self.masks.detach().numpy()
-        for mask in masks:
-            mask = cv2.UMat(mask)
-            contour, hierarchy = cv2.findContours(
-                mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_TC89_L1
-            )
-
-            reshaped_contour = []
-            for entity in contour:
-                assert len(entity.shape) == 3
-                assert entity.shape[1] == 1, "Hierarchical contours are not allowed"
-                reshaped_contour.append(entity.reshape(-1).tolist())
-            contours.append(reshaped_contour)
-        return contours
-
-    def __len__(self):
-        return len(self.masks)
-
-    def __getitem__(self, index):
-        # Probably it can cause some overhead
-        # but preserves consistency
-        masks = self.masks[index].clone()
-        return BinaryMaskList(masks, self.size)
-
-    def __iter__(self):
-        return iter(self.masks)
-
-    def __repr__(self):
-        s = self.__class__.__name__ + "("
-        s += "num_instances={}, ".format(len(self.masks))
-        s += "image_width={}, ".format(self.size[0])
-        s += "image_height={})".format(self.size[1])
-        return s
-
-
-class PolygonInstance(object):
-    """
-    This class holds a set of polygons that represents a single instance
-    of an object mask. The object can be represented as a set of
-    polygons
-    """
-
-    def __init__(self, polygons, size):
-        """
-            Arguments:
-                a list of lists of numbers.
-                The first level refers to all the polygons that compose the
-                object, and the second level to the polygon coordinates.
-        """
-        if isinstance(polygons, (list, tuple)):
-            valid_polygons = []
-            for p in polygons:
-                p = torch.as_tensor(p, dtype=torch.float32)
-                if len(p) >= 6:  # 3 * 2 coordinates
-                    valid_polygons.append(p)
-            polygons = valid_polygons
-
-        elif isinstance(polygons, PolygonInstance):
-            polygons = copy.copy(polygons.polygons)
-        else:
-            RuntimeError(
-                "Type of argument `polygons` is not allowed:%s" % (type(polygons))
-            )
-
-        """ This crashes the training way too many times...
-        for p in polygons:
-            assert p[::2].min() >= 0
-            assert p[::2].max() < size[0]
-            assert p[1::2].min() >= 0
-            assert p[1::2].max() , size[1]
-        """
-
-        self.polygons = polygons
-        self.size = tuple(size)
-
-    def transpose(self, method):
-        if method not in (FLIP_LEFT_RIGHT, FLIP_TOP_BOTTOM):
-            raise NotImplementedError(
-                "Only FLIP_LEFT_RIGHT and FLIP_TOP_BOTTOM implemented"
-            )
-
-        flipped_polygons = []
-        width, height = self.size
-        if method == FLIP_LEFT_RIGHT:
-            dim = width
-            idx = 0
-        elif method == FLIP_TOP_BOTTOM:
-            dim = height
-            idx = 1
-
-        for poly in self.polygons:
-            p = poly.clone()
-            TO_REMOVE = 1
-            p[idx::2] = dim - poly[idx::2] - TO_REMOVE
-            flipped_polygons.append(p)
-
-        return PolygonInstance(flipped_polygons, size=self.size)
-
-    def crop(self, box):
-        assert isinstance(box, (list, tuple, torch.Tensor)), str(type(box))
-
-        # box is assumed to be xyxy
-        current_width, current_height = self.size
-        xmin, ymin, xmax, ymax = map(float, box)
-
-        assert xmin <= xmax and ymin <= ymax, str(box)
-        xmin = min(max(xmin, 0), current_width - 1)
-        ymin = min(max(ymin, 0), current_height - 1)
-
-        xmax = min(max(xmax, 0), current_width)
-        ymax = min(max(ymax, 0), current_height)
-
-        xmax = max(xmax, xmin + 1)
-        ymax = max(ymax, ymin + 1)
-
-        w, h = xmax - xmin, ymax - ymin
-
-        cropped_polygons = []
-        for poly in self.polygons:
-            p = poly.clone()
-            p[0::2] = p[0::2] - xmin  # .clamp(min=0, max=w)
-            p[1::2] = p[1::2] - ymin  # .clamp(min=0, max=h)
-            cropped_polygons.append(p)
-
-        return PolygonInstance(cropped_polygons, size=(w, h))
-
-    def resize(self, size):
-        try:
-            iter(size)
-        except TypeError:
-            assert isinstance(size, (int, float))
-            size = size, size
-
-        ratios = tuple(float(s) / float(s_orig) for s, s_orig in zip(size, self.size))
-
-        if ratios[0] == ratios[1]:
-            ratio = ratios[0]
-            scaled_polys = [p * ratio for p in self.polygons]
-            return PolygonInstance(scaled_polys, size)
-
-        ratio_w, ratio_h = ratios
-        scaled_polygons = []
-        for poly in self.polygons:
-            p = poly.clone()
-            p[0::2] *= ratio_w
-            p[1::2] *= ratio_h
-            scaled_polygons.append(p)
-
-        return PolygonInstance(scaled_polygons, size=size)
-
-    def convert_to_binarymask(self):
-        width, height = self.size
-        # formatting for COCO PythonAPI
-        polygons = [p.numpy() for p in self.polygons]
-        rles = mask_utils.frPyObjects(polygons, height, width)
-        rle = mask_utils.merge(rles)
-        mask = mask_utils.decode(rle)
-        mask = torch.from_numpy(mask)
-        return mask
-
-    def __len__(self):
-        return len(self.polygons)
-
-    def __repr__(self):
-        s = self.__class__.__name__ + "("
-        s += "num_groups={}, ".format(len(self.polygons))
-        s += "image_width={}, ".format(self.size[0])
-        s += "image_height={}, ".format(self.size[1])
-        return s
-
-
-class PolygonList(object):
-    """
-    This class handles PolygonInstances for all objects in the image
-    """
-
-    def __init__(self, polygons, size):
-        """
-        Arguments:
-            polygons:
-                a list of list of lists of numbers. The first
-                level of the list correspond to individual instances,
-                the second level to all the polygons that compose the
-                object, and the third level to the polygon coordinates.
-
-                OR
-
-                a list of PolygonInstances.
-
-                OR
-
-                a PolygonList
-
-            size: absolute image size
-
-        """
-        if isinstance(polygons, (list, tuple)):
-            if len(polygons) == 0:
-                polygons = [[[]]]
-            if isinstance(polygons[0], (list, tuple)):
-                assert isinstance(polygons[0][0], (list, tuple)), str(
-                    type(polygons[0][0])
-                )
-            else:
-                assert isinstance(polygons[0], PolygonInstance), str(type(polygons[0]))
-
-        elif isinstance(polygons, PolygonList):
-            size = polygons.size
-            polygons = polygons.polygons
-
-        else:
-            RuntimeError(
-                "Type of argument `polygons` is not allowed:%s" % (type(polygons))
-            )
-
-        assert isinstance(size, (list, tuple)), str(type(size))
-
-        self.polygons = []
-        for p in polygons:
-            p = PolygonInstance(p, size)
-            if len(p) > 0:
-                self.polygons.append(p)
-
-        self.size = tuple(size)
-
-    def transpose(self, method):
-        if method not in (FLIP_LEFT_RIGHT, FLIP_TOP_BOTTOM):
-            raise NotImplementedError(
-                "Only FLIP_LEFT_RIGHT and FLIP_TOP_BOTTOM implemented"
-            )
-
-        flipped_polygons = []
-        for polygon in self.polygons:
-            flipped_polygons.append(polygon.transpose(method))
-
-        return PolygonList(flipped_polygons, size=self.size)
-
-    def crop(self, box):
-        w, h = box[2] - box[0], box[3] - box[1]
-        cropped_polygons = []
-        for polygon in self.polygons:
-            cropped_polygons.append(polygon.crop(box))
-
-        cropped_size = w, h
-        return PolygonList(cropped_polygons, cropped_size)
-
-    def resize(self, size):
-        resized_polygons = []
-        for polygon in self.polygons:
-            resized_polygons.append(polygon.resize(size))
-
-        resized_size = size
-        return PolygonList(resized_polygons, resized_size)
-
-    def to(self, *args, **kwargs):
-        return self
-
-    def convert_to_binarymask(self):
-        if len(self) > 0:
-            masks = torch.stack([p.convert_to_binarymask() for p in self.polygons])
-        else:
-            size = self.size
-            masks = torch.empty([0, size[1], size[0]], dtype=torch.uint8)
-
-        return BinaryMaskList(masks, size=self.size)
-
-    def __len__(self):
-        return len(self.polygons)
-
-    def __getitem__(self, item):
-        if isinstance(item, int):
-            selected_polygons = [self.polygons[item]]
-        elif isinstance(item, slice):
-            selected_polygons = self.polygons[item]
-        else:
-            # advanced indexing on a single dimension
-            selected_polygons = []
-            if isinstance(item, torch.Tensor) and item.dtype == torch.uint8:
-                item = item.nonzero()
-                item = item.squeeze(1) if item.numel() > 0 else item
-                item = item.tolist()
-            for i in item:
-                selected_polygons.append(self.polygons[i])
-        return PolygonList(selected_polygons, size=self.size)
-
-    def __iter__(self):
-        return iter(self.polygons)
-
-    def __repr__(self):
-        s = self.__class__.__name__ + "("
-        s += "num_instances={}, ".format(len(self.polygons))
-        s += "image_width={}, ".format(self.size[0])
-        s += "image_height={})".format(self.size[1])
-        return s
-
-
-class SegmentationMask(object):
-
-    """
-    This class stores the segmentations for all objects in the image.
-    It wraps BinaryMaskList and PolygonList conveniently.
-    """
-
-    def __init__(self, instances, size, mode="poly"):
-        """
-        Arguments:
-            instances: two types
-                (1) polygon
-                (2) binary mask
-            size: (width, height)
-            mode: 'poly', 'mask'. if mode is 'mask', convert mask of any format to binary mask
-        """
-
-        assert isinstance(size, (list, tuple))
-        assert len(size) == 2
-        if isinstance(size[0], torch.Tensor):
-            assert isinstance(size[1], torch.Tensor)
-            size = size[0].item(), size[1].item()
-
-        assert isinstance(size[0], (int, float))
-        assert isinstance(size[1], (int, float))
-
-        if mode == "poly":
-            self.instances = PolygonList(instances, size)
-        elif mode == "mask":
-            self.instances = BinaryMaskList(instances, size)
-        else:
-            raise NotImplementedError("Unknown mode: %s" % str(mode))
-
-        self.mode = mode
-        self.size = tuple(size)
-
-    def transpose(self, method):
-        flipped_instances = self.instances.transpose(method)
-        return SegmentationMask(flipped_instances, self.size, self.mode)
-
-    def crop(self, box):
-        cropped_instances = self.instances.crop(box)
-        cropped_size = cropped_instances.size
-        return SegmentationMask(cropped_instances, cropped_size, self.mode)
-
-    def resize(self, size, *args, **kwargs):
-        resized_instances = self.instances.resize(size)
-        resized_size = size
-        return SegmentationMask(resized_instances, resized_size, self.mode)
-
-    def to(self, *args, **kwargs):
-        return self
-
-    def convert(self, mode):
-        if mode == self.mode:
-            return self
-
-        if mode == "poly":
-            converted_instances = self.instances.convert_to_polygon()
-        elif mode == "mask":
-            converted_instances = self.instances.convert_to_binarymask()
-        else:
-            raise NotImplementedError("Unknown mode: %s" % str(mode))
-
-        return SegmentationMask(converted_instances, self.size, mode)
-
-    def get_mask_tensor(self):
-        instances = self.instances
-        if self.mode == "poly":
-            instances = instances.convert_to_binarymask()
-        # If there is only 1 instance
-        return instances.masks.squeeze(0)
-
-    def __len__(self):
-        return len(self.instances)
-
-    def __getitem__(self, item):
-        selected_instances = self.instances.__getitem__(item)
-        return SegmentationMask(selected_instances, self.size, self.mode)
-
-    def __iter__(self):
-        self.iter_idx = 0
-        return self
-
-    def __next__(self):
-        if self.iter_idx < self.__len__():
-            next_segmentation = self.__getitem__(self.iter_idx)
-            self.iter_idx += 1
-            return next_segmentation
-        raise StopIteration()
-        
-    next = __next__  # Python 2 compatibility
-
-    def __repr__(self):
-        s = self.__class__.__name__ + "("
-        s += "num_instances={}, ".format(len(self.instances))
-        s += "image_width={}, ".format(self.size[0])
-        s += "image_height={}, ".format(self.size[1])
-        s += "mode={})".format(self.mode)
-        return s

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/background.py

@@ -1 +0,0 @@
-from starlette.background import BackgroundTasks as BackgroundTasks  # noqa

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/ttLib/tables/T_S_I_C_.py

@@ -1,5 +0,0 @@
-from .otBase import BaseTTXConverter
-
-
-class table_T_S_I_C_(BaseTTXConverter):
-    pass

spaces/DaleChen/AutoGPT/autogpt/__main__.py

@@ -1,5 +0,0 @@
-"""Auto-GPT: A GPT powered AI Assistant"""
-import autogpt.cli
-
-if __name__ == "__main__":
-    autogpt.cli.main()

spaces/DanteOz/Minimal-Endpoint/app.py

@@ -1,14 +0,0 @@
-from flask import Flask
-
-app = Flask(__name__)
-
-@app.route("/")
-def index():
-    return "<p>Hello, World!</p>"
-
-@app.route("/predict")
-def predict():
-    return {"output": "prediction"}
-
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)

spaces/Datasculptor/3D-Room-Layout-Estimation_LGT-Net/loss/boundary_loss.py

@@ -1,51 +0,0 @@
-""" 
-@Date: 2021/08/12
-@description: For HorizonNet, using latitudes to calculate loss.
-"""
-import torch
-import torch.nn as nn
-from utils.conversion import depth2xyz, xyz2lonlat
-
-
-class BoundaryLoss(nn.Module):
-    def __init__(self):
-        super().__init__()
-        self.loss = nn.L1Loss()
-
-    def forward(self, gt, dt):
-        gt_floor_xyz = depth2xyz(gt['depth'])
-        gt_ceil_xyz = gt_floor_xyz.clone()
-        gt_ceil_xyz[..., 1] = -gt['ratio']
-
-        gt_floor_boundary = xyz2lonlat(gt_floor_xyz)[..., -1:]
-        gt_ceil_boundary = xyz2lonlat(gt_ceil_xyz)[..., -1:]
-
-        gt_boundary = torch.cat([gt_floor_boundary, gt_ceil_boundary], dim=-1).permute(0, 2, 1)
-        dt_boundary = dt['boundary']
-
-        loss = self.loss(gt_boundary, dt_boundary)
-        return loss
-
-
-if __name__ == '__main__':
-    import numpy as np
-    from dataset.mp3d_dataset import MP3DDataset
-
-    mp3d_dataset = MP3DDataset(root_dir='../src/dataset/mp3d', mode='train')
-    gt = mp3d_dataset.__getitem__(0)
-
-    gt['depth'] = torch.from_numpy(gt['depth'][np.newaxis])  # batch size is 1
-    gt['ratio'] = torch.from_numpy(gt['ratio'][np.newaxis])  # batch size is 1
-
-    dummy_dt = {
-        'depth': gt['depth'].clone(),
-        'boundary': torch.cat([
-            xyz2lonlat(depth2xyz(gt['depth']))[..., -1:],
-            xyz2lonlat(depth2xyz(gt['depth'], plan_y=-gt['ratio']))[..., -1:]
-            ], dim=-1).permute(0, 2, 1)
-    }
-    # dummy_dt['boundary'][:, :, :20] /= 1.2  # some different
-
-    boundary_loss = BoundaryLoss()
-    loss = boundary_loss(gt, dummy_dt)
-    print(loss)

spaces/DemoLou/moe-tts/text/shanghainese.py

@@ -1,64 +0,0 @@
-import re
-import cn2an
-import opencc
-
-
-converter = opencc.OpenCC('chinese_dialect_lexicons/zaonhe')
-
-# List of (Latin alphabet, ipa) pairs:
-_latin_to_ipa = [(re.compile('%s' % x[0]), x[1]) for x in [
-    ('A', 'ᴇ'),
-    ('B', 'bi'),
-    ('C', 'si'),
-    ('D', 'di'),
-    ('E', 'i'),
-    ('F', 'ᴇf'),
-    ('G', 'dʑi'),
-    ('H', 'ᴇtɕʰ'),
-    ('I', 'ᴀi'),
-    ('J', 'dʑᴇ'),
-    ('K', 'kʰᴇ'),
-    ('L', 'ᴇl'),
-    ('M', 'ᴇm'),
-    ('N', 'ᴇn'),
-    ('O', 'o'),
-    ('P', 'pʰi'),
-    ('Q', 'kʰiu'),
-    ('R', 'ᴀl'),
-    ('S', 'ᴇs'),
-    ('T', 'tʰi'),
-    ('U', 'ɦiu'),
-    ('V', 'vi'),
-    ('W', 'dᴀbɤliu'),
-    ('X', 'ᴇks'),
-    ('Y', 'uᴀi'),
-    ('Z', 'zᴇ')
-]]
-
-
-def _number_to_shanghainese(num):
-    num = cn2an.an2cn(num).replace('一十','十').replace('二十', '廿').replace('二', '两')
-    return re.sub(r'((?:^|[^三四五六七八九])十|廿)两', r'\1二', num)
-
-
-def number_to_shanghainese(text):
-    return re.sub(r'\d+(?:\.?\d+)?', lambda x: _number_to_shanghainese(x.group()), text)
-
-
-def latin_to_ipa(text):
-    for regex, replacement in _latin_to_ipa:
-        text = re.sub(regex, replacement, text)
-    return text
-
-
-def shanghainese_to_ipa(text):
-    text = number_to_shanghainese(text.upper())
-    text = converter.convert(text).replace('-','').replace('$',' ')
-    text = re.sub(r'[A-Z]', lambda x: latin_to_ipa(x.group())+' ', text)
-    text = re.sub(r'[、；：]', '，', text)
-    text = re.sub(r'\s*，\s*', ', ', text)
-    text = re.sub(r'\s*。\s*', '. ', text)
-    text = re.sub(r'\s*？\s*', '? ', text)
-    text = re.sub(r'\s*！\s*', '! ', text)
-    text = re.sub(r'\s*$', '', text)
-    return text

spaces/DiamondYin/AnewGame/index.html

@@ -1,122 +0,0 @@
-<!DOCTYPE html>
-<html lang="en-us">
-  <head>
-    <meta charset="utf-8">
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
-    <title>Unity WebGL Player | New Unity Project</title>
-    <link rel="shortcut icon" href="TemplateData/favicon.ico">
-    <link rel="stylesheet" href="TemplateData/style.css">
-  </head>
-  <body>
-    <div id="unity-container" class="unity-desktop">
-      <canvas id="unity-canvas" width=960 height=600 tabindex="-1"></canvas>
-      <div id="unity-loading-bar">
-        <div id="unity-logo"></div>
-        <div id="unity-progress-bar-empty">
-          <div id="unity-progress-bar-full"></div>
-        </div>
-      </div>
-      <div id="unity-warning"> </div>
-      <div id="unity-footer">
-        <div id="unity-webgl-logo"></div>
-        <div id="unity-fullscreen-button"></div>
-        <div id="unity-build-title">New Unity Project</div>
-      </div>
-    </div>
-    <script>
-
-      var container = document.querySelector("#unity-container");
-      var canvas = document.querySelector("#unity-canvas");
-      var loadingBar = document.querySelector("#unity-loading-bar");
-      var progressBarFull = document.querySelector("#unity-progress-bar-full");
-      var fullscreenButton = document.querySelector("#unity-fullscreen-button");
-      var warningBanner = document.querySelector("#unity-warning");
-
-      // Shows a temporary message banner/ribbon for a few seconds, or
-      // a permanent error message on top of the canvas if type=='error'.
-      // If type=='warning', a yellow highlight color is used.
-      // Modify or remove this function to customize the visually presented
-      // way that non-critical warnings and error messages are presented to the
-      // user.
-      function unityShowBanner(msg, type) {
-        function updateBannerVisibility() {
-          warningBanner.style.display = warningBanner.children.length ? 'block' : 'none';
-        }
-        var div = document.createElement('div');
-        div.innerHTML = msg;
-        warningBanner.appendChild(div);
-        if (type == 'error') div.style = 'background: red; padding: 10px;';
-        else {
-          if (type == 'warning') div.style = 'background: yellow; padding: 10px;';
-          setTimeout(function() {
-            warningBanner.removeChild(div);
-            updateBannerVisibility();
-          }, 5000);
-        }
-        updateBannerVisibility();
-      }
-
-      var buildUrl = "Build";
-      var loaderUrl = buildUrl + "/WaliwebGLgameFPS.loader.js";
-      var config = {
-        dataUrl: buildUrl + "/WaliwebGLgameFPS.data",
-        frameworkUrl: buildUrl + "/WaliwebGLgameFPS.framework.js",
-        codeUrl: buildUrl + "/WaliwebGLgameFPS.wasm",
-        streamingAssetsUrl: "StreamingAssets",
-        companyName: "DefaultCompany",
-        productName: "New Unity Project",
-        productVersion: "0.1",
-        showBanner: unityShowBanner,
-      };
-
-      // By default Unity keeps WebGL canvas render target size matched with
-      // the DOM size of the canvas element (scaled by window.devicePixelRatio)
-      // Set this to false if you want to decouple this synchronization from
-      // happening inside the engine, and you would instead like to size up
-      // the canvas DOM size and WebGL render target sizes yourself.
-      // config.matchWebGLToCanvasSize = false;
-
-      if (/iPhone|iPad|iPod|Android/i.test(navigator.userAgent)) {
-        // Mobile device style: fill the whole browser client area with the game canvas:
-
-        var meta = document.createElement('meta');
-        meta.name = 'viewport';
-        meta.content = 'width=device-width, height=device-height, initial-scale=1.0, user-scalable=no, shrink-to-fit=yes';
-        document.getElementsByTagName('head')[0].appendChild(meta);
-        container.className = "unity-mobile";
-        canvas.className = "unity-mobile";
-
-        // To lower canvas resolution on mobile devices to gain some
-        // performance, uncomment the following line:
-        // config.devicePixelRatio = 1;
-
-
-      } else {
-        // Desktop style: Render the game canvas in a window that can be maximized to fullscreen:
-
-        canvas.style.width = "960px";
-        canvas.style.height = "600px";
-      }
-
-      loadingBar.style.display = "block";
-
-      var script = document.createElement("script");
-      script.src = loaderUrl;
-      script.onload = () => {
-        createUnityInstance(canvas, config, (progress) => {
-          progressBarFull.style.width = 100 * progress + "%";
-              }).then((unityInstance) => {
-                loadingBar.style.display = "none";
-                fullscreenButton.onclick = () => {
-                  unityInstance.SetFullscreen(1);
-                };
-              }).catch((message) => {
-                alert(message);
-              });
-            };
-
-      document.body.appendChild(script);
-
-    </script>
-  </body>
-</html>

spaces/DragGan/DragGan-Inversion/stylegan_human/training_scripts/sg3/training/networks_stylegan2.py

@@ -1,1007 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-# 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.
-
-"""Network architectures from the paper
-"Analyzing and Improving the Image Quality of StyleGAN".
-Matches the original implementation of configs E-F by Karras et al. at
-https://github.com/NVlabs/stylegan2/blob/master/training/networks_stylegan2.py"""
-
-import numpy as np
-import torch
-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
-
-# ----------------------------------------------------------------------------
-
-
-@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 modulated_conv2d(
-    # Input tensor of shape [batch_size, in_channels, in_height, in_width].
-    x,
-    # Weight tensor of shape [out_channels, in_channels, kernel_height, kernel_width].
-    weight,
-    # Modulation coefficients of shape [batch_size, in_channels].
-    styles,
-    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.
-    # Low-pass filter to apply when resampling activations. Must be prepared beforehand by calling upfirdn2d.setup_filter().
-    resample_filter=None,
-    demodulate=True,     # Apply weight demodulation?
-    # False = convolution, True = correlation (matches torch.nn.functional.conv2d).
-    flip_weight=True,
-    # Perform modulation, convolution, and demodulation as a single fused operation?
-    fused_modconv=True,
-):
-    batch_size = x.shape[0]
-    out_channels, in_channels, kh, kw = weight.shape
-    misc.assert_shape(weight, [out_channels, in_channels, kh, kw])  # [OIkk]
-    misc.assert_shape(x, [batch_size, in_channels, None, None])  # [NIHW]
-    misc.assert_shape(styles, [batch_size, in_channels])  # [NI]
-
-    # Pre-normalize inputs to avoid FP16 overflow.
-    if x.dtype == torch.float16 and demodulate:
-        weight = weight * (1 / np.sqrt(in_channels * kh * kw) /
-                           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 demodulate or fused_modconv:
-        w = weight.unsqueeze(0)  # [NOIkk]
-        w = w * styles.reshape(batch_size, 1, -1, 1, 1)  # [NOIkk]
-    if demodulate:
-        dcoefs = (w.square().sum(dim=[2, 3, 4]) + 1e-8).rsqrt()  # [NO]
-    if demodulate and fused_modconv:
-        w = w * dcoefs.reshape(batch_size, -1, 1, 1, 1)  # [NOIkk]
-
-    # Execute by scaling the activations before and after the convolution.
-    if not fused_modconv:
-        x = x * styles.to(x.dtype).reshape(batch_size, -1, 1, 1)
-        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)
-        if demodulate and noise is not None:
-            x = fma.fma(x, dcoefs.to(x.dtype).reshape(
-                batch_size, -1, 1, 1), noise.to(x.dtype))
-        elif demodulate:
-            x = x * dcoefs.to(x.dtype).reshape(batch_size, -1, 1, 1)
-        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)
-    misc.assert_shape(x, [batch_size, in_channels, None, None])
-    x = x.reshape(1, -1, *x.shape[2:])
-    w = w.reshape(-1, in_channels, kh, kw)
-    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)
-    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 function: 'relu', 'lrelu', etc.
-                 activation='linear',
-                 lr_multiplier=1,        # Learning rate multiplier.
-                 bias_init=0,        # Initial value for the additive bias.
-                 ):
-        super().__init__()
-        self.in_features = in_features
-        self.out_features = out_features
-        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
-
-    def extra_repr(self):
-        return f'in_features={self.in_features:d}, out_features={self.out_features:d}, activation={self.activation:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Conv2dLayer(torch.nn.Module):
-    def __init__(self,
-                 in_channels,                    # Number of input channels.
-                 out_channels,                   # Number of output channels.
-                 # Width and height of the convolution kernel.
-                 kernel_size,
-                 bias=True,         # Apply additive bias before the activation function?
-                 # Activation function: 'relu', 'lrelu', etc.
-                 activation='linear',
-                 up=1,            # Integer upsampling factor.
-                 down=1,            # Integer downsampling factor.
-                 # Low-pass filter to apply when resampling activations.
-                 resample_filter=[1, 3, 3, 1],
-                 # Clamp the output to +-X, None = disable clamping.
-                 conv_clamp=None,
-                 channels_last=False,        # Expect the input to have memory_format=channels_last?
-                 trainable=True,         # Update the weights of this layer during training?
-                 ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        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
-
-        memory_format = torch.channels_last if channels_last else torch.contiguous_format
-        weight = torch.randn([out_channels, in_channels, kernel_size, kernel_size]).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
-        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)
-
-        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
-
-    def extra_repr(self):
-        return ' '.join([
-            f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, activation={self.activation:s},',
-            f'up={self.up}, down={self.down}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class MappingNetwork(torch.nn.Module):
-    def __init__(self,
-                 # Input latent (Z) dimensionality, 0 = no latent.
-                 z_dim,
-                 # Conditioning label (C) dimensionality, 0 = no label.
-                 c_dim,
-                 # Intermediate latent (W) dimensionality.
-                 w_dim,
-                 # Number of intermediate latents to output, None = do not broadcast.
-                 num_ws,
-                 num_layers=8,        # Number of mapping layers.
-                 # Label embedding dimensionality, None = same as w_dim.
-                 embed_features=None,
-                 # Number of intermediate features in the mapping layers, None = same as w_dim.
-                 layer_features=None,
-                 # Activation function: 'relu', 'lrelu', etc.
-                 activation='lrelu',
-                 # Learning rate multiplier for the mapping layers.
-                 lr_multiplier=0.01,
-                 # Decay for tracking the moving average of W during training, None = do not track.
-                 w_avg_beta=0.998,
-                 ):
-        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:
-            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, c, truncation_psi=1, truncation_cutoff=None, update_emas=False):
-        # 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))
-            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 update_emas and self.w_avg_beta is not None:
-            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
-
-    def extra_repr(self):
-        return f'z_dim={self.z_dim:d}, c_dim={self.c_dim:d}, w_dim={self.w_dim:d}, num_ws={self.num_ws:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisLayer(torch.nn.Module):
-    def __init__(self,
-                 in_channels,                    # Number of input channels.
-                 out_channels,                   # Number of output channels.
-                 # Intermediate latent (W) dimensionality.
-                 w_dim,
-                 resolution,                     # Resolution of this layer.
-                 kernel_size=3,            # Convolution kernel size.
-                 up=1,            # Integer upsampling factor.
-                 use_noise=True,         # Enable noise input?
-                 # Activation function: 'relu', 'lrelu', etc.
-                 activation='lrelu',
-                 # Low-pass filter to apply when resampling activations.
-                 resample_filter=[1, 3, 3, 1],
-                 # Clamp the output of convolution layers to +-X, None = disable clamping.
-                 conv_clamp=None,
-                 channels_last=False,        # Use channels_last format for the weights?
-                 square=False,        # default if for rectangle images
-                 ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.w_dim = w_dim
-        self.resolution = resolution
-        self.up = up
-        self.use_noise = use_noise
-        self.activation = activation
-        self.conv_clamp = conv_clamp
-        self.register_buffer(
-            'resample_filter', upfirdn2d.setup_filter(resample_filter))
-        self.padding = kernel_size // 2
-        self.act_gain = bias_act.activation_funcs[activation].def_gain
-        self.square = square
-
-        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(
-            [out_channels, in_channels, kernel_size, kernel_size]).to(memory_format=memory_format))
-        if use_noise:
-            if self.square:
-                self.register_buffer(
-                    'noise_const', torch.randn([resolution, resolution]))
-            else:
-                self.register_buffer('noise_const', torch.randn(
-                    [resolution, resolution // 2]))
-            self.noise_strength = torch.nn.Parameter(torch.zeros([]))
-        self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
-
-    def forward(self, x, w, noise_mode='random', fused_modconv=True, gain=1):
-        assert noise_mode in ['random', 'const', 'none']
-        in_resolution = self.resolution // self.up
-        if self.square:
-            misc.assert_shape(
-                x, [None, self.weight.shape[1], in_resolution, in_resolution])
-        else:
-            misc.assert_shape(
-                x, [None, self.weight.shape[1], in_resolution, in_resolution // 2])
-        styles = self.affine(w)
-
-        noise = None
-        if self.use_noise and noise_mode == 'random':
-            if self.square:
-                noise = torch.randn(
-                    [x.shape[0], 1, self.resolution, self.resolution], device=x.device) * self.noise_strength
-            else:
-                noise = torch.randn(
-                    [x.shape[0], 1, self.resolution, self.resolution // 2], device=x.device) * self.noise_strength
-        if self.use_noise and noise_mode == 'const':
-            noise = self.noise_const * self.noise_strength
-
-        flip_weight = (self.up == 1)  # slightly faster
-        x = modulated_conv2d(x=x, weight=self.weight, styles=styles, noise=noise, up=self.up,
-                             padding=self.padding, resample_filter=self.resample_filter, flip_weight=flip_weight, fused_modconv=fused_modconv)
-
-        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
-
-    def extra_repr(self):
-        return ' '.join([
-            f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, w_dim={self.w_dim:d},',
-            f'resolution={self.resolution:d}, up={self.up}, activation={self.activation:s}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class ToRGBLayer(torch.nn.Module):
-    def __init__(self, in_channels, out_channels, w_dim, kernel_size=1, conv_clamp=None, channels_last=False):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.w_dim = w_dim
-        self.conv_clamp = conv_clamp
-        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(
-            [out_channels, in_channels, kernel_size, kernel_size]).to(memory_format=memory_format))
-        self.bias = torch.nn.Parameter(torch.zeros([out_channels]))
-        self.weight_gain = 1 / np.sqrt(in_channels * (kernel_size ** 2))
-
-    def forward(self, x, w, fused_modconv=True):
-        styles = self.affine(w) * self.weight_gain
-        x = modulated_conv2d(x=x, weight=self.weight, styles=styles,
-                             demodulate=False, fused_modconv=fused_modconv)
-        x = bias_act.bias_act(x, self.bias.to(x.dtype), clamp=self.conv_clamp)
-        return x
-
-    def extra_repr(self):
-        return f'in_channels={self.in_channels:d}, out_channels={self.out_channels:d}, w_dim={self.w_dim:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisBlock(torch.nn.Module):
-    def __init__(self,
-                 # Number of input channels, 0 = first block.
-                 in_channels,
-                 # Number of output channels.
-                 out_channels,
-                 # Intermediate latent (W) dimensionality.
-                 w_dim,
-                 # Resolution of this block.
-                 resolution,
-                 # Number of output color channels.
-                 img_channels,
-                 is_last,                                # Is this the last block?
-                 # Architecture: 'orig', 'skip', 'resnet'.
-                 architecture='skip',
-                 # Low-pass filter to apply when resampling activations.
-                 resample_filter=[1, 3, 3, 1],
-                 # Clamp the output of convolution layers to +-X, None = disable clamping.
-                 conv_clamp=256,
-                 use_fp16=False,        # Use FP16 for this block?
-                 fp16_channels_last=False,        # Use channels-last memory format with FP16?
-                 square=False,        # default is for rectangle images
-                 # Default value of fused_modconv. 'inference_only' = True for inference, False for training.
-                 fused_modconv_default=True,
-                 # Arguments for SynthesisLayer.
-                 **layer_kwargs,
-                 ):
-        assert architecture in ['orig', 'skip', 'resnet']
-        super().__init__()
-        self.in_channels = in_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.fused_modconv_default = fused_modconv_default
-        self.register_buffer(
-            'resample_filter', upfirdn2d.setup_filter(resample_filter))
-        self.num_conv = 0
-        self.num_torgb = 0
-        self.square = square
-
-        if in_channels == 0:
-            if self.square:
-                self.const = torch.nn.Parameter(torch.randn(
-                    [out_channels, resolution, resolution]))
-            else:  # rectangle
-                self.const = torch.nn.Parameter(torch.randn(
-                    [out_channels, resolution, resolution // 2]))
-
-        if in_channels != 0:
-            self.conv0 = SynthesisLayer(in_channels, out_channels, w_dim=w_dim, resolution=resolution, up=2,
-                                        resample_filter=resample_filter, conv_clamp=conv_clamp, channels_last=self.channels_last,  square=square, **layer_kwargs)
-            self.num_conv += 1
-
-        self.conv1 = SynthesisLayer(out_channels, out_channels, w_dim=w_dim, resolution=resolution,
-                                    conv_clamp=conv_clamp, channels_last=self.channels_last, square=square, **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)
-            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)
-
-    def forward(self, x, img, ws, force_fp32=False, fused_modconv=None, update_emas=False, **layer_kwargs):
-        _ = update_emas  # unused
-        misc.assert_shape(
-            ws, [None, self.num_conv + self.num_torgb, self.w_dim])
-        w_iter = iter(ws.unbind(dim=1))
-        if ws.device.type != 'cuda':
-            force_fp32 = True
-        dtype = torch.float16 if self.use_fp16 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:
-            fused_modconv = self.fused_modconv_default
-        if fused_modconv == 'inference_only':
-            fused_modconv = (not self.training)
-
-        # Input.
-        if self.in_channels == 0:
-            x = self.const.to(dtype=dtype, memory_format=memory_format)
-            x = x.unsqueeze(0).repeat([ws.shape[0], 1, 1, 1])
-        else:
-            if self.square:
-                misc.assert_shape(
-                    x, [None, self.in_channels, self.resolution // 2, self.resolution // 2])
-            else:  # rectangle
-                misc.assert_shape(
-                    x, [None, self.in_channels, self.resolution // 2, self.resolution // 4])
-            x = x.to(dtype=dtype, memory_format=memory_format)
-
-        # Main layers.
-        if self.in_channels == 0:
-            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))
-            x = self.conv0(x, next(w_iter),
-                           fused_modconv=fused_modconv, **layer_kwargs)
-            x = self.conv1(x, next(w_iter), fused_modconv=fused_modconv,
-                           gain=np.sqrt(0.5), **layer_kwargs)
-            x = y.add_(x)
-        else:
-            x = self.conv0(x, next(w_iter),
-                           fused_modconv=fused_modconv, **layer_kwargs)
-            x = self.conv1(x, next(w_iter),
-                           fused_modconv=fused_modconv, **layer_kwargs)
-
-        # ToRGB.
-        if img is not None:
-            if self.square:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution // 2, self.resolution // 2])
-            else:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution // 2, self.resolution // 4])
-            img = upfirdn2d.upsample2d(img, self.resample_filter)
-        if self.is_last or self.architecture == 'skip':
-            y = self.torgb(x, 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
-
-        assert x.dtype == dtype
-        assert img is None or img.dtype == torch.float32
-        return x, img
-
-    def extra_repr(self):
-        return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class SynthesisNetwork(torch.nn.Module):
-    def __init__(self,
-                 # Intermediate latent (W) dimensionality.
-                 w_dim,
-                 img_resolution,             # Output image resolution.
-                 img_channels,               # Number of color channels.
-                 square,
-                 # Overall multiplier for the number of channels.
-                 channel_base=32768,
-                 # Maximum number of channels in any layer.
-                 channel_max=512,
-                 # Use FP16 for the N highest resolutions.
-                 num_fp16_res=4,
-                 **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.square = square
-        self.num_fp16_res = num_fp16_res
-        self.block_resolutions = [
-            2 ** i for i in range(2, self.img_resolution_log2 + 1)]
-        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.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 = SynthesisBlock(in_channels, out_channels, w_dim=w_dim, resolution=res,
-                                   img_channels=img_channels, is_last=is_last, use_fp16=use_fp16, square=square, **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 = []
-        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 extra_repr(self):
-        return ' '.join([
-            f'w_dim={self.w_dim:d}, num_ws={self.num_ws:d},',
-            f'img_resolution={self.img_resolution:d}, img_channels={self.img_channels:d},',
-            f'num_fp16_res={self.num_fp16_res:d}'])
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Generator(torch.nn.Module):
-    def __init__(self,
-                 z_dim,                      # Input latent (Z) dimensionality.
-                 # Conditioning label (C) dimensionality.
-                 c_dim,
-                 # Intermediate latent (W) dimensionality.
-                 w_dim,
-                 square,
-                 img_resolution,             # Output resolution.
-                 img_channels,               # Number of output color channels.
-                 mapping_kwargs={},   # Arguments for MappingNetwork.
-                 **synthesis_kwargs,         # Arguments for SynthesisNetwork.
-                 ):
-        super().__init__()
-        self.z_dim = z_dim
-        self.c_dim = c_dim
-        self.w_dim = w_dim
-        self.square = square
-        self.img_resolution = img_resolution
-        self.img_channels = img_channels
-        self.synthesis = SynthesisNetwork(
-            w_dim=w_dim, img_resolution=img_resolution, img_channels=img_channels, square=square, **synthesis_kwargs)
-        self.num_ws = self.synthesis.num_ws
-        self.mapping = MappingNetwork(
-            z_dim=z_dim, c_dim=c_dim, w_dim=w_dim, num_ws=self.num_ws, **mapping_kwargs)
-
-    def forward(self, z, c, truncation_psi=1, truncation_cutoff=None, update_emas=False, **synthesis_kwargs):
-        ws = self.mapping(z, c, truncation_psi=truncation_psi,
-                          truncation_cutoff=truncation_cutoff, update_emas=update_emas)
-        img = self.synthesis(ws, update_emas=update_emas, **synthesis_kwargs)
-        return img
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class DiscriminatorBlock(torch.nn.Module):
-    def __init__(self,
-                 # Number of input channels, 0 = first block.
-                 in_channels,
-                 # Number of intermediate channels.
-                 tmp_channels,
-                 # Number of output channels.
-                 out_channels,
-                 # Resolution of this block.
-                 resolution,
-                 # Number of input color channels.
-                 img_channels,
-                 # Index of the first layer.
-                 first_layer_idx,
-                 # Architecture: 'orig', 'skip', 'resnet'.
-                 architecture='resnet',
-                 # Activation function: 'relu', 'lrelu', etc.
-                 activation='lrelu',
-                 # Low-pass filter to apply when resampling activations.
-                 resample_filter=[1, 3, 3, 1],
-                 # Clamp the output of convolution layers to +-X, None = disable clamping.
-                 conv_clamp=None,
-                 use_fp16=False,        # Use FP16 for this block?
-                 fp16_channels_last=False,        # Use channels-last memory format with FP16?
-                 # Freeze-D: Number of layers to freeze.
-                 freeze_layers=0,
-                 square=False,
-                 ):
-        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.square = square
-
-        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):
-        if (x if x is not None else img).device.type != 'cuda':
-            force_fp32 = True
-        dtype = torch.float16 if self.use_fp16 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:
-            if self.square:
-                misc.assert_shape(
-                    x, [None, self.in_channels, self.resolution, self.resolution])
-            else:
-                misc.assert_shape(
-                    x, [None, self.in_channels, self.resolution, self.resolution // 2])
-            x = x.to(dtype=dtype, memory_format=memory_format)
-
-        # FromRGB.
-        if self.in_channels == 0 or self.architecture == 'skip':
-            if self.square:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution, self.resolution])
-            else:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution, self.resolution // 2])
-            img = img.to(dtype=dtype, memory_format=memory_format)
-            y = self.fromrgb(img)
-            x = x + y if x is not None else y
-            img = upfirdn2d.downsample2d(
-                img, self.resample_filter) if self.architecture == 'skip' else None
-
-        # 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
-
-    def extra_repr(self):
-        return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@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
-
-        # [GnFcHW] Split minibatch N into n groups of size G, and channels C into F groups of size c.
-        y = x.reshape(G, -1, F, c, H, W)
-        # [GnFcHW] Subtract mean over group.
-        y = y - y.mean(dim=0)
-        # [nFcHW]  Calc variance over group.
-        y = y.square().mean(dim=0)
-        y = (y + 1e-8).sqrt()               # [nFcHW]  Calc stddev over group.
-        # [nF]     Take average over channels and pixels.
-        y = y.mean(dim=[2, 3, 4])
-        y = y.reshape(-1, F, 1, 1)          # [nF11]   Add missing dimensions.
-        # [NFHW]   Replicate over group and pixels.
-        y = y.repeat(G, 1, H, W)
-        # [NCHW]   Append to input as new channels.
-        x = torch.cat([x, y], dim=1)
-        return x
-
-    def extra_repr(self):
-        return f'group_size={self.group_size}, num_channels={self.num_channels:d}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class DiscriminatorEpilogue(torch.nn.Module):
-    def __init__(self,
-                 in_channels,                    # Number of input channels.
-                 # Dimensionality of mapped conditioning label, 0 = no label.
-                 cmap_dim,
-                 resolution,                     # Resolution of this block.
-                 # Number of input color channels.
-                 img_channels,
-                 # Architecture: 'orig', 'skip', 'resnet'.
-                 architecture='resnet',
-                 # Group size for the minibatch standard deviation layer, None = entire minibatch.
-                 mbstd_group_size=4,
-                 # Number of features for the minibatch standard deviation layer, 0 = disable.
-                 mbstd_num_channels=1,
-                 # Activation function: 'relu', 'lrelu', etc.
-                 activation='lrelu',
-                 # Clamp the output of convolution layers to +-X, None = disable clamping.
-                 conv_clamp=None,
-                 square=False,
-                 ):
-        assert architecture in ['orig', 'skip', 'resnet']
-        super().__init__()
-        self.in_channels = in_channels
-        self.cmap_dim = cmap_dim
-        self.resolution = resolution
-        self.img_channels = img_channels
-        self.architecture = architecture
-        self.square = square
-
-        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)
-
-        if self.square:
-            self.fc = FullyConnectedLayer(
-                in_channels * (resolution ** 2), in_channels, activation=activation)
-        else:
-            self.fc = FullyConnectedLayer(
-                in_channels * (resolution ** 2 // 2), in_channels, activation=activation)
-
-        self.out = FullyConnectedLayer(
-            in_channels, 1 if cmap_dim == 0 else cmap_dim)
-
-    def forward(self, x, img, cmap, force_fp32=False):
-        if self.square:
-            misc.assert_shape(x, [None, self.in_channels,
-                              self.resolution, self.resolution])
-        else:
-            misc.assert_shape(
-                x, [None, self.in_channels, self.resolution, self.resolution // 2])  # [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':
-            if self.square:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution, self.resolution])
-            else:
-                misc.assert_shape(
-                    img, [None, self.img_channels, self.resolution, self.resolution // 2])
-
-            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:
-            misc.assert_shape(cmap, [None, self.cmap_dim])
-            x = (x * cmap).sum(dim=1, keepdim=True) * \
-                (1 / np.sqrt(self.cmap_dim))
-
-        assert x.dtype == dtype
-        return x
-
-    def extra_repr(self):
-        return f'resolution={self.resolution:d}, architecture={self.architecture:s}'
-
-# ----------------------------------------------------------------------------
-
-
-@persistence.persistent_class
-class Discriminator(torch.nn.Module):
-    def __init__(self,
-                 # Conditioning label (C) dimensionality.
-                 c_dim,
-                 img_resolution,                 # Input resolution.
-                 # Number of input color channels.
-                 img_channels,
-                 # Architecture: 'orig', 'skip', 'resnet'.
-                 architecture='resnet',
-                 # Overall multiplier for the number of channels.
-                 channel_base=32768,
-                 # Maximum number of channels in any layer.
-                 channel_max=512,
-                 # Use FP16 for the N highest resolutions.
-                 num_fp16_res=4,
-                 # Clamp the output of convolution layers to +-X, None = disable clamping.
-                 conv_clamp=256,
-                 # Dimensionality of mapped conditioning label, None = default.
-                 cmap_dim=None,
-                 square=False,    # default for rectangle images
-                 block_kwargs={},       # Arguments for DiscriminatorBlock.
-                 mapping_kwargs={},       # Arguments for MappingNetwork.
-                 # Arguments for DiscriminatorEpilogue.
-                 epilogue_kwargs={},
-                 ):
-        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.square = square
-        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, square=square, **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, square=square, **epilogue_kwargs, **common_kwargs)
-
-    def forward(self, img, c, update_emas=False, **block_kwargs):
-        _ = update_emas  # unused
-        x = None
-        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
-
-    def extra_repr(self):
-        return f'c_dim={self.c_dim:d}, img_resolution={self.img_resolution:d}, img_channels={self.img_channels:d}'
-
-# ----------------------------------------------------------------------------

spaces/DragGan/DragGan/stylegan_human/torch_utils/op_edit/fused_act.py

@@ -1,99 +0,0 @@
-# Copyright (c) SenseTime Research. All rights reserved.
-
-import os
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-from torch.autograd import Function
-from torch.utils.cpp_extension import load
-
-
-module_path = os.path.dirname(__file__)
-fused = load(
-    "fused",
-    sources=[
-        os.path.join(module_path, "fused_bias_act.cpp"),
-        os.path.join(module_path, "fused_bias_act_kernel.cu"),
-    ],
-)
-
-
-class FusedLeakyReLUFunctionBackward(Function):
-    @staticmethod
-    def forward(ctx, grad_output, out, negative_slope, scale):
-        ctx.save_for_backward(out)
-        ctx.negative_slope = negative_slope
-        ctx.scale = scale
-
-        empty = grad_output.new_empty(0)
-
-        grad_input = fused.fused_bias_act(
-            grad_output, empty, out, 3, 1, negative_slope, scale
-        )
-
-        dim = [0]
-
-        if grad_input.ndim > 2:
-            dim += list(range(2, grad_input.ndim))
-
-        grad_bias = grad_input.sum(dim).detach()
-
-        return grad_input, grad_bias
-
-    @staticmethod
-    def backward(ctx, gradgrad_input, gradgrad_bias):
-        (out,) = ctx.saved_tensors
-        gradgrad_out = fused.fused_bias_act(
-            gradgrad_input, gradgrad_bias, out, 3, 1, ctx.negative_slope, ctx.scale
-        )
-
-        return gradgrad_out, None, None, None
-
-
-class FusedLeakyReLUFunction(Function):
-    @staticmethod
-    def forward(ctx, input, bias, negative_slope, scale):
-        empty = input.new_empty(0)
-        out = fused.fused_bias_act(input, bias, empty, 3, 0, negative_slope, scale)
-        ctx.save_for_backward(out)
-        ctx.negative_slope = negative_slope
-        ctx.scale = scale
-
-        return out
-
-    @staticmethod
-    def backward(ctx, grad_output):
-        (out,) = ctx.saved_tensors
-
-        grad_input, grad_bias = FusedLeakyReLUFunctionBackward.apply(
-            grad_output, out, ctx.negative_slope, ctx.scale
-        )
-
-        return grad_input, grad_bias, None, None
-
-
-class FusedLeakyReLU(nn.Module):
-    def __init__(self, channel, negative_slope=0.2, scale=2 ** 0.5):
-        super().__init__()
-
-        self.bias = nn.Parameter(torch.zeros(channel))
-        self.negative_slope = negative_slope
-        self.scale = scale
-
-    def forward(self, input):
-        return fused_leaky_relu(input, self.bias, self.negative_slope, self.scale)
-
-
-def fused_leaky_relu(input, bias, negative_slope=0.2, scale=2 ** 0.5):
-    if input.device.type == "cpu":
-        rest_dim = [1] * (input.ndim - bias.ndim - 1)
-        return (
-            F.leaky_relu(
-                input + bias.view(1, bias.shape[0], *rest_dim), negative_slope=0.2
-            )
-            * scale
-        )
-
-    else:
-        return FusedLeakyReLUFunction.apply(input, bias, negative_slope, scale)