Update parquet files (step 25 of 476)

spaces/1-13-am/neural-style-transfer/README.md

@@ -1,12 +0,0 @@
----
-title: Neural Style Transfer
-emoji: 🦀
-colorFrom: pink
-colorTo: gray
-sdk: gradio
-sdk_version: 3.46.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/1acneusushi/gradio-2dmoleculeeditor/data/CASIO Classpad 3.0 [Emulator Crack] Serial Key Troubleshooting and Support for the Emulator.md

@@ -1,83 +0,0 @@
-
-<h1>CASIO Classpad 3.0 [Emulator Crack] Serial Key</h1>
-<p>Are you looking for a way to use CASIO Classpad 3.0 on your PC without buying the original calculator? Do you want to enjoy the features and benefits of CASIO Classpad 3.0 without spending a lot of money? If yes, then you might be interested in using an emulator with a crack and serial key.</p>
-<h2>CASIO Classpad 3.0 [Emulator Crack] Serial Key</h2><br /><p><b><b>Download File</b> &mdash;&mdash;&mdash; <a href="https://byltly.com/2uKvRP">https://byltly.com/2uKvRP</a></b></p><br /><br />
-<p>An emulator is a software that simulates the functions and features of another device or system on your PC. A crack is a file that modifies or bypasses the security features of a software to make it work without limitations or restrictions. A serial key is a code that activates or registers a software to make it valid or authentic.</p>
-<p>In this article, we will explain what CASIO Classpad 3.0 is, what an emulator is, why you need an emulator for CASIO Classpad 3.0, how to get an emulator for CASIO Classpad 3.0, how to use an emulator for CASIO Classpad 3.0, how to get a crack and serial key for CASIO Classpad 3.0 emulator, how to use a crack and serial key for CASIO Classpad 3.0 emulator, what are the risks of using a crack and serial key for CASIO Classpad 3.0 emulator, how to avoid or solve the problems of using a crack and serial key for CASIO Classpad 3.0 emulator, and what are the alternatives to using a crack and serial key for CASIO Classpad 3.0 emulator.</p>
-<p>By the end of this article, you will have a clear understanding of how to use CASIO Classpad 3.0 [Emulator Crack] Serial Key on your PC.</p>
-<p>How to get CASIO Classpad 3.0 emulator crack for free<br />
-CASIO Classpad 3.0 emulator crack download link<br />
-CASIO Classpad 3.0 emulator crack activation code<br />
-CASIO Classpad 3.0 emulator crack full version<br />
-CASIO Classpad 3.0 emulator crack license key<br />
-CASIO Classpad 3.0 emulator crack torrent<br />
-CASIO Classpad 3.0 emulator crack patch<br />
-CASIO Classpad 3.0 emulator crack keygen<br />
-CASIO Classpad 3.0 emulator crack registration key<br />
-CASIO Classpad 3.0 emulator crack product key<br />
-CASIO Classpad 3.0 emulator crack software<br />
-CASIO Classpad 3.0 emulator crack online<br />
-CASIO Classpad 3.0 emulator crack generator<br />
-CASIO Classpad 3.0 emulator crack no survey<br />
-CASIO Classpad 3.0 emulator crack working<br />
-CASIO Classpad 3.0 emulator crack latest<br />
-CASIO Classpad 3.0 emulator crack updated<br />
-CASIO Classpad 3.0 emulator crack review<br />
-CASIO Classpad 3.0 emulator crack tutorial<br />
-CASIO Classpad 3.0 emulator crack guide<br />
-CASIO Classpad 3.0 emulator crack instructions<br />
-CASIO Classpad 3.0 emulator crack tips<br />
-CASIO Classpad 3.0 emulator crack tricks<br />
-CASIO Classpad 3.0 emulator crack hacks<br />
-CASIO Classpad 3.0 emulator crack cheats<br />
-CASIO Classpad 3.0 emulator crack features<br />
-CASIO Classpad 3.0 emulator crack benefits<br />
-CASIO Classpad 3.0 emulator crack advantages<br />
-CASIO Classpad 3.0 emulator crack disadvantages<br />
-CASIO Classpad 3.0 emulator crack pros and cons<br />
-CASIO Classpad 3.0 emulator crack comparison<br />
-CASIO Classpad 3.0 emulator crack alternatives<br />
-CASIO Classpad 3.0 emulator crack best practices<br />
-CASIO Classpad 3.0 emulator crack requirements<br />
-CASIO Classpad 3.0 emulator crack specifications<br />
-CASIO Classpad 3.0 emulator crack system requirements<br />
-CASIO Classpad 3.0 emulator crack compatibility<br />
-CASIO Classpad 3.0 emulator crack support<br />
-CASIO Classpad 3.0 emulator crack customer service<br />
-CASIO Classpad 3.0 emulator crack feedback<br />
-CASIO Classpad 3.0 emulator crack testimonials<br />
-CASIO Classpad 3.0 emulator crack ratings<br />
-CASIO Classpad 3.0 emulator crack quality<br />
-CASIO Classpad 3.0 emulator crack performance<br />
-CASIO Classpad 3.0 emulator crack reliability<br />
-CASIO Classpad 3.0 emulator crack security<br />
-CASIO Classpad 3.0 emulator crack privacy<br />
-CASIO Classpad 3.0 emulator crack warranty<br />
-CASIO Classpad 3.0 emulator crack refund policy<br />
-CASIO Classpad 3.0 emulator crack discount code</p>
- <h2>What is CASIO Classpad 3.0?</h2>
-<p>CASIO Classpad 3.0 is a powerful software that simulates the functions and features of the CASIO Classpad 330 calculator on your PC. You can use it for learning, teaching, or doing complex calculations with ease.</p>
-<p>Some of the features and benefits of CASIO Classpad 3.0 are:</p>
-<ul>
-<li>It has a large touch-screen display that allows you to input data, draw graphs, edit formulas, manipulate images, etc.</li>
-<li>It supports various mathematical functions such as algebra, calculus, geometry, statistics, probability, etc.</li>
-<li>It has a built-in spreadsheet application that allows you to perform data analysis, create charts, etc.</li>
-<li>It has a built-in eActivity application that allows you to create interactive worksheets, presentations, quizzes, etc.</li>
-<li>It has a built-in geometry application that allows you to construct geometric figures, measure angles, lengths, areas, etc.</li>
-<li>It has a built-in programming language that allows you to create custom applications, games, etc.</li>
-<li>It has a built-in communication function that allows you to connect with other devices via USB or wireless LAN.</li>
-<li>It has a built-in memory function that allows you to store data, formulas, images, etc.</li>
-</ul>
- <h2>What is an emulator?</h2>
-<p>An emulator is a software that simulates the functions and features of another device or system on your PC. For example, you can use an emulator to play games designed for consoles such as PlayStation or Nintendo on your PC.</p>
- <p>There are different types of emulators depending on the device or system they emulate. Some examples are:</p>
- <ul>
- <li>Console emulators: They emulate video game consoles such as PlayStation, Nintendo, Sega, etc.</li>
- <li>Arcade emulators: They emulate arcade machines such as Pac-Man, Street Fighter, etc.</li>
- <li>Computer emulators: They emulate personal computers such as Windows, Mac OS X, Linux, etc.</li>
- <li>Mobile emulators: They emulate mobile devices such as Android, iOS, Windows Phone, etc.</li>
- <li>Calculator emulators: They emulate calculators such as TI-83, HP-12C, CASIO ClassPad, etc.</li>
- </ul>
- <h2>Why do you need an emulator for CASIO ClassPad</p> 0a6ba089eb<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Activehome Pro LINK Download.md

@@ -1,8 +0,0 @@
-<br />
-<p>activehome pro is a powerful home automation system that allows you to control all sorts of devices, such as lights, locks, audio systems, and other appliances and devices. it also allows you to interact with your home through the web. it is a very powerful home automation system.</p>
-<p>activehome pro has a versatile application programming interface (api) that lets you integrate activehome pro with other systems. api support for activehome pro includes: </p>
-<h2>activehome pro download</h2><br /><p><b><b>Download</b> &#127383; <a href="https://imgfil.com/2uxZ0O">https://imgfil.com/2uxZ0O</a></b></p><br /><br /> <ul> <li>simple integration into a light switch</li> <li>remote access with the activehome live api</li> <li>remote access with the activehome api</li> <li>local and remote event-based triggering using the activehome device api</li> <li>configuration and operation of devices and appliances using the activehome device api</li> </ul>
-<p>activehome acts as a central monitoring station for your home. it monitors the status of your lights and appliances and sends you alerts when it detects activity. activehome also monitors activity and status to help you find and resolve service calls. in addition to monitoring device status, activehome also reports the power consumption of each device to help you manage your energy consumption.</p>
-<p>activehome pro will ensure that your lights and appliances are always off. however, you can set a schedule so that when no one is home, activehome will turn lights and appliances on. in addition, activehome pro keeps track of any malfunctions so that if a light or appliance is not working, you will know exactly where to find the problem. you can schedule activehome to turn lights and appliances on when you are away from home, and so that lights and appliances that are already on will turn off when you are away.</p> 899543212b<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Como Eliminar Archivos Duplicados En Tu PC [2020].md

@@ -1,6 +0,0 @@
-<h2>Como Eliminar Archivos Duplicados en Tu PC [2020]</h2><br /><p><b><b>Download File</b> &#127775; <a href="https://imgfil.com/2uy16g">https://imgfil.com/2uy16g</a></b></p><br /><br />
-
-el cambio aplicado en la version 16 de tu, se debe a una depreciación para no tener que cambiar su código, lo que significa que ya no se va a tener que actualizar los códigos existentes para que funcione con la versión nueva.[2020] en la version 17 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la version 18 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 19 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 20 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 21 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 22 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 23 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 24 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 25 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 26 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 27 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 28 para tu lo haría con un error ya que no eliminaba los archivos duplicados, el cambio aplicado en la versión 29 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/801artistry/RVC801/infer/modules/vc/modules.py

@@ -1,526 +0,0 @@
-import os, sys
-import traceback
-import logging
-now_dir = os.getcwd()
-sys.path.append(now_dir)
-logger = logging.getLogger(__name__)
-import lib.globals.globals as rvc_globals
-import numpy as np
-import soundfile as sf
-import torch
-from io import BytesIO
-from infer.lib.audio import load_audio
-from infer.lib.audio import wav2
-from infer.lib.infer_pack.models import (
-    SynthesizerTrnMs256NSFsid,
-    SynthesizerTrnMs256NSFsid_nono,
-    SynthesizerTrnMs768NSFsid,
-    SynthesizerTrnMs768NSFsid_nono,
-)
-from infer.modules.vc.pipeline import Pipeline
-from infer.modules.vc.utils import *
-import time
-import scipy.io.wavfile as wavfile
-
-def note_to_hz(note_name):
-        SEMITONES = {'C': -9, 'C#': -8, 'D': -7, 'D#': -6, 'E': -5, 'F': -4, 'F#': -3, 'G': -2, 'G#': -1, 'A': 0, 'A#': 1, 'B': 2}
-        pitch_class, octave = note_name[:-1], int(note_name[-1])
-        semitone = SEMITONES[pitch_class]
-        note_number = 12 * (octave - 4) + semitone
-        frequency = 440.0 * (2.0 ** (1.0/12)) ** note_number
-        return frequency
-
-class VC:
-    def __init__(self, config):
-        self.n_spk = None
-        self.tgt_sr = None
-        self.net_g = None
-        self.pipeline = None
-        self.cpt = None
-        self.version = None
-        self.if_f0 = None
-        self.version = None
-        self.hubert_model = None
-
-        self.config = config
-
-    def get_vc(self, sid, *to_return_protect):
-        logger.info("Get sid: " + sid)
-
-        to_return_protect0 = {
-            "visible": self.if_f0 != 0,
-            "value": to_return_protect[0]
-            if self.if_f0 != 0 and to_return_protect
-            else 0.5,
-            "__type__": "update",
-        }
-        to_return_protect1 = {
-            "visible": self.if_f0 != 0,
-            "value": to_return_protect[1]
-            if self.if_f0 != 0 and to_return_protect
-            else 0.33,
-            "__type__": "update",
-        }
-
-        if not sid:
-            if self.hubert_model is not None:  # 考虑到轮询, 需要加个判断看是否 sid 是由有模型切换到无模型的
-                logger.info("Clean model cache")
-                del (
-                    self.net_g,
-                    self.n_spk,
-                    self.vc,
-                    self.hubert_model,
-                    self.tgt_sr,
-                )  # ,cpt
-                self.hubert_model = (
-                    self.net_g
-                ) = self.n_spk = self.vc = self.hubert_model = self.tgt_sr = None
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
-                ###楼下不这么折腾清理不干净
-                self.if_f0 = self.cpt.get("f0", 1)
-                self.version = self.cpt.get("version", "v1")
-                if self.version == "v1":
-                    if self.if_f0 == 1:
-                        self.net_g = SynthesizerTrnMs256NSFsid(
-                            *self.cpt["config"], is_half=self.config.is_half
-                        )
-                    else:
-                        self.net_g = SynthesizerTrnMs256NSFsid_nono(*self.cpt["config"])
-                elif self.version == "v2":
-                    if self.if_f0 == 1:
-                        self.net_g = SynthesizerTrnMs768NSFsid(
-                            *self.cpt["config"], is_half=self.config.is_half
-                        )
-                    else:
-                        self.net_g = SynthesizerTrnMs768NSFsid_nono(*self.cpt["config"])
-                del self.net_g, self.cpt
-                if torch.cuda.is_available():
-                    torch.cuda.empty_cache()
-            return (
-                {"visible": False, "__type__": "update"},
-                {
-                    "visible": True,
-                    "value": to_return_protect0,
-                    "__type__": "update",
-                },
-                {
-                    "visible": True,
-                    "value": to_return_protect1,
-                    "__type__": "update",
-                },
-                "",
-                "",
-            )
-        #person = f'{os.getenv("weight_root")}/{sid}'
-        person = f'{sid}'
-        #logger.info(f"Loading: {person}")
-        logger.info(f"Loading...")
-        self.cpt = torch.load(person, map_location="cpu")
-        self.tgt_sr = self.cpt["config"][-1]
-        self.cpt["config"][-3] = self.cpt["weight"]["emb_g.weight"].shape[0]  # n_spk
-        self.if_f0 = self.cpt.get("f0", 1)
-        self.version = self.cpt.get("version", "v1")
-
-        synthesizer_class = {
-            ("v1", 1): SynthesizerTrnMs256NSFsid,
-            ("v1", 0): SynthesizerTrnMs256NSFsid_nono,
-            ("v2", 1): SynthesizerTrnMs768NSFsid,
-            ("v2", 0): SynthesizerTrnMs768NSFsid_nono,
-        }
-
-        self.net_g = synthesizer_class.get(
-            (self.version, self.if_f0), SynthesizerTrnMs256NSFsid
-        )(*self.cpt["config"], is_half=self.config.is_half)
-
-        del self.net_g.enc_q
-
-        self.net_g.load_state_dict(self.cpt["weight"], strict=False)
-        self.net_g.eval().to(self.config.device)
-        if self.config.is_half:
-            self.net_g = self.net_g.half()
-        else:
-            self.net_g = self.net_g.float()
-
-        self.pipeline = Pipeline(self.tgt_sr, self.config)
-        n_spk = self.cpt["config"][-3]
-        index = {"value": get_index_path_from_model(sid), "__type__": "update"}
-        logger.info("Select index: " + index["value"])
-
-        return (
-            (
-                {"visible": False, "maximum": n_spk, "__type__": "update"},
-                to_return_protect0,
-                to_return_protect1
-            )
-            if to_return_protect
-            else {"visible": False, "maximum": n_spk, "__type__": "update"}
-        )
-    
-
-    def vc_single(
-        self,
-        sid,
-        input_audio_path0,
-        input_audio_path1,
-        f0_up_key,
-        f0_file,
-        f0_method,
-        file_index,
-        file_index2,
-        index_rate,
-        filter_radius,
-        resample_sr,
-        rms_mix_rate,
-        protect,
-        crepe_hop_length,
-        f0_min,
-        note_min,
-        f0_max,
-        note_max,
-        f0_autotune,
-    ):
-        global total_time
-        total_time = 0
-        start_time = time.time()
-        if not input_audio_path0 and not input_audio_path1:
-            return "You need to upload an audio", None
-        
-        if (not os.path.exists(input_audio_path0)) and (not os.path.exists(os.path.join(now_dir, input_audio_path0))):
-            return "Audio was not properly selected or doesn't exist", None
-        
-        input_audio_path1 = input_audio_path1 or input_audio_path0
-        print(f"\nStarting inference for '{os.path.basename(input_audio_path1)}'")
-        print("-------------------")
-        f0_up_key = int(f0_up_key)
-        if rvc_globals.NotesOrHertz and f0_method != 'rmvpe':
-            f0_min = note_to_hz(note_min) if note_min else 50
-            f0_max = note_to_hz(note_max) if note_max else 1100
-            print(f"Converted Min pitch: freq - {f0_min}\n"
-                  f"Converted Max pitch: freq - {f0_max}")
-        else:
-            f0_min = f0_min or 50
-            f0_max = f0_max or 1100
-        try:
-            input_audio_path1 = input_audio_path1 or input_audio_path0
-            print(f"Attempting to load {input_audio_path1}....")
-            audio = load_audio(file=input_audio_path1,
-                               sr=16000,
-                               DoFormant=rvc_globals.DoFormant,
-                               Quefrency=rvc_globals.Quefrency,
-                               Timbre=rvc_globals.Timbre)
-            
-            audio_max = np.abs(audio).max() / 0.95
-            if audio_max > 1:
-                audio /= audio_max
-            times = [0, 0, 0]
-
-            if self.hubert_model is None:
-                self.hubert_model = load_hubert(self.config)
-
-            try:
-                self.if_f0 = self.cpt.get("f0", 1)
-            except NameError:
-                message = "Model was not properly selected"
-                print(message)
-                return message, None
-            
-            file_index = (
-                (
-                    file_index.strip(" ")
-                    .strip('"')
-                    .strip("\n")
-                    .strip('"')
-                    .strip(" ")
-                    .replace("trained", "added")
-                )
-                if file_index != ""
-                else file_index2
-            )  # 防止小白写错，自动帮他替换掉
-
-            try:
-                audio_opt = self.pipeline.pipeline(
-                    self.hubert_model,
-                    self.net_g,
-                    sid,
-                    audio,
-                    input_audio_path1,
-                    times,
-                    f0_up_key,
-                    f0_method,
-                    file_index,
-                    index_rate,
-                    self.if_f0,
-                    filter_radius,
-                    self.tgt_sr,
-                    resample_sr,
-                    rms_mix_rate,
-                    self.version,
-                    protect,
-                    crepe_hop_length,
-                    f0_autotune,
-                    f0_file=f0_file,
-                    f0_min=f0_min,
-                    f0_max=f0_max
-                    )
-            except AssertionError:
-                message = "Mismatching index version detected (v1 with v2, or v2 with v1)."
-                print(message)
-                return message, None
-            except NameError:
-                message = "RVC libraries are still loading. Please try again in a few seconds."
-                print(message)
-                return message, None
-
-            if self.tgt_sr != resample_sr >= 16000:
-                self.tgt_sr = resample_sr
-            index_info = (
-                "Index:\n%s." % file_index
-                if os.path.exists(file_index)
-                else "Index not used."
-            )
-            end_time = time.time()
-            total_time = end_time - start_time
-
-            output_folder = "audio-outputs"
-            os.makedirs(output_folder, exist_ok=True)  
-            output_filename = "generated_audio_{}.wav"
-            output_count = 1
-            while True:
-                current_output_path = os.path.join(output_folder, output_filename.format(output_count))
-                if not os.path.exists(current_output_path):
-                    break
-                output_count += 1
-            
-            wavfile.write(current_output_path, self.tgt_sr, audio_opt)
-            print(f"Generated audio saved to: {current_output_path}")
-            return f"Success.\n {index_info}\nTime:\n npy:{times[0]}, f0:{times[1]}, infer:{times[2]}\nTotal Time: {total_time} seconds", (self.tgt_sr, audio_opt)
-        except:
-            info = traceback.format_exc()
-            logger.warn(info)
-            return info, (None, None)
-
-    def vc_single_dont_save(
-        self,
-        sid,
-        input_audio_path0,
-        input_audio_path1,
-        f0_up_key,
-        f0_file,
-        f0_method,
-        file_index,
-        file_index2,
-        index_rate,
-        filter_radius,
-        resample_sr,
-        rms_mix_rate,
-        protect,
-        crepe_hop_length,
-        f0_min,
-        note_min,
-        f0_max,
-        note_max,
-        f0_autotune,
-    ):
-        global total_time
-        total_time = 0
-        start_time = time.time()
-        if not input_audio_path0 and not input_audio_path1:
-            return "You need to upload an audio", None
-        
-        if (not os.path.exists(input_audio_path0)) and (not os.path.exists(os.path.join(now_dir, input_audio_path0))):
-            return "Audio was not properly selected or doesn't exist", None
-        
-        input_audio_path1 = input_audio_path1 or input_audio_path0
-        print(f"\nStarting inference for '{os.path.basename(input_audio_path1)}'")
-        print("-------------------")
-        f0_up_key = int(f0_up_key)
-        if rvc_globals.NotesOrHertz and f0_method != 'rmvpe':
-            f0_min = note_to_hz(note_min) if note_min else 50
-            f0_max = note_to_hz(note_max) if note_max else 1100
-            print(f"Converted Min pitch: freq - {f0_min}\n"
-                  f"Converted Max pitch: freq - {f0_max}")
-        else:
-            f0_min = f0_min or 50
-            f0_max = f0_max or 1100
-        try:
-            input_audio_path1 = input_audio_path1 or input_audio_path0
-            print(f"Attempting to load {input_audio_path1}....")
-            audio = load_audio(file=input_audio_path1,
-                               sr=16000,
-                               DoFormant=rvc_globals.DoFormant,
-                               Quefrency=rvc_globals.Quefrency,
-                               Timbre=rvc_globals.Timbre)
-            
-            audio_max = np.abs(audio).max() / 0.95
-            if audio_max > 1:
-                audio /= audio_max
-            times = [0, 0, 0]
-
-            if self.hubert_model is None:
-                self.hubert_model = load_hubert(self.config)
-
-            try:
-                self.if_f0 = self.cpt.get("f0", 1)
-            except NameError:
-                message = "Model was not properly selected"
-                print(message)
-                return message, None
-            
-            file_index = (
-                (
-                    file_index.strip(" ")
-                    .strip('"')
-                    .strip("\n")
-                    .strip('"')
-                    .strip(" ")
-                    .replace("trained", "added")
-                )
-                if file_index != ""
-                else file_index2
-            )  # 防止小白写错，自动帮他替换掉
-
-            try:
-                audio_opt = self.pipeline.pipeline(
-                    self.hubert_model,
-                    self.net_g,
-                    sid,
-                    audio,
-                    input_audio_path1,
-                    times,
-                    f0_up_key,
-                    f0_method,
-                    file_index,
-                    index_rate,
-                    self.if_f0,
-                    filter_radius,
-                    self.tgt_sr,
-                    resample_sr,
-                    rms_mix_rate,
-                    self.version,
-                    protect,
-                    crepe_hop_length,
-                    f0_autotune,
-                    f0_file=f0_file,
-                    f0_min=f0_min,
-                    f0_max=f0_max
-                    )
-            except AssertionError:
-                message = "Mismatching index version detected (v1 with v2, or v2 with v1)."
-                print(message)
-                return message, None
-            except NameError:
-                message = "RVC libraries are still loading. Please try again in a few seconds."
-                print(message)
-                return message, None
-
-            if self.tgt_sr != resample_sr >= 16000:
-                self.tgt_sr = resample_sr
-            index_info = (
-                "Index:\n%s." % file_index
-                if os.path.exists(file_index)
-                else "Index not used."
-            )
-            end_time = time.time()
-            total_time = end_time - start_time
-
-            return f"Success.\n {index_info}\nTime:\n npy:{times[0]}, f0:{times[1]}, infer:{times[2]}\nTotal Time: {total_time} seconds", (self.tgt_sr, audio_opt)
-        except:
-            info = traceback.format_exc()
-            logger.warn(info)
-            return info, (None, None)
-
-
-    def vc_multi(
-        self,
-        sid,
-        dir_path,
-        opt_root,
-        paths,
-        f0_up_key,
-        f0_method,
-        file_index,
-        file_index2,
-        index_rate,
-        filter_radius,
-        resample_sr,
-        rms_mix_rate,
-        protect,
-        format1,
-        crepe_hop_length,
-        f0_min,
-        note_min,
-        f0_max,
-        note_max,
-        f0_autotune,
-    ):
-        if rvc_globals.NotesOrHertz and f0_method != 'rmvpe':
-            f0_min = note_to_hz(note_min) if note_min else 50
-            f0_max = note_to_hz(note_max) if note_max else 1100
-            print(f"Converted Min pitch: freq - {f0_min}\n"
-                  f"Converted Max pitch: freq - {f0_max}")
-        else:
-            f0_min = f0_min or 50
-            f0_max = f0_max or 1100
-        try:
-            dir_path = (
-                dir_path.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-            )  # 防止小白拷路径头尾带了空格和"和回车
-            opt_root = opt_root.strip(" ").strip('"').strip("\n").strip('"').strip(" ")
-            os.makedirs(opt_root, exist_ok=True)
-            try:
-                if dir_path != "":
-                    paths = [
-                        os.path.join(dir_path, name) for name in os.listdir(dir_path)
-                    ]
-                else:
-                    paths = [path.name for path in paths]
-            except:
-                traceback.print_exc()
-                paths = [path.name for path in paths]
-            infos = []
-            for path in paths:
-                info, opt = self.vc_single(
-                    sid,
-                    path,
-                    f0_up_key,
-                    None,
-                    f0_method,
-                    file_index,
-                    file_index2,
-                    # file_big_npy,
-                    index_rate,
-                    filter_radius,
-                    resample_sr,
-                    rms_mix_rate,
-                    protect,
-                )
-                if "Success" in info:
-                    try:
-                        tgt_sr, audio_opt = opt
-                        if format1 in ["wav", "flac"]:
-                            sf.write(
-                                "%s/%s.%s"
-                                % (opt_root, os.path.basename(path), format1),
-                                audio_opt,
-                                tgt_sr,
-                            )
-                        else:
-                            path = "%s/%s.%s" % (opt_root, os.path.basename(path), format1)
-                            with BytesIO() as wavf:
-                                sf.write(
-                                    wavf,
-                                    audio_opt,
-                                    tgt_sr,
-                                    format="wav"
-                                )
-                                wavf.seek(0, 0)
-                                with open(path, "wb") as outf:
-                                    wav2(wavf, outf, format1)
-                    except:
-                        info += traceback.format_exc()
-                infos.append("%s->%s" % (os.path.basename(path), info))
-                yield "\n".join(infos)
-            yield "\n".join(infos)
-        except:
-            yield traceback.format_exc()

spaces/AIConsultant/MusicGen/tests/common_utils/__init__.py

@@ -1,9 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-# flake8: noqa
-from .temp_utils import TempDirMixin
-from .wav_utils import get_batch_white_noise, get_white_noise, save_wav

spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/GenerSpeech/model/generspeech.py

@@ -1,260 +0,0 @@
-import torch
-from modules.GenerSpeech.model.glow_modules import Glow
-from modules.fastspeech.tts_modules import PitchPredictor
-import random
-from modules.GenerSpeech.model.prosody_util import ProsodyAligner, LocalStyleAdaptor
-from utils.pitch_utils import f0_to_coarse, denorm_f0
-from modules.commons.common_layers import *
-import torch.distributions as dist
-from utils.hparams import hparams
-from modules.GenerSpeech.model.mixstyle import MixStyle
-from modules.fastspeech.fs2 import FastSpeech2
-import json
-from modules.fastspeech.tts_modules import DEFAULT_MAX_SOURCE_POSITIONS, DEFAULT_MAX_TARGET_POSITIONS
-
-class GenerSpeech(FastSpeech2):
-    '''
-    GenerSpeech: Towards Style Transfer for Generalizable Out-Of-Domain Text-to-Speech
-    https://arxiv.org/abs/2205.07211
-    '''
-    def __init__(self, dictionary, out_dims=None):
-        super().__init__(dictionary, out_dims)
-
-        # Mixstyle
-        self.norm = MixStyle(p=0.5, alpha=0.1, eps=1e-6, hidden_size=self.hidden_size)
-
-        # emotion embedding
-        self.emo_embed_proj = Linear(256, self.hidden_size, bias=True)
-
-        # build prosody extractor
-        ## frame level
-        self.prosody_extractor_utter = LocalStyleAdaptor(self.hidden_size, hparams['nVQ'], self.padding_idx)
-        self.l1_utter = nn.Linear(self.hidden_size * 2, self.hidden_size)
-        self.align_utter = ProsodyAligner(num_layers=2)
-
-        ## phoneme level
-        self.prosody_extractor_ph = LocalStyleAdaptor(self.hidden_size, hparams['nVQ'], self.padding_idx)
-        self.l1_ph = nn.Linear(self.hidden_size * 2, self.hidden_size)
-        self.align_ph = ProsodyAligner(num_layers=2)
-
-        ## word level
-        self.prosody_extractor_word = LocalStyleAdaptor(self.hidden_size, hparams['nVQ'], self.padding_idx)
-        self.l1_word = nn.Linear(self.hidden_size * 2, self.hidden_size)
-        self.align_word = ProsodyAligner(num_layers=2)
-
-        self.pitch_inpainter_predictor = PitchPredictor(
-            self.hidden_size, n_chans=self.hidden_size,
-            n_layers=3, dropout_rate=0.1, odim=2,
-            padding=hparams['ffn_padding'], kernel_size=hparams['predictor_kernel'])
-
-        # build attention layer
-        self.max_source_positions = DEFAULT_MAX_SOURCE_POSITIONS
-        self.embed_positions = SinusoidalPositionalEmbedding(
-            self.hidden_size, self.padding_idx,
-            init_size=self.max_source_positions + self.padding_idx + 1,
-        )
-
-        # build post flow
-        cond_hs = 80
-        if hparams.get('use_txt_cond', True):
-            cond_hs = cond_hs + hparams['hidden_size']
-
-        cond_hs = cond_hs + hparams['hidden_size'] * 3  # for emo, spk embedding and prosody embedding
-        self.post_flow = Glow(
-            80, hparams['post_glow_hidden'], hparams['post_glow_kernel_size'], 1,
-            hparams['post_glow_n_blocks'], hparams['post_glow_n_block_layers'],
-            n_split=4, n_sqz=2,
-            gin_channels=cond_hs,
-            share_cond_layers=hparams['post_share_cond_layers'],
-            share_wn_layers=hparams['share_wn_layers'],
-            sigmoid_scale=hparams['sigmoid_scale']
-        )
-        self.prior_dist = dist.Normal(0, 1)
-
-
-    def forward(self, txt_tokens, mel2ph=None, ref_mel2ph=None, ref_mel2word=None, spk_embed=None, emo_embed=None, ref_mels=None,
-                f0=None, uv=None, skip_decoder=False, global_steps=0, infer=False, **kwargs):
-        ret = {}
-        encoder_out = self.encoder(txt_tokens)  # [B, T, C]
-        src_nonpadding = (txt_tokens > 0).float()[:, :, None]
-
-        # add spk/emo embed
-        spk_embed = self.spk_embed_proj(spk_embed)[:, None, :]
-        emo_embed = self.emo_embed_proj(emo_embed)[:, None, :]
-
-
-        # add dur
-        dur_inp = (encoder_out + spk_embed + emo_embed) * src_nonpadding
-        mel2ph = self.add_dur(dur_inp, mel2ph, txt_tokens, ret)
-        tgt_nonpadding = (mel2ph > 0).float()[:, :, None]
-        decoder_inp = self.expand_states(encoder_out, mel2ph)
-        decoder_inp = self.norm(decoder_inp, spk_embed + emo_embed)
-
-        # add prosody VQ
-        ret['ref_mel2ph'] = ref_mel2ph
-        ret['ref_mel2word'] = ref_mel2word
-        prosody_utter_mel = self.get_prosody_utter(decoder_inp, ref_mels, ret, infer, global_steps)
-        prosody_ph_mel = self.get_prosody_ph(decoder_inp, ref_mels, ret, infer, global_steps)
-        prosody_word_mel = self.get_prosody_word(decoder_inp, ref_mels, ret, infer, global_steps)
-
-        # add pitch embed
-        pitch_inp_domain_agnostic = decoder_inp * tgt_nonpadding
-        pitch_inp_domain_specific = (decoder_inp + spk_embed + emo_embed + prosody_utter_mel + prosody_ph_mel + prosody_word_mel) * tgt_nonpadding
-        predicted_pitch = self.inpaint_pitch(pitch_inp_domain_agnostic, pitch_inp_domain_specific, f0, uv, mel2ph, ret)
-
-        # decode
-        decoder_inp = decoder_inp + spk_embed + emo_embed + predicted_pitch + prosody_utter_mel + prosody_ph_mel + prosody_word_mel
-        ret['decoder_inp'] = decoder_inp = decoder_inp * tgt_nonpadding
-        if skip_decoder:
-            return ret
-        ret['mel_out'] = self.run_decoder(decoder_inp, tgt_nonpadding, ret, infer=infer, **kwargs)
-
-        # postflow
-        is_training = self.training
-        ret['x_mask'] = tgt_nonpadding
-        ret['spk_embed'] = spk_embed
-        ret['emo_embed'] = emo_embed
-        ret['ref_prosody'] = prosody_utter_mel + prosody_ph_mel + prosody_word_mel
-        self.run_post_glow(ref_mels, infer, is_training, ret)
-        return ret
-
-    def get_prosody_ph(self, encoder_out, ref_mels, ret, infer=False, global_steps=0):
-        # get VQ prosody
-        if global_steps > hparams['vq_start'] or infer:
-            prosody_embedding, loss, ppl = self.prosody_extractor_ph(ref_mels, ret['ref_mel2ph'], no_vq=False)
-            ret['vq_loss_ph'] = loss
-            ret['ppl_ph'] = ppl
-        else:
-            prosody_embedding = self.prosody_extractor_ph(ref_mels, ret['ref_mel2ph'], no_vq=True)
-
-        # add positional embedding
-        positions = self.embed_positions(prosody_embedding[:, :, 0])
-        prosody_embedding = self.l1_ph(torch.cat([prosody_embedding, positions], dim=-1))
-
-
-        # style-to-content attention
-        src_key_padding_mask = encoder_out[:, :, 0].eq(self.padding_idx).data
-        prosody_key_padding_mask = prosody_embedding[:, :, 0].eq(self.padding_idx).data
-        if global_steps < hparams['forcing']:
-            output, guided_loss, attn_emo = self.align_ph(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                   src_key_padding_mask, prosody_key_padding_mask, forcing=True)
-        else:
-            output, guided_loss, attn_emo = self.align_ph(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                       src_key_padding_mask, prosody_key_padding_mask, forcing=False)
-
-        ret['gloss_ph'] = guided_loss
-        ret['attn_ph'] = attn_emo
-        return output.transpose(0, 1)
-
-    def get_prosody_word(self, encoder_out, ref_mels, ret, infer=False, global_steps=0):
-        # get VQ prosody
-        if global_steps > hparams['vq_start'] or infer:
-            prosody_embedding, loss, ppl = self.prosody_extractor_word(ref_mels, ret['ref_mel2word'], no_vq=False)
-            ret['vq_loss_word'] = loss
-            ret['ppl_word'] = ppl
-        else:
-            prosody_embedding = self.prosody_extractor_word(ref_mels, ret['ref_mel2word'], no_vq=True)
-
-        # add positional embedding
-        positions = self.embed_positions(prosody_embedding[:, :, 0])
-        prosody_embedding = self.l1_word(torch.cat([prosody_embedding, positions], dim=-1))
-
-
-        # style-to-content attention
-        src_key_padding_mask = encoder_out[:, :, 0].eq(self.padding_idx).data
-        prosody_key_padding_mask = prosody_embedding[:, :, 0].eq(self.padding_idx).data
-        if global_steps < hparams['forcing']:
-            output, guided_loss, attn_emo = self.align_word(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                   src_key_padding_mask, prosody_key_padding_mask, forcing=True)
-        else:
-            output, guided_loss, attn_emo = self.align_word(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                       src_key_padding_mask, prosody_key_padding_mask, forcing=False)
-        ret['gloss_word'] = guided_loss
-        ret['attn_word'] = attn_emo
-        return output.transpose(0, 1)
-
-    def get_prosody_utter(self, encoder_out, ref_mels, ret, infer=False, global_steps=0):
-        # get VQ prosody
-        if global_steps > hparams['vq_start'] or infer:
-            prosody_embedding, loss, ppl = self.prosody_extractor_utter(ref_mels, no_vq=False)
-            ret['vq_loss_utter'] = loss
-            ret['ppl_utter'] = ppl
-        else:
-            prosody_embedding = self.prosody_extractor_utter(ref_mels, no_vq=True)
-
-        # add positional embedding
-        positions = self.embed_positions(prosody_embedding[:, :, 0])
-        prosody_embedding = self.l1_utter(torch.cat([prosody_embedding, positions], dim=-1))
-
-
-        # style-to-content attention
-        src_key_padding_mask = encoder_out[:, :, 0].eq(self.padding_idx).data
-        prosody_key_padding_mask = prosody_embedding[:, :, 0].eq(self.padding_idx).data
-        if global_steps < hparams['forcing']:
-            output, guided_loss, attn_emo = self.align_utter(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                   src_key_padding_mask, prosody_key_padding_mask, forcing=True)
-        else:
-            output, guided_loss, attn_emo = self.align_utter(encoder_out.transpose(0, 1), prosody_embedding.transpose(0, 1),
-                                                       src_key_padding_mask, prosody_key_padding_mask, forcing=False)
-        ret['gloss_utter'] = guided_loss
-        ret['attn_utter'] = attn_emo
-        return output.transpose(0, 1)
-
-
-
-    def inpaint_pitch(self, pitch_inp_domain_agnostic, pitch_inp_domain_specific, f0, uv, mel2ph, ret):
-        if hparams['pitch_type'] == 'frame':
-            pitch_padding = mel2ph == 0
-        if hparams['predictor_grad'] != 1:
-            pitch_inp_domain_agnostic = pitch_inp_domain_agnostic.detach() + hparams['predictor_grad'] * (pitch_inp_domain_agnostic - pitch_inp_domain_agnostic.detach())
-            pitch_inp_domain_specific = pitch_inp_domain_specific.detach() + hparams['predictor_grad'] * (pitch_inp_domain_specific - pitch_inp_domain_specific.detach())
-
-        pitch_domain_agnostic = self.pitch_predictor(pitch_inp_domain_agnostic)
-        pitch_domain_specific = self.pitch_inpainter_predictor(pitch_inp_domain_specific)
-        pitch_pred = pitch_domain_agnostic + pitch_domain_specific
-        ret['pitch_pred'] = pitch_pred
-
-        use_uv = hparams['pitch_type'] == 'frame' and hparams['use_uv']
-        if f0 is None:
-            f0 = pitch_pred[:, :, 0]  # [B, T]
-            if use_uv:
-                uv = pitch_pred[:, :, 1] > 0  # [B, T]
-        f0_denorm = denorm_f0(f0, uv if use_uv else None, hparams, pitch_padding=pitch_padding)
-        pitch = f0_to_coarse(f0_denorm)  # start from 0 [B, T_txt]
-        ret['f0_denorm'] = f0_denorm
-        ret['f0_denorm_pred'] = denorm_f0(pitch_pred[:, :, 0], (pitch_pred[:, :, 1] > 0) if use_uv else None, hparams, pitch_padding=pitch_padding)
-        if hparams['pitch_type'] == 'ph':
-            pitch = torch.gather(F.pad(pitch, [1, 0]), 1, mel2ph)
-            ret['f0_denorm'] = torch.gather(F.pad(ret['f0_denorm'], [1, 0]), 1, mel2ph)
-            ret['f0_denorm_pred'] = torch.gather(F.pad(ret['f0_denorm_pred'], [1, 0]), 1, mel2ph)
-        pitch_embed = self.pitch_embed(pitch)
-        return pitch_embed
-
-    def run_post_glow(self, tgt_mels, infer, is_training, ret):
-        x_recon = ret['mel_out'].transpose(1, 2)
-        g = x_recon
-        B, _, T = g.shape
-        if hparams.get('use_txt_cond', True):
-            g = torch.cat([g, ret['decoder_inp'].transpose(1, 2)], 1)
-        g_spk_embed = ret['spk_embed'].repeat(1, T, 1).transpose(1, 2)
-        g_emo_embed = ret['emo_embed'].repeat(1, T, 1).transpose(1, 2)
-        l_ref_prosody = ret['ref_prosody'].transpose(1, 2)
-        g = torch.cat([g, g_spk_embed, g_emo_embed, l_ref_prosody], dim=1)
-        prior_dist = self.prior_dist
-        if not infer:
-            if is_training:
-                self.train()
-            x_mask = ret['x_mask'].transpose(1, 2)
-            y_lengths = x_mask.sum(-1)
-            g = g.detach()
-            tgt_mels = tgt_mels.transpose(1, 2)
-            z_postflow, ldj = self.post_flow(tgt_mels, x_mask, g=g)
-            ldj = ldj / y_lengths / 80
-            ret['z_pf'], ret['ldj_pf'] = z_postflow, ldj
-            ret['postflow'] = -prior_dist.log_prob(z_postflow).mean() - ldj.mean()
-        else:
-            x_mask = torch.ones_like(x_recon[:, :1, :])
-            z_post = prior_dist.sample(x_recon.shape).to(g.device) * hparams['noise_scale']
-            x_recon_, _ = self.post_flow(z_post, x_mask, g, reverse=True)
-            x_recon = x_recon_
-            ret['mel_out'] = x_recon.transpose(1, 2)

spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/diff/candidate_decoder.py

@@ -1,96 +0,0 @@
-from modules.fastspeech.tts_modules import FastspeechDecoder
-# from modules.fastspeech.fast_tacotron import DecoderRNN
-# from modules.fastspeech.speedy_speech.speedy_speech import ConvBlocks
-# from modules.fastspeech.conformer.conformer import ConformerDecoder
-import torch
-from torch.nn import functional as F
-import torch.nn as nn
-import math
-from utils.hparams import hparams
-from .diffusion import Mish
-Linear = nn.Linear
-
-
-class SinusoidalPosEmb(nn.Module):
-    def __init__(self, dim):
-        super().__init__()
-        self.dim = dim
-
-    def forward(self, x):
-        device = x.device
-        half_dim = self.dim // 2
-        emb = math.log(10000) / (half_dim - 1)
-        emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
-        emb = x[:, None] * emb[None, :]
-        emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
-        return emb
-
-
-def Conv1d(*args, **kwargs):
-    layer = nn.Conv1d(*args, **kwargs)
-    nn.init.kaiming_normal_(layer.weight)
-    return layer
-
-
-class FFT(FastspeechDecoder):
-    def __init__(self, hidden_size=None, num_layers=None, kernel_size=None, num_heads=None):
-        super().__init__(hidden_size, num_layers, kernel_size, num_heads=num_heads)
-        dim = hparams['residual_channels']
-        self.input_projection = Conv1d(hparams['audio_num_mel_bins'], dim, 1)
-        self.diffusion_embedding = SinusoidalPosEmb(dim)
-        self.mlp = nn.Sequential(
-            nn.Linear(dim, dim * 4),
-            Mish(),
-            nn.Linear(dim * 4, dim)
-        )
-        self.get_mel_out = Linear(hparams['hidden_size'], 80, bias=True)
-        self.get_decode_inp = Linear(hparams['hidden_size'] + dim + dim,
-                                     hparams['hidden_size'])  # hs + dim + 80 -> hs
-
-    def forward(self, spec, diffusion_step, cond, padding_mask=None, attn_mask=None, return_hiddens=False):
-        """
-        :param spec: [B, 1, 80, T]
-        :param diffusion_step: [B, 1]
-        :param cond: [B, M, T]
-        :return:
-        """
-        x = spec[:, 0]
-        x = self.input_projection(x).permute([0, 2, 1])  #  [B, T, residual_channel]
-        diffusion_step = self.diffusion_embedding(diffusion_step)
-        diffusion_step = self.mlp(diffusion_step)  # [B, dim]
-        cond = cond.permute([0, 2, 1])  # [B, T, M]
-
-        seq_len = cond.shape[1]  # [T_mel]
-        time_embed = diffusion_step[:, None, :]  # [B, 1, dim]
-        time_embed = time_embed.repeat([1, seq_len, 1])  # # [B, T, dim]
-
-        decoder_inp = torch.cat([x, cond, time_embed], dim=-1)  # [B, T, dim + H + dim]
-        decoder_inp = self.get_decode_inp(decoder_inp)  # [B, T, H]
-        x = decoder_inp
-
-        '''
-        Required x: [B, T, C]
-        :return: [B, T, C] or [L, B, T, C]
-        '''
-        padding_mask = x.abs().sum(-1).eq(0).data if padding_mask is None else padding_mask
-        nonpadding_mask_TB = 1 - padding_mask.transpose(0, 1).float()[:, :, None]  # [T, B, 1]
-        if self.use_pos_embed:
-            positions = self.pos_embed_alpha * self.embed_positions(x[..., 0])
-            x = x + positions
-            x = F.dropout(x, p=self.dropout, training=self.training)
-        # B x T x C -> T x B x C
-        x = x.transpose(0, 1) * nonpadding_mask_TB
-        hiddens = []
-        for layer in self.layers:
-            x = layer(x, encoder_padding_mask=padding_mask, attn_mask=attn_mask) * nonpadding_mask_TB
-            hiddens.append(x)
-        if self.use_last_norm:
-            x = self.layer_norm(x) * nonpadding_mask_TB
-        if return_hiddens:
-            x = torch.stack(hiddens, 0)  # [L, T, B, C]
-            x = x.transpose(1, 2)  # [L, B, T, C]
-        else:
-            x = x.transpose(0, 1)  # [B, T, C]
-
-        x = self.get_mel_out(x).permute([0, 2, 1])  # [B, 80, T]
-        return x[:, None, :, :]

spaces/AIGC-Audio/AudioGPT/NeuralSeq/modules/parallel_wavegan/layers/upsample.py

@@ -1,183 +0,0 @@
-# -*- coding: utf-8 -*-
-
-"""Upsampling module.
-
-This code is modified from https://github.com/r9y9/wavenet_vocoder.
-
-"""
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-
-from . import Conv1d
-
-
-class Stretch2d(torch.nn.Module):
-    """Stretch2d module."""
-
-    def __init__(self, x_scale, y_scale, mode="nearest"):
-        """Initialize Stretch2d module.
-
-        Args:
-            x_scale (int): X scaling factor (Time axis in spectrogram).
-            y_scale (int): Y scaling factor (Frequency axis in spectrogram).
-            mode (str): Interpolation mode.
-
-        """
-        super(Stretch2d, self).__init__()
-        self.x_scale = x_scale
-        self.y_scale = y_scale
-        self.mode = mode
-
-    def forward(self, x):
-        """Calculate forward propagation.
-
-        Args:
-            x (Tensor): Input tensor (B, C, F, T).
-
-        Returns:
-            Tensor: Interpolated tensor (B, C, F * y_scale, T * x_scale),
-
-        """
-        return F.interpolate(
-            x, scale_factor=(self.y_scale, self.x_scale), mode=self.mode)
-
-
-class Conv2d(torch.nn.Conv2d):
-    """Conv2d module with customized initialization."""
-
-    def __init__(self, *args, **kwargs):
-        """Initialize Conv2d module."""
-        super(Conv2d, self).__init__(*args, **kwargs)
-
-    def reset_parameters(self):
-        """Reset parameters."""
-        self.weight.data.fill_(1. / np.prod(self.kernel_size))
-        if self.bias is not None:
-            torch.nn.init.constant_(self.bias, 0.0)
-
-
-class UpsampleNetwork(torch.nn.Module):
-    """Upsampling network module."""
-
-    def __init__(self,
-                 upsample_scales,
-                 nonlinear_activation=None,
-                 nonlinear_activation_params={},
-                 interpolate_mode="nearest",
-                 freq_axis_kernel_size=1,
-                 use_causal_conv=False,
-                 ):
-        """Initialize upsampling network module.
-
-        Args:
-            upsample_scales (list): List of upsampling scales.
-            nonlinear_activation (str): Activation function name.
-            nonlinear_activation_params (dict): Arguments for specified activation function.
-            interpolate_mode (str): Interpolation mode.
-            freq_axis_kernel_size (int): Kernel size in the direction of frequency axis.
-
-        """
-        super(UpsampleNetwork, self).__init__()
-        self.use_causal_conv = use_causal_conv
-        self.up_layers = torch.nn.ModuleList()
-        for scale in upsample_scales:
-            # interpolation layer
-            stretch = Stretch2d(scale, 1, interpolate_mode)
-            self.up_layers += [stretch]
-
-            # conv layer
-            assert (freq_axis_kernel_size - 1) % 2 == 0, "Not support even number freq axis kernel size."
-            freq_axis_padding = (freq_axis_kernel_size - 1) // 2
-            kernel_size = (freq_axis_kernel_size, scale * 2 + 1)
-            if use_causal_conv:
-                padding = (freq_axis_padding, scale * 2)
-            else:
-                padding = (freq_axis_padding, scale)
-            conv = Conv2d(1, 1, kernel_size=kernel_size, padding=padding, bias=False)
-            self.up_layers += [conv]
-
-            # nonlinear
-            if nonlinear_activation is not None:
-                nonlinear = getattr(torch.nn, nonlinear_activation)(**nonlinear_activation_params)
-                self.up_layers += [nonlinear]
-
-    def forward(self, c):
-        """Calculate forward propagation.
-
-        Args:
-            c : Input tensor (B, C, T).
-
-        Returns:
-            Tensor: Upsampled tensor (B, C, T'), where T' = T * prod(upsample_scales).
-
-        """
-        c = c.unsqueeze(1)  # (B, 1, C, T)
-        for f in self.up_layers:
-            if self.use_causal_conv and isinstance(f, Conv2d):
-                c = f(c)[..., :c.size(-1)]
-            else:
-                c = f(c)
-        return c.squeeze(1)  # (B, C, T')
-
-
-class ConvInUpsampleNetwork(torch.nn.Module):
-    """Convolution + upsampling network module."""
-
-    def __init__(self,
-                 upsample_scales,
-                 nonlinear_activation=None,
-                 nonlinear_activation_params={},
-                 interpolate_mode="nearest",
-                 freq_axis_kernel_size=1,
-                 aux_channels=80,
-                 aux_context_window=0,
-                 use_causal_conv=False
-                 ):
-        """Initialize convolution + upsampling network module.
-
-        Args:
-            upsample_scales (list): List of upsampling scales.
-            nonlinear_activation (str): Activation function name.
-            nonlinear_activation_params (dict): Arguments for specified activation function.
-            mode (str): Interpolation mode.
-            freq_axis_kernel_size (int): Kernel size in the direction of frequency axis.
-            aux_channels (int): Number of channels of pre-convolutional layer.
-            aux_context_window (int): Context window size of the pre-convolutional layer.
-            use_causal_conv (bool): Whether to use causal structure.
-
-        """
-        super(ConvInUpsampleNetwork, self).__init__()
-        self.aux_context_window = aux_context_window
-        self.use_causal_conv = use_causal_conv and aux_context_window > 0
-        # To capture wide-context information in conditional features
-        kernel_size = aux_context_window + 1 if use_causal_conv else 2 * aux_context_window + 1
-        # NOTE(kan-bayashi): Here do not use padding because the input is already padded
-        self.conv_in = Conv1d(aux_channels, aux_channels, kernel_size=kernel_size, bias=False)
-        self.upsample = UpsampleNetwork(
-            upsample_scales=upsample_scales,
-            nonlinear_activation=nonlinear_activation,
-            nonlinear_activation_params=nonlinear_activation_params,
-            interpolate_mode=interpolate_mode,
-            freq_axis_kernel_size=freq_axis_kernel_size,
-            use_causal_conv=use_causal_conv,
-        )
-
-    def forward(self, c):
-        """Calculate forward propagation.
-
-        Args:
-            c : Input tensor (B, C, T').
-
-        Returns:
-            Tensor: Upsampled tensor (B, C, T),
-                where T = (T' - aux_context_window * 2) * prod(upsample_scales).
-
-        Note:
-            The length of inputs considers the context window size.
-
-        """
-        c_ = self.conv_in(c)
-        c = c_[:, :, :-self.aux_context_window] if self.use_causal_conv else c_
-        return self.upsample(c)

spaces/AIGC-Audio/AudioGPT/NeuralSeq/tasks/svs/task.py

@@ -1,84 +0,0 @@
-import torch
-
-import utils
-from modules.diff.diffusion import GaussianDiffusion
-from modules.diff.net import DiffNet
-from tasks.tts.fs2 import FastSpeech2Task
-from utils.hparams import hparams
-
-
-DIFF_DECODERS = {
-    'wavenet': lambda hp: DiffNet(hp['audio_num_mel_bins']),
-}
-
-
-class DiffFsTask(FastSpeech2Task):
-    def build_tts_model(self):
-        mel_bins = hparams['audio_num_mel_bins']
-        self.model = GaussianDiffusion(
-            phone_encoder=self.phone_encoder,
-            out_dims=mel_bins, denoise_fn=DIFF_DECODERS[hparams['diff_decoder_type']](hparams),
-            timesteps=hparams['timesteps'],
-            loss_type=hparams['diff_loss_type'],
-            spec_min=hparams['spec_min'], spec_max=hparams['spec_max'],
-        )
-
-    def run_model(self, model, sample, return_output=False, infer=False):
-        txt_tokens = sample['txt_tokens']  # [B, T_t]
-        target = sample['mels']  # [B, T_s, 80]
-        mel2ph = sample['mel2ph']  # [B, T_s]
-        f0 = sample['f0']
-        uv = sample['uv']
-        energy = sample['energy']
-        spk_embed = sample.get('spk_embed') if not hparams['use_spk_id'] else sample.get('spk_ids')
-        if hparams['pitch_type'] == 'cwt':
-            cwt_spec = sample[f'cwt_spec']
-            f0_mean = sample['f0_mean']
-            f0_std = sample['f0_std']
-            sample['f0_cwt'] = f0 = model.cwt2f0_norm(cwt_spec, f0_mean, f0_std, mel2ph)
-
-        output = model(txt_tokens, mel2ph=mel2ph, spk_embed=spk_embed,
-                       ref_mels=target, f0=f0, uv=uv, energy=energy, infer=infer)
-
-        losses = {}
-        if 'diff_loss' in output:
-            losses['mel'] = output['diff_loss']
-        self.add_dur_loss(output['dur'], mel2ph, txt_tokens, losses=losses)
-        if hparams['use_pitch_embed']:
-            self.add_pitch_loss(output, sample, losses)
-        if hparams['use_energy_embed']:
-            self.add_energy_loss(output['energy_pred'], energy, losses)
-        if not return_output:
-            return losses
-        else:
-            return losses, output
-
-    def _training_step(self, sample, batch_idx, _):
-        log_outputs = self.run_model(self.model, sample)
-        total_loss = sum([v for v in log_outputs.values() if isinstance(v, torch.Tensor) and v.requires_grad])
-        log_outputs['batch_size'] = sample['txt_tokens'].size()[0]
-        log_outputs['lr'] = self.scheduler.get_lr()[0]
-        return total_loss, log_outputs
-
-    def validation_step(self, sample, batch_idx):
-        outputs = {}
-        outputs['losses'] = {}
-        outputs['losses'], model_out = self.run_model(self.model, sample, return_output=True, infer=False)
-        outputs['total_loss'] = sum(outputs['losses'].values())
-        outputs['nsamples'] = sample['nsamples']
-        outputs = utils.tensors_to_scalars(outputs)
-        if batch_idx < hparams['num_valid_plots']:
-            _, model_out = self.run_model(self.model, sample, return_output=True, infer=True)
-            self.plot_mel(batch_idx, sample['mels'], model_out['mel_out'])
-        return outputs
-
-    def build_scheduler(self, optimizer):
-        return torch.optim.lr_scheduler.StepLR(optimizer, hparams['decay_steps'], gamma=0.5)
-
-    def optimizer_step(self, epoch, batch_idx, optimizer, optimizer_idx):
-        if optimizer is None:
-            return
-        optimizer.step()
-        optimizer.zero_grad()
-        if self.scheduler is not None:
-            self.scheduler.step(self.global_step // hparams['accumulate_grad_batches'])

spaces/AIWaves/SOP_Generation-single/Action/__init__.py

@@ -1 +0,0 @@
-from .base_action import Action

spaces/AIWaves/SOP_Generation-single/Component/ToolComponent.py

@@ -1,887 +0,0 @@
-from abc import abstractmethod
-import uuid
-from text2vec import semantic_search
-from utils import (
-    get_relevant_history,
-    load_knowledge_base_qa,
-    load_knowledge_base_UnstructuredFile,
-    get_embedding,
-    extract,
-)
-import json
-from typing import Dict, List
-import os
-from googleapiclient.discovery import build
-import requests
-from selenium import webdriver
-from selenium.webdriver.common.by import By
-from selenium.webdriver.support.ui import WebDriverWait
-from selenium.webdriver.support import expected_conditions as EC
-from bs4 import BeautifulSoup
-import base64
-import re
-from datetime import datetime, timedelta
-from typing import Tuple, List, Any, Dict
-from email.mime.text import MIMEText
-from email.mime.multipart import MIMEMultipart
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-from googleapiclient.discovery import build
-from googleapiclient.errors import HttpError
-from tqdm import tqdm
-
-class ToolComponent:
-    def __init__(self):
-        pass
-
-    @abstractmethod
-    def func(self):
-        pass
-    
-class KnowledgeBaseComponent(ToolComponent):
-    """
-    Inject knowledge base
-    top_k : Top_k with the highest matching degree
-    type : "QA" or others
-    knowledge_base(json_path) : knowledge_base_path
-    """
-    def __init__(self, top_k, type, knowledge_base):
-        super().__init__()
-        self.top_k = top_k
-        self.type = type
-        self.knowledge_base = knowledge_base
-
-        if self.type == "QA":
-            (
-                self.kb_embeddings,
-                self.kb_questions,
-                self.kb_answers,
-                self.kb_chunks,
-            ) = load_knowledge_base_qa(self.knowledge_base)
-        else:
-            self.kb_embeddings, self.kb_chunks = load_knowledge_base_UnstructuredFile(
-                self.knowledge_base
-            )
-
-    def func(self, agent):
-        query = (
-            agent.long_term_memory[-1]["content"]
-            if len(agent.long_term_memory) > 0
-            else ""
-        )
-        knowledge = ""
-        query = extract(query, "query")
-        query_embedding = get_embedding(query)
-        hits = semantic_search(query_embedding, self.kb_embeddings, top_k=50)
-        hits = hits[0]
-        temp = []
-        if self.type == "QA":
-            for hit in hits:
-                matching_idx = hit["corpus_id"]
-                if self.kb_chunks[matching_idx] in temp:
-                    pass
-                else:
-                    knowledge = (
-                        knowledge
-                        + f"question:{self.kb_questions[matching_idx]},answer:{self.kb_answers[matching_idx]}\n\n"
-                    )
-                    temp.append(self.kb_answers[matching_idx])
-                    if len(temp) == 1:
-                        break
-            print(hits[0]["score"])
-            score = hits[0]["score"]
-            if score < 0.5:
-                return {"prompt": "No matching knowledge base"}
-            else:
-                return {"prompt": "The relevant content is: " + knowledge + "\n"}
-        else:
-            for hit in hits:
-                matching_idx = hit["corpus_id"]
-                if self.kb_chunks[matching_idx] in temp:
-                    pass
-                else:
-                    knowledge = knowledge + f"{self.kb_answers[matching_idx]}\n\n"
-                    temp.append(self.kb_answers[matching_idx])
-                    if len(temp) == self.top_k:
-                        break
-            print(hits[0]["score"])
-            score = hits[0]["score"]
-            if score < 0.5:
-                return {"prompt": "No matching knowledge base"}
-            else:
-                print(knowledge)
-                return {"prompt": "The relevant content is: " + knowledge + "\n"}
-
-
-class StaticComponent(ToolComponent):
-    "Return static response"
-    def __init__(self, output):
-        super().__init__()
-        self.output = output
-
-    def func(self, agent):
-        outputdict = {"response": self.output}
-        return outputdict
-
-
-class ExtractComponent(ToolComponent):
-    """
-    Extract keywords based on the current scene and store them in the environment
-    extract_words(list) : Keywords to be extracted
-    system_prompt & last_prompt : Prompt to extract keywords
-    """
-    def __init__(
-        self,
-        extract_words,
-        system_prompt,
-        last_prompt=None,
-    ):
-        super().__init__()
-        self.extract_words = extract_words
-        self.system_prompt = system_prompt
-        self.default_prompt = (
-            "Please strictly adhere to the following format for outputting:\n"
-        )
-        for extract_word in extract_words:
-            self.default_prompt += (
-                f"<{extract_word}> the content you need to extract </{extract_word}>"
-            )
-        self.last_prompt = last_prompt if last_prompt else self.default_prompt
-
-    def func(self, agent):
-        response = agent.LLM.get_response(
-            agent.long_term_memory,
-            self.system_prompt,
-            self.last_prompt,
-            stream=False,
-        )
-        for extract_word in self.extract_words:
-            key = extract(response, extract_word)
-            key = key if key else response
-            agent.environment.shared_memory[extract_word] = key
-
-        return {}
-
-
-"""Search sources: chatgpt/search engines/specific search sources/can even be multimodal (if it comes to clothing)"""
-
-
-class WebSearchComponent(ToolComponent):
-    """search engines"""
-
-    __ENGINE_NAME__: List = ["google", "bing"]
-
-    def __init__(self, engine_name: str, api: Dict):
-        """
-        :param engine_name: The name of the search engine used
-        :param api: Pass in a dictionary, such as {"bing":"key1", "google":"key2", ...}, of course each value can also be a list, or more complicated
-        """
-        super(WebSearchComponent, self).__init__()
-        """Determine whether the key and engine_name of the api are legal"""
-
-        assert engine_name in WebSearchComponent.__ENGINE_NAME__
-        for api_name in api:
-            assert api_name in WebSearchComponent.__ENGINE_NAME__
-
-        self.api = api
-        self.engine_name = engine_name
-
-        self.search: Dict = {"bing": self._bing_search, "google": self._google_search}
-
-    def _bing_search(self, query: str, **kwargs):
-        """Initialize search hyperparameters"""
-        subscription_key = self.api["bing"]
-        search_url = "https://api.bing.microsoft.com/v7.0/search"
-        headers = {"Ocp-Apim-Subscription-Key": subscription_key}
-        params = {
-            "q": query,
-            "textDecorations": True,
-            "textFormat": "HTML",
-            "count": 10,
-        }
-        """start searching"""
-        response = requests.get(search_url, headers=headers, params=params)
-        response.raise_for_status()
-        results = response.json()["webPages"]["value"]
-        """execute"""
-        metadata_results = []
-        for result in results:
-            metadata_result = {
-                "snippet": result["snippet"],
-                "title": result["name"],
-                "link": result["url"],
-            }
-            metadata_results.append(metadata_result)
-        return {"meta data": metadata_results}
-
-    def _google_search(self, query: str, **kwargs):
-        """Initialize search hyperparameters"""
-        api_key = self.api[self.engine_name]["api_key"]
-        cse_id = self.api[self.engine_name]["cse_id"]
-        service = build("customsearch", "v1", developerKey=api_key)
-        """start searching"""
-        results = (
-            service.cse().list(q=query, cx=cse_id, num=10, **kwargs).execute()["items"]
-        )
-        """execute"""
-        metadata_results = []
-        for result in results:
-            metadata_result = {
-                "snippet": result["snippet"],
-                "title": result["title"],
-                "link": result["link"],
-            }
-            metadata_results.append(metadata_result)
-        return {"meta data": metadata_results}
-
-    def func(self, agent, **kwargs) -> Dict:
-        query = (
-            agent.long_term_memory[-1]["content"]
-            if len(agent.long_term_memory) > 0
-            else " "
-        )
-        response = agent.LLM.get_response(
-            None,
-            system_prompt=f"Please analyze the provided conversation and identify keywords that can be used for a search engine query. Format the output as <keywords>extracted keywords</keywords>:\nConversation:\n{query}",
-            stream=False,
-        )
-        response = extract(response, "keywords")
-        query = response if response else query
-
-        search_results = self.search[self.engine_name](query=query, **kwargs)
-        information = ""
-        for i in search_results["meta data"][:5]:
-            information += i["snippet"]
-        return {
-            "prompt": "You can refer to the following information to reply:\n"
-            + information
-        }
-
-    def convert_search_engine_to(self, engine_name):
-        assert engine_name in WebSearchComponent.__ENGINE_NAME__
-        self.engine_name = engine_name
-
-
-class WebCrawlComponent(ToolComponent):
-    """Open a single web page for crawling"""
-
-    def __init__(self):
-        super(WebCrawlComponent, self).__init__()
-
-    def func(self, agent_dict) -> Dict:
-        url = agent_dict["url"]
-        print(f"crawling {url} ......")
-        content = ""
-        """Crawling content from url may need to be carried out according to different websites, such as wiki, baidu, zhihu, etc."""
-        driver = webdriver.Chrome()
-        try:
-            """open url"""
-            driver.get(url)
-
-            """wait 20 second"""
-            wait = WebDriverWait(driver, 20)
-            wait.until(EC.presence_of_element_located((By.TAG_NAME, "body")))
-
-            """crawl code"""
-            page_source = driver.page_source
-
-            """parse"""
-            soup = BeautifulSoup(page_source, "html.parser")
-
-            """concatenate"""
-            for paragraph in soup.find_all("p"):
-                content = f"{content}\n{paragraph.get_text()}"
-        except Exception as e:
-            print("Error:", e)
-        finally:
-            """quit"""
-            driver.quit()
-        return {"content": content.strip()}
-
-
-class MailComponent(ToolComponent):
-    __VALID_ACTION__ = ["read", "send"]
-
-    def __init__(
-        self, cfg_file: str, default_action: str = "read", name: str = "e-mail"
-    ):
-        """'../config/google_mail.json'"""
-        super(MailComponent, self).__init__(name)
-        self.name = name
-        assert (
-            default_action.lower() in self.__VALID_ACTION__
-        ), f"Action `{default_action}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
-        self.action = default_action.lower()
-        self.credential = self._login(cfg_file)
-
-    def _login(self, cfg_file: str):
-        SCOPES = [
-            "https://www.googleapis.com/auth/gmail.readonly",
-            "https://www.googleapis.com/auth/gmail.send",
-        ]
-        creds = None
-        if os.path.exists("token.json"):
-            print("Login Successfully!")
-            creds = Credentials.from_authorized_user_file("token.json", SCOPES)
-        if not creds or not creds.valid:
-            print("Please authorize in an open browser.")
-            if creds and creds.expired and creds.refresh_token:
-                creds.refresh(Request())
-            else:
-                flow = InstalledAppFlow.from_client_secrets_file(cfg_file, SCOPES)
-                creds = flow.run_local_server(port=0)
-            # Save the credentials for the next run
-            with open("token.json", "w") as token:
-                token.write(creds.to_json())
-        return creds
-
-    def _read(self, mail_dict: dict):
-        credential = self.credential
-        state = mail_dict["state"] if "state" in mail_dict else None
-        time_between = (
-            mail_dict["time_between"] if "time_between" in mail_dict else None
-        )
-        sender_mail = mail_dict["sender_mail"] if "sender_mail" in mail_dict else None
-        only_both = mail_dict["only_both"] if "only_both" in mail_dict else False
-        order_by_time = (
-            mail_dict["order_by_time"] if "order_by_time" in mail_dict else "descend"
-        )
-        include_word = (
-            mail_dict["include_word"] if "include_word" in mail_dict else None
-        )
-        exclude_word = (
-            mail_dict["exclude_word"] if "exclude_word" in mail_dict else None
-        )
-        MAX_SEARCH_CNT = (
-            mail_dict["MAX_SEARCH_CNT"] if "MAX_SEARCH_CNT" in mail_dict else 50
-        )
-        number = mail_dict["number"] if "number" in mail_dict else 10
-        if state is None:
-            state = "all"
-        if time_between is not None:
-            assert isinstance(time_between, tuple)
-            assert len(time_between) == 2
-        assert state in ["all", "unread", "read", "sent"]
-        if only_both:
-            assert sender_mail is not None
-        if sender_mail is not None:
-            assert isinstance(sender_mail, str)
-        assert credential
-        assert order_by_time in ["descend", "ascend"]
-
-        def generate_query():
-            query = ""
-            if state in ["unread", "read"]:
-                query = f"is:{state}"
-            if state in ["sent"]:
-                query = f"in:{state}"
-            if only_both:
-                query = f"{query} from:{sender_mail} OR to:{sender_mail}"
-            if sender_mail is not None and not only_both:
-                query = f"{query} from:({sender_mail})"
-            if include_word is not None:
-                query = f"{query} {include_word}"
-            if exclude_word is not None:
-                query = f"{query} -{exclude_word}"
-            if time_between is not None:
-                TIME_FORMAT = "%Y/%m/%d"
-                t1, t2 = time_between
-                if t1 == "now":
-                    t1 = datetime.now().strftime(TIME_FORMAT)
-                if t2 == "now":
-                    t2 = datetime.now().strftime(TIME_FORMAT)
-                if isinstance(t1, str) and isinstance(t2, str):
-                    t1 = datetime.strptime(t1, TIME_FORMAT)
-                    t2 = datetime.strptime(t2, TIME_FORMAT)
-                elif isinstance(t1, str) and isinstance(t2, int):
-                    t1 = datetime.strptime(t1, TIME_FORMAT)
-                    t2 = t1 + timedelta(days=t2)
-                elif isinstance(t1, int) and isinstance(t2, str):
-                    t2 = datetime.strptime(t2, TIME_FORMAT)
-                    t1 = t2 + timedelta(days=t1)
-                else:
-                    assert False, "invalid time"
-                if t1 > t2:
-                    t1, t2 = t2, t1
-                query = f"{query} after:{t1.strftime(TIME_FORMAT)} before:{t2.strftime(TIME_FORMAT)}"
-            return query.strip()
-
-        def sort_by_time(data: List[Dict]):
-            if order_by_time == "descend":
-                reverse = True
-            else:
-                reverse = False
-            sorted_data = sorted(
-                data,
-                key=lambda x: datetime.strptime(x["time"], "%Y-%m-%d %H:%M:%S"),
-                reverse=reverse,
-            )
-            return sorted_data
-
-        try:
-            service = build("gmail", "v1", credentials=credential)
-            results = (
-                service.users()
-                .messages()
-                .list(userId="me", labelIds=["INBOX"], q=generate_query())
-                .execute()
-            )
-
-            messages = results.get("messages", [])
-            email_data = list()
-
-            if not messages:
-                print("No eligible emails.")
-                return None
-            else:
-                pbar = tqdm(total=min(MAX_SEARCH_CNT, len(messages)))
-                for cnt, message in enumerate(messages):
-                    pbar.update(1)
-                    if cnt >= MAX_SEARCH_CNT:
-                        break
-                    msg = (
-                        service.users()
-                        .messages()
-                        .get(
-                            userId="me",
-                            id=message["id"],
-                            format="full",
-                            metadataHeaders=None,
-                        )
-                        .execute()
-                    )
-
-                    subject = ""
-                    for header in msg["payload"]["headers"]:
-                        if header["name"] == "Subject":
-                            subject = header["value"]
-                            break
-
-                    sender = ""
-                    for header in msg["payload"]["headers"]:
-                        if header["name"] == "From":
-                            sender = re.findall(
-                                r"\b[\w\.-]+@[\w\.-]+\.\w+\b", header["value"]
-                            )[0]
-                            break
-                    body = ""
-                    if "parts" in msg["payload"]:
-                        for part in msg["payload"]["parts"]:
-                            if part["mimeType"] == "text/plain":
-                                data = part["body"]["data"]
-                                body = base64.urlsafe_b64decode(data).decode("utf-8")
-                                break
-
-                    email_info = {
-                        "sender": sender,
-                        "time": datetime.fromtimestamp(
-                            int(msg["internalDate"]) / 1000
-                        ).strftime("%Y-%m-%d %H:%M:%S"),
-                        "subject": subject,
-                        "body": body,
-                    }
-                    email_data.append(email_info)
-                pbar.close()
-            email_data = sort_by_time(email_data)[0:number]
-            return {"results": email_data}
-        except Exception as e:
-            print(e)
-            return None
-
-    def _send(self, mail_dict: dict):
-        recipient_mail = mail_dict["recipient_mail"]
-        subject = mail_dict["subject"]
-        body = mail_dict["body"]
-        credential = self.credential
-        service = build("gmail", "v1", credentials=credential)
-
-        message = MIMEMultipart()
-        message["to"] = recipient_mail
-        message["subject"] = subject
-
-        message.attach(MIMEText(body, "plain"))
-
-        raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode("utf-8")
-        try:
-            message = (
-                service.users()
-                .messages()
-                .send(userId="me", body={"raw": raw_message})
-                .execute()
-            )
-            return {"state": True}
-        except HttpError as error:
-            print(error)
-            return {"state": False}
-
-    def func(self, mail_dict: dict):
-        if "action" in mail_dict:
-            assert mail_dict["action"].lower() in self.__VALID_ACTION__
-            self.action = mail_dict["action"]
-        functions = {"read": self._read, "send": self._send}
-        return functions[self.action](mail_dict)
-
-    def convert_action_to(self, action_name: str):
-        assert (
-            action_name.lower() in self.__VALID_ACTION__
-        ), f"Action `{action_name}` is not allowed! The valid action is in `{self.__VALID_ACTION__}`"
-        self.action = action_name.lower()
-
-
-class WeatherComponet(ToolComponent):
-    def __init__(self, api_key, name="weather", TIME_FORMAT="%Y-%m-%d"):
-        super(WeatherComponet, self).__init__(name)
-        self.name = name
-        self.TIME_FORMAT = TIME_FORMAT
-        self.api_key = api_key
-
-    def _parse(self, data):
-        dict_data: dict = {}
-        for item in data["data"]:
-            date = item["datetime"]
-            dict_data[date] = {}
-            if "weather" in item:
-                dict_data[date]["description"] = item["weather"]["description"]
-            mapping = {
-                "temp": "temperature",
-                "max_temp": "max_temperature",
-                "min_temp": "min_temperature",
-                "precip": "accumulated_precipitation",
-            }
-            for key in ["temp", "max_temp", "min_temp", "precip"]:
-                if key in item:
-                    dict_data[date][mapping[key]] = item[key]
-        return dict_data
-
-    def _query(self, city_name, country_code, start_date, end_date):
-        """https://www.weatherbit.io/api/historical-weather-daily"""
-        # print(datetime.strftime(start_date, self.TIME_FORMAT), datetime.strftime(datetime.now(), self.TIME_FORMAT), end_date, datetime.strftime(datetime.now()+timedelta(days=1), self.TIME_FORMAT))
-        if start_date == datetime.strftime(
-            datetime.now(), self.TIME_FORMAT
-        ) and end_date == datetime.strftime(
-            datetime.now() + timedelta(days=1), self.TIME_FORMAT
-        ):
-            """today"""
-            url = f"https://api.weatherbit.io/v2.0/current?city={city_name}&country={country_code}&key={self.api_key}"
-        else:
-            url = f"https://api.weatherbit.io/v2.0/history/daily?&city={city_name}&country={country_code}&start_date={start_date}&end_date={end_date}&key={self.api_key}"
-        response = requests.get(url)
-        data = response.json()
-        return self._parse(data)
-
-    def func(self, weather_dict: Dict) -> Dict:
-        TIME_FORMAT = self.TIME_FORMAT
-        # Beijing, Shanghai
-        city_name = weather_dict["city_name"]
-        # CN, US
-        country_code = weather_dict["country_code"]
-        # 2020-02-02
-        start_date = datetime.strftime(
-            datetime.strptime(weather_dict["start_date"], self.TIME_FORMAT),
-            self.TIME_FORMAT,
-        )
-        end_date = weather_dict["end_date"] if "end_date" in weather_dict else None
-        if end_date is None:
-            end_date = datetime.strftime(
-                datetime.strptime(start_date, TIME_FORMAT) + timedelta(days=-1),
-                TIME_FORMAT,
-            )
-        else:
-            end_date = datetime.strftime(
-                datetime.strptime(weather_dict["end_date"], self.TIME_FORMAT),
-                self.TIME_FORMAT,
-            )
-        if datetime.strptime(start_date, TIME_FORMAT) > datetime.strptime(
-            end_date, TIME_FORMAT
-        ):
-            start_date, end_date = end_date, start_date
-        assert start_date != end_date
-        return self._query(city_name, country_code, start_date, end_date)
-
-
-class TranslateComponent(ToolComponent):
-    __SUPPORT_LANGUAGE__ = [
-        "af",
-        "am",
-        "ar",
-        "as",
-        "az",
-        "ba",
-        "bg",
-        "bn",
-        "bo",
-        "bs",
-        "ca",
-        "cs",
-        "cy",
-        "da",
-        "de",
-        "dsb",
-        "dv",
-        "el",
-        "en",
-        "es",
-        "et",
-        "eu",
-        "fa",
-        "fi",
-        "fil",
-        "fj",
-        "fo",
-        "fr",
-        "fr-CA",
-        "ga",
-        "gl",
-        "gom",
-        "gu",
-        "ha",
-        "he",
-        "hi",
-        "hr",
-        "hsb",
-        "ht",
-        "hu",
-        "hy",
-        "id",
-        "ig",
-        "ikt",
-        "is",
-        "it",
-        "iu",
-        "iu-Latn",
-        "ja",
-        "ka",
-        "kk",
-        "km",
-        "kmr",
-        "kn",
-        "ko",
-        "ku",
-        "ky",
-        "ln",
-        "lo",
-        "lt",
-        "lug",
-        "lv",
-        "lzh",
-        "mai",
-        "mg",
-        "mi",
-        "mk",
-        "ml",
-        "mn-Cyrl",
-        "mn-Mong",
-        "mr",
-        "ms",
-        "mt",
-        "mww",
-        "my",
-        "nb",
-        "ne",
-        "nl",
-        "nso",
-        "nya",
-        "or",
-        "otq",
-        "pa",
-        "pl",
-        "prs",
-        "ps",
-        "pt",
-        "pt-PT",
-        "ro",
-        "ru",
-        "run",
-        "rw",
-        "sd",
-        "si",
-        "sk",
-        "sl",
-        "sm",
-        "sn",
-        "so",
-        "sq",
-        "sr-Cyrl",
-        "sr-Latn",
-        "st",
-        "sv",
-        "sw",
-        "ta",
-        "te",
-        "th",
-        "ti",
-        "tk",
-        "tlh-Latn",
-        "tlh-Piqd",
-        "tn",
-        "to",
-        "tr",
-        "tt",
-        "ty",
-        "ug",
-        "uk",
-        "ur",
-        "uz",
-        "vi",
-        "xh",
-        "yo",
-        "yua",
-        "yue",
-        "zh-Hans",
-        "zh-Hant",
-        "zu",
-    ]
-
-    def __init__(
-        self, api_key, location, default_target_language="zh-cn", name="translate"
-    ):
-        super(TranslateComponent, self).__init__(name)
-        self.name = name
-        self.api_key = api_key
-        self.location = location
-        self.default_target_language = default_target_language
-
-    def func(self, translate_dict: Dict) -> Dict:
-        content = translate_dict["content"]
-        target_language = self.default_target_language
-        if "target_language" in translate_dict:
-            target_language = translate_dict["target_language"]
-        assert (
-            target_language in self.__SUPPORT_LANGUAGE__
-        ), f"language `{target_language}` is not supported."
-
-        endpoint = "https://api.cognitive.microsofttranslator.com"
-
-        path = "/translate"
-        constructed_url = endpoint + path
-
-        params = {"api-version": "3.0", "to": target_language}
-
-        headers = {
-            "Ocp-Apim-Subscription-Key": self.api_key,
-            "Ocp-Apim-Subscription-Region": self.location,
-            "Content-type": "application/json",
-            "X-ClientTraceId": str(uuid.uuid4()),
-        }
-
-        body = [{"text": content}]
-
-        request = requests.post(
-            constructed_url, params=params, headers=headers, json=body
-        )
-        response = request.json()
-        response = json.dumps(
-            response,
-            sort_keys=True,
-            ensure_ascii=False,
-            indent=4,
-            separators=(",", ": "),
-        )
-        response = eval(response)
-        return {"result": response[0]["translations"][0]["text"]}
-
-
-class APIComponent(ToolComponent):
-    def __init__(self):
-        super(APIComponent, self).__init__()
-
-    def func(self, agent) -> Dict:
-        pass
-
-
-class FunctionComponent(ToolComponent):
-    def __init__(
-        self,
-        functions,
-        function_call="auto",
-        response_type="response",
-        your_function=None,
-    ):
-        super().__init__()
-        self.functions = functions
-        self.function_call = function_call
-        self.parameters = {}
-        self.available_functions = {}
-        self.response_type = response_type
-        if your_function:
-            function_name = your_function["name"]
-            function_content = your_function["content"]
-            exec(function_content)
-            self.available_functions[function_name] = eval(function_name)
-
-        for function in self.functions:
-            self.parameters[function["name"]] = list(
-                function["parameters"]["properties"].keys()
-            )
-            self.available_functions[function["name"]] = eval(function["name"])
-
-    def func(self, agent):
-        messages = agent.long_term_memory
-        outputdict = {}
-        query = agent.long_term_memory[-1].content if len(agent.long_term_memory) > 0 else " "
-        relevant_history = get_relevant_history(
-            query,
-            agent.long_term_memory[:-1],
-            agent.chat_embeddings[:-1],
-        )
-        response = agent.LLM.get_response(
-            messages,
-            None,
-            functions=self.functions,
-            stream=False,
-            function_call=self.function_call,
-            relevant_history=relevant_history,
-        )
-        response_message = response
-        if response_message.get("function_call"):
-            function_name = response_message["function_call"]["name"]
-            fuction_to_call = self.available_functions[function_name]
-            function_args = json.loads(response_message["function_call"]["arguments"])
-            input_args = {}
-            for args_name in self.parameters[function_name]:
-                input_args[args_name] = function_args.get(args_name)
-            function_response = fuction_to_call(**input_args)
-            if self.response_type == "response":
-                outputdict["response"] = function_response
-            elif self.response_type == "prompt":
-                outputdict["prompt"] = function_response
-
-        return outputdict
-
-
-class CodeComponent(ToolComponent):
-    def __init__(self, file_name, keyword) -> None:
-        super().__init__()
-        self.file_name = file_name
-        self.keyword = keyword
-        self.system_prompt = (
-            "you need to extract the modified code as completely as possible."
-        )
-        self.last_prompt = (
-            f"Please strictly adhere to the following format for outputting: \n"
-        )
-        self.last_prompt += (
-            f"<{self.keyword}> the content you need to extract </{self.keyword}>"
-        )
-
-    def func(self, agent):
-        response = agent.LLM.get_response(
-            agent.long_term_memory,
-            self.system_prompt,
-            self.last_prompt,
-            stream=False,
-        )
-        code = extract(response, self.keyword)
-        code = code if code else response
-        os.makedirs("output_code", exist_ok=True)
-        file_name = "output_code/" + self.file_name
-        codes = code.split("\n")
-        if codes[0] == "```python":
-            codes.remove(codes[0])
-        if codes[-1] == "```":
-            codes.remove(codes[-1])
-        code = "\n".join(codes)
-        with open(file_name, "w", encoding="utf-8") as f:
-            f.write(code)
-        return {}

spaces/AgentVerse/agentVerse/README.md

@@ -1,429 +0,0 @@
----
-title: AgentVerse
-sdk: gradio
-license: apache-2.0
-emoji: 🤖
-colorFrom: indigo
-colorTo: indigo
----
-
-<h1 align="center"> 🤖 AgentVerse 🪐 </h1>
-
-<h3 align="center">
-    <p>A Framework for Multi-LLM Environment Simulation</p>
-</h3>
-
-<p align="center">
-    <a href="https://github.com/OpenBMB/AgentVerse/blob/main/LICENSE">
-        <img alt="License: Apache2" src="https://img.shields.io/badge/License-Apache_2.0-green.svg">
-    </a>
-    <a href="https://www.python.org/downloads/release/python-3916/">
-        <img alt="Python Version" src="https://img.shields.io/badge/python-3.9+-blue.svg">
-    </a>
-    <a href="https://github.com/OpenBMB/AgentVerse/actions/">
-        <img alt="Build" src="https://img.shields.io/github/actions/workflow/status/OpenBMB/AgentVerse/test.yml">
-    </a>
-    <a href="https://github.com/psf/black">
-        <img alt="Code Style: Black" src="https://img.shields.io/badge/code%20style-black-black">
-    </a>
-    <a href="https://github.com/OpenBMB/AgentVerse/issues">
-        <img alt="Contributions: Welcome" src="https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat">
-    </a>
-    
-</p>
-
-<p align="center">
-<img src="./imgs/title.png" width="512">
-</p>
-
-<p align="center">
-    【English | <a href="README_zh.md">Chinese</a>】
-</p>
-
-**AgentVerse** offers a versatile framework that streamlines the process of creating custom multi-agent environments for large language models (LLMs). Designed to facilitate swift development and customization with minimal effort, our framework empowers researchers to concentrate on their research, rather than being bogged down by implementation details.
-
-⚠️⚠️⚠️ We're refactoring the code, and the goal is to provide a flexibility to construct simulation(without a predefined goal) and task-solving(with a specific goal) environments. Please note that this README is slightly outdated, we will update it soon. If you require a stable version that exclusively supports simulation environments, you can use [`release-0.1`](https://github.com/OpenBMB/AgentVerse/tree/release-0.1) branch.
-
----
-
-## ✨ Features
-
-- 🥳 **Efficient Environment Building:** Our framework provides a collection of essential building blocks for effortlessly creating a multi-agent environment. With only a few lines in a configuration file, you can easily construct basic environments such as a chat room for LLMs. This process entails defining the environment's settings and prompts for LLMs, enabling researchers like you to concentrate on experimentation and analysis.
-
-- ⚙️ **Customizable Components**: AgentVerse simplifies the multi-agent environment by dividing it into five functional modules and defining their respective interfaces. For complex environments that cannot be constructed directly using the basic modules offered in AgentVerse, you can customize one or more of the interfaces within these five functional modules to efficiently create your own multi-agent environment according to your requirements.
-
-- 🛠 **Tools (Plugins) Utilization**: AgentVerse supports the multi-agent environments with tools. Currently, AgentVerse supports tools provided in [BMTools](https://github.com/OpenBMB/BMTools). 
-
-## 📰 What's New
-- [2023/10/5] 💡 We release the code of our paper [AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors in Agents](https://arxiv.org/abs/2308.10848), and refactor our codebase to enable the creation of both simulation and task-solving environment! We have placed the code for Minecraft example in the paper at the [`minecraft`](https://github.com/OpenBMB/AgentVerse/tree/minecraft) branch. Our tool-using example will soon be updated to the `main` branch. Stay tuned!
-
-- [2023/8/22] 📝 We're excited to share our work-in-progress paper [AgentVerse: Facilitating Multi-Agent Collaboration and Exploring Emergent Behaviors in Agents](https://arxiv.org/abs/2308.10848) related to this repository.
-<p align="center">
-<img width="616" alt="Screen Shot 2023-09-01 at 12 08 57 PM" src="https://github.com/OpenBMB/AgentVerse/assets/11704492/6db1c907-b7fc-42f9-946c-89853a28f386">
-</p>
-
-- [2023/6/5] 🎉 We are thrilled to present an array of [demos](#-simple-demo-video), including [NLP Classroom](#nlp-classroom), [Prisoner Dilemma](#prisoner-dilemma), [Software Design](#software-design), [Database Administrator](#database-administrator-dba), and a simple [H5 Pokemon Game](#pokemon) that enables the interaction with the characters in Pokemon! Try out these demos and have fun!
-- [2023/5/1] 🚀 [AgentVerse](https://github.com/OpenBMB/AgentVerse) is officially launched!
-
-## 🌟 Join Us!
-AgentVerse is on a mission to revolutionize the multi-agent environment for large language models, and we're eagerly looking for passionate collaborators to join us on this exciting journey.
-### How Can You Contribute?
-- **Code Development**: If you're an engineer, help us refine, optimize, and expand the current framework. We're always looking for talented developers to enhance our existing features and develop new modules.
-
-- **Documentation and Tutorials**: If you have a knack for writing, help us improve our documentation, create tutorials, or write blog posts to make AgentVerse more accessible to the broader community.
-
-- **Application Exploration**: If you're intrigued by multi-agent applications and are eager to experiment using AgentVerse, we'd be thrilled to support your journey and see what you create!
-
-- **Feedback and Suggestions**: Use AgentVerse and provide us with feedback. Your insights can lead to potential improvements and ensure that our framework remains top-notch.
-
-Also, if you're passionate about advancing the frontiers of multi-agent environments and are eager to dive deeper into research, we invite you to join our team at THUNLP. To explore this exciting opportunity and embark on a collaborative journey with us, please reach out to [[email protected]]([email protected]) and [[email protected]]([email protected]) and express your interest. We're keen to welcome motivated individuals like you to our lab!
-
-👉Also, check our Discord: https://discord.gg/cnutfCtC.
-
-## 🗓 Coming Soon
-- [x] Code release of our [paper](https://arxiv.org/abs/2308.10848)
-- [ ] Add documentation
-- [ ] Support more sophisticated memory for conversation history
-- [ ] Add support for local LLM
-
-
-## 👾 Simple Demo Video
-
-We demonstrate the following cases that are expertly crafted by AgentVerse.
-<!--
-### [![Demo video](https://i.imgur.com/vKb2F1B.png)](https://youtu.be/9JCVfzMFhaM)
--->
-<!--![image](imgs/multiagent-min.gif)-->
-
-<!-- - **NLP Classroom**: -->
-
-#### NLP Classroom
-In the NLP class, the professor and students engage in interactive communication. When students have a question, they raise their hands and patiently wait for the professor to call on them. Only after being called on by the professor, can students speak and ask their questions.
-
-Use the following command to launch the NLP Classroom example:
-```bash
-python agentverse_command/main_simulation_gui.py --task simulation/nlp_classroom_9players
-```
-
-[Wacth the NLP Classroom Video](https://github.com/OpenBMB/AgentVerse/assets/11704492/6ea07850-595e-4a28-a82e-f863011353c2)
-
-
-#### Prisoner Dilemma
-A prisoner's Dilemma is a thought experiment that challenges two completely rational agents to a dilemma: they can cooperate with their partner for mutual benefit or betray their partner ("defect") for individual reward.
-
-Use the following command to launch the Prisoner Dilemma example:
-```bash
-python agentverse_command/main_simulation_gui.py --task simulation/prisoner_dilemma
-```
-
-[Wacth the Prisoner's Dilemma Video](https://github.com/OpenBMB/AgentVerse/assets/11704492/017c46e5-c738-4fca-9352-b008e2d518bd)
-
-
-#### Software Design
-In the Software Design example, a code writer, a code tester and a code reviewer collaborate on the code generation problem. Given a problem, the code writer first composes the code implementation. The code tester runs the unit tests and provides the feedback. The code viewer then generates a review. After collecting the test feedback and review, the code writer iteratively refines the code.
-
-Use the following command to launch the Software Design example:
-```bash
-python agentverse_command/main_simulation_gui.py --task simulation/sde_team/sde_team_2players
-```
-
-[Wacth the Software Design Video](https://github.com/OpenBMB/AgentVerse/assets/11704492/5058066a-abee-490d-8659-b4e54661626a)
-
-
-#### [Database Administrator (DBA)](https://github.com/TsinghuaDatabaseGroup/DB-GPT)
-
-In the database diagnosis scenario, the Chief DBA monitors the system anomalies (e.g., slow queries, locks, crash down). If detected, the domain experts are alerted to analyze root causes, share insights, and suggest optimization solutions together. The Chief DBA then provides a summarized report to the user.
-
-```bash
-python agentverse_command/main_simulation_gui.py --task simulation/db_diag
-```
-
-[Wacth the DBA Video](https://github.com/OpenBMB/AgentVerse/assets/11704492/c633419d-afbb-47d4-bb12-6bb512e7af3a)
-
-#### [Text Evaluation (ChatEval)](https://github.com/chanchimin/ChatEval)
-In the context of the text evaluation scenario, we recommend users explore the [ChatEval](https://github.com/chanchimin/ChatEval) repo. They've implemented a multi-agent referee team on AgentVerse to assess the quality of text generated by different models. When given two distinct pieces of text, roles within ChatEval can autonomously debate the nuances and disparities, drawing upon their assigned personas, and subsequently provide their judgments. Experiments indicate that their referee team, enriched with diverse roles specified in [config.yaml](#2-configuring-the-agents), aligns more closely with human evaluations. This demo is built upon the [Fastchat](https://github.com/lm-sys/FastChat) repo, and we'd like to express our appreciation for their foundational work.
-
-
-[Wacth the ChatEval Video](https://github.com/OpenBMB/AgentVerse/assets/75533759/58f33468-f15b-4bac-ae01-8d0780019f85)
-
-#### Pokemon
-**Currently available only in [`release-0.1`](https://github.com/OpenBMB/AgentVerse/tree/release-0.1)**. In the game, agents can walk around the game world, and interact with one another. As a player, you take on the role of an agent and can engage with others at any time. There are 6 characters in the Pokémon environment who appeared in Pokemon Emerald: [May](https://bulbapedia.bulbagarden.net/wiki/May_(game)), [Professor Birch](https://bulbapedia.bulbagarden.net/wiki/Professor_Birch), [Steven Stone](https://bulbapedia.bulbagarden.net/wiki/Steven_Stone), [Maxie](https://bulbapedia.bulbagarden.net/wiki/Maxie), [Archie](https://bulbapedia.bulbagarden.net/wiki/Archie) and [Joseph](https://bulbapedia.bulbagarden.net/wiki/Mr._Stone). 
-
-To launch the Pokemon game, first launch a local server with the following command:
-```bash
-uvicorn pokemon_server:app --reload --port 10002
-```
-Then open another terminal in the project's root path and run the following command:
-```bash
-cd ui
-# If you do not have npm installed, you need to install it before running the following commands 
-# https://docs.npmjs.com/downloading-and-installing-node-js-and-npm
-# We have tested on [email protected], [email protected]
-npm install
-npm run watch
-```
-Wait for the compilation to complete, and have fun! (WASD for moving around, and SPACE for launching a conversation.)
-
-[Wacth the Pokemon Video](https://github.com/OpenBMB/AgentVerse/assets/11704492/4d07da68-f942-4205-b558-f155e95782e7)
-
-
-
-## Contents
-
-- [✨ Features](#-features)
-- [📰 What's New](#-whats-new)
-- [🌟 Join Us!](#-join-us)
-  - [How Can You Contribute?](#how-can-you-contribute)
-- [🗓 Coming Soon](#-coming-soon)
-- [👾 Simple Demo Video](#-simple-demo-video)
-    - [NLP Classroom](#nlp-classroom)
-    - [Prisoner Dilemma](#prisoner-dilemma)
-    - [Software Design](#software-design)
-    - [Database Administrator (DBA)](#database-administrator-dba)
-    - [Text Evaluation (ChatEval)](#text-evaluation-chateval)
-    - [Pokemon](#pokemon)
-- [Contents](#contents)
-- [🚀 Getting Started](#-getting-started)
-  - [Installation](#installation)
-  - [Simulation CLI Example](#simulation-cli-example)
-  - [Simulation Local Website Demo](#simulation-local-website-demo)
-  - [Task-Solving CLI Example](#task-solving-cli-example)
-- [💡 Philosophy](#-philosophy)
-  - [Environment](#environment)
-  - [Agent](#agent)
-- [✍️ Customize Your Own Environment](#️-customize-your-own-environment)
-  - [A Simple Example: Building a Classroom Environment](#a-simple-example-building-a-classroom-environment)
-      - [1. Creating a Task Directory and Configuring the Environment](#1-creating-a-task-directory-and-configuring-the-environment)
-      - [2. Configuring the Agents](#2-configuring-the-agents)
-      - [3. Writing an Output Parser](#3-writing-an-output-parser)
-  - [Customization Guide for More Complex Environments](#customization-guide-for-more-complex-environments)
-- [🔎 Examples](#-examples)
-- [Star History](#star-history)
-- [Citation](#citation)
-- [Contact](#contact)
-
-
-
-## 🚀 Getting Started
-
-### Installation
-
-```bash
-pip install -U agentverse
-```
-Or you can install the package by manually cloning the latest repository
-```bash
-git clone https://github.com/OpenBMB/AgentVerse.git --depth 1
-cd AgentVerse
-pip install -r requirements.txt
-```
-Some users have reported problems installing the `orjson` required by `gradio`. One simple workaround is to install it with Anaconda `conda install -c conda-forge orjson`.
-
-You also need to export your OpenAI API key as follows：
-```bash
-# Export your OpenAI API key
-export OPENAI_API_KEY="your_api_key_here"
-# Or if you are using Azure
-export AZURE_OPENAI_API_KEY="your_api_key_here"
-export AZURE_OPENAI_API_BASE="your_api_base_here"
-```
-
-If you want use Azure OpenAI services, pleas export your Azure OpenAI key and OpenAI API base as follows：
-```bash
-export AZURE_OPENAI_API_KEY="your_api_key_here"
-export AZURE_OPENAI_API_BASE="your_api_base_here"
-```
-
-If you want to use the tools provided by BMTools, you need to install BMTools as follows:
-```bash
-git clone git+https://github.com/OpenBMB/BMTools.git
-cd BMTools
-pip install -r requirements.txt
-python setup.py develop
-```
-
-
-<!--
-# Install BMTools
-cd ../
-git clone [email protected]:OpenBMB/BMTools.git
-cd BMTools
-python setup.py develop
--->
-
-### Simulation CLI Example
-
-You can create a multi-agent environments provided by us. Using the classroom scenario as an example. In this scenario, there are nine agents, one playing the role of a professor and the other eight as students.
-
-```shell
-python3 agentverse_command/main_simulation_cli.py --task simulation/nlp_classroom_9players
-# or if you have installed AgentVerse via pip
-agentverse-simulation --task simulation/nlp_classroom_9players
-```
-
-### Simulation Local Website Demo
-
-We also provide a local website demo for this environment. You can launch it with
-
-```shell
-python3 agentverse_command/main_simulation_gui.py --task simulation/nlp_classroom_9players
-# or if you have installed AgentVerse via pip
-agentverse-simulation-gui --task simulation/nlp_classroom_9players
-```
-After successfully launching the local server, you can visit [http://127.0.0.1:7860/](http://127.0.0.1:7860/) to view the classroom environment.
-
-### Task-Solving CLI Example
-
-To run the experiments with the task-solving environment proposed in our [paper](https://arxiv.org/abs/2308.10848), you can use the following command:
-
-```shell
-# Run the Humaneval benchmark using gpt-3.5-turbo
-python3 agentverse_command/main_tasksolving_cli.py --task tasksolving/humaneval/gpt-3.5 --dataset_path data/humaneval/test.jsonl --overwrite
-# or if you have installed AgentVerse via pip
-agentverse-tasksolving --task tasksolving/humaneval/gpt-3.5 --dataset_path data/humaneval/test.jsonl --overwrite
-```
-
-You can take a look at `agentverse/tasks/tasksolving` for more experiments we have done in our paper.
-
-
-## 💡 Philosophy
-
-### Environment
-
-At the core of our framework is the environment, which plays a crucial role in enabling researchers to study the behavior of agents under different conditions. We believe that the environment should be flexible and extensible, allowing researchers to easily customize it to fit their needs. To achieve this, we have abstracted the environment into five rule components, and implementing different environments is actually implementing different rules:
-
-- **Describer**: This component provides a description of the environment at each turn for each agent. You can customize the describer to define the specific requirements of their environment, such as the agents with whom an agent can interact.
-- **Order**: This component defines the order in which agents take actions within the environment. You can customize the order to reflect the desired interaction between agents. We provide several basic order options, including `random`, `sequential`, and `concurrent` (in which all agents take an action in each turn).
-- **Selector**: This component selects the valid messages generated by agents. Sometimes agents may generate invalid responses, and the selector is used to filter out unexpected results.
-- **Updater**: This component updates the memory of each agent. In certain cases, the response generated by one agent should not be seen by all agents (e.g., if agents are in different rooms). For each response, the updater updates only the agents who can see it.
-- **Visibility**: This component maintains the list of agents that each agent can see throughout the environment's changes. For example, when an agent moves from one room to another, the list of visible agents of each agent should be updated by `visibility`.
-
-By abstracting the environment into these five components, we have created a highly flexible and extensible framework that enables researchers to easily build and customize their own multi-agent environments.
-
-### Agent
-
-Another fundamental component is the agent. Currently we provide two types of agents: **ConversationAgent** and **ToolAgent**. You can also customize your own agent by inheriting BaseAgent class (tutorial coming soon).
-
-## ✍️ Customize Your Own Environment
-
-We have provided several examples in the `agentverse/tasks` directory. To customize your environment, you should
-
-1. Create a task directory in `agentverse/tasks` 
-2. Write the configuration file
-3. Write the output parser that parses the response of your agents.
-4. Add your parser in `agentverse/tasks/__init__.py`
-
-We will use a simple example in `agentverse/tasks/nlp_classroom_3players` to illustrate the procedure.
-
-### A Simple Example: Building a Classroom Environment
-
-To illustrate how to customize your environment, we'll use a simple example of building a classroom environment where one agent is the professor, one is the student, and one is the teaching assistant.
-
-##### 1. Creating a Task Directory and Configuring the Environment
-
-First, we need to create a task directory and write our configuration file for the environment. In the `agentverse/tasks` directory, create a new directory called `nlp_classroom_3players`. Inside this directory, create a `config.yaml` file and write the following configuration:
-
-```yaml
-# config.yaml
-environment:
-  env_type: basic				# Use the basic environment provided in AgentVerse
-  max_turns: 10					# Specify the maximum number of dialogue turns
-  rule:
-    order:
-      type: sequential	# Use the sequential order
-    visibility:
-      type: all					# Each message can be seen by all agents
-    selector:
-      type: basic				# Basic selector (do not select)
-    updater:
-      type: basic				# Basic updater (update the message to all agents)
-    describer:
-      type: basic				# Basic describer (no description)
-```
-
-This configuration specifies that we will use the basic environment provided in AgentVerse, with a maximum of 10 dialogue turns. We'll use the sequential order, with all messages visible to all agents. We won't be using any selectors, our updater will update the messages to all the agents and our describer will provide no description.
-
-##### 2. Configuring the Agents
-
-Next, we'll configure the agents. In the `config.yaml` file, we'll add the configuration for each agent. Here's an example configuration for the professor:
-
-```yaml
-# config.yaml
-agents:
-  -
-    agent_type: conversation
-    name: Professor Micheal		# Name of the agent
-    role_description: You are Prof. Micheal, ...	# Description of the agent
-    memory: 
-      memory_type: chat_history		# Will store all the chat history
-    prompt_template: *professor_prompt
-    llm:
-      llm_type: text-davinci-003    # Will use OpenAICompletion LLM
-      model: text-davinci-003       # The arguments passed to the api call
-      temperature: 0.7
-      max_tokens: 250
-```
-
-In this example, we'll use the `conversation` agent type. We've given the agent a name and a description, and we'll store the chat history in memory. We've also provided a prompt template with placeholders marked as ${placeholder}. These will be instantiated by the `_fill_prompt_template` method of the agent.
-
-##### 3. Writing an Output Parser
-
-The next step is to write a simple parser for your agent's response. Because you may have specified the output format in your prompt template, you need to provide a corresponding parser. In this example, we inform the model to output in the following format in our prompt template
-
-```
-Action: Speak
-Action Input: (the content)
-```
-
-We'll write a parser to extract the content from the agent's response. Refer to the code for more details. We've decorated our parser function with `@output_parser_registry.register('classroom_parser')` to register it with our framework. Finally, we import our parser in `agentverse/tasks/__init__.py`.
-
-With these steps, we've successfully built a simple classroom environment and customized it for our needs.
-
-### Customization Guide for More Complex Environments
-
-While we provide a basic framework for building environments with our five rule components, more complex environments may require further customization. A detailed documentation and tutorial is coming soon. Here we briefly introduce some steps you can take to customize your environment:
-
-1. **Customize the five rule components**. Each rule component has an interface, allowing you to customize its behavior to suit your specific needs. It's important to note that these components are not necessarily independent and can interact through the `rule_params` dictionary in the environment. You can create your own rule components and integrate them with the existing ones to build more complex interactions between agents.
-2. **Customize the environment itself**. Our `basic` environment provides a default execution order for the five rule components that is suitable for most cases, but you can inherit the `BaseEnvironment` class and write your own `run` method to implement a more sophisticated execution order.
-3. **Customize the agent**. Depending on your specific use case, you may also need to inherit the `BaseAgent` class. For example, you may want to use your local LLM as your agents or create agents with specialized knowledge or skills.
-
-
-
-## 🔎 Examples
-
-Currently, we offer some simple examples in the `agentverse/tasks` directory, each demonstrating different possibilities of our framework. While the performance of these examples may not be optimal due to limited prompt engineering, they are intended to showcase the capabilities of our framework, such as allowing the use of tools.
-
-Here's a brief overview of each example:
-
-1. `nlp_classroom_3players`: This example illustrates a simple case in which agents will speak in sequential order. 
-2. `nlp_classroom_9players`: This is an NLP class example. Here, students can raise their hand when they have a question, and the professor can call on the students to let them ask. Students are only allowed to speak after they are called on.
-3. `nlp_classroom_9players_group`: This example showcases group discussions. The professor may initiate a group discussion when needed, and students can exclusively interact with fellow students within the same group during the discussion.
-4. `nlp_classroom_3players_withtool`: Students in this classroom can use Bing search API when listening to the class.
-5. `math_problem_2players_tools`: A simple example demonstrating how two agents can use the WolframAlpha API to play an arithmetic game.
-6. `prisoner_dilema`: The Prisoner's Dilemma is a thought experiment involving two rational agents facing a choice between cooperating for mutual benefit or betraying their partner for individual gain.
-7. `db_diag`: The Chief DBA monitors (agents) the database system for anomalies and alerts memory and CPU agents if any are detected. They (agents) analyze root causes and suggest optimization solutions. The Chief DBA (agent) provides a diagnosis summary to the user, who can give instructions or evaluate the proposed solutions' effectiveness.
-8. `sde_team`: In the SDE team, code writer, code tester and code reviewer collaborate on the code generation problem. 
-9. `pokemon`:  This example intimates Pokemon game.
-
-
-## Star History
-
-[![Star History Chart](https://api.star-history.com/svg?repos=OpenBMB/AgentVerse&type=Date)](https://star-history.com/#OpenBMB/AgentVerse&Date)
-
-
-## Citation
-If you find this repo helpful, feel free to cite us.
-```
-@article{chen2023agentverse,
-  title={Agentverse: Facilitating multi-agent collaboration and exploring emergent behaviors in agents},
-  author={Chen, Weize and Su, Yusheng and Zuo, Jingwei and Yang, Cheng and Yuan, Chenfei and Qian, Chen and Chan, Chi-Min and Qin, Yujia and Lu, Yaxi and Xie, Ruobing and others},
-  journal={arXiv preprint arXiv:2308.10848},
-  year={2023}
-}
-```
-
-## Contact
-
-Weize Chen: [email protected]
-
-[Yusheng Su](https://yushengsu-thu.github.io/): [email protected]

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/colorinput/colorinput/methods/OpenColorPicker.js

@@ -1,53 +0,0 @@
-import CreateColorPicker from './CreateColorPicker.js';
-import DropDown from '../../../dropdown/DropDown.js';
-
-var OpenColorPicker = function () {
-    if (this.colorPicker) {
-        return;
-    }
-
-    // Layout it to get full height
-    var colorPicker = CreateColorPicker.call(this).layout();
-
-    var dropDownBehavior = new DropDown(colorPicker, {
-        // Transition
-        duration: {
-            in: this.colorPickerEaseInDuration,
-            out: this.colorPickerEaseOutDuration
-        },
-        transitIn: this.colorPickerTransitInCallback,
-        transitOut: this.colorPickerTransitOutCallback,
-
-        // Position
-        expandDirection: this.colorPickerExpandDirection,
-
-        alignTargetX: this,
-        alignTargetY: this,
-
-        bounds: this.colorPickerBounds,
-
-        // Close condition
-        touchOutsideClose: true,
-    })
-        .on('open', function () {
-            // After popping up
-            // Can click
-            colorPicker.on('valuechange', function (value) {
-                this.setValue(value);
-            }, this);
-        }, this)
-
-        .on('close', function () {
-            this.colorPicker = undefined;
-            this.dropDownBehavior = undefined;
-        }, this)
-
-    this.colorPicker = colorPicker;
-    this.dropDownBehavior = dropDownBehavior;
-
-    this.pin(colorPicker);
-
-    return this;
-}
-
-export default OpenColorPicker;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/sides/childbehaviors/Visible.js

@@ -1,21 +0,0 @@
-import IndexOf from '../../../../plugins/utils/object/IndexOf.js';
-import Container from '../../container/Container.js';
-
-const ContainerSetChildVisible = Container.prototype.setChildVisible;
-
-export default {
-    setChildVisible(child, visible) {
-        var key;
-        if (typeof (child) === 'string') {
-            var key = child;
-            child = this.sizerChildren[key];
-        } else {
-            key = IndexOf(this.sizerChildren, child);
-        }
-        if (visible === undefined) {
-            visible = (this.currentChildKey === key) ? true : false;
-        }
-        ContainerSetChildVisible.call(this, child, visible);
-        return this;
-    }
-}

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/optimization/tome.md

@@ -1,116 +0,0 @@
-<!--Copyright 2023 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.
--->
-
-# Token Merging
-
-Token Merging (introduced in [Token Merging: Your ViT But Faster](https://arxiv.org/abs/2210.09461)) works by merging the redundant tokens / patches progressively in the forward pass of a Transformer-based network. It can speed up the inference latency of the underlying network.
-
-After Token Merging (ToMe) was released, the authors released [Token Merging for Fast Stable Diffusion](https://arxiv.org/abs/2303.17604), which introduced a version of ToMe which is more compatible with Stable Diffusion. We can use ToMe to gracefully speed up the inference latency of a [`DiffusionPipeline`]. This doc discusses how to apply ToMe to the [`StableDiffusionPipeline`], the expected speedups, and the qualitative aspects of using ToMe on the [`StableDiffusionPipeline`]. 
-
-## Using ToMe
-
-The authors of ToMe released a convenient Python library called [`tomesd`](https://github.com/dbolya/tomesd) that lets us apply ToMe to a [`DiffusionPipeline`] like so:
-
-```diff
-from diffusers import StableDiffusionPipeline
-import tomesd
-
-pipeline = StableDiffusionPipeline.from_pretrained(
-      "runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16
-).to("cuda")
-+ tomesd.apply_patch(pipeline, ratio=0.5)
-
-image = pipeline("a photo of an astronaut riding a horse on mars").images[0]
-```
-
-And that’s it! 
-
-`tomesd.apply_patch()` exposes [a number of arguments](https://github.com/dbolya/tomesd#usage) to let us strike a balance between the pipeline inference speed and the quality of the generated tokens. Amongst those arguments, the most important one is `ratio`. `ratio` controls the number of tokens that will be merged during the forward pass. For more details on `tomesd`, please refer to the original repository https://github.com/dbolya/tomesd and [the paper](https://arxiv.org/abs/2303.17604). 
-
-## Benchmarking `tomesd` with `StableDiffusionPipeline`
-
-We benchmarked the impact of using `tomesd` on [`StableDiffusionPipeline`] along with [xformers](https://huggingface.co/docs/diffusers/optimization/xformers) across different image resolutions. We used A100 and V100 as our test GPU devices with the following development environment (with Python 3.8.5):
-
-```bash
-- `diffusers` version: 0.15.1
-- Python version: 3.8.16
-- PyTorch version (GPU?): 1.13.1+cu116 (True)
-- Huggingface_hub version: 0.13.2
-- Transformers version: 4.27.2
-- Accelerate version: 0.18.0
-- xFormers version: 0.0.16
-- tomesd version: 0.1.2
-```
-
-We used this script for benchmarking: [https://gist.github.com/sayakpaul/27aec6bca7eb7b0e0aa4112205850335](https://gist.github.com/sayakpaul/27aec6bca7eb7b0e0aa4112205850335). Following are our findings: 
-
-### A100
-
-| Resolution | Batch size | Vanilla | ToMe | ToMe + xFormers | ToMe speedup (%) | ToMe + xFormers speedup (%) |
-| --- | --- | --- | --- | --- | --- | --- |
-| 512 | 10 | 6.88 | 5.26 | 4.69 | 23.54651163 | 31.83139535 |
-|  |  |  |  |  |  |  |
-| 768 | 10 | OOM | 14.71 | 11 |  |  |
-|  | 8 | OOM | 11.56 | 8.84 |  |  |
-|  | 4 | OOM | 5.98 | 4.66 |  |  |
-|  | 2 | 4.99 | 3.24 | 3.1 | 35.07014028 | 37.8757515 |
-|  | 1 | 3.29 | 2.24 | 2.03 | 31.91489362 | 38.29787234 |
-|  |  |  |  |  |  |  |
-| 1024 | 10 | OOM | OOM | OOM |  |  |
-|  | 8 | OOM | OOM | OOM |  |  |
-|  | 4 | OOM | 12.51 | 9.09 |  |  |
-|  | 2 | OOM | 6.52 | 4.96 |  |  |
-|  | 1 | 6.4 | 3.61 | 2.81 | 43.59375 | 56.09375 |
-
-***The timings reported here are in seconds. Speedups are calculated over the `Vanilla` timings.*** 
-
-### V100
-
-| Resolution | Batch size | Vanilla | ToMe | ToMe + xFormers | ToMe speedup (%) | ToMe + xFormers speedup (%) |
-| --- | --- | --- | --- | --- | --- | --- |
-| 512 | 10 | OOM | 10.03 | 9.29 |  |  |
-|  | 8 | OOM | 8.05 | 7.47 |  |  |
-|  | 4 | 5.7 | 4.3 | 3.98 | 24.56140351 | 30.1754386 |
-|  | 2 | 3.14 | 2.43 | 2.27 | 22.61146497 | 27.70700637 |
-|  | 1 | 1.88 | 1.57 | 1.57 | 16.4893617 | 16.4893617 |
-|  |  |  |  |  |  |  |
-| 768 | 10 | OOM | OOM | 23.67 |  |  |
-|  | 8 | OOM | OOM | 18.81 |  |  |
-|  | 4 | OOM | 11.81 | 9.7 |  |  |
-|  | 2 | OOM | 6.27 | 5.2 |  |  |
-|  | 1 | 5.43 | 3.38 | 2.82 | 37.75322284 | 48.06629834 |
-|  |  |  |  |  |  |  |
-| 1024 | 10 | OOM | OOM | OOM |  |  |
-|  | 8 | OOM | OOM | OOM |  |  |
-|  | 4 | OOM | OOM | 19.35 |  |  |
-|  | 2 | OOM | 13 | 10.78 |  |  |
-|  | 1 | OOM | 6.66 | 5.54 |  |  |
-
-As seen in the tables above, the speedup with `tomesd` becomes more pronounced for larger image resolutions. It is also interesting to note that with `tomesd`, it becomes possible to run the pipeline on a higher resolution, like 1024x1024. 
-
-It might be possible to speed up inference even further with [`torch.compile()`](https://huggingface.co/docs/diffusers/optimization/torch2.0). 
-
-## Quality
-
-As reported in [the paper](https://arxiv.org/abs/2303.17604), ToMe can preserve the quality of the generated images to a great extent while speeding up inference. By increasing the `ratio`, it is possible to further speed up inference, but that might come at the cost of a deterioration in the image quality. 
-
-To test the quality of the generated samples using our setup, we sampled a few prompts from the “Parti Prompts” (introduced in [Parti](https://parti.research.google/)) and performed inference with the [`StableDiffusionPipeline`] in the following settings:
-
-- Vanilla [`StableDiffusionPipeline`]
-- [`StableDiffusionPipeline`] + ToMe
-- [`StableDiffusionPipeline`] + ToMe + xformers
-
-We didn’t notice any significant decrease in the quality of the generated samples. Here are samples: 
-
-![tome-samples](https://huggingface.co/datasets/diffusers/docs-images/resolve/main/tome/tome_samples.png)
-
-You can check out the generated samples [here](https://wandb.ai/sayakpaul/tomesd-results/runs/23j4bj3i?workspace=). We used [this script](https://gist.github.com/sayakpaul/8cac98d7f22399085a060992f411ecbd) for conducting this experiment.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/ko/optimization/onnx.md

@@ -1,65 +0,0 @@
-<!--Copyright 2023 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.
--->
-
-
-# 추론을 위해 ONNX 런타임을 사용하는 방법
-
-🤗 Diffusers는 ONNX Runtime과 호환되는 Stable Diffusion 파이프라인을 제공합니다. 이를 통해 ONNX(CPU 포함)를 지원하고 PyTorch의 가속 버전을 사용할 수 없는 모든 하드웨어에서 Stable Diffusion을 실행할 수 있습니다.
-
-## 설치
-
-다음 명령어로 ONNX Runtime를 지원하는 🤗 Optimum를 설치합니다:
-
-```
-pip install optimum["onnxruntime"]
-```
-
-## Stable Diffusion 추론
-
-아래 코드는 ONNX 런타임을 사용하는 방법을 보여줍니다. `StableDiffusionPipeline` 대신 `OnnxStableDiffusionPipeline`을 사용해야 합니다. 
-PyTorch 모델을 불러오고 즉시 ONNX 형식으로 변환하려는 경우 `export=True`로 설정합니다.
-
-```python
-from optimum.onnxruntime import ORTStableDiffusionPipeline
-
-model_id = "runwayml/stable-diffusion-v1-5"
-pipe = ORTStableDiffusionPipeline.from_pretrained(model_id, export=True)
-prompt = "a photo of an astronaut riding a horse on mars"
-images = pipe(prompt).images[0]
-pipe.save_pretrained("./onnx-stable-diffusion-v1-5")
-```
-
-파이프라인을 ONNX 형식으로 오프라인으로 내보내고 나중에 추론에 사용하려는 경우, 
-[`optimum-cli export`](https://huggingface.co/docs/optimum/main/en/exporters/onnx/usage_guides/export_a_model#exporting-a-model-to-onnx-using-the-cli) 명령어를 사용할 수 있습니다:
-
-```bash
-optimum-cli export onnx --model runwayml/stable-diffusion-v1-5 sd_v15_onnx/
-```
-
-그 다음 추론을 수행합니다:
-
-```python 
-from optimum.onnxruntime import ORTStableDiffusionPipeline
-
-model_id = "sd_v15_onnx"
-pipe = ORTStableDiffusionPipeline.from_pretrained(model_id)
-prompt = "a photo of an astronaut riding a horse on mars"
-images = pipe(prompt).images[0]
-```
-
-Notice that we didn't have to specify `export=True` above.
-
-[Optimum 문서](https://huggingface.co/docs/optimum/)에서 더 많은 예시를 찾을 수 있습니다.
-
-## 알려진 이슈들
-
-- 여러 프롬프트를 배치로 생성하면 너무 많은 메모리가 사용되는 것 같습니다. 이를 조사하는 동안, 배치 대신 반복 방법이 필요할 수도 있습니다.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/utils/outputs.py

@@ -1,108 +0,0 @@
-# Copyright 2023 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.
-"""
-Generic utilities
-"""
-
-from collections import OrderedDict
-from dataclasses import fields
-from typing import Any, Tuple
-
-import numpy as np
-
-from .import_utils import is_torch_available
-
-
-def is_tensor(x):
-    """
-    Tests if `x` is a `torch.Tensor` or `np.ndarray`.
-    """
-    if is_torch_available():
-        import torch
-
-        if isinstance(x, torch.Tensor):
-            return True
-
-    return isinstance(x, np.ndarray)
-
-
-class BaseOutput(OrderedDict):
-    """
-    Base class for all model outputs as dataclass. Has a `__getitem__` that allows indexing by integer or slice (like a
-    tuple) or strings (like a dictionary) that will ignore the `None` attributes. Otherwise behaves like a regular
-    Python dictionary.
-
-    <Tip warning={true}>
-
-    You can't unpack a [`BaseOutput`] directly. Use the [`~utils.BaseOutput.to_tuple`] method to convert it to a tuple
-    first.
-
-    </Tip>
-    """
-
-    def __post_init__(self):
-        class_fields = fields(self)
-
-        # Safety and consistency checks
-        if not len(class_fields):
-            raise ValueError(f"{self.__class__.__name__} has no fields.")
-
-        first_field = getattr(self, class_fields[0].name)
-        other_fields_are_none = all(getattr(self, field.name) is None for field in class_fields[1:])
-
-        if other_fields_are_none and isinstance(first_field, dict):
-            for key, value in first_field.items():
-                self[key] = value
-        else:
-            for field in class_fields:
-                v = getattr(self, field.name)
-                if v is not None:
-                    self[field.name] = v
-
-    def __delitem__(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.")
-
-    def setdefault(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``setdefault`` on a {self.__class__.__name__} instance.")
-
-    def pop(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``pop`` on a {self.__class__.__name__} instance.")
-
-    def update(self, *args, **kwargs):
-        raise Exception(f"You cannot use ``update`` on a {self.__class__.__name__} instance.")
-
-    def __getitem__(self, k):
-        if isinstance(k, str):
-            inner_dict = dict(self.items())
-            return inner_dict[k]
-        else:
-            return self.to_tuple()[k]
-
-    def __setattr__(self, name, value):
-        if name in self.keys() and value is not None:
-            # Don't call self.__setitem__ to avoid recursion errors
-            super().__setitem__(name, value)
-        super().__setattr__(name, value)
-
-    def __setitem__(self, key, value):
-        # Will raise a KeyException if needed
-        super().__setitem__(key, value)
-        # Don't call self.__setattr__ to avoid recursion errors
-        super().__setattr__(key, value)
-
-    def to_tuple(self) -> Tuple[Any]:
-        """
-        Convert self to a tuple containing all the attributes/keys that are not `None`.
-        """
-        return tuple(self[k] for k in self.keys())

spaces/Andy1621/uniformer_image_detection/configs/fcos/fcos_r50_caffe_fpn_gn-head_4x4_1x_coco.py

@@ -1,4 +0,0 @@
-# TODO: Remove this config after benchmarking all related configs
-_base_ = 'fcos_r50_caffe_fpn_gn-head_1x_coco.py'
-
-data = dict(samples_per_gpu=4, workers_per_gpu=4)

spaces/AquaSuisei/ChatGPTXE/chatgpt - macOS.command

@@ -1,7 +0,0 @@
-#!/bin/bash
-echo Opening ChuanhuChatGPT...
-cd "$(dirname "${BASH_SOURCE[0]}")"
-nohup python3 ChuanhuChatbot.py >/dev/null 2>&1 &
-sleep 5
-open http://127.0.0.1:7860
-echo Finished opening ChuanhuChatGPT (http://127.0.0.1:7860/). If you kill ChuanhuChatbot, Use "pkill -f 'ChuanhuChatbot'" command in terminal.

spaces/ArcanAlt/arcanDream/Dockerfile

@@ -1,11 +0,0 @@
-FROM node:18
-
-WORKDIR /app
-
-RUN npm install express express-http-proxy
-
-COPY . .
-
-EXPOSE 7860
-
-CMD [ "node", "server.js" ]

spaces/Big-Web/MMSD/env/Lib/site-packages/dateutil/zoneinfo/__init__.py

@@ -1,167 +0,0 @@
-# -*- coding: utf-8 -*-
-import warnings
-import json
-
-from tarfile import TarFile
-from pkgutil import get_data
-from io import BytesIO
-
-from dateutil.tz import tzfile as _tzfile
-
-__all__ = ["get_zonefile_instance", "gettz", "gettz_db_metadata"]
-
-ZONEFILENAME = "dateutil-zoneinfo.tar.gz"
-METADATA_FN = 'METADATA'
-
-
-class tzfile(_tzfile):
-    def __reduce__(self):
-        return (gettz, (self._filename,))
-
-
-def getzoneinfofile_stream():
-    try:
-        return BytesIO(get_data(__name__, ZONEFILENAME))
-    except IOError as e:  # TODO  switch to FileNotFoundError?
-        warnings.warn("I/O error({0}): {1}".format(e.errno, e.strerror))
-        return None
-
-
-class ZoneInfoFile(object):
-    def __init__(self, zonefile_stream=None):
-        if zonefile_stream is not None:
-            with TarFile.open(fileobj=zonefile_stream) as tf:
-                self.zones = {zf.name: tzfile(tf.extractfile(zf), filename=zf.name)
-                              for zf in tf.getmembers()
-                              if zf.isfile() and zf.name != METADATA_FN}
-                # deal with links: They'll point to their parent object. Less
-                # waste of memory
-                links = {zl.name: self.zones[zl.linkname]
-                         for zl in tf.getmembers() if
-                         zl.islnk() or zl.issym()}
-                self.zones.update(links)
-                try:
-                    metadata_json = tf.extractfile(tf.getmember(METADATA_FN))
-                    metadata_str = metadata_json.read().decode('UTF-8')
-                    self.metadata = json.loads(metadata_str)
-                except KeyError:
-                    # no metadata in tar file
-                    self.metadata = None
-        else:
-            self.zones = {}
-            self.metadata = None
-
-    def get(self, name, default=None):
-        """
-        Wrapper for :func:`ZoneInfoFile.zones.get`. This is a convenience method
-        for retrieving zones from the zone dictionary.
-
-        :param name:
-            The name of the zone to retrieve. (Generally IANA zone names)
-
-        :param default:
-            The value to return in the event of a missing key.
-
-        .. versionadded:: 2.6.0
-
-        """
-        return self.zones.get(name, default)
-
-
-# The current API has gettz as a module function, although in fact it taps into
-# a stateful class. So as a workaround for now, without changing the API, we
-# will create a new "global" class instance the first time a user requests a
-# timezone. Ugly, but adheres to the api.
-#
-# TODO: Remove after deprecation period.
-_CLASS_ZONE_INSTANCE = []
-
-
-def get_zonefile_instance(new_instance=False):
-    """
-    This is a convenience function which provides a :class:`ZoneInfoFile`
-    instance using the data provided by the ``dateutil`` package. By default, it
-    caches a single instance of the ZoneInfoFile object and returns that.
-
-    :param new_instance:
-        If ``True``, a new instance of :class:`ZoneInfoFile` is instantiated and
-        used as the cached instance for the next call. Otherwise, new instances
-        are created only as necessary.
-
-    :return:
-        Returns a :class:`ZoneInfoFile` object.
-
-    .. versionadded:: 2.6
-    """
-    if new_instance:
-        zif = None
-    else:
-        zif = getattr(get_zonefile_instance, '_cached_instance', None)
-
-    if zif is None:
-        zif = ZoneInfoFile(getzoneinfofile_stream())
-
-        get_zonefile_instance._cached_instance = zif
-
-    return zif
-
-
-def gettz(name):
-    """
-    This retrieves a time zone from the local zoneinfo tarball that is packaged
-    with dateutil.
-
-    :param name:
-        An IANA-style time zone name, as found in the zoneinfo file.
-
-    :return:
-        Returns a :class:`dateutil.tz.tzfile` time zone object.
-
-    .. warning::
-        It is generally inadvisable to use this function, and it is only
-        provided for API compatibility with earlier versions. This is *not*
-        equivalent to ``dateutil.tz.gettz()``, which selects an appropriate
-        time zone based on the inputs, favoring system zoneinfo. This is ONLY
-        for accessing the dateutil-specific zoneinfo (which may be out of
-        date compared to the system zoneinfo).
-
-    .. deprecated:: 2.6
-        If you need to use a specific zoneinfofile over the system zoneinfo,
-        instantiate a :class:`dateutil.zoneinfo.ZoneInfoFile` object and call
-        :func:`dateutil.zoneinfo.ZoneInfoFile.get(name)` instead.
-
-        Use :func:`get_zonefile_instance` to retrieve an instance of the
-        dateutil-provided zoneinfo.
-    """
-    warnings.warn("zoneinfo.gettz() will be removed in future versions, "
-                  "to use the dateutil-provided zoneinfo files, instantiate a "
-                  "ZoneInfoFile object and use ZoneInfoFile.zones.get() "
-                  "instead. See the documentation for details.",
-                  DeprecationWarning)
-
-    if len(_CLASS_ZONE_INSTANCE) == 0:
-        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
-    return _CLASS_ZONE_INSTANCE[0].zones.get(name)
-
-
-def gettz_db_metadata():
-    """ Get the zonefile metadata
-
-    See `zonefile_metadata`_
-
-    :returns:
-        A dictionary with the database metadata
-
-    .. deprecated:: 2.6
-        See deprecation warning in :func:`zoneinfo.gettz`. To get metadata,
-        query the attribute ``zoneinfo.ZoneInfoFile.metadata``.
-    """
-    warnings.warn("zoneinfo.gettz_db_metadata() will be removed in future "
-                  "versions, to use the dateutil-provided zoneinfo files, "
-                  "ZoneInfoFile object and query the 'metadata' attribute "
-                  "instead. See the documentation for details.",
-                  DeprecationWarning)
-
-    if len(_CLASS_ZONE_INSTANCE) == 0:
-        _CLASS_ZONE_INSTANCE.append(ZoneInfoFile(getzoneinfofile_stream()))
-    return _CLASS_ZONE_INSTANCE[0].metadata

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/command/setopt.py

@@ -1,149 +0,0 @@
-from distutils.util import convert_path
-from distutils import log
-from distutils.errors import DistutilsOptionError
-import distutils
-import os
-import configparser
-
-from setuptools import Command
-
-__all__ = ['config_file', 'edit_config', 'option_base', 'setopt']
-
-
-def config_file(kind="local"):
-    """Get the filename of the distutils, local, global, or per-user config
-
-    `kind` must be one of "local", "global", or "user"
-    """
-    if kind == 'local':
-        return 'setup.cfg'
-    if kind == 'global':
-        return os.path.join(
-            os.path.dirname(distutils.__file__), 'distutils.cfg'
-        )
-    if kind == 'user':
-        dot = os.name == 'posix' and '.' or ''
-        return os.path.expanduser(convert_path("~/%spydistutils.cfg" % dot))
-    raise ValueError(
-        "config_file() type must be 'local', 'global', or 'user'", kind
-    )
-
-
-def edit_config(filename, settings, dry_run=False):
-    """Edit a configuration file to include `settings`
-
-    `settings` is a dictionary of dictionaries or ``None`` values, keyed by
-    command/section name.  A ``None`` value means to delete the entire section,
-    while a dictionary lists settings to be changed or deleted in that section.
-    A setting of ``None`` means to delete that setting.
-    """
-    log.debug("Reading configuration from %s", filename)
-    opts = configparser.RawConfigParser()
-    opts.optionxform = lambda x: x
-    opts.read([filename])
-    for section, options in settings.items():
-        if options is None:
-            log.info("Deleting section [%s] from %s", section, filename)
-            opts.remove_section(section)
-        else:
-            if not opts.has_section(section):
-                log.debug("Adding new section [%s] to %s", section, filename)
-                opts.add_section(section)
-            for option, value in options.items():
-                if value is None:
-                    log.debug(
-                        "Deleting %s.%s from %s",
-                        section, option, filename
-                    )
-                    opts.remove_option(section, option)
-                    if not opts.options(section):
-                        log.info("Deleting empty [%s] section from %s",
-                                 section, filename)
-                        opts.remove_section(section)
-                else:
-                    log.debug(
-                        "Setting %s.%s to %r in %s",
-                        section, option, value, filename
-                    )
-                    opts.set(section, option, value)
-
-    log.info("Writing %s", filename)
-    if not dry_run:
-        with open(filename, 'w') as f:
-            opts.write(f)
-
-
-class option_base(Command):
-    """Abstract base class for commands that mess with config files"""
-
-    user_options = [
-        ('global-config', 'g',
-         "save options to the site-wide distutils.cfg file"),
-        ('user-config', 'u',
-         "save options to the current user's pydistutils.cfg file"),
-        ('filename=', 'f',
-         "configuration file to use (default=setup.cfg)"),
-    ]
-
-    boolean_options = [
-        'global-config', 'user-config',
-    ]
-
-    def initialize_options(self):
-        self.global_config = None
-        self.user_config = None
-        self.filename = None
-
-    def finalize_options(self):
-        filenames = []
-        if self.global_config:
-            filenames.append(config_file('global'))
-        if self.user_config:
-            filenames.append(config_file('user'))
-        if self.filename is not None:
-            filenames.append(self.filename)
-        if not filenames:
-            filenames.append(config_file('local'))
-        if len(filenames) > 1:
-            raise DistutilsOptionError(
-                "Must specify only one configuration file option",
-                filenames
-            )
-        self.filename, = filenames
-
-
-class setopt(option_base):
-    """Save command-line options to a file"""
-
-    description = "set an option in setup.cfg or another config file"
-
-    user_options = [
-        ('command=', 'c', 'command to set an option for'),
-        ('option=', 'o', 'option to set'),
-        ('set-value=', 's', 'value of the option'),
-        ('remove', 'r', 'remove (unset) the value'),
-    ] + option_base.user_options
-
-    boolean_options = option_base.boolean_options + ['remove']
-
-    def initialize_options(self):
-        option_base.initialize_options(self)
-        self.command = None
-        self.option = None
-        self.set_value = None
-        self.remove = None
-
-    def finalize_options(self):
-        option_base.finalize_options(self)
-        if self.command is None or self.option is None:
-            raise DistutilsOptionError("Must specify --command *and* --option")
-        if self.set_value is None and not self.remove:
-            raise DistutilsOptionError("Must specify --set-value or --remove")
-
-    def run(self):
-        edit_config(
-            self.filename, {
-                self.command: {self.option.replace('-', '_'): self.set_value}
-            },
-            self.dry_run
-        )

spaces/CVPR/LIVE/thrust/thrust/system/cuda/detail/reverse.h

@@ -1,98 +0,0 @@
-/******************************************************************************
- * Copyright (c) 2016, NVIDIA CORPORATION.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are met:
- *     * Redistributions of source code must retain the above copyright
- *       notice, this list of conditions and the following disclaimer.
- *     * Redistributions in binary form must reproduce the above copyright
- *       notice, this list of conditions and the following disclaimer in the
- *       documentation and/or other materials provided with the distribution.
- *     * Neither the name of the NVIDIA CORPORATION nor the
- *       names of its contributors may be used to endorse or promote products
- *       derived from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- ******************************************************************************/
-#pragma once
-
-
-#if THRUST_DEVICE_COMPILER == THRUST_DEVICE_COMPILER_NVCC
-#include <thrust/system/cuda/detail/execution_policy.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived, class ItemsIt, class ResultIt>
-ResultIt __host__ __device__
-reverse_copy(execution_policy<Derived> &policy,
-             ItemsIt                    first,
-             ItemsIt                    last,
-             ResultIt                   result);
-
-template <class Derived, class ItemsIt>
-void __host__ __device__
-reverse(execution_policy<Derived> &policy,
-        ItemsIt                    first,
-        ItemsIt                    last);
-
-}    // namespace cuda_cub
-} // end namespace thrust
-
-#include <thrust/advance.h>
-#include <thrust/distance.h>
-#include <thrust/system/cuda/detail/swap_ranges.h>
-#include <thrust/system/cuda/detail/copy.h>
-#include <thrust/iterator/reverse_iterator.h>
-
-namespace thrust
-{
-namespace cuda_cub {
-
-template <class Derived,
-          class ItemsIt,
-          class ResultIt>
-ResultIt __host__ __device__
-reverse_copy(execution_policy<Derived> &policy,
-             ItemsIt                    first,
-             ItemsIt                    last,
-             ResultIt                   result)
-{
-  return cuda_cub::copy(policy,
-                        make_reverse_iterator(last),
-                        make_reverse_iterator(first),
-                        result);
-}
-
-template <class Derived,
-          class ItemsIt>
-void __host__ __device__
-reverse(execution_policy<Derived> &policy,
-        ItemsIt                    first,
-        ItemsIt                    last)
-{
-  typedef typename thrust::iterator_difference<ItemsIt>::type difference_type;
-
-  // find the midpoint of [first,last)
-  difference_type N = thrust::distance(first, last);
-  ItemsIt mid(first);
-  thrust::advance(mid, N / 2);
-
-  cuda_cub::swap_ranges(policy, first, mid, make_reverse_iterator(last));
-}
-
-
-}    // namespace cuda_cub
-} // end namespace thrust
-#endif

spaces/CVPR/WALT/mmdet/models/detectors/cornernet.py

@@ -1,95 +0,0 @@
-import torch
-
-from mmdet.core import bbox2result, bbox_mapping_back
-from ..builder import DETECTORS
-from .single_stage import SingleStageDetector
-
-
-@DETECTORS.register_module()
-class CornerNet(SingleStageDetector):
-    """CornerNet.
-
-    This detector is the implementation of the paper `CornerNet: Detecting
-    Objects as Paired Keypoints <https://arxiv.org/abs/1808.01244>`_ .
-    """
-
-    def __init__(self,
-                 backbone,
-                 neck,
-                 bbox_head,
-                 train_cfg=None,
-                 test_cfg=None,
-                 pretrained=None):
-        super(CornerNet, self).__init__(backbone, neck, bbox_head, train_cfg,
-                                        test_cfg, pretrained)
-
-    def merge_aug_results(self, aug_results, img_metas):
-        """Merge augmented detection bboxes and score.
-
-        Args:
-            aug_results (list[list[Tensor]]): Det_bboxes and det_labels of each
-                image.
-            img_metas (list[list[dict]]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-
-        Returns:
-            tuple: (bboxes, labels)
-        """
-        recovered_bboxes, aug_labels = [], []
-        for bboxes_labels, img_info in zip(aug_results, img_metas):
-            img_shape = img_info[0]['img_shape']  # using shape before padding
-            scale_factor = img_info[0]['scale_factor']
-            flip = img_info[0]['flip']
-            bboxes, labels = bboxes_labels
-            bboxes, scores = bboxes[:, :4], bboxes[:, -1:]
-            bboxes = bbox_mapping_back(bboxes, img_shape, scale_factor, flip)
-            recovered_bboxes.append(torch.cat([bboxes, scores], dim=-1))
-            aug_labels.append(labels)
-
-        bboxes = torch.cat(recovered_bboxes, dim=0)
-        labels = torch.cat(aug_labels)
-
-        if bboxes.shape[0] > 0:
-            out_bboxes, out_labels = self.bbox_head._bboxes_nms(
-                bboxes, labels, self.bbox_head.test_cfg)
-        else:
-            out_bboxes, out_labels = bboxes, labels
-
-        return out_bboxes, out_labels
-
-    def aug_test(self, imgs, img_metas, rescale=False):
-        """Augment testing of CornerNet.
-
-        Args:
-            imgs (list[Tensor]): Augmented images.
-            img_metas (list[list[dict]]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            rescale (bool): If True, return boxes in original image space.
-                Default: False.
-
-        Note:
-            ``imgs`` must including flipped image pairs.
-
-        Returns:
-            list[list[np.ndarray]]: BBox results of each image and classes.
-                The outer list corresponds to each image. The inner list
-                corresponds to each class.
-        """
-        img_inds = list(range(len(imgs)))
-
-        assert img_metas[0][0]['flip'] + img_metas[1][0]['flip'], (
-            'aug test must have flipped image pair')
-        aug_results = []
-        for ind, flip_ind in zip(img_inds[0::2], img_inds[1::2]):
-            img_pair = torch.cat([imgs[ind], imgs[flip_ind]])
-            x = self.extract_feat(img_pair)
-            outs = self.bbox_head(x)
-            bbox_list = self.bbox_head.get_bboxes(
-                *outs, [img_metas[ind], img_metas[flip_ind]], False, False)
-            aug_results.append(bbox_list[0])
-            aug_results.append(bbox_list[1])
-
-        bboxes, labels = self.merge_aug_results(aug_results, img_metas)
-        bbox_results = bbox2result(bboxes, labels, self.bbox_head.num_classes)
-
-        return [bbox_results]

spaces/CVPR/WALT/mmdet/models/losses/iou_loss.py

@@ -1,436 +0,0 @@
-import math
-
-import mmcv
-import torch
-import torch.nn as nn
-
-from mmdet.core import bbox_overlaps
-from ..builder import LOSSES
-from .utils import weighted_loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def iou_loss(pred, target, linear=False, eps=1e-6):
-    """IoU loss.
-
-    Computing the IoU loss between a set of predicted bboxes and target bboxes.
-    The loss is calculated as negative log of IoU.
-
-    Args:
-        pred (torch.Tensor): Predicted bboxes of format (x1, y1, x2, y2),
-            shape (n, 4).
-        target (torch.Tensor): Corresponding gt bboxes, shape (n, 4).
-        linear (bool, optional): If True, use linear scale of loss instead of
-            log scale. Default: False.
-        eps (float): Eps to avoid log(0).
-
-    Return:
-        torch.Tensor: Loss tensor.
-    """
-    ious = bbox_overlaps(pred, target, is_aligned=True).clamp(min=eps)
-    if linear:
-        loss = 1 - ious
-    else:
-        loss = -ious.log()
-    return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def bounded_iou_loss(pred, target, beta=0.2, eps=1e-3):
-    """BIoULoss.
-
-    This is an implementation of paper
-    `Improving Object Localization with Fitness NMS and Bounded IoU Loss.
-    <https://arxiv.org/abs/1711.00164>`_.
-
-    Args:
-        pred (torch.Tensor): Predicted bboxes.
-        target (torch.Tensor): Target bboxes.
-        beta (float): beta parameter in smoothl1.
-        eps (float): eps to avoid NaN.
-    """
-    pred_ctrx = (pred[:, 0] + pred[:, 2]) * 0.5
-    pred_ctry = (pred[:, 1] + pred[:, 3]) * 0.5
-    pred_w = pred[:, 2] - pred[:, 0]
-    pred_h = pred[:, 3] - pred[:, 1]
-    with torch.no_grad():
-        target_ctrx = (target[:, 0] + target[:, 2]) * 0.5
-        target_ctry = (target[:, 1] + target[:, 3]) * 0.5
-        target_w = target[:, 2] - target[:, 0]
-        target_h = target[:, 3] - target[:, 1]
-
-    dx = target_ctrx - pred_ctrx
-    dy = target_ctry - pred_ctry
-
-    loss_dx = 1 - torch.max(
-        (target_w - 2 * dx.abs()) /
-        (target_w + 2 * dx.abs() + eps), torch.zeros_like(dx))
-    loss_dy = 1 - torch.max(
-        (target_h - 2 * dy.abs()) /
-        (target_h + 2 * dy.abs() + eps), torch.zeros_like(dy))
-    loss_dw = 1 - torch.min(target_w / (pred_w + eps), pred_w /
-                            (target_w + eps))
-    loss_dh = 1 - torch.min(target_h / (pred_h + eps), pred_h /
-                            (target_h + eps))
-    loss_comb = torch.stack([loss_dx, loss_dy, loss_dw, loss_dh],
-                            dim=-1).view(loss_dx.size(0), -1)
-
-    loss = torch.where(loss_comb < beta, 0.5 * loss_comb * loss_comb / beta,
-                       loss_comb - 0.5 * beta)
-    return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def giou_loss(pred, target, eps=1e-7):
-    r"""`Generalized Intersection over Union: A Metric and A Loss for Bounding
-    Box Regression <https://arxiv.org/abs/1902.09630>`_.
-
-    Args:
-        pred (torch.Tensor): Predicted bboxes of format (x1, y1, x2, y2),
-            shape (n, 4).
-        target (torch.Tensor): Corresponding gt bboxes, shape (n, 4).
-        eps (float): Eps to avoid log(0).
-
-    Return:
-        Tensor: Loss tensor.
-    """
-    gious = bbox_overlaps(pred, target, mode='giou', is_aligned=True, eps=eps)
-    loss = 1 - gious
-    return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def diou_loss(pred, target, eps=1e-7):
-    r"""`Implementation of Distance-IoU Loss: Faster and Better
-    Learning for Bounding Box Regression, https://arxiv.org/abs/1911.08287`_.
-
-    Code is modified from https://github.com/Zzh-tju/DIoU.
-
-    Args:
-        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
-            shape (n, 4).
-        target (Tensor): Corresponding gt bboxes, shape (n, 4).
-        eps (float): Eps to avoid log(0).
-    Return:
-        Tensor: Loss tensor.
-    """
-    # overlap
-    lt = torch.max(pred[:, :2], target[:, :2])
-    rb = torch.min(pred[:, 2:], target[:, 2:])
-    wh = (rb - lt).clamp(min=0)
-    overlap = wh[:, 0] * wh[:, 1]
-
-    # union
-    ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
-    ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
-    union = ap + ag - overlap + eps
-
-    # IoU
-    ious = overlap / union
-
-    # enclose area
-    enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
-    enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
-    enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
-
-    cw = enclose_wh[:, 0]
-    ch = enclose_wh[:, 1]
-
-    c2 = cw**2 + ch**2 + eps
-
-    b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
-    b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
-    b2_x1, b2_y1 = target[:, 0], target[:, 1]
-    b2_x2, b2_y2 = target[:, 2], target[:, 3]
-
-    left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
-    right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
-    rho2 = left + right
-
-    # DIoU
-    dious = ious - rho2 / c2
-    loss = 1 - dious
-    return loss
-
-
-@mmcv.jit(derivate=True, coderize=True)
-@weighted_loss
-def ciou_loss(pred, target, eps=1e-7):
-    r"""`Implementation of paper `Enhancing Geometric Factors into
-    Model Learning and Inference for Object Detection and Instance
-    Segmentation <https://arxiv.org/abs/2005.03572>`_.
-
-    Code is modified from https://github.com/Zzh-tju/CIoU.
-
-    Args:
-        pred (Tensor): Predicted bboxes of format (x1, y1, x2, y2),
-            shape (n, 4).
-        target (Tensor): Corresponding gt bboxes, shape (n, 4).
-        eps (float): Eps to avoid log(0).
-    Return:
-        Tensor: Loss tensor.
-    """
-    # overlap
-    lt = torch.max(pred[:, :2], target[:, :2])
-    rb = torch.min(pred[:, 2:], target[:, 2:])
-    wh = (rb - lt).clamp(min=0)
-    overlap = wh[:, 0] * wh[:, 1]
-
-    # union
-    ap = (pred[:, 2] - pred[:, 0]) * (pred[:, 3] - pred[:, 1])
-    ag = (target[:, 2] - target[:, 0]) * (target[:, 3] - target[:, 1])
-    union = ap + ag - overlap + eps
-
-    # IoU
-    ious = overlap / union
-
-    # enclose area
-    enclose_x1y1 = torch.min(pred[:, :2], target[:, :2])
-    enclose_x2y2 = torch.max(pred[:, 2:], target[:, 2:])
-    enclose_wh = (enclose_x2y2 - enclose_x1y1).clamp(min=0)
-
-    cw = enclose_wh[:, 0]
-    ch = enclose_wh[:, 1]
-
-    c2 = cw**2 + ch**2 + eps
-
-    b1_x1, b1_y1 = pred[:, 0], pred[:, 1]
-    b1_x2, b1_y2 = pred[:, 2], pred[:, 3]
-    b2_x1, b2_y1 = target[:, 0], target[:, 1]
-    b2_x2, b2_y2 = target[:, 2], target[:, 3]
-
-    w1, h1 = b1_x2 - b1_x1, b1_y2 - b1_y1 + eps
-    w2, h2 = b2_x2 - b2_x1, b2_y2 - b2_y1 + eps
-
-    left = ((b2_x1 + b2_x2) - (b1_x1 + b1_x2))**2 / 4
-    right = ((b2_y1 + b2_y2) - (b1_y1 + b1_y2))**2 / 4
-    rho2 = left + right
-
-    factor = 4 / math.pi**2
-    v = factor * torch.pow(torch.atan(w2 / h2) - torch.atan(w1 / h1), 2)
-
-    # CIoU
-    cious = ious - (rho2 / c2 + v**2 / (1 - ious + v))
-    loss = 1 - cious
-    return loss
-
-
-@LOSSES.register_module()
-class IoULoss(nn.Module):
-    """IoULoss.
-
-    Computing the IoU loss between a set of predicted bboxes and target bboxes.
-
-    Args:
-        linear (bool): If True, use linear scale of loss instead of log scale.
-            Default: False.
-        eps (float): Eps to avoid log(0).
-        reduction (str): Options are "none", "mean" and "sum".
-        loss_weight (float): Weight of loss.
-    """
-
-    def __init__(self,
-                 linear=False,
-                 eps=1e-6,
-                 reduction='mean',
-                 loss_weight=1.0):
-        super(IoULoss, self).__init__()
-        self.linear = linear
-        self.eps = eps
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        """Forward function.
-
-        Args:
-            pred (torch.Tensor): The prediction.
-            target (torch.Tensor): The learning target of the prediction.
-            weight (torch.Tensor, optional): The weight of loss for each
-                prediction. Defaults to None.
-            avg_factor (int, optional): Average factor that is used to average
-                the loss. Defaults to None.
-            reduction_override (str, optional): The reduction method used to
-                override the original reduction method of the loss.
-                Defaults to None. Options are "none", "mean" and "sum".
-        """
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        if (weight is not None) and (not torch.any(weight > 0)) and (
-                reduction != 'none'):
-            return (pred * weight).sum()  # 0
-        if weight is not None and weight.dim() > 1:
-            # TODO: remove this in the future
-            # reduce the weight of shape (n, 4) to (n,) to match the
-            # iou_loss of shape (n,)
-            assert weight.shape == pred.shape
-            weight = weight.mean(-1)
-        loss = self.loss_weight * iou_loss(
-            pred,
-            target,
-            weight,
-            linear=self.linear,
-            eps=self.eps,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss
-
-
-@LOSSES.register_module()
-class BoundedIoULoss(nn.Module):
-
-    def __init__(self, beta=0.2, eps=1e-3, reduction='mean', loss_weight=1.0):
-        super(BoundedIoULoss, self).__init__()
-        self.beta = beta
-        self.eps = eps
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        if weight is not None and not torch.any(weight > 0):
-            return (pred * weight).sum()  # 0
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        loss = self.loss_weight * bounded_iou_loss(
-            pred,
-            target,
-            weight,
-            beta=self.beta,
-            eps=self.eps,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss
-
-
-@LOSSES.register_module()
-class GIoULoss(nn.Module):
-
-    def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
-        super(GIoULoss, self).__init__()
-        self.eps = eps
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        if weight is not None and not torch.any(weight > 0):
-            return (pred * weight).sum()  # 0
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        if weight is not None and weight.dim() > 1:
-            # TODO: remove this in the future
-            # reduce the weight of shape (n, 4) to (n,) to match the
-            # giou_loss of shape (n,)
-            assert weight.shape == pred.shape
-            weight = weight.mean(-1)
-        loss = self.loss_weight * giou_loss(
-            pred,
-            target,
-            weight,
-            eps=self.eps,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss
-
-
-@LOSSES.register_module()
-class DIoULoss(nn.Module):
-
-    def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
-        super(DIoULoss, self).__init__()
-        self.eps = eps
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        if weight is not None and not torch.any(weight > 0):
-            return (pred * weight).sum()  # 0
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        if weight is not None and weight.dim() > 1:
-            # TODO: remove this in the future
-            # reduce the weight of shape (n, 4) to (n,) to match the
-            # giou_loss of shape (n,)
-            assert weight.shape == pred.shape
-            weight = weight.mean(-1)
-        loss = self.loss_weight * diou_loss(
-            pred,
-            target,
-            weight,
-            eps=self.eps,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss
-
-
-@LOSSES.register_module()
-class CIoULoss(nn.Module):
-
-    def __init__(self, eps=1e-6, reduction='mean', loss_weight=1.0):
-        super(CIoULoss, self).__init__()
-        self.eps = eps
-        self.reduction = reduction
-        self.loss_weight = loss_weight
-
-    def forward(self,
-                pred,
-                target,
-                weight=None,
-                avg_factor=None,
-                reduction_override=None,
-                **kwargs):
-        if weight is not None and not torch.any(weight > 0):
-            return (pred * weight).sum()  # 0
-        assert reduction_override in (None, 'none', 'mean', 'sum')
-        reduction = (
-            reduction_override if reduction_override else self.reduction)
-        if weight is not None and weight.dim() > 1:
-            # TODO: remove this in the future
-            # reduce the weight of shape (n, 4) to (n,) to match the
-            # giou_loss of shape (n,)
-            assert weight.shape == pred.shape
-            weight = weight.mean(-1)
-        loss = self.loss_weight * ciou_loss(
-            pred,
-            target,
-            weight,
-            eps=self.eps,
-            reduction=reduction,
-            avg_factor=avg_factor,
-            **kwargs)
-        return loss

spaces/CVPR/WALT/mmdet/models/roi_heads/cascade_roi_head.py

@@ -1,507 +0,0 @@
-import torch
-import torch.nn as nn
-
-from mmdet.core import (bbox2result, bbox2roi, bbox_mapping, build_assigner,
-                        build_sampler, merge_aug_bboxes, merge_aug_masks,
-                        multiclass_nms)
-from ..builder import HEADS, build_head, build_roi_extractor
-from .base_roi_head import BaseRoIHead
-from .test_mixins import BBoxTestMixin, MaskTestMixin
-
-
-@HEADS.register_module()
-class CascadeRoIHead(BaseRoIHead, BBoxTestMixin, MaskTestMixin):
-    """Cascade roi head including one bbox head and one mask head.
-
-    https://arxiv.org/abs/1712.00726
-    """
-
-    def __init__(self,
-                 num_stages,
-                 stage_loss_weights,
-                 bbox_roi_extractor=None,
-                 bbox_head=None,
-                 mask_roi_extractor=None,
-                 mask_head=None,
-                 shared_head=None,
-                 train_cfg=None,
-                 test_cfg=None):
-        assert bbox_roi_extractor is not None
-        assert bbox_head is not None
-        assert shared_head is None, \
-            'Shared head is not supported in Cascade RCNN anymore'
-        self.num_stages = num_stages
-        self.stage_loss_weights = stage_loss_weights
-        super(CascadeRoIHead, self).__init__(
-            bbox_roi_extractor=bbox_roi_extractor,
-            bbox_head=bbox_head,
-            mask_roi_extractor=mask_roi_extractor,
-            mask_head=mask_head,
-            shared_head=shared_head,
-            train_cfg=train_cfg,
-            test_cfg=test_cfg)
-
-    def init_bbox_head(self, bbox_roi_extractor, bbox_head):
-        """Initialize box head and box roi extractor.
-
-        Args:
-            bbox_roi_extractor (dict): Config of box roi extractor.
-            bbox_head (dict): Config of box in box head.
-        """
-        self.bbox_roi_extractor = nn.ModuleList()
-        self.bbox_head = nn.ModuleList()
-        if not isinstance(bbox_roi_extractor, list):
-            bbox_roi_extractor = [
-                bbox_roi_extractor for _ in range(self.num_stages)
-            ]
-        if not isinstance(bbox_head, list):
-            bbox_head = [bbox_head for _ in range(self.num_stages)]
-        assert len(bbox_roi_extractor) == len(bbox_head) == self.num_stages
-        for roi_extractor, head in zip(bbox_roi_extractor, bbox_head):
-            self.bbox_roi_extractor.append(build_roi_extractor(roi_extractor))
-            self.bbox_head.append(build_head(head))
-
-    def init_mask_head(self, mask_roi_extractor, mask_head):
-        """Initialize mask head and mask roi extractor.
-
-        Args:
-            mask_roi_extractor (dict): Config of mask roi extractor.
-            mask_head (dict): Config of mask in mask head.
-        """
-        self.mask_head = nn.ModuleList()
-        if not isinstance(mask_head, list):
-            mask_head = [mask_head for _ in range(self.num_stages)]
-        assert len(mask_head) == self.num_stages
-        for head in mask_head:
-            self.mask_head.append(build_head(head))
-        if mask_roi_extractor is not None:
-            self.share_roi_extractor = False
-            self.mask_roi_extractor = nn.ModuleList()
-            if not isinstance(mask_roi_extractor, list):
-                mask_roi_extractor = [
-                    mask_roi_extractor for _ in range(self.num_stages)
-                ]
-            assert len(mask_roi_extractor) == self.num_stages
-            for roi_extractor in mask_roi_extractor:
-                self.mask_roi_extractor.append(
-                    build_roi_extractor(roi_extractor))
-        else:
-            self.share_roi_extractor = True
-            self.mask_roi_extractor = self.bbox_roi_extractor
-
-    def init_assigner_sampler(self):
-        """Initialize assigner and sampler for each stage."""
-        self.bbox_assigner = []
-        self.bbox_sampler = []
-        if self.train_cfg is not None:
-            for idx, rcnn_train_cfg in enumerate(self.train_cfg):
-                self.bbox_assigner.append(
-                    build_assigner(rcnn_train_cfg.assigner))
-                self.current_stage = idx
-                self.bbox_sampler.append(
-                    build_sampler(rcnn_train_cfg.sampler, context=self))
-
-    def init_weights(self, pretrained):
-        """Initialize the weights in head.
-
-        Args:
-            pretrained (str, optional): Path to pre-trained weights.
-                Defaults to None.
-        """
-        if self.with_shared_head:
-            self.shared_head.init_weights(pretrained=pretrained)
-        for i in range(self.num_stages):
-            if self.with_bbox:
-                self.bbox_roi_extractor[i].init_weights()
-                self.bbox_head[i].init_weights()
-            if self.with_mask:
-                if not self.share_roi_extractor:
-                    self.mask_roi_extractor[i].init_weights()
-                self.mask_head[i].init_weights()
-
-    def forward_dummy(self, x, proposals):
-        """Dummy forward function."""
-        # bbox head
-        outs = ()
-        rois = bbox2roi([proposals])
-        if self.with_bbox:
-            for i in range(self.num_stages):
-                bbox_results = self._bbox_forward(i, x, rois)
-                outs = outs + (bbox_results['cls_score'],
-                               bbox_results['bbox_pred'])
-        # mask heads
-        if self.with_mask:
-            mask_rois = rois[:100]
-            for i in range(self.num_stages):
-                mask_results = self._mask_forward(i, x, mask_rois)
-                outs = outs + (mask_results['mask_pred'], )
-        return outs
-
-    def _bbox_forward(self, stage, x, rois):
-        """Box head forward function used in both training and testing."""
-        bbox_roi_extractor = self.bbox_roi_extractor[stage]
-        bbox_head = self.bbox_head[stage]
-        bbox_feats = bbox_roi_extractor(x[:bbox_roi_extractor.num_inputs],
-                                        rois)
-        # do not support caffe_c4 model anymore
-        cls_score, bbox_pred = bbox_head(bbox_feats)
-
-        bbox_results = dict(
-            cls_score=cls_score, bbox_pred=bbox_pred, bbox_feats=bbox_feats)
-        return bbox_results
-
-    def _bbox_forward_train(self, stage, x, sampling_results, gt_bboxes,
-                            gt_labels, rcnn_train_cfg):
-        """Run forward function and calculate loss for box head in training."""
-        rois = bbox2roi([res.bboxes for res in sampling_results])
-        bbox_results = self._bbox_forward(stage, x, rois)
-        bbox_targets = self.bbox_head[stage].get_targets(
-            sampling_results, gt_bboxes, gt_labels, rcnn_train_cfg)
-        loss_bbox = self.bbox_head[stage].loss(bbox_results['cls_score'],
-                                               bbox_results['bbox_pred'], rois,
-                                               *bbox_targets)
-
-        bbox_results.update(
-            loss_bbox=loss_bbox, rois=rois, bbox_targets=bbox_targets)
-        return bbox_results
-
-    def _mask_forward(self, stage, x, rois):
-        """Mask head forward function used in both training and testing."""
-        mask_roi_extractor = self.mask_roi_extractor[stage]
-        mask_head = self.mask_head[stage]
-        mask_feats = mask_roi_extractor(x[:mask_roi_extractor.num_inputs],
-                                        rois)
-        # do not support caffe_c4 model anymore
-        mask_pred = mask_head(mask_feats)
-
-        mask_results = dict(mask_pred=mask_pred)
-        return mask_results
-
-    def _mask_forward_train(self,
-                            stage,
-                            x,
-                            sampling_results,
-                            gt_masks,
-                            rcnn_train_cfg,
-                            bbox_feats=None):
-        """Run forward function and calculate loss for mask head in
-        training."""
-        pos_rois = bbox2roi([res.pos_bboxes for res in sampling_results])
-        mask_results = self._mask_forward(stage, x, pos_rois)
-
-        mask_targets = self.mask_head[stage].get_targets(
-            sampling_results, gt_masks, rcnn_train_cfg)
-        pos_labels = torch.cat([res.pos_gt_labels for res in sampling_results])
-        loss_mask = self.mask_head[stage].loss(mask_results['mask_pred'],
-                                               mask_targets, pos_labels)
-
-        mask_results.update(loss_mask=loss_mask)
-        return mask_results
-
-    def forward_train(self,
-                      x,
-                      img_metas,
-                      proposal_list,
-                      gt_bboxes,
-                      gt_labels,
-                      gt_bboxes_ignore=None,
-                      gt_masks=None):
-        """
-        Args:
-            x (list[Tensor]): list of multi-level img features.
-            img_metas (list[dict]): list of image info dict where each dict
-                has: 'img_shape', 'scale_factor', 'flip', and may also contain
-                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
-                For details on the values of these keys see
-                `mmdet/datasets/pipelines/formatting.py:Collect`.
-            proposals (list[Tensors]): list of region proposals.
-            gt_bboxes (list[Tensor]): Ground truth bboxes for each image with
-                shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format.
-            gt_labels (list[Tensor]): class indices corresponding to each box
-            gt_bboxes_ignore (None | list[Tensor]): specify which bounding
-                boxes can be ignored when computing the loss.
-            gt_masks (None | Tensor) : true segmentation masks for each box
-                used if the architecture supports a segmentation task.
-
-        Returns:
-            dict[str, Tensor]: a dictionary of loss components
-        """
-        losses = dict()
-        for i in range(self.num_stages):
-            self.current_stage = i
-            rcnn_train_cfg = self.train_cfg[i]
-            lw = self.stage_loss_weights[i]
-
-            # assign gts and sample proposals
-            sampling_results = []
-            if self.with_bbox or self.with_mask:
-                bbox_assigner = self.bbox_assigner[i]
-                bbox_sampler = self.bbox_sampler[i]
-                num_imgs = len(img_metas)
-                if gt_bboxes_ignore is None:
-                    gt_bboxes_ignore = [None for _ in range(num_imgs)]
-
-                for j in range(num_imgs):
-                    assign_result = bbox_assigner.assign(
-                        proposal_list[j], gt_bboxes[j], gt_bboxes_ignore[j],
-                        gt_labels[j])
-                    sampling_result = bbox_sampler.sample(
-                        assign_result,
-                        proposal_list[j],
-                        gt_bboxes[j],
-                        gt_labels[j],
-                        feats=[lvl_feat[j][None] for lvl_feat in x])
-                    sampling_results.append(sampling_result)
-
-            # bbox head forward and loss
-            bbox_results = self._bbox_forward_train(i, x, sampling_results,
-                                                    gt_bboxes, gt_labels,
-                                                    rcnn_train_cfg)
-
-            for name, value in bbox_results['loss_bbox'].items():
-                losses[f's{i}.{name}'] = (
-                    value * lw if 'loss' in name else value)
-
-            # mask head forward and loss
-            if self.with_mask:
-                mask_results = self._mask_forward_train(
-                    i, x, sampling_results, gt_masks, rcnn_train_cfg,
-                    bbox_results['bbox_feats'])
-                for name, value in mask_results['loss_mask'].items():
-                    losses[f's{i}.{name}'] = (
-                        value * lw if 'loss' in name else value)
-
-            # refine bboxes
-            if i < self.num_stages - 1:
-                pos_is_gts = [res.pos_is_gt for res in sampling_results]
-                # bbox_targets is a tuple
-                roi_labels = bbox_results['bbox_targets'][0]
-                with torch.no_grad():
-                    roi_labels = torch.where(
-                        roi_labels == self.bbox_head[i].num_classes,
-                        bbox_results['cls_score'][:, :-1].argmax(1),
-                        roi_labels)
-                    proposal_list = self.bbox_head[i].refine_bboxes(
-                        bbox_results['rois'], roi_labels,
-                        bbox_results['bbox_pred'], pos_is_gts, img_metas)
-
-        return losses
-
-    def simple_test(self, x, proposal_list, img_metas, rescale=False):
-        """Test without augmentation."""
-        assert self.with_bbox, 'Bbox head must be implemented.'
-        num_imgs = len(proposal_list)
-        img_shapes = tuple(meta['img_shape'] for meta in img_metas)
-        ori_shapes = tuple(meta['ori_shape'] for meta in img_metas)
-        scale_factors = tuple(meta['scale_factor'] for meta in img_metas)
-
-        # "ms" in variable names means multi-stage
-        ms_bbox_result = {}
-        ms_segm_result = {}
-        ms_scores = []
-        rcnn_test_cfg = self.test_cfg
-
-        rois = bbox2roi(proposal_list)
-        for i in range(self.num_stages):
-            bbox_results = self._bbox_forward(i, x, rois)
-
-            # split batch bbox prediction back to each image
-            cls_score = bbox_results['cls_score']
-            bbox_pred = bbox_results['bbox_pred']
-            num_proposals_per_img = tuple(
-                len(proposals) for proposals in proposal_list)
-            rois = rois.split(num_proposals_per_img, 0)
-            cls_score = cls_score.split(num_proposals_per_img, 0)
-            if isinstance(bbox_pred, torch.Tensor):
-                bbox_pred = bbox_pred.split(num_proposals_per_img, 0)
-            else:
-                bbox_pred = self.bbox_head[i].bbox_pred_split(
-                    bbox_pred, num_proposals_per_img)
-            ms_scores.append(cls_score)
-
-            if i < self.num_stages - 1:
-                bbox_label = [s[:, :-1].argmax(dim=1) for s in cls_score]
-                rois = torch.cat([
-                    self.bbox_head[i].regress_by_class(rois[j], bbox_label[j],
-                                                       bbox_pred[j],
-                                                       img_metas[j])
-                    for j in range(num_imgs)
-                ])
-
-        # average scores of each image by stages
-        cls_score = [
-            sum([score[i] for score in ms_scores]) / float(len(ms_scores))
-            for i in range(num_imgs)
-        ]
-
-        # apply bbox post-processing to each image individually
-        det_bboxes = []
-        det_labels = []
-        for i in range(num_imgs):
-            det_bbox, det_label = self.bbox_head[-1].get_bboxes(
-                rois[i],
-                cls_score[i],
-                bbox_pred[i],
-                img_shapes[i],
-                scale_factors[i],
-                rescale=rescale,
-                cfg=rcnn_test_cfg)
-            det_bboxes.append(det_bbox)
-            det_labels.append(det_label)
-
-        if torch.onnx.is_in_onnx_export():
-            return det_bboxes, det_labels
-        bbox_results = [
-            bbox2result(det_bboxes[i], det_labels[i],
-                        self.bbox_head[-1].num_classes)
-            for i in range(num_imgs)
-        ]
-        ms_bbox_result['ensemble'] = bbox_results
-
-        if self.with_mask:
-            if all(det_bbox.shape[0] == 0 for det_bbox in det_bboxes):
-                mask_classes = self.mask_head[-1].num_classes
-                segm_results = [[[] for _ in range(mask_classes)]
-                                for _ in range(num_imgs)]
-            else:
-                if rescale and not isinstance(scale_factors[0], float):
-                    scale_factors = [
-                        torch.from_numpy(scale_factor).to(det_bboxes[0].device)
-                        for scale_factor in scale_factors
-                    ]
-                _bboxes = [
-                    det_bboxes[i][:, :4] *
-                    scale_factors[i] if rescale else det_bboxes[i][:, :4]
-                    for i in range(len(det_bboxes))
-                ]
-                mask_rois = bbox2roi(_bboxes)
-                num_mask_rois_per_img = tuple(
-                    _bbox.size(0) for _bbox in _bboxes)
-                aug_masks = []
-                for i in range(self.num_stages):
-                    mask_results = self._mask_forward(i, x, mask_rois)
-                    mask_pred = mask_results['mask_pred']
-                    # split batch mask prediction back to each image
-                    mask_pred = mask_pred.split(num_mask_rois_per_img, 0)
-                    aug_masks.append(
-                        [m.sigmoid().cpu().numpy() for m in mask_pred])
-
-                # apply mask post-processing to each image individually
-                segm_results = []
-                for i in range(num_imgs):
-                    if det_bboxes[i].shape[0] == 0:
-                        segm_results.append(
-                            [[]
-                             for _ in range(self.mask_head[-1].num_classes)])
-                    else:
-                        aug_mask = [mask[i] for mask in aug_masks]
-                        merged_masks = merge_aug_masks(
-                            aug_mask, [[img_metas[i]]] * self.num_stages,
-                            rcnn_test_cfg)
-                        segm_result = self.mask_head[-1].get_seg_masks(
-                            merged_masks, _bboxes[i], det_labels[i],
-                            rcnn_test_cfg, ori_shapes[i], scale_factors[i],
-                            rescale)
-                        segm_results.append(segm_result)
-            ms_segm_result['ensemble'] = segm_results
-
-        if self.with_mask:
-            results = list(
-                zip(ms_bbox_result['ensemble'], ms_segm_result['ensemble']))
-        else:
-            results = ms_bbox_result['ensemble']
-
-        return results
-
-    def aug_test(self, features, proposal_list, img_metas, rescale=False):
-        """Test with augmentations.
-
-        If rescale is False, then returned bboxes and masks will fit the scale
-        of imgs[0].
-        """
-        rcnn_test_cfg = self.test_cfg
-        aug_bboxes = []
-        aug_scores = []
-        for x, img_meta in zip(features, img_metas):
-            # only one image in the batch
-            img_shape = img_meta[0]['img_shape']
-            scale_factor = img_meta[0]['scale_factor']
-            flip = img_meta[0]['flip']
-            flip_direction = img_meta[0]['flip_direction']
-
-            proposals = bbox_mapping(proposal_list[0][:, :4], img_shape,
-                                     scale_factor, flip, flip_direction)
-            # "ms" in variable names means multi-stage
-            ms_scores = []
-
-            rois = bbox2roi([proposals])
-            for i in range(self.num_stages):
-                bbox_results = self._bbox_forward(i, x, rois)
-                ms_scores.append(bbox_results['cls_score'])
-
-                if i < self.num_stages - 1:
-                    bbox_label = bbox_results['cls_score'][:, :-1].argmax(
-                        dim=1)
-                    rois = self.bbox_head[i].regress_by_class(
-                        rois, bbox_label, bbox_results['bbox_pred'],
-                        img_meta[0])
-
-            cls_score = sum(ms_scores) / float(len(ms_scores))
-            bboxes, scores = self.bbox_head[-1].get_bboxes(
-                rois,
-                cls_score,
-                bbox_results['bbox_pred'],
-                img_shape,
-                scale_factor,
-                rescale=False,
-                cfg=None)
-            aug_bboxes.append(bboxes)
-            aug_scores.append(scores)
-
-        # after merging, bboxes will be rescaled to the original image size
-        merged_bboxes, merged_scores = merge_aug_bboxes(
-            aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)
-        det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,
-                                                rcnn_test_cfg.score_thr,
-                                                rcnn_test_cfg.nms,
-                                                rcnn_test_cfg.max_per_img)
-
-        bbox_result = bbox2result(det_bboxes, det_labels,
-                                  self.bbox_head[-1].num_classes)
-
-        if self.with_mask:
-            if det_bboxes.shape[0] == 0:
-                segm_result = [[[]
-                                for _ in range(self.mask_head[-1].num_classes)]
-                               ]
-            else:
-                aug_masks = []
-                aug_img_metas = []
-                for x, img_meta in zip(features, img_metas):
-                    img_shape = img_meta[0]['img_shape']
-                    scale_factor = img_meta[0]['scale_factor']
-                    flip = img_meta[0]['flip']
-                    flip_direction = img_meta[0]['flip_direction']
-                    _bboxes = bbox_mapping(det_bboxes[:, :4], img_shape,
-                                           scale_factor, flip, flip_direction)
-                    mask_rois = bbox2roi([_bboxes])
-                    for i in range(self.num_stages):
-                        mask_results = self._mask_forward(i, x, mask_rois)
-                        aug_masks.append(
-                            mask_results['mask_pred'].sigmoid().cpu().numpy())
-                        aug_img_metas.append(img_meta)
-                merged_masks = merge_aug_masks(aug_masks, aug_img_metas,
-                                               self.test_cfg)
-
-                ori_shape = img_metas[0][0]['ori_shape']
-                segm_result = self.mask_head[-1].get_seg_masks(
-                    merged_masks,
-                    det_bboxes,
-                    det_labels,
-                    rcnn_test_cfg,
-                    ori_shape,
-                    scale_factor=1.0,
-                    rescale=False)
-            return [(bbox_result, segm_result)]
-        else:
-            return [bbox_result]

spaces/CVPR/WALT/mmdet/models/roi_heads/test_mixins.py

@@ -1,368 +0,0 @@
-import logging
-import sys
-
-import torch
-
-from mmdet.core import (bbox2roi, bbox_mapping, merge_aug_bboxes,
-                        merge_aug_masks, multiclass_nms)
-
-logger = logging.getLogger(__name__)
-
-if sys.version_info >= (3, 7):
-    from mmdet.utils.contextmanagers import completed
-
-
-class BBoxTestMixin(object):
-
-    if sys.version_info >= (3, 7):
-
-        async def async_test_bboxes(self,
-                                    x,
-                                    img_metas,
-                                    proposals,
-                                    rcnn_test_cfg,
-                                    rescale=False,
-                                    bbox_semaphore=None,
-                                    global_lock=None):
-            """Asynchronized test for box head without augmentation."""
-            rois = bbox2roi(proposals)
-            roi_feats = self.bbox_roi_extractor(
-                x[:len(self.bbox_roi_extractor.featmap_strides)], rois)
-            if self.with_shared_head:
-                roi_feats = self.shared_head(roi_feats)
-            sleep_interval = rcnn_test_cfg.get('async_sleep_interval', 0.017)
-
-            async with completed(
-                    __name__, 'bbox_head_forward',
-                    sleep_interval=sleep_interval):
-                cls_score, bbox_pred = self.bbox_head(roi_feats)
-
-            img_shape = img_metas[0]['img_shape']
-            scale_factor = img_metas[0]['scale_factor']
-            det_bboxes, det_labels = self.bbox_head.get_bboxes(
-                rois,
-                cls_score,
-                bbox_pred,
-                img_shape,
-                scale_factor,
-                rescale=rescale,
-                cfg=rcnn_test_cfg)
-            return det_bboxes, det_labels
-
-    def simple_test_bboxes(self,
-                           x,
-                           img_metas,
-                           proposals,
-                           rcnn_test_cfg,
-                           rescale=False):
-        """Test only det bboxes without augmentation.
-
-        Args:
-            x (tuple[Tensor]): Feature maps of all scale level.
-            img_metas (list[dict]): Image meta info.
-            proposals (Tensor or List[Tensor]): Region proposals.
-            rcnn_test_cfg (obj:`ConfigDict`): `test_cfg` of R-CNN.
-            rescale (bool): If True, return boxes in original image space.
-                Default: False.
-
-        Returns:
-            tuple[list[Tensor], list[Tensor]]: The first list contains
-                the boxes of the corresponding image in a batch, each
-                tensor has the shape (num_boxes, 5) and last dimension
-                5 represent (tl_x, tl_y, br_x, br_y, score). Each Tensor
-                in the second list is the labels with shape (num_boxes, ).
-                The length of both lists should be equal to batch_size.
-        """
-        # get origin input shape to support onnx dynamic input shape
-        if torch.onnx.is_in_onnx_export():
-            assert len(
-                img_metas
-            ) == 1, 'Only support one input image while in exporting to ONNX'
-            img_shapes = img_metas[0]['img_shape_for_onnx']
-        else:
-            img_shapes = tuple(meta['img_shape'] for meta in img_metas)
-        scale_factors = tuple(meta['scale_factor'] for meta in img_metas)
-
-        # The length of proposals of different batches may be different.
-        # In order to form a batch, a padding operation is required.
-        if isinstance(proposals, list):
-            # padding to form a batch
-            max_size = max([proposal.size(0) for proposal in proposals])
-            for i, proposal in enumerate(proposals):
-                supplement = proposal.new_full(
-                    (max_size - proposal.size(0), proposal.size(1)), 0)
-                proposals[i] = torch.cat((supplement, proposal), dim=0)
-            rois = torch.stack(proposals, dim=0)
-        else:
-            rois = proposals
-
-        batch_index = torch.arange(
-            rois.size(0), device=rois.device).float().view(-1, 1, 1).expand(
-                rois.size(0), rois.size(1), 1)
-        rois = torch.cat([batch_index, rois[..., :4]], dim=-1)
-        batch_size = rois.shape[0]
-        num_proposals_per_img = rois.shape[1]
-
-        # Eliminate the batch dimension
-        rois = rois.view(-1, 5)
-        bbox_results = self._bbox_forward(x, rois)
-        cls_score = bbox_results['cls_score']
-        bbox_pred = bbox_results['bbox_pred']
-
-        # Recover the batch dimension
-        rois = rois.reshape(batch_size, num_proposals_per_img, -1)
-        cls_score = cls_score.reshape(batch_size, num_proposals_per_img, -1)
-
-        if not torch.onnx.is_in_onnx_export():
-            # remove padding
-            supplement_mask = rois[..., -1] == 0
-            cls_score[supplement_mask, :] = 0
-
-        # bbox_pred would be None in some detector when with_reg is False,
-        # e.g. Grid R-CNN.
-        if bbox_pred is not None:
-            # the bbox prediction of some detectors like SABL is not Tensor
-            if isinstance(bbox_pred, torch.Tensor):
-                bbox_pred = bbox_pred.reshape(batch_size,
-                                              num_proposals_per_img, -1)
-                if not torch.onnx.is_in_onnx_export():
-                    bbox_pred[supplement_mask, :] = 0
-            else:
-                # TODO: Looking forward to a better way
-                # For SABL
-                bbox_preds = self.bbox_head.bbox_pred_split(
-                    bbox_pred, num_proposals_per_img)
-                # apply bbox post-processing to each image individually
-                det_bboxes = []
-                det_labels = []
-                for i in range(len(proposals)):
-                    # remove padding
-                    supplement_mask = proposals[i][..., -1] == 0
-                    for bbox in bbox_preds[i]:
-                        bbox[supplement_mask] = 0
-                    det_bbox, det_label = self.bbox_head.get_bboxes(
-                        rois[i],
-                        cls_score[i],
-                        bbox_preds[i],
-                        img_shapes[i],
-                        scale_factors[i],
-                        rescale=rescale,
-                        cfg=rcnn_test_cfg)
-                    det_bboxes.append(det_bbox)
-                    det_labels.append(det_label)
-                return det_bboxes, det_labels
-        else:
-            bbox_pred = None
-
-        return self.bbox_head.get_bboxes(
-            rois,
-            cls_score,
-            bbox_pred,
-            img_shapes,
-            scale_factors,
-            rescale=rescale,
-            cfg=rcnn_test_cfg)
-
-    def aug_test_bboxes(self, feats, img_metas, proposal_list, rcnn_test_cfg):
-        """Test det bboxes with test time augmentation."""
-        aug_bboxes = []
-        aug_scores = []
-        for x, img_meta in zip(feats, img_metas):
-            # only one image in the batch
-            img_shape = img_meta[0]['img_shape']
-            scale_factor = img_meta[0]['scale_factor']
-            flip = img_meta[0]['flip']
-            flip_direction = img_meta[0]['flip_direction']
-            # TODO more flexible
-            proposals = bbox_mapping(proposal_list[0][:, :4], img_shape,
-                                     scale_factor, flip, flip_direction)
-            rois = bbox2roi([proposals])
-            bbox_results = self._bbox_forward(x, rois)
-            bboxes, scores = self.bbox_head.get_bboxes(
-                rois,
-                bbox_results['cls_score'],
-                bbox_results['bbox_pred'],
-                img_shape,
-                scale_factor,
-                rescale=False,
-                cfg=None)
-            aug_bboxes.append(bboxes)
-            aug_scores.append(scores)
-        # after merging, bboxes will be rescaled to the original image size
-        merged_bboxes, merged_scores = merge_aug_bboxes(
-            aug_bboxes, aug_scores, img_metas, rcnn_test_cfg)
-        det_bboxes, det_labels = multiclass_nms(merged_bboxes, merged_scores,
-                                                rcnn_test_cfg.score_thr,
-                                                rcnn_test_cfg.nms,
-                                                rcnn_test_cfg.max_per_img)
-        return det_bboxes, det_labels
-
-
-class MaskTestMixin(object):
-
-    if sys.version_info >= (3, 7):
-
-        async def async_test_mask(self,
-                                  x,
-                                  img_metas,
-                                  det_bboxes,
-                                  det_labels,
-                                  rescale=False,
-                                  mask_test_cfg=None):
-            """Asynchronized test for mask head without augmentation."""
-            # image shape of the first image in the batch (only one)
-            ori_shape = img_metas[0]['ori_shape']
-            scale_factor = img_metas[0]['scale_factor']
-            if det_bboxes.shape[0] == 0:
-                segm_result = [[] for _ in range(self.mask_head.num_classes)]
-            else:
-                if rescale and not isinstance(scale_factor,
-                                              (float, torch.Tensor)):
-                    scale_factor = det_bboxes.new_tensor(scale_factor)
-                _bboxes = (
-                    det_bboxes[:, :4] *
-                    scale_factor if rescale else det_bboxes)
-                mask_rois = bbox2roi([_bboxes])
-                mask_feats = self.mask_roi_extractor(
-                    x[:len(self.mask_roi_extractor.featmap_strides)],
-                    mask_rois)
-
-                if self.with_shared_head:
-                    mask_feats = self.shared_head(mask_feats)
-                if mask_test_cfg and mask_test_cfg.get('async_sleep_interval'):
-                    sleep_interval = mask_test_cfg['async_sleep_interval']
-                else:
-                    sleep_interval = 0.035
-                async with completed(
-                        __name__,
-                        'mask_head_forward',
-                        sleep_interval=sleep_interval):
-                    mask_pred = self.mask_head(mask_feats)
-                segm_result = self.mask_head.get_seg_masks(
-                    mask_pred, _bboxes, det_labels, self.test_cfg, ori_shape,
-                    scale_factor, rescale)
-            return segm_result
-
-    def simple_test_mask(self,
-                         x,
-                         img_metas,
-                         det_bboxes,
-                         det_labels,
-                         rescale=False):
-        """Simple test for mask head without augmentation."""
-        # image shapes of images in the batch
-        ori_shapes = tuple(meta['ori_shape'] for meta in img_metas)
-        scale_factors = tuple(meta['scale_factor'] for meta in img_metas)
-
-        # The length of proposals of different batches may be different.
-        # In order to form a batch, a padding operation is required.
-        if isinstance(det_bboxes, list):
-            # padding to form a batch
-            max_size = max([bboxes.size(0) for bboxes in det_bboxes])
-            for i, (bbox, label) in enumerate(zip(det_bboxes, det_labels)):
-                supplement_bbox = bbox.new_full(
-                    (max_size - bbox.size(0), bbox.size(1)), 0)
-                supplement_label = label.new_full((max_size - label.size(0), ),
-                                                  0)
-                det_bboxes[i] = torch.cat((supplement_bbox, bbox), dim=0)
-                det_labels[i] = torch.cat((supplement_label, label), dim=0)
-            det_bboxes = torch.stack(det_bboxes, dim=0)
-            det_labels = torch.stack(det_labels, dim=0)
-
-        batch_size = det_bboxes.size(0)
-        num_proposals_per_img = det_bboxes.shape[1]
-
-        # if det_bboxes is rescaled to the original image size, we need to
-        # rescale it back to the testing scale to obtain RoIs.
-        det_bboxes = det_bboxes[..., :4]
-        if rescale:
-            if not isinstance(scale_factors[0], float):
-                scale_factors = det_bboxes.new_tensor(scale_factors)
-            det_bboxes = det_bboxes * scale_factors.unsqueeze(1)
-
-        batch_index = torch.arange(
-            det_bboxes.size(0), device=det_bboxes.device).float().view(
-                -1, 1, 1).expand(det_bboxes.size(0), det_bboxes.size(1), 1)
-        mask_rois = torch.cat([batch_index, det_bboxes], dim=-1)
-        mask_rois = mask_rois.view(-1, 5)
-        mask_results = self._mask_forward(x, mask_rois)
-        mask_pred = mask_results['mask_pred']
-        try:
-            mask_full_pred, mask_occ_pred = mask_pred
-        except:
-            mask_full_pred = mask_pred
-            mask_occ_pred = mask_pred
-
-
-        # Recover the batch dimension
-        mask_full_preds = mask_full_pred.reshape(batch_size, num_proposals_per_img,
-                                       *mask_full_pred.shape[1:])
-
-        mask_occ_preds = mask_occ_pred.reshape(batch_size, num_proposals_per_img,
-                                       *mask_occ_pred.shape[1:])
-
-
-        # apply mask post-processing to each image individually
-        segm_results = []
-        for i in range(batch_size):
-            mask_full_pred = mask_full_preds[i]
-            mask_occ_pred = mask_occ_preds[i]
-            det_bbox = det_bboxes[i]
-            det_label = det_labels[i]
-
-            # remove padding
-            supplement_mask = det_bbox[..., -1] != 0
-            mask_full_pred = mask_full_pred[supplement_mask]
-            mask_occ_pred = mask_occ_pred[supplement_mask]
-            det_bbox = det_bbox[supplement_mask]
-            det_label = det_label[supplement_mask]
-
-            if det_label.shape[0] == 0:
-                segm_results.append([[]
-                                     for _ in range(self.mask_head.num_classes)
-                                     ])
-            else:
-                segm_result_vis = self.mask_head.get_seg_masks(
-                        mask_full_pred[:,0:1], det_bbox, det_label, self.test_cfg,
-                    ori_shapes[i], scale_factors[i], rescale)
-                
-                segm_result_occ = self.mask_head.get_seg_masks(
-                    mask_occ_pred[:,0:1], det_bbox, det_label, self.test_cfg,
-                    ori_shapes[i], scale_factors[i], rescale)
-
-                segm_result = segm_result_vis
-                segm_result[1] = segm_result_occ[0]
-
-                segm_results.append(segm_result)
-        return segm_results
-
-    def aug_test_mask(self, feats, img_metas, det_bboxes, det_labels):
-        """Test for mask head with test time augmentation."""
-        if det_bboxes.shape[0] == 0:
-            segm_result = [[] for _ in range(self.mask_head.num_classes)]
-        else:
-            aug_masks = []
-            for x, img_meta in zip(feats, img_metas):
-                img_shape = img_meta[0]['img_shape']
-                scale_factor = img_meta[0]['scale_factor']
-                flip = img_meta[0]['flip']
-                flip_direction = img_meta[0]['flip_direction']
-                _bboxes = bbox_mapping(det_bboxes[:, :4], img_shape,
-                                       scale_factor, flip, flip_direction)
-                mask_rois = bbox2roi([_bboxes])
-                mask_results = self._mask_forward(x, mask_rois)
-                # convert to numpy array to save memory
-                aug_masks.append(
-                    mask_results['mask_pred'].sigmoid().cpu().numpy())
-            merged_masks = merge_aug_masks(aug_masks, img_metas, self.test_cfg)
-
-            ori_shape = img_metas[0][0]['ori_shape']
-            segm_result = self.mask_head.get_seg_masks(
-                merged_masks,
-                det_bboxes,
-                det_labels,
-                self.test_cfg,
-                ori_shape,
-                scale_factor=1.0,
-                rescale=False)
-        return segm_result

spaces/ChallengeHub/Chinese-LangChain/create_knowledge.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python
-# -*- coding:utf-8 _*-
-"""
-@author:quincy qiang
-@license: Apache Licence
-@file: create_knowledge.py
-@time: 2023/04/18
-@contact: [email protected]
-@software: PyCharm
-@description: - emoji：https://emojixd.com/pocket/science
-"""
-import os
-import pandas as pd
-from langchain.schema import Document
-from langchain.document_loaders import UnstructuredFileLoader
-from langchain.embeddings.huggingface import HuggingFaceEmbeddings
-from langchain.vectorstores import FAISS
-from tqdm import tqdm
-# 中文Wikipedia数据导入示例：
-embedding_model_name = '/root/pretrained_models/text2vec-large-chinese'
-docs_path = '/root/GoMall/Knowledge-ChatGLM/cache/financial_research_reports'
-embeddings = HuggingFaceEmbeddings(model_name=embedding_model_name)
-
-
-# Wikipedia数据处理
-
-# docs = []
-
-# with open('docs/zh_wikipedia/zhwiki.sim.utf8', 'r', encoding='utf-8') as f:
-#     for idx, line in tqdm(enumerate(f.readlines())):
-#         metadata = {"source": f'doc_id_{idx}'}
-#         docs.append(Document(page_content=line.strip(), metadata=metadata))
-#
-# vector_store = FAISS.from_documents(docs, embeddings)
-# vector_store.save_local('cache/zh_wikipedia/')
-
-
-
-docs = []
-
-with open('cache/zh_wikipedia/wiki.zh-sim-cleaned.txt', 'r', encoding='utf-8') as f:
-    for idx, line in tqdm(enumerate(f.readlines())):
-        metadata = {"source": f'doc_id_{idx}'}
-        docs.append(Document(page_content=line.strip(), metadata=metadata))
-
-vector_store = FAISS.from_documents(docs, embeddings)
-vector_store.save_local('cache/zh_wikipedia/')
-
-
-# 金融研报数据处理
-# docs = []
-#
-# for doc in tqdm(os.listdir(docs_path)):
-#     if doc.endswith('.txt'):
-#         # print(doc)
-#         loader = UnstructuredFileLoader(f'{docs_path}/{doc}', mode="elements")
-#         doc = loader.load()
-#         docs.extend(doc)
-# vector_store = FAISS.from_documents(docs, embeddings)
-# vector_store.save_local('cache/financial_research_reports')
-
-
-# 英雄联盟
-
-docs = []
-
-lol_df = pd.read_csv('cache/lol/champions.csv')
-# lol_df.columns = ['id', '英雄简称', '英雄全称', '出生地', '人物属性', '英雄类别', '英雄故事']
-print(lol_df)
-
-for idx, row in lol_df.iterrows():
-    metadata = {"source": f'doc_id_{idx}'}
-    text = ' '.join(row.values)
-    # for col in ['英雄简称', '英雄全称', '出生地', '人物属性', '英雄类别', '英雄故事']:
-    #     text += row[col]
-    docs.append(Document(page_content=text, metadata=metadata))
-
-vector_store = FAISS.from_documents(docs, embeddings)
-vector_store.save_local('cache/lol/')

spaces/Cvandi/remake/realesrgan/data/realesrgan_paired_dataset.py

@@ -1,108 +0,0 @@
-import os
-from basicsr.data.data_util import paired_paths_from_folder, paired_paths_from_lmdb
-from basicsr.data.transforms import augment, paired_random_crop
-from basicsr.utils import FileClient, imfrombytes, img2tensor
-from basicsr.utils.registry import DATASET_REGISTRY
-from torch.utils import data as data
-from torchvision.transforms.functional import normalize
-
-
-@DATASET_REGISTRY.register()
-class RealESRGANPairedDataset(data.Dataset):
-    """Paired image dataset for image restoration.
-
-    Read LQ (Low Quality, e.g. LR (Low Resolution), blurry, noisy, etc) and GT image pairs.
-
-    There are three modes:
-    1. 'lmdb': Use lmdb files.
-        If opt['io_backend'] == lmdb.
-    2. 'meta_info': Use meta information file to generate paths.
-        If opt['io_backend'] != lmdb and opt['meta_info'] is not None.
-    3. 'folder': Scan folders to generate paths.
-        The rest.
-
-    Args:
-        opt (dict): Config for train datasets. It contains the following keys:
-            dataroot_gt (str): Data root path for gt.
-            dataroot_lq (str): Data root path for lq.
-            meta_info (str): Path for meta information file.
-            io_backend (dict): IO backend type and other kwarg.
-            filename_tmpl (str): Template for each filename. Note that the template excludes the file extension.
-                Default: '{}'.
-            gt_size (int): Cropped patched size for gt patches.
-            use_hflip (bool): Use horizontal flips.
-            use_rot (bool): Use rotation (use vertical flip and transposing h
-                and w for implementation).
-
-            scale (bool): Scale, which will be added automatically.
-            phase (str): 'train' or 'val'.
-    """
-
-    def __init__(self, opt):
-        super(RealESRGANPairedDataset, self).__init__()
-        self.opt = opt
-        self.file_client = None
-        self.io_backend_opt = opt['io_backend']
-        # mean and std for normalizing the input images
-        self.mean = opt['mean'] if 'mean' in opt else None
-        self.std = opt['std'] if 'std' in opt else None
-
-        self.gt_folder, self.lq_folder = opt['dataroot_gt'], opt['dataroot_lq']
-        self.filename_tmpl = opt['filename_tmpl'] if 'filename_tmpl' in opt else '{}'
-
-        # file client (lmdb io backend)
-        if self.io_backend_opt['type'] == 'lmdb':
-            self.io_backend_opt['db_paths'] = [self.lq_folder, self.gt_folder]
-            self.io_backend_opt['client_keys'] = ['lq', 'gt']
-            self.paths = paired_paths_from_lmdb([self.lq_folder, self.gt_folder], ['lq', 'gt'])
-        elif 'meta_info' in self.opt and self.opt['meta_info'] is not None:
-            # disk backend with meta_info
-            # Each line in the meta_info describes the relative path to an image
-            with open(self.opt['meta_info']) as fin:
-                paths = [line.strip() for line in fin]
-            self.paths = []
-            for path in paths:
-                gt_path, lq_path = path.split(', ')
-                gt_path = os.path.join(self.gt_folder, gt_path)
-                lq_path = os.path.join(self.lq_folder, lq_path)
-                self.paths.append(dict([('gt_path', gt_path), ('lq_path', lq_path)]))
-        else:
-            # disk backend
-            # it will scan the whole folder to get meta info
-            # it will be time-consuming for folders with too many files. It is recommended using an extra meta txt file
-            self.paths = paired_paths_from_folder([self.lq_folder, self.gt_folder], ['lq', 'gt'], self.filename_tmpl)
-
-    def __getitem__(self, index):
-        if self.file_client is None:
-            self.file_client = FileClient(self.io_backend_opt.pop('type'), **self.io_backend_opt)
-
-        scale = self.opt['scale']
-
-        # Load gt and lq images. Dimension order: HWC; channel order: BGR;
-        # image range: [0, 1], float32.
-        gt_path = self.paths[index]['gt_path']
-        img_bytes = self.file_client.get(gt_path, 'gt')
-        img_gt = imfrombytes(img_bytes, float32=True)
-        lq_path = self.paths[index]['lq_path']
-        img_bytes = self.file_client.get(lq_path, 'lq')
-        img_lq = imfrombytes(img_bytes, float32=True)
-
-        # augmentation for training
-        if self.opt['phase'] == 'train':
-            gt_size = self.opt['gt_size']
-            # random crop
-            img_gt, img_lq = paired_random_crop(img_gt, img_lq, gt_size, scale, gt_path)
-            # flip, rotation
-            img_gt, img_lq = augment([img_gt, img_lq], self.opt['use_hflip'], self.opt['use_rot'])
-
-        # BGR to RGB, HWC to CHW, numpy to tensor
-        img_gt, img_lq = img2tensor([img_gt, img_lq], bgr2rgb=True, float32=True)
-        # normalize
-        if self.mean is not None or self.std is not None:
-            normalize(img_lq, self.mean, self.std, inplace=True)
-            normalize(img_gt, self.mean, self.std, inplace=True)
-
-        return {'lq': img_lq, 'gt': img_gt, 'lq_path': lq_path, 'gt_path': gt_path}
-
-    def __len__(self):
-        return len(self.paths)

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/misc/testTools.py

@@ -1,229 +0,0 @@
-"""Helpers for writing unit tests."""
-
-from collections.abc import Iterable
-from io import BytesIO
-import os
-import re
-import shutil
-import sys
-import tempfile
-from unittest import TestCase as _TestCase
-from fontTools.config import Config
-from fontTools.misc.textTools import tobytes
-from fontTools.misc.xmlWriter import XMLWriter
-
-
-def parseXML(xmlSnippet):
-    """Parses a snippet of XML.
-
-    Input can be either a single string (unicode or UTF-8 bytes), or a
-    a sequence of strings.
-
-    The result is in the same format that would be returned by
-    XMLReader, but the parser imposes no constraints on the root
-    element so it can be called on small snippets of TTX files.
-    """
-    # To support snippets with multiple elements, we add a fake root.
-    reader = TestXMLReader_()
-    xml = b"<root>"
-    if isinstance(xmlSnippet, bytes):
-        xml += xmlSnippet
-    elif isinstance(xmlSnippet, str):
-        xml += tobytes(xmlSnippet, "utf-8")
-    elif isinstance(xmlSnippet, Iterable):
-        xml += b"".join(tobytes(s, "utf-8") for s in xmlSnippet)
-    else:
-        raise TypeError(
-            "expected string or sequence of strings; found %r"
-            % type(xmlSnippet).__name__
-        )
-    xml += b"</root>"
-    reader.parser.Parse(xml, 0)
-    return reader.root[2]
-
-
-def parseXmlInto(font, parseInto, xmlSnippet):
-    parsed_xml = [e for e in parseXML(xmlSnippet.strip()) if not isinstance(e, str)]
-    for name, attrs, content in parsed_xml:
-        parseInto.fromXML(name, attrs, content, font)
-    parseInto.populateDefaults()
-    return parseInto
-
-
-class FakeFont:
-    def __init__(self, glyphs):
-        self.glyphOrder_ = glyphs
-        self.reverseGlyphOrderDict_ = {g: i for i, g in enumerate(glyphs)}
-        self.lazy = False
-        self.tables = {}
-        self.cfg = Config()
-
-    def __getitem__(self, tag):
-        return self.tables[tag]
-
-    def __setitem__(self, tag, table):
-        self.tables[tag] = table
-
-    def get(self, tag, default=None):
-        return self.tables.get(tag, default)
-
-    def getGlyphID(self, name):
-        return self.reverseGlyphOrderDict_[name]
-
-    def getGlyphIDMany(self, lst):
-        return [self.getGlyphID(gid) for gid in lst]
-
-    def getGlyphName(self, glyphID):
-        if glyphID < len(self.glyphOrder_):
-            return self.glyphOrder_[glyphID]
-        else:
-            return "glyph%.5d" % glyphID
-
-    def getGlyphNameMany(self, lst):
-        return [self.getGlyphName(gid) for gid in lst]
-
-    def getGlyphOrder(self):
-        return self.glyphOrder_
-
-    def getReverseGlyphMap(self):
-        return self.reverseGlyphOrderDict_
-
-    def getGlyphNames(self):
-        return sorted(self.getGlyphOrder())
-
-
-class TestXMLReader_(object):
-    def __init__(self):
-        from xml.parsers.expat import ParserCreate
-
-        self.parser = ParserCreate()
-        self.parser.StartElementHandler = self.startElement_
-        self.parser.EndElementHandler = self.endElement_
-        self.parser.CharacterDataHandler = self.addCharacterData_
-        self.root = None
-        self.stack = []
-
-    def startElement_(self, name, attrs):
-        element = (name, attrs, [])
-        if self.stack:
-            self.stack[-1][2].append(element)
-        else:
-            self.root = element
-        self.stack.append(element)
-
-    def endElement_(self, name):
-        self.stack.pop()
-
-    def addCharacterData_(self, data):
-        self.stack[-1][2].append(data)
-
-
-def makeXMLWriter(newlinestr="\n"):
-    # don't write OS-specific new lines
-    writer = XMLWriter(BytesIO(), newlinestr=newlinestr)
-    # erase XML declaration
-    writer.file.seek(0)
-    writer.file.truncate()
-    return writer
-
-
-def getXML(func, ttFont=None):
-    """Call the passed toXML function and return the written content as a
-    list of lines (unicode strings).
-    Result is stripped of XML declaration and OS-specific newline characters.
-    """
-    writer = makeXMLWriter()
-    func(writer, ttFont)
-    xml = writer.file.getvalue().decode("utf-8")
-    # toXML methods must always end with a writer.newline()
-    assert xml.endswith("\n")
-    return xml.splitlines()
-
-
-def stripVariableItemsFromTTX(
-    string: str,
-    ttLibVersion: bool = True,
-    checkSumAdjustment: bool = True,
-    modified: bool = True,
-    created: bool = True,
-    sfntVersion: bool = False,  # opt-in only
-) -> str:
-    """Strip stuff like ttLibVersion, checksums, timestamps, etc. from TTX dumps."""
-    # ttlib changes with the fontTools version
-    if ttLibVersion:
-        string = re.sub(' ttLibVersion="[^"]+"', "", string)
-    # sometimes (e.g. some subsetter tests) we don't care whether it's OTF or TTF
-    if sfntVersion:
-        string = re.sub(' sfntVersion="[^"]+"', "", string)
-    # head table checksum and creation and mod date changes with each save.
-    if checkSumAdjustment:
-        string = re.sub('<checkSumAdjustment value="[^"]+"/>', "", string)
-    if modified:
-        string = re.sub('<modified value="[^"]+"/>', "", string)
-    if created:
-        string = re.sub('<created value="[^"]+"/>', "", string)
-    return string
-
-
-class MockFont(object):
-    """A font-like object that automatically adds any looked up glyphname
-    to its glyphOrder."""
-
-    def __init__(self):
-        self._glyphOrder = [".notdef"]
-
-        class AllocatingDict(dict):
-            def __missing__(reverseDict, key):
-                self._glyphOrder.append(key)
-                gid = len(reverseDict)
-                reverseDict[key] = gid
-                return gid
-
-        self._reverseGlyphOrder = AllocatingDict({".notdef": 0})
-        self.lazy = False
-
-    def getGlyphID(self, glyph):
-        gid = self._reverseGlyphOrder[glyph]
-        return gid
-
-    def getReverseGlyphMap(self):
-        return self._reverseGlyphOrder
-
-    def getGlyphName(self, gid):
-        return self._glyphOrder[gid]
-
-    def getGlyphOrder(self):
-        return self._glyphOrder
-
-
-class TestCase(_TestCase):
-    def __init__(self, methodName):
-        _TestCase.__init__(self, methodName)
-        # Python 3 renamed assertRaisesRegexp to assertRaisesRegex,
-        # and fires deprecation warnings if a program uses the old name.
-        if not hasattr(self, "assertRaisesRegex"):
-            self.assertRaisesRegex = self.assertRaisesRegexp
-
-
-class DataFilesHandler(TestCase):
-    def setUp(self):
-        self.tempdir = None
-        self.num_tempfiles = 0
-
-    def tearDown(self):
-        if self.tempdir:
-            shutil.rmtree(self.tempdir)
-
-    def getpath(self, testfile):
-        folder = os.path.dirname(sys.modules[self.__module__].__file__)
-        return os.path.join(folder, "data", testfile)
-
-    def temp_dir(self):
-        if not self.tempdir:
-            self.tempdir = tempfile.mkdtemp()
-
-    def temp_font(self, font_path, file_name):
-        self.temp_dir()
-        temppath = os.path.join(self.tempdir, file_name)
-        shutil.copy2(font_path, temppath)
-        return temppath

spaces/EuroPython2022/pulsar-clip/README.md

@@ -1,13 +0,0 @@
----
-title: Pulsar Clip
-emoji: 😻
-colorFrom: yellow
-colorTo: blue
-sdk: gradio
-sdk_version: 3.1.4b5
-app_file: app.py
-pinned: false
-license: agpl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/FrankZxShen/so-vits-svc-models-ba/diffusion/infer_gt_mel.py

@@ -1,74 +0,0 @@
-import numpy as np
-import torch
-import torch.nn.functional as F
-from diffusion.unit2mel import load_model_vocoder
-
-
-class DiffGtMel:
-    def __init__(self, project_path=None, device=None):
-        self.project_path = project_path
-        if device is not None:
-            self.device = device
-        else:
-            self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-        self.model = None
-        self.vocoder = None
-        self.args = None
-
-    def flush_model(self, project_path, ddsp_config=None):
-        if (self.model is None) or (project_path != self.project_path):
-            model, vocoder, args = load_model_vocoder(project_path, device=self.device)
-            if self.check_args(ddsp_config, args):
-                self.model = model
-                self.vocoder = vocoder
-                self.args = args
-
-    def check_args(self, args1, args2):
-        if args1.data.block_size != args2.data.block_size:
-            raise ValueError("DDSP与DIFF模型的block_size不一致")
-        if args1.data.sampling_rate != args2.data.sampling_rate:
-            raise ValueError("DDSP与DIFF模型的sampling_rate不一致")
-        if args1.data.encoder != args2.data.encoder:
-            raise ValueError("DDSP与DIFF模型的encoder不一致")
-        return True
-
-    def __call__(self, audio, f0, hubert, volume, acc=1, spk_id=1, k_step=0, method='pndm',
-                 spk_mix_dict=None, start_frame=0):
-        input_mel = self.vocoder.extract(audio, self.args.data.sampling_rate)
-        out_mel = self.model(
-            hubert,
-            f0,
-            volume,
-            spk_id=spk_id,
-            spk_mix_dict=spk_mix_dict,
-            gt_spec=input_mel,
-            infer=True,
-            infer_speedup=acc,
-            method=method,
-            k_step=k_step,
-            use_tqdm=False)
-        if start_frame > 0:
-            out_mel = out_mel[:, start_frame:, :]
-            f0 = f0[:, start_frame:, :]
-        output = self.vocoder.infer(out_mel, f0)
-        if start_frame > 0:
-            output = F.pad(output, (start_frame * self.vocoder.vocoder_hop_size, 0))
-        return output
-
-    def infer(self, audio, f0, hubert, volume, acc=1, spk_id=1, k_step=0, method='pndm', silence_front=0,
-              use_silence=False, spk_mix_dict=None):
-        start_frame = int(silence_front * self.vocoder.vocoder_sample_rate / self.vocoder.vocoder_hop_size)
-        if use_silence:
-            audio = audio[:, start_frame * self.vocoder.vocoder_hop_size:]
-            f0 = f0[:, start_frame:, :]
-            hubert = hubert[:, start_frame:, :]
-            volume = volume[:, start_frame:, :]
-            _start_frame = 0
-        else:
-            _start_frame = start_frame
-        audio = self.__call__(audio, f0, hubert, volume, acc=acc, spk_id=spk_id, k_step=k_step,
-                              method=method, spk_mix_dict=spk_mix_dict, start_frame=_start_frame)
-        if use_silence:
-            if start_frame > 0:
-                audio = F.pad(audio, (start_frame * self.vocoder.vocoder_hop_size, 0))
-        return audio

spaces/GMFTBY/PandaGPT/model/ImageBind/__init__.py

@@ -1,2 +0,0 @@
-from .models import imagebind_model
-from .models.imagebind_model import ModalityType

spaces/GaenKoki/voicevox/speaker_info/388f246b-8c41-4ac1-8e2d-5d79f3ff56d9/policy.md

@@ -1,3 +0,0 @@
-dummy2 policy
-
-https://voicevox.hiroshiba.jp/

spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/block_on_cylinder_on_pallet.py

@@ -1,58 +0,0 @@
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-class BlockOnCylinderOnPallet(Task):
-    """Pick up each block and place it on the corresponding colored cylinder, which are located in specific positions on a pallet."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 15
-        self.lang_template = "place the {} cylinder on the pallet"
-        self.lang_template_2 = "place the {} block on the {} cylinder"
-
-        self.task_completed_desc = "done placing blocks on cylinders and cylinder on pallet."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add pallet.
-        pallet_size = (0.35, 0.35, 0.01)
-        pallet_pose = self.get_random_pose(env, pallet_size)
-        pallet_urdf = 'pallet/pallet.urdf'
-        env.add_object(pallet_urdf, pallet_pose, 'fixed')
-
-        # Define colors.
-        block_colors = ['red']
-        cylinder_colors = ['blue']
-
-        # Add cylinders.
-        cylinder_size = (0.04, 0.04, 0.06)
-        cylinder_template = 'cylinder/cylinder-template.urdf'
-        cylinders = []
-
-
-        replace = {'DIM': cylinder_size, 'HALF': (cylinder_size[0] / 2, cylinder_size[1] / 2, cylinder_size[2] / 2), 'COLOR': block_colors[0]}
-        cylinder_urdf = self.fill_template(cylinder_template, replace)
-        cylinder_pose = self.get_random_pose(env, cylinder_size)
-        cylinder_id = env.add_object(cylinder_urdf, cylinder_pose)
-        cylinders.append(cylinder_id)
-
-        # Add blocks.
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'block/block.urdf'
-        blocks = []
-        block_pose = self.get_random_pose(env, block_size)
-        block_id = env.add_object(block_urdf, block_pose, color=cylinder_colors[0])
-        blocks.append(block_id)
-
-        # Goal: place the cylinder on top of the pallet
-        self.add_goal(objs=[cylinders[0]], matches=np.ones((1, 1)), targ_poses=[pallet_pose], replace=False,
-                      rotations=True, metric='pose', params=None, step_max_reward=1/2, language_goal=self.lang_template.format(cylinder_colors[0]))
-
-
-        # Goal: place the block on top of the cylinder
-        language_goal = self.lang_template_2.format(block_colors[0], cylinder_colors[0])
-        self.add_goal(objs=[blocks[0]], matches=np.ones((1, 1)), targ_poses=[pallet_pose], replace=False,
-                      rotations=True, metric='pose', params=None, step_max_reward=1/2, language_goal=language_goal)

spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/color_cued_ball_corner_sorting.py

@@ -1,62 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-class ColorCuedBallCornerSorting(Task):
-    """Pick up each colored ball and place it in the corner of the same color while avoiding a zone marked by small blocks."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "place the {color} ball in the {color} corner"
-        self.task_completed_desc = "done sorting balls."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add corners.
-        corner_size = (0.05, 0.05, 0.05)
-        corner_urdf = 'corner/corner-template.urdf'
-        corner_colors = ['red', 'blue', 'green', 'yellow']
-        corner_poses = []
-        for color in corner_colors:
-            corner_pose = self.get_random_pose(env, corner_size)
-            env.add_object(corner_urdf, corner_pose, color=color, category='fixed')
-            corner_poses.append(corner_pose)
-
-        # Add balls.
-        balls = []
-        ball_size = (0.04, 0.04, 0.04)
-        ball_urdf = 'ball/ball-template.urdf'
-        for color in corner_colors:
-            ball_pose = self.get_random_pose(env, ball_size)
-            ball_id = env.add_object(ball_urdf, ball_pose, color=color)
-            balls.append(ball_id)
-
-        # Add zone.
-        zone_size = (0.2, 0.2, 0.05)
-        zone_pose = self.get_random_pose(env, zone_size)
-        zone_urdf = 'zone/zone.urdf'
-        env.add_object(zone_urdf, zone_pose, 'fixed')
-
-        # Add blocks.
-        block_size = (0.04, 0.04, 0.04)
-        block_urdf = 'block/block_for_anchors.urdf'
-        for _ in range(4):
-            block_pose = self.get_random_pose(env, block_size)
-            env.add_object(block_urdf, block_pose)
-
-        # Goal: each ball is in the corner of the same color.
-        for i in range(4):
-            self.add_goal(objs=[balls[i]], matches=np.ones((1, 1)), targ_poses=[corner_poses[i]], replace=False,
-                          rotations=True, metric='pose', params=None, step_max_reward=1/4,
-                          language_goal=self.lang_template.format(color=corner_colors[i]))

spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/color_ordered_insertion_new.py

@@ -1,52 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-class ColorOrderedInsertionNew(Task):
-    """Insert differently-colored ell objects into the matching color fixture in a specific order."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "put the {color} L shape block in the L shape hole"
-        self.task_completed_desc = "done with insertion."
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Define colors and their order
-        colors = ['red', 'blue', 'green', 'yellow']
-        color_order = {color: i for i, color in enumerate(colors)}
-
-        # Add fixtures.
-        fixture_size = (0.12, 0.12, 0.02)
-        fixture_urdf = 'insertion/fixture.urdf'
-        fixtures = []
-        for color in colors:
-            fixture_pose = self.get_random_pose(env, fixture_size)
-            fixture_id = env.add_object(fixture_urdf, fixture_pose, color=utils.COLORS[color], category='fixed')
-            fixtures.append(fixture_id)
-
-        # Add ell objects.
-        ell_size = (0.04, 0.04, 0.04)
-        ell_urdf = 'insertion/ell.urdf'
-        ells = []
-        for color in colors:
-            ell_pose = self.get_random_pose(env, ell_size)
-            ell_id = env.add_object(ell_urdf, ell_pose, color=utils.COLORS[color])
-            ells.append(ell_id)
-
-        # Goal: each ell is inserted into the matching color fixture in the correct order.
-        for i, ell in enumerate(ells):
-            self.add_goal(objs=[ell], matches=np.ones((1, 1)), targ_poses=[p.getBasePositionAndOrientation(fixtures[i])], replace=False,
-                          rotations=True, metric='pose', params=None, step_max_reward=1 / len(ells),
-                          language_goal=self.lang_template.format(color=colors[i]))

spaces/Gen-Sim/Gen-Sim/cliport/generated_tasks/move_piles_along_line.py

@@ -1,70 +0,0 @@
-import numpy as np
-import os
-import pybullet as p
-import random
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-import numpy as np
-from cliport.tasks import primitives
-from cliport.tasks.grippers import Spatula
-from cliport.tasks.task import Task
-from cliport.utils import utils
-
-class MovePilesAlongLine(Task):
-    """Move three piles of small blocks, each pile a different color (red, blue, green), 
-    along three matching colored lines to three separate zones of the same color using a spatula."""
-
-    def __init__(self):
-        super().__init__()
-        self.max_steps = 20
-        self.lang_template = "move the piles of blocks along the lines to the matching colored zones"
-        self.task_completed_desc = "done moving piles."
-        self.primitive = primitives.push
-        self.ee = Spatula
-        self.additional_reset()
-
-    def reset(self, env):
-        super().reset(env)
-
-        # Add three colored lines.
-        line_template = 'line/line-template.urdf'
-        line_colors = ['red', 'blue', 'green']
-        line_poses = []
-        for color in line_colors:
-            line_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-            line_pose = self.get_random_pose(env, line_size)
-            replace = {'DIM': line_size, 'HALF': (line_size[0] / 2, line_size[1] / 2, line_size[2] / 2), 'COLOR': color}
-            line_urdf = self.fill_template(line_template, replace)
-            env.add_object(line_urdf, line_pose, 'fixed')
-            line_poses.append(line_pose)
-
-        # Add three colored zones.
-        zone_template = 'zone/zone.urdf'
-        zone_poses = []
-        for color in line_colors:
-            zone_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-            zone_pose = self.get_random_pose(env, zone_size)
-            replace = {'DIM': zone_size, 'HALF': (zone_size[0] / 2, zone_size[1] / 2, zone_size[2] / 2), 'COLOR': color}
-            zone_urdf = self.fill_template(zone_template, replace)
-            env.add_object(zone_urdf, zone_pose, 'fixed')
-            zone_poses.append(zone_pose)
-
-        # Add three piles of small blocks.
-        block_template = 'block/small.urdf'
-        block_colors = ['red', 'blue', 'green']
-        block_ids = []
-        for color in block_colors:
-            block_size = self.get_random_size(0.1, 0.15, 0.1, 0.15, 0.05, 0.05)
-            block_pose = self.get_random_pose(env, block_size)
-            replace = {'DIM': block_size, 'HALF': (block_size[0] / 2, block_size[1] / 2, block_size[2] / 2), 'COLOR': color}
-            block_urdf = self.fill_template(block_template, replace)
-            block_id = env.add_object(block_urdf, block_pose)
-            block_ids.append(block_id)
-
-        # Add goals.
-        for i in range(3):
-            self.add_goal(objs=[block_ids[i]], matches=np.ones((1, 1)), targ_poses=[zone_poses[i]], replace=False,
-                          rotations=False, metric='zone', params=[(zone_poses[i], zone_size)], step_max_reward=1/3,
-                          language_goal=self.lang_template)

spaces/Gradio-Blocks/uniformer_image_detection/mmdet/core/bbox/coder/tblr_bbox_coder.py

@@ -1,198 +0,0 @@
-import mmcv
-import torch
-
-from ..builder import BBOX_CODERS
-from .base_bbox_coder import BaseBBoxCoder
-
-
-@BBOX_CODERS.register_module()
-class TBLRBBoxCoder(BaseBBoxCoder):
-    """TBLR BBox coder.
-
-    Following the practice in `FSAF <https://arxiv.org/abs/1903.00621>`_,
-    this coder encodes gt bboxes (x1, y1, x2, y2) into (top, bottom, left,
-    right) and decode it back to the original.
-
-    Args:
-        normalizer (list | float): Normalization factor to be
-          divided with when coding the coordinates. If it is a list, it should
-          have length of 4 indicating normalization factor in tblr dims.
-          Otherwise it is a unified float factor for all dims. Default: 4.0
-        clip_border (bool, optional): Whether clip the objects outside the
-            border of the image. Defaults to True.
-    """
-
-    def __init__(self, normalizer=4.0, clip_border=True):
-        super(BaseBBoxCoder, self).__init__()
-        self.normalizer = normalizer
-        self.clip_border = clip_border
-
-    def encode(self, bboxes, gt_bboxes):
-        """Get box regression transformation deltas that can be used to
-        transform the ``bboxes`` into the ``gt_bboxes`` in the (top, left,
-        bottom, right) order.
-
-        Args:
-            bboxes (torch.Tensor): source boxes, e.g., object proposals.
-            gt_bboxes (torch.Tensor): target of the transformation, e.g.,
-                ground truth boxes.
-
-        Returns:
-            torch.Tensor: Box transformation deltas
-        """
-        assert bboxes.size(0) == gt_bboxes.size(0)
-        assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
-        encoded_bboxes = bboxes2tblr(
-            bboxes, gt_bboxes, normalizer=self.normalizer)
-        return encoded_bboxes
-
-    def decode(self, bboxes, pred_bboxes, max_shape=None):
-        """Apply transformation `pred_bboxes` to `boxes`.
-
-        Args:
-            bboxes (torch.Tensor): Basic boxes.Shape (B, N, 4) or (N, 4)
-            pred_bboxes (torch.Tensor): Encoded boxes with shape
-               (B, N, 4) or (N, 4)
-            max_shape (Sequence[int] or torch.Tensor or Sequence[
-               Sequence[int]],optional): Maximum bounds for boxes, specifies
-               (H, W, C) or (H, W). If bboxes shape is (B, N, 4), then
-               the max_shape should be a Sequence[Sequence[int]]
-               and the length of max_shape should also be B.
-
-        Returns:
-            torch.Tensor: Decoded boxes.
-        """
-        decoded_bboxes = tblr2bboxes(
-            bboxes,
-            pred_bboxes,
-            normalizer=self.normalizer,
-            max_shape=max_shape,
-            clip_border=self.clip_border)
-
-        return decoded_bboxes
-
-
-@mmcv.jit(coderize=True)
-def bboxes2tblr(priors, gts, normalizer=4.0, normalize_by_wh=True):
-    """Encode ground truth boxes to tblr coordinate.
-
-    It first convert the gt coordinate to tblr format,
-     (top, bottom, left, right), relative to prior box centers.
-     The tblr coordinate may be normalized by the side length of prior bboxes
-     if `normalize_by_wh` is specified as True, and it is then normalized by
-     the `normalizer` factor.
-
-    Args:
-        priors (Tensor): Prior boxes in point form
-            Shape: (num_proposals,4).
-        gts (Tensor): Coords of ground truth for each prior in point-form
-            Shape: (num_proposals, 4).
-        normalizer (Sequence[float] | float): normalization parameter of
-            encoded boxes. If it is a list, it has to have length = 4.
-            Default: 4.0
-        normalize_by_wh (bool): Whether to normalize tblr coordinate by the
-            side length (wh) of prior bboxes.
-
-    Return:
-        encoded boxes (Tensor), Shape: (num_proposals, 4)
-    """
-
-    # dist b/t match center and prior's center
-    if not isinstance(normalizer, float):
-        normalizer = torch.tensor(normalizer, device=priors.device)
-        assert len(normalizer) == 4, 'Normalizer must have length = 4'
-    assert priors.size(0) == gts.size(0)
-    prior_centers = (priors[:, 0:2] + priors[:, 2:4]) / 2
-    xmin, ymin, xmax, ymax = gts.split(1, dim=1)
-    top = prior_centers[:, 1].unsqueeze(1) - ymin
-    bottom = ymax - prior_centers[:, 1].unsqueeze(1)
-    left = prior_centers[:, 0].unsqueeze(1) - xmin
-    right = xmax - prior_centers[:, 0].unsqueeze(1)
-    loc = torch.cat((top, bottom, left, right), dim=1)
-    if normalize_by_wh:
-        # Normalize tblr by anchor width and height
-        wh = priors[:, 2:4] - priors[:, 0:2]
-        w, h = torch.split(wh, 1, dim=1)
-        loc[:, :2] /= h  # tb is normalized by h
-        loc[:, 2:] /= w  # lr is normalized by w
-    # Normalize tblr by the given normalization factor
-    return loc / normalizer
-
-
-@mmcv.jit(coderize=True)
-def tblr2bboxes(priors,
-                tblr,
-                normalizer=4.0,
-                normalize_by_wh=True,
-                max_shape=None,
-                clip_border=True):
-    """Decode tblr outputs to prediction boxes.
-
-    The process includes 3 steps: 1) De-normalize tblr coordinates by
-    multiplying it with `normalizer`; 2) De-normalize tblr coordinates by the
-    prior bbox width and height if `normalize_by_wh` is `True`; 3) Convert
-    tblr (top, bottom, left, right) pair relative to the center of priors back
-    to (xmin, ymin, xmax, ymax) coordinate.
-
-    Args:
-        priors (Tensor): Prior boxes in point form (x0, y0, x1, y1)
-          Shape: (N,4) or (B, N, 4).
-        tblr (Tensor): Coords of network output in tblr form
-          Shape: (N, 4) or (B, N, 4).
-        normalizer (Sequence[float] | float): Normalization parameter of
-          encoded boxes. By list, it represents the normalization factors at
-          tblr dims. By float, it is the unified normalization factor at all
-          dims. Default: 4.0
-        normalize_by_wh (bool): Whether the tblr coordinates have been
-          normalized by the side length (wh) of prior bboxes.
-        max_shape (Sequence[int] or torch.Tensor or Sequence[
-            Sequence[int]],optional): Maximum bounds for boxes, specifies
-            (H, W, C) or (H, W). If priors shape is (B, N, 4), then
-            the max_shape should be a Sequence[Sequence[int]]
-            and the length of max_shape should also be B.
-        clip_border (bool, optional): Whether clip the objects outside the
-            border of the image. Defaults to True.
-
-    Return:
-        encoded boxes (Tensor): Boxes with shape (N, 4) or (B, N, 4)
-    """
-    if not isinstance(normalizer, float):
-        normalizer = torch.tensor(normalizer, device=priors.device)
-        assert len(normalizer) == 4, 'Normalizer must have length = 4'
-    assert priors.size(0) == tblr.size(0)
-    if priors.ndim == 3:
-        assert priors.size(1) == tblr.size(1)
-
-    loc_decode = tblr * normalizer
-    prior_centers = (priors[..., 0:2] + priors[..., 2:4]) / 2
-    if normalize_by_wh:
-        wh = priors[..., 2:4] - priors[..., 0:2]
-        w, h = torch.split(wh, 1, dim=-1)
-        # Inplace operation with slice would failed for exporting to ONNX
-        th = h * loc_decode[..., :2]  # tb
-        tw = w * loc_decode[..., 2:]  # lr
-        loc_decode = torch.cat([th, tw], dim=-1)
-    # Cannot be exported using onnx when loc_decode.split(1, dim=-1)
-    top, bottom, left, right = loc_decode.split((1, 1, 1, 1), dim=-1)
-    xmin = prior_centers[..., 0].unsqueeze(-1) - left
-    xmax = prior_centers[..., 0].unsqueeze(-1) + right
-    ymin = prior_centers[..., 1].unsqueeze(-1) - top
-    ymax = prior_centers[..., 1].unsqueeze(-1) + bottom
-
-    bboxes = torch.cat((xmin, ymin, xmax, ymax), dim=-1)
-
-    if clip_border and max_shape is not None:
-        if not isinstance(max_shape, torch.Tensor):
-            max_shape = priors.new_tensor(max_shape)
-        max_shape = max_shape[..., :2].type_as(priors)
-        if max_shape.ndim == 2:
-            assert bboxes.ndim == 3
-            assert max_shape.size(0) == bboxes.size(0)
-
-        min_xy = priors.new_tensor(0)
-        max_xy = torch.cat([max_shape, max_shape],
-                           dim=-1).flip(-1).unsqueeze(-2)
-        bboxes = torch.where(bboxes < min_xy, min_xy, bboxes)
-        bboxes = torch.where(bboxes > max_xy, max_xy, bboxes)
-
-    return bboxes

spaces/Gradio-Blocks/uniformer_image_detection/mmdet/models/losses/__init__.py

@@ -1,29 +0,0 @@
-from .accuracy import Accuracy, accuracy
-from .ae_loss import AssociativeEmbeddingLoss
-from .balanced_l1_loss import BalancedL1Loss, balanced_l1_loss
-from .cross_entropy_loss import (CrossEntropyLoss, binary_cross_entropy,
-                                 cross_entropy, mask_cross_entropy)
-from .focal_loss import FocalLoss, sigmoid_focal_loss
-from .gaussian_focal_loss import GaussianFocalLoss
-from .gfocal_loss import DistributionFocalLoss, QualityFocalLoss
-from .ghm_loss import GHMC, GHMR
-from .iou_loss import (BoundedIoULoss, CIoULoss, DIoULoss, GIoULoss, IoULoss,
-                       bounded_iou_loss, iou_loss)
-from .kd_loss import KnowledgeDistillationKLDivLoss
-from .mse_loss import MSELoss, mse_loss
-from .pisa_loss import carl_loss, isr_p
-from .smooth_l1_loss import L1Loss, SmoothL1Loss, l1_loss, smooth_l1_loss
-from .utils import reduce_loss, weight_reduce_loss, weighted_loss
-from .varifocal_loss import VarifocalLoss
-
-__all__ = [
-    'accuracy', 'Accuracy', 'cross_entropy', 'binary_cross_entropy',
-    'mask_cross_entropy', 'CrossEntropyLoss', 'sigmoid_focal_loss',
-    'FocalLoss', 'smooth_l1_loss', 'SmoothL1Loss', 'balanced_l1_loss',
-    'BalancedL1Loss', 'mse_loss', 'MSELoss', 'iou_loss', 'bounded_iou_loss',
-    'IoULoss', 'BoundedIoULoss', 'GIoULoss', 'DIoULoss', 'CIoULoss', 'GHMC',
-    'GHMR', 'reduce_loss', 'weight_reduce_loss', 'weighted_loss', 'L1Loss',
-    'l1_loss', 'isr_p', 'carl_loss', 'AssociativeEmbeddingLoss',
-    'GaussianFocalLoss', 'QualityFocalLoss', 'DistributionFocalLoss',
-    'VarifocalLoss', 'KnowledgeDistillationKLDivLoss'
-]

spaces/Gradio-Blocks/uniformer_image_segmentation/configs/deeplabv3/deeplabv3_r50-d8_480x480_40k_pascal_context.py

@@ -1,10 +0,0 @@
-_base_ = [
-    '../_base_/models/deeplabv3_r50-d8.py',
-    '../_base_/datasets/pascal_context.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=60),
-    auxiliary_head=dict(num_classes=60),
-    test_cfg=dict(mode='slide', crop_size=(480, 480), stride=(320, 320)))
-optimizer = dict(type='SGD', lr=0.004, momentum=0.9, weight_decay=0.0001)

spaces/Gradio-Blocks/uniformer_image_segmentation/configs/fcn/fcn_d6_r50-d16_512x1024_40k_cityscapes.py

@@ -1,8 +0,0 @@
-_base_ = [
-    '../_base_/models/fcn_r50-d8.py', '../_base_/datasets/cityscapes.py',
-    '../_base_/default_runtime.py', '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
-    backbone=dict(dilations=(1, 1, 1, 2), strides=(1, 2, 2, 1)),
-    decode_head=dict(dilation=6),
-    auxiliary_head=dict(dilation=6))

spaces/Gradio-Blocks/uniformer_image_segmentation/configs/nonlocal_net/nonlocal_r101-d8_512x512_40k_voc12aug.py

@@ -1,2 +0,0 @@
-_base_ = './nonlocal_r50-d8_512x512_40k_voc12aug.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))

spaces/Gradio-Blocks/uniformer_image_segmentation/configs/resnest/fcn_s101-d8_512x512_160k_ade20k.py

@@ -1,9 +0,0 @@
-_base_ = '../fcn/fcn_r101-d8_512x512_160k_ade20k.py'
-model = dict(
-    pretrained='open-mmlab://resnest101',
-    backbone=dict(
-        type='ResNeSt',
-        stem_channels=128,
-        radix=2,
-        reduction_factor=4,
-        avg_down_stride=True))

spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/losses/sisnr.py

@@ -1,92 +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 math
-import typing as tp
-
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-def _unfold(a: torch.Tensor, kernel_size: int, stride: int) -> torch.Tensor:
-    """Given input of size [*OT, T], output Tensor of size [*OT, F, K]
-    with K the kernel size, by extracting frames with the given stride.
-    This will pad the input so that `F = ceil(T / K)`.
-    see https://github.com/pytorch/pytorch/issues/60466
-    """
-    *shape, length = a.shape
-    n_frames = math.ceil(length / stride)
-    tgt_length = (n_frames - 1) * stride + kernel_size
-    a = F.pad(a, (0, tgt_length - length))
-    strides = list(a.stride())
-    assert strides[-1] == 1, "data should be contiguous"
-    strides = strides[:-1] + [stride, 1]
-    return a.as_strided([*shape, n_frames, kernel_size], strides)
-
-
-def _center(x: torch.Tensor) -> torch.Tensor:
-    return x - x.mean(-1, True)
-
-
-def _norm2(x: torch.Tensor) -> torch.Tensor:
-    return x.pow(2).sum(-1, True)
-
-
-class SISNR(nn.Module):
-    """SISNR loss.
-
-    Input should be [B, C, T], output is scalar.
-
-    Args:
-        sample_rate (int): Sample rate.
-        segment (float or None): Evaluate on chunks of that many seconds. If None, evaluate on
-            entire audio only.
-        overlap (float): Overlap between chunks, i.e. 0.5 = 50 % overlap.
-        epsilon (float): Epsilon value for numerical stability.
-    """
-    def __init__(
-        self,
-        sample_rate: int = 16000,
-        segment: tp.Optional[float] = 20,
-        overlap: float = 0.5,
-        epsilon: float = torch.finfo(torch.float32).eps,
-    ):
-        super().__init__()
-        self.sample_rate = sample_rate
-        self.segment = segment
-        self.overlap = overlap
-        self.epsilon = epsilon
-
-    def forward(self, out_sig: torch.Tensor, ref_sig: torch.Tensor) -> torch.Tensor:
-        B, C, T = ref_sig.shape
-        assert ref_sig.shape == out_sig.shape
-
-        if self.segment is None:
-            frame = T
-            stride = T
-        else:
-            frame = int(self.segment * self.sample_rate)
-            stride = int(frame * (1 - self.overlap))
-
-        epsilon = self.epsilon * frame  # make epsilon prop to frame size.
-
-        gt = _unfold(ref_sig, frame, stride)
-        est = _unfold(out_sig, frame, stride)
-        if self.segment is None:
-            assert gt.shape[-1] == 1
-
-        gt = _center(gt)
-        est = _center(est)
-        dot = torch.einsum("bcft,bcft->bcf", gt, est)
-
-        proj = dot[:, :, :, None] * gt / (epsilon + _norm2(gt))
-        noise = est - proj
-
-        sisnr = 10 * (
-            torch.log10(epsilon + _norm2(proj)) - torch.log10(epsilon + _norm2(noise))
-        )
-        return -1 * sisnr[..., 0].mean()

spaces/HLasse/textdescriptives/data_viewer.py

@@ -1,26 +0,0 @@
-"""
-Class for showing header and download button in the same row.
-"""
-
-import streamlit as st
-
-
-class DataViewer:
-    def _convert_df_to_csv(self, data, **kwargs):
-        return data.to_csv(**kwargs).encode("utf-8")
-
-    def _header_and_download(
-        self, header, data, file_name, key=None, label="Download", help="Download data"
-    ):
-        col1, col2 = st.columns([9, 2])
-        with col1:
-            st.subheader(header)
-        with col2:
-            st.write("")
-            st.download_button(
-                label=label,
-                data=self._convert_df_to_csv(data, index=False),
-                file_name=file_name,
-                key=key,
-                help=help,
-            )

spaces/HaHaBill/LandShapes-Antarctica/netdissect/dissect.html

@@ -1,399 +0,0 @@
-<!doctype html>
-<html>
-<head>
-<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
-<script src="https://code.jquery.com/jquery-3.3.1.js" integrity="sha256-2Kok7MbOyxpgUVvAk/HJ2jigOSYS2auK4Pfzbm7uH60=" crossorigin="anonymous"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.12.9/umd/popper.min.js" integrity="sha384-ApNbgh9B+Y1QKtv3Rn7W3mgPxhU9K/ScQsAP7hUibX39j7fakFPskvXusvfa0b4Q" crossorigin="anonymous"></script>
-<script src="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/js/bootstrap.min.js" integrity="sha384-JZR6Spejh4U02d8jOt6vLEHfe/JQGiRRSQQxSfFWpi1MquVdAyjUar5+76PVCmYl" crossorigin="anonymous"></script>
-<script src="https://cdnjs.cloudflare.com/ajax/libs/vue/2.5.16/vue.js" integrity="sha256-CMMTrj5gGwOAXBeFi7kNokqowkzbeL8ydAJy39ewjkQ=" crossorigin="anonymous"></script>
-<script src="https://cdn.jsdelivr.net/npm/[email protected]/lodash.js" integrity="sha256-qwbDmNVLiCqkqRBpF46q5bjYH11j5cd+K+Y6D3/ja28=" crossorigin="anonymous"></script>
-<style>
-[v-cloak] {
-  display: none;
-}
-.unitviz, .unitviz .modal-header, .unitviz .modal-body, .unitviz .modal-footer {
-  font-family: Arial;
-  font-size: 15px;
-}
-.unitgrid {
-  text-align: center;
-  border-spacing: 5px;
-  border-collapse: separate;
-}
-.unitgrid .info {
-  text-align: left;
-}
-.unitgrid .layername {
-  display: none;
-}
-.unitlabel {
-  font-weight: bold;
-  font-size: 150%;
-  text-align: center;
-  line-height: 1;
-}
-.lowscore .unitlabel {
-   color: silver;
-}
-.thumbcrop {
-  overflow: hidden;
-  width: 288px;
-  height: 72px;
-}
-.thumbcrop img, .img-scroller img {
-  image-rendering: pixelated;
-}
-.unit {
-  display: inline-block;
-  background: white;
-  padding: 3px;
-  margin: 2px;
-  box-shadow: 0 5px 12px grey;
-}
-.iou {
-  display: inline-block;
-  float: right;
-  margin-left: 5px;
-}
-.modal .big-modal {
-  width:auto;
-  max-width:90%;
-  max-height:80%;
-}
-.modal-title {
-  display: inline-block;
-}
-.footer-caption {
-  float: left;
-  width: 100%;
-}
-.histogram {
-  text-align: center;
-  margin-top: 3px;
-}
-.img-wrapper {
-  text-align: center;
-  position: relative;
-}
-.img-mask, .img-seg {
-  position: absolute;
-  top: 0;
-  left: 0;
-  z-index: 0;
-  visibility: hidden;
-}
-input.hidden-toggle {
-  display: none;
-}
-#show-seg:checked ~ .img-wrapper .img-seg,
-#show-mask:checked ~ .img-wrapper .img-mask {
-  visibility: visible;
-}
-.img-controls {
-  text-align: right;
-}
-.img-controls label {
-  display: inline-block;
-  background: silver;
-  padding: 10px;
-  margin-top: 0;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
-.seginfo {
-  display: inline-block;
-  padding: 10px;
-  float: left;
-}
-.img-mask {
-  pointer-events: none;
-}
-.colorsample {
-  display: inline-block;
-  height: 42px;
-  width: 42px;
-  float: left;
-}
-#show-seg:checked ~ .img-controls .toggle-seg,
-#show-mask:checked ~ .img-controls .toggle-mask {
-  background: navy;
-  color: white;
-}
-.big-modal img {
-  max-height: 60vh;
-}
-.img-scroller {
-  overflow-x: scroll;
-}
-.img-scroller .img-fluid {
-  max-width: initial;
-}
-.gridheader {
-  font-size: 12px;
-  margin-bottom: 10px;
-  margin-left: 30px;
-  margin-right: 30px;
-}
-.gridheader:after {
-  content: '';
-  display: table;
-  clear: both;
-}
-.sortheader {
-  float: right;
-  cursor: default;
-}
-.layerinfo {
-  float: left;
-}
-.sortby {
-  text-decoration: underline;
-  cursor: pointer;
-}
-.sortby.currentsort {
-  text-decoration: none;
-  font-weight: bold;
-  cursor: default;
-}
-.bg-inverse {
-  background: #021B54;
-}
-.dropmenu {
-  display: inline-block;
-  vertical-align: top;
-  position: relative;
-}
-.dropmenulist {
-  pointer-events: auto;
-  visibility: hidden;
-  transition: visiblity 1s;
-  position: absolute;
-  z-index: 1;
-  background: white;
-  right: 0;
-  text-align: right;
-  white-space: nowrap;
-}
-.dropmenu:focus {
-  pointer-events: none;
-}
-.dropmenu:focus .dropmenulist {
-  visibility: visible;
-}
-</style>
-</head>
-<body class="unitviz">
-<div id="app" v-if="dissect" v-cloak>
-
-<nav class="navbar navbar-expand navbar-dark bg-inverse">
-<span class="navbar-brand">{{ dissect.netname || 'Dissection' }}</span>
-<ul class="navbar-nav mr-auto">
-<li :class="{'nav-item': true, active: lindex == selected_layer}"
-    v-for="(lrec, lindex) in dissect.layers">
- <a class="nav-link" :href="'#' + lindex"
-    >{{lrec.layer}}</a>
-</li>
-</ul>
-<ul class="navbar-nav ml-auto" v-if="dissect.meta">
-  <li class="navbar-text ml-2" v-for="(v, k) in dissect.meta">
-    {{k}}={{v | fixed(3, true)}}
-  </li>
-</ul>
-</nav>
-
-<div v-for="lrec in [dissect.layers[selected_layer]]">
-<div v-if="'bargraph' in lrec" class="histogram">
-<a data-toggle="lightbox" :href="lrec.dirname + '/bargraph.svg?'+Math.random()"
-   :data-title="'Summary of ' + (dissect.netname || 'labels')
-          + ' at ' + lrec.layer">
-<img class="img-fluid"
-   :src="lrec.dirname + '/' + lrec.bargraph + '?'+Math.random()">
-</a>
-</div>
-
-<div class="gridheader">
-<div class="layerinfo">
-<span v-if="'interpretable' in lrec"
->{{lrec.interpretable}}/</span
->{{lrec.units.length}} units
-<span v-if="'labels' in lrec">
-covering {{lrec.labels.length}} concepts
-with IoU &ge; {{dissect.iou_threshold}}
-</span>
-</div>
-
-<div class="sortheader">
-sort by
-<span v-for="rank in lrec['rankings']" v-if="!rank.metric">
-<span :class="{sortby: true, currentsort: sort_order == rank.name}"
-      :data-ranking="rank.name"
-      v-on:click="sort_order = $event.currentTarget.dataset.ranking"
-      >{{rank.name}}</span>
-<span> </span>
-</span>
-<span v-for="metric in _.filter(_.uniq(lrec.rankings.map(x => x.metric)))">
-  <div class="dropmenu sortby" tabindex="0">
-    <div class="dropmenutop">
-      *-{{ metric }}
-    </div>
-    <div class="dropmenulist">
-        <div v-for="rank in lrec['rankings']" v-if="rank.metric == metric">
-        <span :class="{sortby: true, currentsort: sort_order == rank.name}"
-              :data-ranking="rank.name"
-              v-on:click="sort_order = $event.currentTarget.dataset.ranking"
-              >{{rank.name}}</span>
-        </div>
-    </div>
-  </div>
-  <span> </span>
-</span>
-
-</div>
-
-</div>
-<div class="unitgrid"
-      v-for="lk in [_.find(lrec.rankings, x=>x.name == sort_order)
-                     .metric || 'iou']"
-><div :class="{unit: true, lowscore: lk == 'iou' && !urec.interp}"
-      v-for="urec in _.find(lrec.rankings, x=>x.name == sort_order)
-                      .ranking.map(x=>lrec.units[x])">
-<div v-if="lk+'_label' in urec" class="unitlabel">{{urec[lk+'_label']}}</div>
-<div class="info"
- ><span class="layername">{{lrec.layer}}</span
- > <span class="unitnum">unit {{urec.unit}}</span
- > <span v-if="lk+'_cat' in urec" class="category">({{urec[lk+'_cat']}})</span
- > <span v-if="lk+'_iou' in urec" class="iou"
-         >iou {{urec[lk + '_iou'] | fixed(2)}}</span
- > <span v-if="lk in urec" class="iou"
-         >{{lk}} {{urec[lk] | fixed(2)}}</span></div>
-<div class="thumbcrop" v-for="imprefix in [lrec['image_prefix_' + lk] || '']"
-><a data-toggle="lightbox"
- :href="lrec.dirname + '/' + imprefix + 'image/' + urec.unit + '-top.jpg'"
-><img
- :src="lrec.dirname + '/' + imprefix + 'image/' + urec.unit + '-top.jpg'"
- height="72"></a></div>
-</div></div> <!-- end unit -->
-
-</div> <!-- end unit grid -->
-
-</div> <!-- end container -->
-
-</div> <!-- end app -->
-
-<div class="modal" id="lightbox">
-  <div class="modal-dialog big-modal" role="document">
-    <div class="modal-content">
-      <div class="modal-header">
-        <h5 class="modal-title"></h5>
-        <button type="button" class="close"
-             data-dismiss="modal" aria-label="Close">
-          <span aria-hidden="true">&times;</span>
-        </button>
-      </div>
-      <div class="modal-body">
-        <input id="show-seg" class="hidden-toggle" type="checkbox">
-        <input id="show-mask" class="hidden-toggle" type="checkbox" checked>
-        <div class="img-wrapper img-scroller">
-          <img class="fullsize img-fluid img-orig">
-          <img class="fullsize img-fluid img-seg">
-          <img class="fullsize img-fluid img-mask">
-        </div>
-        <div class="img-controls">
-          <canvas class="colorsample" height=1 width=1></canvas>
-          <div class="seginfo">
-          </div>
-          <label for="show-seg" class="toggle-seg">segmentation</label>
-          <label for="show-mask" class="toggle-mask">mask</label>
-        </div>
-      </div>
-      <div class="modal-footer">
-        <div class="footer-caption">
-        </div>
-      </div>
-    </div>
-  </div>
-</div>
-<script>
-$(document).on('click', '[data-toggle=lightbox]', function(event) {
-    if ($(this).attr('href').match(/-top/)) {
-        $('#lightbox img.img-orig').attr('src',
-            $(this).attr('href').replace(/-top.jpg/, '-orig.jpg'));
-        $('#lightbox img.img-seg').attr('src',
-            $(this).attr('href').replace(/-top.jpg/, '-seg.png'));
-        $('#lightbox img.img-mask').attr('src',
-            $(this).attr('href').replace(/-top.jpg/, '-mask.png'));
-        $('#lightbox .img-seg, #lightbox .img-mask, .img-controls').show();
-    } else {
-        $('#lightbox img.img-orig').attr('src', $(this).attr('href'));
-        $('#lightbox .img-seg, #lightbox .img-mask, .img-controls').hide();
-    }
-    $('#lightbox .modal-title').text($(this).data('title') ||
-       $(this).closest('.unit').find('.unitlabel').text());
-    $('#lightbox .footer-caption').text($(this).data('footer') ||
-       $(this).closest('.unit').find('.info').text());
-    $('#lightbox .segcolors').text('');
-    event.preventDefault();
-    $('#lightbox').modal();
-    $('#lightbox img').closest('div').scrollLeft(0);
-});
-$(document).on('click', '#lightbox img.img-seg', function(event) {
-  var elt_pos = $(this).offset();
-  var img_x = event.pageX - elt_pos.left;
-  var img_y = event.pageY - elt_pos.top;
-  var canvas = $('#lightbox .colorsample').get(0);
-  canvas.getContext('2d').drawImage(this, img_x, img_y, 1, 1, 0, 0, 1, 1);
-  var pixelData = canvas.getContext('2d').getImageData(0, 0, 1, 1).data;
-  var colorkey = pixelData[0] + ',' + pixelData[1] + ',' + pixelData[2];
-  var meaning = theapp.dissect.segcolors[colorkey];
-  $('#lightbox .seginfo').text(meaning);
-});
-
-var theapp = new Vue({
-  el: '#app',
-  data: {
-    sort_order: 'unit',
-    sort_fields: {
-      label: [[], []],
-      score: [['iou'], ['desc']],
-      unit:  [['unit'], ['asc']],
-    },
-    selected_layer: null,
-    dissect: null
-  },
-  created: function() {
-    var self = this;
-    $.getJSON('dissect.json?' + Math.random(), function(d) {
-      self.dissect = d;
-      for (var layer of d.layers) {
-        // Preprocess ranking records to sort them.
-        for (var rank of layer.rankings) {
-          if (!('ranking' in rank)) {
-            rank.ranking = rank.score.map((score, index) => [score, index])
-                .sort(([score1], [score2]) => score1 - score2)
-                .map(([, index]) => index);
-          }
-        }
-      }
-      self.sort_order = d.default_ranking;
-      self.hashchange();
-    });
-    $(window).on('hashchange', function() { self.hashchange(); });
-  },
-  methods: {
-    hashchange: function() {
-      this.selected_layer = +window.location.hash.substr(1) || 0;
-    },
-  },
-  filters: {
-    fixed: function(value, digits, truncate) {
-       if (typeof value != 'number') return value;
-       var fixed = value.toFixed(digits);
-       return truncate ? +fixed : fixed;
-    }
-  }
-});
-</script>
-</body>
-</html>