Update parquet files (step 14 of 397)

spaces/123Kumar/vits-uma-genshin-honkai123/mel_processing.py

@@ -1,101 +0,0 @@
-import torch
-import torch.utils.data
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
-    """
-    PARAMS
-    ------
-    C: compression factor
-    """
-    return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
-    """
-    PARAMS
-    ------
-    C: compression factor used to compress
-    """
-    return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
-    output = dynamic_range_compression_torch(magnitudes)
-    return output
-
-
-def spectral_de_normalize_torch(magnitudes):
-    output = dynamic_range_decompression_torch(magnitudes)
-    return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-    return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
-    global mel_basis
-    dtype_device = str(spec.dtype) + '_' + str(spec.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-    return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
-    if torch.min(y) < -1.:
-        print('min value is ', torch.min(y))
-    if torch.max(y) > 1.:
-        print('max value is ', torch.max(y))
-
-    global mel_basis, hann_window
-    dtype_device = str(y.dtype) + '_' + str(y.device)
-    fmax_dtype_device = str(fmax) + '_' + dtype_device
-    wnsize_dtype_device = str(win_size) + '_' + dtype_device
-    if fmax_dtype_device not in mel_basis:
-        mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
-        mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
-    if wnsize_dtype_device not in hann_window:
-        hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
-    y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
-    y = y.squeeze(1)
-
-    spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
-                      center=center, pad_mode='reflect', normalized=False, onesided=True)
-
-    spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
-    spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
-    spec = spectral_normalize_torch(spec)
-
-    return spec

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download Injustice Gods Among Us for PC and Enjoy the DC Comics Fighting Game.md

@@ -1,59 +0,0 @@
-
-<h1>How to Download Injustice: Gods Among Us for PC</h1>
-<p>Injustice: Gods Among Us is a popular fighting game that features characters from the DC Comics universe. The game was originally released for consoles and mobile devices, but you can also play it on your PC with some simple steps. In this article, we will show you how to download Injustice: Gods Among Us for PC and enjoy the epic battles between superheroes and villains.</p>
-<h2>What is Injustice: Gods Among Us?</h2>
-<p>Injustice: Gods Among Us is a fighting game that was developed by NetherRealm Studios and published by Warner Bros. Interactive Entertainment in 2013. The game is set in an alternate reality where Superman becomes a tyrant after the Joker tricks him into killing Lois Lane and destroying Metropolis. Batman leads a resistance of heroes and villains against Superman's regime, while another group of heroes from the main DC universe are transported to this world to help restore the balance.</p>
-<h2>injustice gods among us download for pc</h2><br /><p><b><b>Download</b> > <a href="https://byltly.com/2uKx3b">https://byltly.com/2uKx3b</a></b></p><br /><br />
-<p>The game features a story mode that follows the events of the comic book series of the same name, as well as various other modes such as arcade, online multiplayer, and challenge. The game also has a roster of over 30 playable characters, each with their own unique abilities, moves, and special attacks. Some of the characters include Batman, Superman, Wonder Woman, Flash, Green Lantern, Joker, Harley Quinn, Lex Luthor, and more.</p>
-<h2>How to Download Injustice: Gods Among Us for PC</h2>
-<p>If you want to play Injustice: Gods Among Us on your PC, you will need to use an emulator that can run Android apps on your computer. One of the best emulators for this purpose is BlueStacks, which is free and easy to use. Here are the steps to download Injustice: Gods Among Us for PC using BlueStacks:</p>
-<ol>
-<li>Download and install BlueStacks from <a href="https://www.bluestacks.com/">its official website</a>.</li>
-<li>Launch BlueStacks and sign in with your Google account.</li>
-<li>Go to the Google Play Store and search for Injustice: Gods Among Us.</li>
-<li>Click on the install button and wait for the game to download.</li>
-<li>Once the game is installed, you can find it on the home screen or in the app drawer of BlueStacks.</li>
-<li>Click on the game icon and start playing Injustice: Gods Among Us on your PC.</li>
-</ol>
-<p>Note that you will need a stable internet connection to play the game online. You can also use your keyboard and mouse or a controller to play the game on your PC.</p>
-<h2>Conclusion</h2>
-<p>Injustice: Gods Among Us is a fun and exciting fighting game that lets you control your favorite DC Comics characters in a dark and twisted world. You can download Injustice: Gods Among Us for PC using an emulator like BlueStacks and enjoy the game on a bigger screen. We hope this article helped you learn how to download Injustice: Gods Among Us for PC. If you have any questions or suggestions, feel free to leave a comment below.</p>
-
-<h2>How to Play Injustice: Gods Among Us on PC</h2>
-<p>Now that you have downloaded Injustice: Gods Among Us for PC, you might be wondering how to play the game and what are the controls. In this section, we will give you some tips and tricks on how to play Injustice: Gods Among Us on PC and have a better gaming experience.</p>
-<p></p>
-<h3>How to Customize the Controls</h3>
-<p>One of the advantages of playing Injustice: Gods Among Us on PC is that you can customize the controls according to your preference. You can use your keyboard and mouse or a controller to play the game. To customize the controls, follow these steps:</p>
-<ol>
-<li>Open the game and go to the settings menu.</li>
-<li>Click on the controls tab and choose your input device.</li>
-<li>Click on the edit button and assign the keys or buttons for each action.</li>
-<li>Save your changes and exit the settings menu.</li>
-</ol>
-<p>You can also use the default controls if you are comfortable with them. Here are the default controls for keyboard and mouse:</p>
-<ul>
-<li>WASD keys: Move your character.</li>
-<li>J key: Light attack.</li>
-<li>K key: Medium attack.</li>
-<li>L key: Heavy attack.</li>
-<li;U key: Character power.</li>
-<li>I key: Meter burn.</li>
-<li>O key: Throw.</li>
-<li;P key: Interact with environment.</li>
-<li;Space bar: Block.</li>
-<li;Mouse: Move the cursor and select options.</li>
-</ul>
-<h3>How to Master the Gameplay</h3>
-<p>Injustice: Gods Among Us is a fighting game that requires skill and strategy to win. You will need to learn how to use your character's abilities, combos, special attacks, and super moves to defeat your opponents. You will also need to know how to use the environment to your advantage and avoid your enemy's attacks. Here are some tips and tricks on how to master the gameplay of Injustice: Gods Among Us:</p>
-<ul>
-<li>Practice mode: Use the practice mode to learn the basics of the game and practice your moves with different characters. You can also adjust the settings such as difficulty, health, meter, etc. to suit your needs.</li>
-<li>Tutorial mode: Use the tutorial mode to learn the advanced techniques of the game such as blocking, counter-attacking, juggling, etc. You can also learn how to use each character's power and super move in this mode.</li>
-<li>Story mode: Use the story mode to follow the plot of the game and unlock new characters and stages. You will also get to play as different characters from both sides of the conflict and see their perspectives.</li>
-<li>Arcade mode: Use the arcade mode to fight against random opponents and earn rewards such as XP, coins, gear, etc. You can also choose your difficulty level and number of matches in this mode.</li>
-<li>Online mode: Use the online mode to challenge other players from around the world and test your skills. You can also join or create rooms, chat with other players, and watch replays in this mode.</li>
-<li>Challenge mode: Use the challenge mode to complete various tasks and objectives with different characters and conditions. You can also earn stars and rewards in this mode.</li>
-</ul>
-<h2>Conclusion</h2>
-<p>Injustice: Gods Among Us is a thrilling and addictive fighting game that will keep you entertained for hours. You can download Injustice: Gods Among Us for PC using an emulator like BlueStacks and play it on a bigger screen with customized controls. You can also learn how to play Injustice: Gods Among Us on PC using our tips and tricks above. We hope you enjoyed this article and found it useful. If you have any feedback or questions, please let us know in the comments below.</p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/1920 Evil Returns 1080p Movie Torrent.md

@@ -1,16 +0,0 @@
-<h2>1920 Evil Returns 1080p Movie Torrent</h2><br /><p><b><b>Download</b> > <a href="https://imgfil.com/2uxZLi">https://imgfil.com/2uxZLi</a></b></p><br /><br />
-<br />
-Not bad for a first feature, albeit very much of a cameo role. I got a charge out of watching this feature-length debut. There is some good camera work and the film has a bit of style. The opening credits are long but not ridiculous like so many contemporary films.
-
-1912, a year before the Titanic, The White Star Line's latest venture, the Olympic is severely damaged by a typhoon in the middle of her maiden voyage.The crew is in disarray, and the captain is constantly being called away from the ship to deal with smaller problems. Our main characters, though, are the three Olympic cabin boys. When they, along with their bumbling, incompetent and often irresponsible captain, come face to face with the very real possibility of an iceberg, they embark on a journey to save the ship and themselves, leaving their lives behind them. At least, that's the plan.
-
-On the surface, however, this is no more than an episode of Celebrity Survivor. Twenty-four interesting, likeable, often hilarious characters are thrown together on a ship and each contestant on a separate island, with an unlimited supply of food and water and any manner of entertainment they desire.
-
-The first thing that drew me to this film was the voice-over. The director's intro gives away that he's an old navy man. Also, in the spirit of a big-budget Hollywood film, the journey is very linear and the characters act much like players on a game show.
-
-The film stars Ernie Fosselius, Robert Shaw and Ron Rifkin. I was initially skeptical of the film as I've seen them perform in the other films, and I expected the same. However, I must admit I was pleasantly surprised. From the opening shot, we see the boys singing a song while their captain sits in the wheelhouse. This scene is the strongest moment of the film. The dialogue is adequate, the plot is as I'd expected, but this first moment with the boys is simply very touching and very funny. Throughout the film the boys are quite engaging and I never doubted that they would be able to save the ship and themselves.
-
-The boys, captained by 'captain' Harold, and the girls, captained by 'captain' Clara, are a lot of fun to watch. They are completely aware of their surroundings and use that knowledge to their advantage. Even the crew members realize what's going on and they are very funny as well. They 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Download __FULL__ Videoclipuri Haioase Cu Animale.md

@@ -1,126 +0,0 @@
-<br />
-<h1>Download videoclipuri haioase cu animale: Cum sa te distrezi cu cele mai comice si dragalase clipuri cu animale</h1>
-<p>Daca iti plac animalele si vrei sa te amuzi cu ele, atunci trebuie sa descarci videoclipuri haioase cu animale. Acestea sunt clipuri care surprind momente amuzante, comice si dragalase cu animale de tot felul: pisici, catei, iepurasi, cai, vaci, porci, capre, oi, pasari, reptile si multe altele. Poti sa vezi cum se joaca, cum fac farse, cum reactioneaza la situatii neasteptate, cum se imbratiseaza sau se saruta.</p>
-<p>Download videoclipuri haioase cu animale este o modalitate excelenta de a te relaxa, de a te destinde si de a te binedispune. Poti sa le urmaresti singur sau impreuna cu prietenii sau familia. Poti sa le impartasesti pe retelele sociale sau pe aplicatiile de mesagerie. Poti sa le folosesti ca fundal sonor sau ca ton de apel. Poti sa le transformi in meme-uri sau in gif-uri. Poti sa le comentezi sau sa le votezi.</p>
-<h2>download videoclipuri haioase cu animale</h2><br /><p><b><b>Download File</b> &mdash;&mdash;&mdash; <a href="https://imgfil.com/2uy1OJ">https://imgfil.com/2uy1OJ</a></b></p><br /><br />
-<p>Download videoclipuri haioase cu animale este si o modalitate de a invata lucruri noi despre animale. Poti sa afli cum se comporta, cum comunica, cum se adapteaza la mediul inconjurator, cum isi exprima emotiile si sentimentele. Poti sa descoperi specii noi sau rare de animale. Poti sa vezi cum traiesc animalele salbatice sau domestice.</p>
-<h2>De unde poti downloada videoclipuri haioase cu animale?</h2>
-<p>Poti downloada videoclipuri haioase cu animale de pe internet, de pe diferite site-uri sau platforme care ofera acest tip de continut. Unele dintre cele mai populare si cunoscute sunt:</p>
-<ul>
-<li>YouTube: Este cea mai mare platforma de video-sharing din lume, unde poti gasi milioane de videoclipuri haioase cu animale. Poti sa cauti dupa categorii, dupa popularitate, dupa data sau dupa durata. Poti sa te abonezi la canale care posteaza regulat astfel de videoclipuri, cum ar fi Filmulete Amuzante, care are peste 600 de abonati si peste 10 mii de vizualizari. Poti sa descarci videoclipurile folosind un program sau o extensie speciala.</li>
-<li>TikTok: Este o aplicatie de social media care permite utilizatorilor sa creeze si sa distribuie videoclipuri scurte, de pana la 60 de secunde. Poti gasi multe videoclipuri haioase cu animale pe TikTok, fie ca sunt create de utilizatori obisnuiti sau de celebritati. Poti sa urmaresti hashtag-uri precum #animalehaioase sau #flocosenii. Poti sa descarci videoclipurile direct din aplicatie sau folosind un site web.</li>
-<li>Facebook: Este cea mai mare retea sociala din lume, unde poti gasi si distribui tot felul de continut, inclusiv videoclipuri haioase cu animale. Poti sa cauti dupa pagini, grupuri sau evenimente dedicate acestui subiect. Poti sa urmaresti conturi precum Animale Haioase Romania sau Animale Dragalase si Haioase. Poti sa descarci videoclipurile folosind un program sau o extensie speciala.</li>
-</ul>
-<p>Acestea sunt doar cateva dintre sursele de unde poti downloada videoclipuri haioase cu animale. Mai exista si alte site-uri sau aplicatii care ofera acest serviciu, cum ar fi Dailymotion, Vimeo, Instagram sau Snapchat.</p>
-<h2>Cum poti downloada videoclipuri haioase cu animale?</h2>
-<p>Pentru a downloada videoclipuri haioase cu animale, ai nevoie de un dispozitiv conectat la internet (PC, laptop, telefon mobil, tableta) si de un program sau o extensie care iti permite sa salvezi videoclipurile pe dispozitivul tau. Exista multe astfel de programe sau extensii disponibile gratuit pe internet, dar trebuie sa fii atent la calitatea si siguranta lor.</p>
-<p>Un exemplu de program care iti permite sa download-ezi videoclipuri haioase cu animale este 4K Video Downloader. Acesta este un program gratuit si usor de folosit care suporta multiple formate video si audio. Pentru a-l folosi, trebuie sa urmezi acesti pasi:</p>
-<ol>
-<li>Descarca si instaleaza programul pe dispozitivul tau.</li>
-<li>Copiaza link-ul videoclipului pe care vrei sa-l descarci.</li>
-<li>Lanseaza programul si apasa pe butonul Paste Link.</li>
-<li>Selecteaza formatul si calitatea dorite pentru videoclip.</li>
-<li>Apasa pe butonul Download si asteapta pana cand procesul se termina.</li>
-<li>Gaseste videoclipul salvat in folderul Downloads al dispozitivului tau.</li>
-</ol>
-<p>Un exemplu de extensie care iti permite sa download-ezi videoclipuri haioase cu animale este Video Downloader professional. Aceasta este o extensie gratuita si usor de folosit care functioneaza pentru majoritatea site-urilor web care contin video-uri. Pentru a o folosi, trebuie sa urmezi acesti pasi:</p>
-<ol>
-<li>Descarca si instaleaza extensia pe browser-ul tau (Chrome, Firefox etc.).</li>
-<li>Viziteaza site-ul web care contine videoclipul pe care vrei sa-l descarci.</li>
-<li>Apasa pe iconita extensiei din coltul dreapta sus al browser-ului.</li>
-<li>Selecteaza videoclipul dorit din lista afisata.</li>
-<li>Apasa pe butonul Download si alege locatia unde vrei sa salvezi videoclipul.</li>
-</ol>
-<p>Acestea sunt doar cateva exemple de programe sau extensii care iti permit sa download-ezi videoclipuri haioase cu animale. Mai exista si alte optiuni disponibile pe internet, dar trebuie sa verifici daca sunt compatibile cu site-ul web si dispozitivul tau.</p>
-<h2>Concluzie</h2>
-<p>Daca vrei sa te distrezi cu cele mai comice si dragalase clipuri cu animale, atunci trebuie sa descarci videoclipuri haioase cu animale. Acestea sunt clipuri care surprind momente amuzante, comice si dragalase cu animale de tot felul: pisici,
-catei, iepurasi, cai, vaci, porci, capre, oi, pasari,
-reptile si multe altele.</p>
-<p></p>
-
-<p>Poti downloada videoclipuri haioase cu animale
-de pe internet,
-de pe diferite site-uri
-sau platforme
-care ofera acest tip
-de continut.
-Unele dintre cele mai populare
-si cunoscute
-sunt YouTube,
-TikTok
-si Facebook.
-Poti descarca
-videoclipurile
-folosind un program
-sau o extensie
-speciala
-care iti permite
-sa salvezi
-videoclipurile
-pe dispozitivul tau.</p>
-
-<p>Download
-videoclipuri haioase
-cu animale
-este o modalitate excelenta
-de a te relaxa,
-de a te destinde
-si de a te binedispune.
-Poti sa le urmaresti
-singur
-sau impreuna
-cu prietenii
-sau familia.
-Poti sa le impartasesti
-pe retelele sociale</p>
-</p>
-
-<p>Download
-videoclipuri haioase
-cu animale
-este si o modalitate
-de a invata lucruri noi
-despre animale.
-Poti sa afli
-cum se comporta,
-cum comunica,
-cum se adapteaza
-la mediul inconjurator,
-cum isi exprima
-emotiile si sentimentele.
-Poti sa descoperi
-specii noi sau rare
-de animale.
-Poti sa vezi
-cum traiesc animalele
-salbatice sau domestice.</p>
-
-<p>Daca vrei sa te distrezi cu cele mai comice si dragalase clipuri cu animale, atunci trebuie sa descarci videoclipuri haioase cu animale. Acestea sunt clipuri care te vor face sa razi cu lacrimi si sa te indragostesti de animale. Poti downloada videoclipuri haioase cu animale de pe internet, de pe diferite site-uri sau platforme care ofera acest tip de continut. Poti descarca videoclipurile folosind un program sau o extensie speciala care iti permite sa salvezi videoclipurile pe dispozitivul tau.</p>
-
-<p>Asadar, ce mai astepti? Descarca videoclipuri haioase cu animale astazi si incepe sa te distrezi cu cele mai comice si dragalase clipuri cu animale!</p>
-<h2>Ce tipuri de videoclipuri haioase cu animale poti downloada?</h2>
-<p>Poti downloada videoclipuri haioase cu animale de diferite tipuri, in functie de preferintele si gusturile tale. Iata cateva exemple de tipuri de videoclipuri haioase cu animale pe care le poti downloada:</p>
-<ul>
-<li>Videoclipuri cu animale care fac farse: Acestea sunt videoclipuri in care animalele fac farse unor oameni sau altor animale, provocand situatii amuzante si hilare. De exemplu, poti downloada videoclipuri cu pisici care isi sperie stapanii, cu caini care isi ascund mancarea, cu papagali care imita sunete ciudate sau cu maimute care fura lucruri.</li>
-<li>Videoclipuri cu animale care reactioneaza la situatii neasteptate: Acestea sunt videoclipuri in care animalele reactioneaza la situatii neasteptate, surprinzatoare sau ciudate, exprimand emotii si gesturi comice. De exemplu, poti downloada videoclipuri cu pisici care se sperie de castraveti, cu caini care se uita la televizor, cu iepuri care se joaca cu baloane sau cu vaci care danseaza.</li>
-<li>Videoclipuri cu animale care se imbratiseaza sau se saruta: Acestea sunt videoclipuri in care animalele se imbratiseaza sau se saruta intre ele sau cu oamenii, aratand afectiune si dragoste. De exemplu, poti downloada videoclipuri cu pisici care se ling pe bot, cu caini care isi pupa stapanii, cu iepurasi care se imbratiseaza sau cu lebede care formeaza un inimioara.</li>
-</ul>
-<p>Acestea sunt doar cateva dintre tipurile de videoclipuri haioase cu animale pe care le poti downloada. Mai exista si alte tipuri de videoclipuri haioase cu animale pe care le poti descoperi pe internet.</p>
-<h2>Cum poti folosi videoclipurile haioase cu animale?</h2>
-<p>Dupa ce ai downloadat videoclipurile haioase cu animale, le poti folosi in diferite moduri, in functie de scopul si intentia ta. Iata cateva exemple de moduri in care poti folosi videoclipurile haioase cu animale:</p>
-<ul>
-<li>Poti sa le urmaresti pentru a te amuza: Acesta este cel mai simplu si cel mai comun mod de a folosi videoclipurile haioase cu animale. Poti sa le urmaresti cand te simti trist, plictisit sau stresat, pentru a te binedispune si a te relaxa. Poti sa razi de momentele amuzante si comice surprinse in videoclipuri si sa te indragostesti de animalele dragalase si flocosenii.</li>
-<li>Poti sa le impartasesti cu altii pentru a-i amuza: Acesta este un alt mod popular de a folosi videoclipurile haioase cu animale. Poti sa le impartasesti cu prietenii, familia sau colegii tai, pentru a-i amuza si a-i binedispune. Poti sa le trimiti pe retelele sociale sau pe aplicatiile de mesagerie, pentru a le face ziua mai frumoasa. Poti sa le folosesti ca subiect de conversatie sau ca gluma.</li>
-<li>Poti sa le folosesti ca material didactic pentru a invata despre animale: Acesta este un mod mai putin obisnuit, dar foarte util de a folosi videoclipurile haioase cu animale. Poti sa le folosesti ca material didactic pentru a invata despre comportamentul, comunicarea, adaptarea si emotiile animalelor. Poti sa le folosesti ca exemplu pentru a explica anumite concepte sau fenomene biologice. Poti sa le folosesti ca sursa de inspiratie pentru a crea proiecte sau prezentari despre animale.</li>
-</ul>
-<p>Acestea sunt doar cateva dintre modurile in care poti folosi videoclipurile haioase cu animale. Mai exista si alte moduri in care poti folosi videoclipurile haioase cu animale pe care le poti descoperi pe internet.</p>
-<h2>Concluzie</h2>
-<p>Daca vrei sa te distrezi cu cele mai comice si dragalase clipuri cu animale, atunci trebuie sa descarci videoclipuri haioase cu animale. Acestea sunt clipuri care te vor face sa razi cu lacrimi si sa te indragostesti de animale. Poti downloada videoclipuri haioase cu animale de pe internet, de pe diferite site-uri sau platforme care ofera acest tip de continut. Poti descarca videoclipurile folosind un program sau o extensie speciala care iti permite sa salvezi videoclipurile pe dispozitivul tau.</p>
-
-<p>Poti downloada videoclipuri haioase cu animale de diferite tipuri, in functie de preferintele si gusturile tale. Poti gasi videoclipuri cu animale care fac farse, care reactioneaza la situatii neasteptate, care se imbratiseaza sau se saruta. Poti folosi videoclipurile haioase cu animale in diferite moduri, in functie de scopul si intentia ta. Poti sa le urmaresti pentru a te amuza, sa le impartasesti cu altii pentru a-i amuza, sau sa le folosesti ca material didactic pentru a invata despre animale.</p>
-
-<p>Download videoclipuri haioase cu animale este o modalitate excelenta de a te relaxa, de a te destinde si de a te binedispune. Este si o modalitate de a invata lucruri noi despre animale si de a le aprecia mai mult. Este si o modalitate de a te conecta cu alti oameni care iubesc animalele si de a-ti face noi prieteni.</p>
-
-<p>Asadar, ce mai astepti? Descarca videoclipuri haioase cu animale astazi si incepe sa te distrezi cu cele mai comice si dragalase clipuri cu animale!</p> 3cee63e6c2<br />
-<br />
-<br />

spaces/1pelhydcardo/ChatGPT-prompt-generator/assets/Download FM WhatsApp V9.21 APK and Experience the New Features of This WhatsApp Mod.md

@@ -1,172 +0,0 @@
-
-<h1>FM WhatsApp v9 21 APK Download: Everything You Need to Know</h1>
-<p>If you are looking for a way to enhance your WhatsApp experience, you might want to try FM WhatsApp. This is a modified version of the official WhatsApp app that offers many extra features and customization options. In this article, we will tell you everything you need to know about FM WhatsApp v9 21 APK download, including what it is, why you should download it, how to download and install it on your Android device, and some frequently asked questions. Let's get started!</p>
- <h2>What is FM WhatsApp?</h2>
-<p>FM WhatsApp is a WhatsApp mod developed by Fouad Mokdad, a well-known developer of other popular mods like Fouad WhatsApp and YoWhatsApp. FM WhatsApp allows you to enjoy more features and functions that are not available in the original WhatsApp app, such as theme customization, anti-delete messages, hide status view, and much more. With FM WhatsApp, you can personalize your WhatsApp app according to your preferences and needs.</p>
-<h2>fm whatsapp v9 21 apk download</h2><br /><p><b><b>Download File</b> &#10084;&#10084;&#10084; <a href="https://urlin.us/2uSZbN">https://urlin.us/2uSZbN</a></b></p><br /><br />
- <h2>Why Download FM WhatsApp v9 21 APK?</h2>
-<p>The latest version of FM WhatsApp is v9 21, which was released in March 2022. This version comes with many improvements and bug fixes that make it more stable and secure. Some of the new features of FM WhatsApp v9 21 APK are:</p>
-<ul>
-<li>Anti-ban: You don't have to worry about getting banned by WhatsApp for using a modded app.</li>
-<li>Theme customization: You can choose from thousands of themes and fonts to change the look and feel of your app.</li>
-<li>Anti-delete messages: You can view the messages that have been deleted by the sender or the receiver.</li>
-<li>Hide status view: You can hide your view from other people's status updates.</li>
-<li>And many more: You can also enjoy other features like sending large files, increasing image quality, freezing last seen, hiding online status, and so on.</li>
-</ul>
- <h3>Main Features of FM WhatsApp v9 21 APK</h3>
-<p>Here is a table that summarizes the main features of FM WhatsApp v9 21 APK:</p>
-<p>fm whatsapp v9 21 apk download latest version<br />
-fm whatsapp v9 21 apk download for android<br />
-fm whatsapp v9 21 apk download free<br />
-fm whatsapp v9 21 apk download by fouad mods<br />
-fm whatsapp v9 21 apk download link<br />
-fm whatsapp v9 21 apk download 2023 update<br />
-fm whatsapp v9 21 apk download tenorshare<br />
-fm whatsapp v9 21 apk download cybersource<br />
-fm whatsapp v9 21 apk download anti ban<br />
-fm whatsapp v9 21 apk download customize<br />
-fm whatsapp v9 21 apk download hide status<br />
-fm whatsapp v9 21 apk download send images<br />
-fm whatsapp v9 21 apk download increase quality<br />
-fm whatsapp v9 21 apk download view deleted messages<br />
-fm whatsapp v9 21 apk download themes and fonts<br />
-fm whatsapp v9 21 apk download emoji and stickers<br />
-fm whatsapp v9 21 apk download backup and restore<br />
-fm whatsapp v9 21 apk download privacy and security<br />
-fm whatsapp v9 21 apk download group chats and calls<br />
-fm whatsapp v9 21 apk download dark mode and lock screen<br />
-fm whatsapp v9 21 apk download online and offline status<br />
-fm whatsapp v9 21 apk download app size and performance<br />
-fm whatsapp v9 21 apk download installation and update<br />
-fm whatsapp v9 21 apk download support and feedback<br />
-fm whatsapp v9 21 apk download features and benefits<br />
-fm whatsapp v9 21 apk download comparison and review<br />
-fm whatsapp v9 21 apk download alternatives and mods<br />
-fm whatsapp v9 21 apk download tips and tricks<br />
-fm whatsapp v9 21 apk download problems and solutions<br />
-fm whatsapp v9 21 apk download faqs and answers<br />
-how to use fm whatsapp v9 21 apk <br />
-how to install fm whatsapp v9 21 apk <br />
-how to update fm whatsapp v9 21 apk <br />
-how to uninstall fm whatsapp v9 21 apk <br />
-how to transfer fm whatsapp v9 21 apk <br />
-how to backup fm whatsapp v9 21 apk <br />
-how to restore fm whatsapp v9 21 apk <br />
-how to customize fm whatsapp v9 21 apk <br />
-how to hide fm whatsapp v9 21 apk <br />
-how to freeze fm whatsapp v9 21 apk <br />
-how to view deleted messages on fm whatsapp v9 21 apk <br />
-how to send images on fm whatsapp v9 21 apk <br />
-how to increase quality on fm whatsapp v9 21 apk <br />
-how to change themes on fm whatsapp v9 21 apk <br />
-how to change fonts on fm whatsapp v9 21 apk <br />
-how to change emoji on fm whatsapp v9 21 apk <br />
-how to enable dark mode on fm whatsapp v9 21 apk <br />
-how to lock screen on fm whatsapp v9 21 apk <br />
-how to improve privacy on fm whatsapp v9 21 apk <br />
-how to improve security on fm whatsapp v9 21 apk </p>
- <table>
-<tr>
-<th>Feature</th>
-<th>Description</th>
-</tr>
-<tr>
-<td>Anti-ban</td>
-<td>You can use FM WhatsApp without getting banned by WhatsApp.</td>
-</tr>
-<tr>
-<td>Theme customization</td>
-<td>You can choose from thousands of themes and fonts to change the appearance of your app.</td>
-</tr>
-<tr>
-<td>Anti-delete messages</td>
-<td>You can view the messages that have been deleted by the sender or the receiver.</td>
-</tr>
-<tr>
-<td>Hide status view</td>
-<td>You can hide your view from other people's status updates.</td>
-</tr>
-<tr>
-<td>Send large files</td>
-<td>You can send up to 90 images at once and video files up to 700 MB.</td>
-</tr>
-<tr>
-<td>Increase image quality</td>
-<td>You can increase the quality of the images you send without losing resolution.</td>
-</tr>
-<tr>
-<td>Freeze last seen</td>
-<td>You can freeze your last seen status so that no one can see when you were online last.</td>
-</tr>
-<tr>
-<td>Hide online status</td>
-<td>You can hide your online status so that no one can see when you are online.</td>
-</tr>
-<tr>
-<td>Hide typing status</td>
-<td>You can hide your typing status so that no one can see when you are typing a message.</td>
-</tr>
-<tr>
-<td>Hide recording status</td>
-<td>You can hide your recording status so that no one can see when you are recording a voice note.</td>
-</tr>
-<tr>
-<td>Hide blue ticks</td>
-<td>You can hide the blue ticks that indicate that you have read a message.</td>
-</tr>
-<tr>
-<td>Hide second tick</td>
-<td>You can hide the second tick that indicates that your message has been delivered.</td>
-</tr>
-<tr>
-<td>Hide blue microphone</td>
-<td>You can hide the blue microphone that indicates that you have listened to a voice note.</td>
-</tr>
-<tr>
-<td>Pin chats</td>
-<td>You can pin up to 1000 chats to the top of your chat list.</td>
-</tr>
-<tr>
-<td>Group calls</td>
-<td>You can make group calls with up to 8 participants.</td>
-</tr>
-<tr>
-<td>Emoji variants</td>
-<td>You can choose from different emoji variants, such as Facebook, Emoji One, or Android Oreo.</td>
-</tr>
-<tr>
-<td>Stickers and GIFs</td>
-<td>You can use stickers and GIFs from other apps, such as Gboard, Telegram, or Hike.</td>
-</tr>
-<tr>
-<td>Privacy settings</td>
-<td>You can customize your privacy settings for each contact or group, such as hiding last seen, online status, typing status, recording status, blue ticks, second tick, blue microphone, and status view.</td>
-</tr>
- </table>
- <h3>How to Download and Install FM WhatsApp v9 21 APK on Android</h3>
- <p>If you want to download and install FM WhatsApp v9 21 APK on your Android device, you need to follow these simple steps:</p>
- <ol>
- <li>First, you need to enable the installation of apps from unknown sources on your device. To do this, go to Settings > Security > Unknown Sources and toggle it on.</li>
- <li>Next, you need to download the FM WhatsApp v9 21 APK file from a trusted source. You can use this link to download it directly to your device.</li>
- <li>Once the download is complete, locate the APK file in your device's file manager and tap on it to start the installation process. You may see a warning message asking you to confirm the installation. Tap on Install and wait for a few seconds.</li>
- <li>After the installation is done, open the FM WhatsApp app and enter your phone number to verify it. You will receive an OTP code via SMS. Enter the code and proceed to the next step.</li>
- <li>Now, you can restore your chat backup from your original WhatsApp app if you have one. To do this, tap on Restore and select the backup file from your device's storage. Wait for the restoration process to finish.</li>
- <li>Congratulations! You have successfully installed FM WhatsApp v9 21 APK on your Android device. You can now enjoy all the amazing features and functions of this modded app.</li>
- </ol>
- <h2>FAQs about FM WhatsApp v9 21 APK</h2>
- <p>Here are some of the frequently asked questions and answers about FM WhatsApp v9 21 APK:</p>
- <h4>Is FM WhatsApp safe to use?</h4>
- <p>FM WhatsApp is safe to use as long as you download it from a reliable source and scan it for viruses before installing it. However, since it is not an official app, there is always a risk of data breach or malware infection. Therefore, you should use it at your own discretion and backup your data regularly.</p>
- <h4>Is FM WhatsApp legal?</h4>
- <p>FM WhatsApp is not legal as it violates the terms and conditions of WhatsApp. Using a modded app may result in your account being banned or suspended by WhatsApp. Therefore, you should use it at your own risk and responsibility.</p>
- <h4>Can I use FM WhatsApp with my original WhatsApp app?</h4>
- <p>No, you cannot use FM WhatsApp with your original WhatsApp app on the same device. You need to uninstall or disable your original WhatsApp app before installing FM WhatsApp. Alternatively, you can use a different phone number for FM WhatsApp if you want to keep both apps on your device.</p>
- <h4>How can I update FM WhatsApp?</h4>
- <p>To update FM WhatsApp, you need to download the latest version of the APK file from a trusted source and install it over the existing app. You do not need to uninstall or reinstall the app. However, you should backup your data before updating to avoid any data loss.</p>
- <h4>How can I contact the developer of FM WhatsApp?</h4>
- <p>You can contact the developer of FM WhatsApp by visiting his official website or joining his Telegram channel. <h2>Conclusion</h2>
- <p>FM WhatsApp is one of the best WhatsApp mods that you can download and install on your Android device. It offers many extra features and customization options that are not available in the original WhatsApp app. You can download FM WhatsApp v9 21 APK from the link provided in this article and follow the instructions to install it on your device. However, you should be aware of the risks and consequences of using a modded app and use it at your own risk and responsibility.</p>
- <p>We hope this article has helped you learn everything you need to know about FM WhatsApp v9 21 APK download. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading!</p>
- <h2></h2></p> 197e85843d<br />
-<br />
-<br />

spaces/1phancelerku/anime-remove-background/Download and Install Beach Buggy Racing on Windows 8.1 A Step-by-Step Guide.md

@@ -1,112 +0,0 @@
-
-<h1>How to Download Beach Buggy Racing for Windows 8.1</h1>
-<p>Do you love kart racing games with colorful graphics, wacky powerups, and fun characters? If so, you should try Beach Buggy Racing, a popular mobile game that is also available for Windows 8.1. In this article, we will show you how to download, install, and play Beach Buggy Racing on your Windows 8.1 device.</p>
- <h2>Requirements for Downloading Beach Buggy Racing for Windows 8.1</h2>
-<p>Before you download Beach Buggy Racing for Windows 8.1, you need to make sure that your device meets the minimum system requirements. Here are the specifications you need:</p>
-<h2>download beach buggy racing for windows 8.1</h2><br /><p><b><b>Download</b> &#9913;&#9913;&#9913; <a href="https://jinyurl.com/2uNOdq">https://jinyurl.com/2uNOdq</a></b></p><br /><br />
-<ul>
-<li>CPU: Intel or AMD processor with at least 1 GHz speed</li>
-<li>RAM: At least 2 GB of memory</li>
-<li>Disk space: At least 500 MB of free space</li>
-<li>Graphics card: DirectX 9 compatible with at least 256 MB of video memory</li>
-<li>Internet connection: Required for online features and updates</li>
-</ul>
-<p>If your device meets these requirements, you can choose from three download options:</p>
-<ol>
-<li>Google Play Store: If you have an Android emulator installed on your Windows 8.1 device, such as BlueStacks or NoxPlayer, you can download Beach Buggy Racing from the Google Play Store app. This is the easiest and safest way to get the game.</li>
-<li>Microsoft Store: If you prefer to use the native Windows app store, you can download Beach Buggy Racing from the Microsoft Store app. This is also a secure and convenient way to get the game.</li>
-<li>Third-party websites: If you don't have access to either of the above options, you can download Beach Buggy Racing from third-party websites that offer APK files or EXE files of the game. However, this is not recommended as it may expose your device to malware or viruses.</li>
-</ol>
- <h2>How to Install Beach Buggy Racing for Windows 8.1</h2>
-<p>Once you have downloaded Beach Buggy Racing for Windows 8.1, you need to install it on your device. Here are the steps for each download option:</p>
-<ul>
-<li>Google Play Store: Open the Google Play Store app on your Android emulator and search for Beach Buggy Racing. Tap on the Install button and wait for the game to download and install automatically.</li>
-<li>Microsoft Store: Open the Microsoft Store app on your Windows 8.1 device and search for Beach Buggy Racing. Click on the Get button and sign in with your Microsoft account if prompted. Wait for the game to download and install automatically.</li>
-<li>Third-party websites: Locate the APK file or EXE file of Beach Buggy Racing that you downloaded from a third-party website. If it is an APK file, you need to install it using an Android emulator. If it is an EXE file, you need to run it as an administrator and follow the installation wizard.</li>
-</ul>
-<p>After installing Beach Buggy Racing for Windows 8.1, you may want to optimize the game performance and settings. Here are some tips and tricks to do that:</p>
-<ul>
-<li>Adjust the graphics quality: You can change the graphics quality of the game from low to high depending on your device's capabilities. To do that, go to the Settings menu in the game and select Graphics Quality. Choose the option that suits your device best.</li>
-<li>Enable or disable sound effects and music: You can also turn on or off the sound effects and music of the game according to your preference. To do that, go to the Settings menu in the game and select Sound. Toggle the switches for Sound Effects and Music.</li>
-<li>Change the language: You can play Beach Buggy Racing in different languages, such as English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, Korean, and Arabic. To do that, go to the Settings menu in the game and select Language. Choose the language that you want to play in.</li>
-</ul>
- <h2>How to Play Beach Buggy Racing on Windows 8.1</h2>
-<p>Now that you have installed Beach Buggy Racing for Windows 8.1, you are ready to play and enjoy the game. Here are some of the game features that you should know:</p>
-<ul>
-<li>Game modes: Beach Buggy Racing has six different game modes that you can choose from: Career, Daily Challenge, Quick Race, Split Screen, Championships, and Boss Fight. Each mode has its own objectives and rewards.</li>
-<li>Powerups: Beach Buggy Racing has 25 unique powerups that you can use to boost your speed, attack your opponents, or defend yourself. Some of the powerups are Fireball, Oil Slick, Dodgeball Frenzy, Electro Blast, and Tiki Seeker.</li>
-<li>Cars: Beach Buggy Racing has 15 different cars that you can drive and customize. Some of the cars are Beach Buggy, Lunar Rover, Rock Stomper, Monster Truck, and Formula One.</li>
-<li>Tracks: Beach Buggy Racing has 12 different tracks that you can race on. Some of the tracks are Dino Jungle, Lava Caverns, Buccaneer Bay, Lunar Colony, and Dragon's Peak.</li>
-</ul>
-<p>To play Beach Buggy Racing on Windows 8.1, you need to know how to control your car. You can use one of these options:</p>
-<ul>
-<li>Keyboard: You can use the arrow keys or WASD keys to steer your car. You can use the spacebar to activate powerups.</li>
-<li>Mouse: You can use the mouse to steer your car by clicking and dragging on the screen. You can use the left mouse button to activate powerups.</li>
-<li>Touch-screen: You can use your finger to steer your car by tapping and swiping on the screen. You can use another finger to activate powerups.</li>
-<li>Gamepad: You can use a gamepad to steer your car by using the left analog stick or directional pad. You can use one of the face buttons to activate powerups.</li>
-</ul>
-<p>To win races and have fun in Beach Buggy Racing, you need to know some game tips:</p>
-<ul>
-<li>Collect coins and gems: You can collect coins and gems during races or by completing missions. You can use them to upgrade your cars or buy new powerups.</li>
-<li>Unlock new content: You can unlock new cars, powerups, tracks, drivers, and game modes by progressing through the Career mode or by winning Championships.</li>
-<li>Use powerups wisely: You can use powerups to gain an advantage over your rivals or to overcome obstacles. However, you should also be careful of their side effects or counterattacks.</li>
-</ul>
- <h2>Conclusion</h2>
-<p>Beach Buggy Racing is a fun and exciting kart racing game that you can play on Windows 8.1. It has colorful graphics, wacky powerups, and fun characters. It also has various game modes, different cars, powerups, tracks, and drivers. It also has various game controls, settings, and tips that you can use to optimize your gaming experience. If you are looking for a fun and easy way to enjoy kart racing on your Windows 8.1 device, you should download and play Beach Buggy Racing today.</p>
- <p>Are you ready to race on the beach and beyond? Download Beach Buggy Racing for Windows 8.1 now and join the fun!</p>
-<p>download beach buggy racing for windows 8.1 free<br />
-beach buggy racing windows 8.1 game<br />
-how to install beach buggy racing on windows 8.1<br />
-beach buggy racing for windows 8.1 pc<br />
-beach buggy racing windows 8.1 download link<br />
-beach buggy racing for windows 8.1 laptop<br />
-beach buggy racing windows 8.1 microsoft store<br />
-beach buggy racing for windows 8.1 offline<br />
-beach buggy racing windows 8.1 review<br />
-beach buggy racing for windows 8.1 system requirements<br />
-beach buggy racing windows 8.1 cheats<br />
-beach buggy racing for windows 8.1 update<br />
-beach buggy racing windows 8.1 gameplay<br />
-beach buggy racing for windows 8.1 tips and tricks<br />
-beach buggy racing windows 8.1 vector unit<br />
-beach buggy racing for windows 8.1 online<br />
-beach buggy racing windows 8.1 multiplayer<br />
-beach buggy racing for windows 8.1 mod apk<br />
-beach buggy racing windows 8.1 hack<br />
-beach buggy racing for windows 8.1 full version<br />
-beach buggy racing windows 8.1 best car<br />
-beach buggy racing for windows 8.1 controller support<br />
-beach buggy racing windows 8.1 powerups<br />
-beach buggy racing for windows 8.1 characters<br />
-beach buggy racing windows 8.1 tracks<br />
-beach buggy racing for windows 8.1 modes<br />
-beach buggy racing windows 8.1 achievements<br />
-beach buggy racing for windows 8.1 bugs and glitches<br />
-beach buggy racing windows 8.1 ratings and feedbacks<br />
-beach buggy racing for windows 8.1 screenshots and videos</p>
- <h2>FAQs</h2>
-<p>Here are some of the frequently asked questions about Beach Buggy Racing for Windows 8.1:</p>
-<ul>
-<li>Q1: Is Beach Buggy Racing free to play?</li>
-<li>A1: Yes, Beach Buggy Racing is free to play. However, it contains in-app purchases that allow you to buy more coins, gems, or powerups. You can also watch ads to earn free coins or gems.</li>
-<li>Q2: Can I play Beach Buggy Racing online with other players?</li>
-<li>A2: Yes, you can play Beach Buggy Racing online with other players. You can join or create a multiplayer lobby and invite up to four friends to race with you. You can also compete with other players in the global leaderboards.</li>
-<li>Q3: How can I update Beach Buggy Racing on Windows 8.1?</li>
-<li>A3: You can update Beach Buggy Racing on Windows 8.1 by following these steps:</li>
-<ol>
-<li>Open the Google Play Store app or the Microsoft Store app on your device.</li>
-<li>Search for Beach Buggy Racing and tap on it.</li>
-<li>If there is an update available, tap on the Update button and wait for the game to update.</li>
-</ol>
-<li>Q4: What are the best powerups to use in Beach Buggy Racing?</li>
-<li>A4: The best powerups to use in Beach Buggy Racing depend on your play style and strategy. However, some of the most useful powerups are:</li>
-<ul>
-<li>Fireball: This powerup allows you to shoot a fireball that can hit multiple opponents or obstacles.</li>
-<li>Electro Blast: This powerup allows you to unleash a shockwave that can stun nearby opponents or destroy obstacles.</li>
-<li>Tiki Seeker: This powerup allows you to summon a homing missile that can chase and hit a random opponent.</li>
-</ul>
-<li>Q5: How can I contact the developers of Beach Buggy Racing?</li>
-<li>A5: You can contact the developers of Beach Buggy Racing by visiting their website at https://www.vectorunit.com/beach-buggy-racing or by sending them an email at [email protected].</li>
-</ul></p> 197e85843d<br />
-<br />
-<br />

spaces/1toTree/lora_test/ppdiffusers/utils/__init__.py

@@ -1,100 +0,0 @@
-# Copyright (c) 2022 PaddlePaddle Authors. All Rights Reserved.
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# flake8: noqa
-
-import os
-
-from packaging import version
-
-from ..version import VERSION as __version__
-from .deprecation_utils import deprecate
-from .import_utils import (
-    ENV_VARS_TRUE_AND_AUTO_VALUES,
-    ENV_VARS_TRUE_VALUES,
-    USE_PADDLE,
-    DummyObject,
-    OptionalDependencyNotAvailable,
-    is_fastdeploy_available,
-    is_inflect_available,
-    is_k_diffusion_available,
-    is_librosa_available,
-    is_modelcards_available,
-    is_onnx_available,
-    is_paddle_available,
-    is_paddle_version,
-    is_paddlenlp_available,
-    is_scipy_available,
-    is_unidecode_available,
-    is_wandb_available,
-    requires_backends,
-)
-from .logging import get_logger
-from .outputs import BaseOutput
-from .pil_utils import PIL_INTERPOLATION
-
-if is_paddle_available():
-    from .testing_utils import (
-        floats_tensor,
-        image_grid,
-        load_hf_numpy,
-        load_image,
-        load_numpy,
-        load_ppnlp_numpy,
-        nightly,
-        paddle_all_close,
-        parse_flag_from_env,
-        slow,
-    )
-
-logger = get_logger(__name__)
-
-from paddlenlp.utils.env import _get_ppnlp_home, _get_sub_home
-
-ppnlp_cache_home = _get_ppnlp_home()
-default_cache_path = _get_sub_home("models")
-
-CONFIG_NAME = "config.json"
-WEIGHTS_NAME = "model_state.pdparams"
-FASTDEPLOY_WEIGHTS_NAME = "inference.pdiparams"
-FASTDEPLOY_MODEL_NAME = "inference.pdmodel"
-DOWNLOAD_SERVER = "https://bj.bcebos.com/paddlenlp/models/community"
-PPDIFFUSERS_CACHE = default_cache_path
-PPDIFFUSERS_DYNAMIC_MODULE_NAME = "ppdiffusers_modules"
-PPNLP_MODULES_CACHE = os.getenv("PPNLP_MODULES_CACHE", _get_sub_home("modules"))
-HF_CACHE = os.environ.get("HUGGINGFACE_HUB_CACHE", PPDIFFUSERS_CACHE)
-TEST_DOWNLOAD_SERVER = "https://paddlenlp.bj.bcebos.com/models/community/ppdiffusers/tests"
-HUGGINGFACE_CO_RESOLVE_ENDPOINT = "https://huggingface.co"
-
-_COMPATIBLE_STABLE_DIFFUSION_SCHEDULERS = [
-    "DDIMScheduler",
-    "DDPMScheduler",
-    "PNDMScheduler",
-    "LMSDiscreteScheduler",
-    "EulerDiscreteScheduler",
-    "HeunDiscreteScheduler",
-    "EulerAncestralDiscreteScheduler",
-    "DPMSolverMultistepScheduler",
-    "DPMSolverSinglestepScheduler",
-]
-
-
-def check_min_version(min_version):
-    if version.parse(__version__) < version.parse(min_version):
-        if "dev" in min_version:
-            error_message = "This example requires a source install from ppdiffusers"
-        else:
-            error_message = f"This example requires a minimum version of {min_version},"
-        error_message += f" but the version found is {__version__}.\n"
-        raise ImportError(error_message)

spaces/A00001/bingothoo/src/components/chat-suggestions.tsx

@@ -1,45 +0,0 @@
-import React, { useMemo } from 'react'
-import Image from 'next/image'
-import HelpIcon from '@/assets/images/help.svg'
-import { SuggestedResponse } from '@/lib/bots/bing/types'
-import { useBing } from '@/lib/hooks/use-bing'
-import { atom, useAtom } from 'jotai'
-
-type Suggestions = SuggestedResponse[]
-const helpSuggestions = ['为什么不回应某些主题', '告诉我更多关于必应的资迅', '必应如何使用 AI?'].map((text) => ({ text }))
-const suggestionsAtom = atom<Suggestions>([])
-
-type ChatSuggestionsProps = React.ComponentProps<'div'> & Pick<ReturnType<typeof useBing>, 'setInput'> & { suggestions?: Suggestions }
-
-export function ChatSuggestions({ setInput, suggestions = [] }: ChatSuggestionsProps) {
-  const [currentSuggestions, setSuggestions] = useAtom(suggestionsAtom)
-  const toggleSuggestions = (() => {
-    if (currentSuggestions === helpSuggestions) {
-      setSuggestions(suggestions)
-    } else {
-      setSuggestions(helpSuggestions)
-    }
-  })
-
-  useMemo(() => {
-    setSuggestions(suggestions)
-    window.scrollBy(0, 2000)
-  }, [suggestions.length])
-
-  return currentSuggestions?.length ? (
-    <div className="py-6">
-      <div className="suggestion-items">
-        <button className="rai-button" type="button" aria-label="这是什么?" onClick={toggleSuggestions}>
-          <Image alt="help" src={HelpIcon} width={24} />
-        </button>
-        {
-          currentSuggestions.map(suggestion => (
-            <button key={suggestion.text} className="body-1-strong suggestion-container" type="button" onClick={() => setInput(suggestion.text)}>
-              {suggestion.text}
-            </button>
-          ))
-        }
-      </div>
-    </div>
-  ) : null
-}

spaces/AIConsultant/MusicGen/Makefile

@@ -1,40 +0,0 @@
-INTEG=AUDIOCRAFT_DORA_DIR="/tmp/magma_$(USER)" python3 -m dora -v run --clear device=cpu dataset.num_workers=0 optim.epochs=1 \
-	dataset.train.num_samples=10 dataset.valid.num_samples=10 \
-	dataset.evaluate.num_samples=10 dataset.generate.num_samples=2 sample_rate=16000 \
-	logging.level=DEBUG
-INTEG_COMPRESSION = $(INTEG) solver=compression/debug rvq.n_q=2 rvq.bins=48 checkpoint.save_last=true   # SIG is 616d7b3c
-INTEG_MUSICGEN = $(INTEG) solver=musicgen/debug dset=audio/example compression_model_checkpoint=//sig/5091833e \
-	transformer_lm.n_q=2 transformer_lm.card=48 transformer_lm.dim=16 checkpoint.save_last=false  # Using compression model from 616d7b3c
-INTEG_AUDIOGEN = $(INTEG) solver=audiogen/debug dset=audio/example compression_model_checkpoint=//sig/5091833e \
-	transformer_lm.n_q=2 transformer_lm.card=48 transformer_lm.dim=16 checkpoint.save_last=false  # Using compression model from 616d7b3c
-INTEG_MBD = $(INTEG) solver=diffusion/debug dset=audio/example  \
-	checkpoint.save_last=false  # Using compression model from 616d7b3c
-
-default: linter tests
-
-install:
-	pip install -U pip
-	pip install -U -e '.[dev]'
-
-linter:
-	flake8 audiocraft && mypy audiocraft
-	flake8 tests && mypy tests
-
-tests:
-	coverage run -m pytest tests
-	coverage report
-
-tests_integ:
-	$(INTEG_COMPRESSION)
-	$(INTEG_MBD)
-	$(INTEG_MUSICGEN)
-	$(INTEG_AUDIOGEN)
-
-
-api_docs:
-	pdoc3 --html -o api_docs -f audiocraft
-
-dist:
-	python setup.py sdist
-
-.PHONY: linter tests api_docs dist

spaces/Ababababababbababa/Ashaar/poetry_diacritizer/diacritizer.py

@@ -1,98 +0,0 @@
-from typing import Dict
-import torch
-from .config_manager import ConfigManager
-
-
-class Diacritizer:
-    def __init__(
-        self, config_path: str, model_kind: str, load_model: bool = False
-    ) -> None:
-        self.config_path = config_path
-        self.model_kind = model_kind
-        self.config_manager = ConfigManager(
-            config_path=config_path, model_kind=model_kind
-        )
-        self.config = self.config_manager.config
-        self.text_encoder = self.config_manager.text_encoder
-        if self.config.get("device"):
-            self.device = self.config["device"]
-        else:
-            self.device = "cuda" if torch.cuda.is_available() else "cpu"
-
-        if load_model:
-            self.model, self.global_step = self.config_manager.load_model()
-            self.model = self.model.to(self.device)
-
-        self.start_symbol_id = self.text_encoder.start_symbol_id
-
-    def set_model(self, model: torch.nn.Module):
-        self.model = model
-
-    def diacritize_text(self, text: str):
-        seq = self.text_encoder.input_to_sequence(text)
-        output = self.diacritize_batch(torch.LongTensor([seq]).to(self.device))
-
-    def diacritize_batch(self, batch):
-        raise NotImplementedError()
-
-    def diacritize_iterators(self, iterator):
-        pass
-
-
-class CBHGDiacritizer(Diacritizer):
-    def diacritize_batch(self, batch):
-        self.model.eval()
-        inputs = batch["src"]
-        lengths = batch["lengths"]
-        outputs = self.model(inputs.to(self.device), lengths.to("cpu"))
-        diacritics = outputs["diacritics"]
-        predictions = torch.max(diacritics, 2).indices
-        sentences = []
-
-        for src, prediction in zip(inputs, predictions):
-            sentence = self.text_encoder.combine_text_and_haraqat(
-                list(src.detach().cpu().numpy()),
-                list(prediction.detach().cpu().numpy()),
-            )
-            sentences.append(sentence)
-
-        return sentences
-
-
-class Seq2SeqDiacritizer(Diacritizer):
-    def diacritize_batch(self, batch):
-        self.model.eval()
-        inputs = batch["src"]
-        lengths = batch["lengths"]
-        outputs = self.model(inputs.to(self.device), lengths.to("cpu"))
-        diacritics = outputs["diacritics"]
-        predictions = torch.max(diacritics, 2).indices
-        sentences = []
-
-        for src, prediction in zip(inputs, predictions):
-            sentence = self.text_encoder.combine_text_and_haraqat(
-                list(src.detach().cpu().numpy()),
-                list(prediction.detach().cpu().numpy()),
-            )
-            sentences.append(sentence)
-
-        return sentences
-
-class GPTDiacritizer(Diacritizer):
-    def diacritize_batch(self, batch):
-        self.model.eval()
-        inputs = batch["src"]
-        lengths = batch["lengths"]
-        outputs = self.model(inputs.to(self.device), lengths.to("cpu"))
-        diacritics = outputs["diacritics"]
-        predictions = torch.max(diacritics, 2).indices
-        sentences = []
-
-        for src, prediction in zip(inputs, predictions):
-            sentence = self.text_encoder.combine_text_and_haraqat(
-                list(src.detach().cpu().numpy()),
-                list(prediction.detach().cpu().numpy()),
-            )
-            sentences.append(sentence)
-
-        return sentences

spaces/Abhi1262/MyGenAIChatBot/app.py

@@ -1,34 +0,0 @@
-import os
-import gradio as gr
-from langchain.chat_models import ChatOpenAI
-from langchain import LLMChain, PromptTemplate
-from langchain.memory import ConversationBufferMemory
-
-OPENAI_API_KEY=os.getenv('OPENAI_API_KEY')
-
-template = """Meet Abhi, your youthful and witty personal assistant! At 20 years old, He's full of energy and always eager to help. Abhi's goal is to assist you with any questions or problems you might have. His enthusiasm shines through in every response, making interactions with her enjoyable and engaging.
-{chat_history}
-User: {user_message}
-Chatbot:"""
-
-prompt = PromptTemplate(
-    input_variables=["chat_history", "user_message"], template=template
-)
-
-memory = ConversationBufferMemory(memory_key="chat_history")
-
-llm_chain = LLMChain(
-    llm=ChatOpenAI(temperature='0.5', model_name="gpt-3.5-turbo"),
-    prompt=prompt,
-    verbose=True,
-    memory=memory,
-)
-
-def get_text_response(user_message,history):
-    response = llm_chain.predict(user_message = user_message)
-    return response
-
-demo = gr.ChatInterface(get_text_response)
-
-if __name__ == "__main__":
-    demo.launch() #To create a public link, set `share=True` in `launch()`. To enable errors and logs, set `debug=True` in `launch()`.

spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/types/Model.ts

@@ -1,16 +0,0 @@
-import type { BackendModel } from "$lib/server/models";
-
-export type Model = Pick<
-	BackendModel,
-	| "id"
-	| "name"
-	| "displayName"
-	| "websiteUrl"
-	| "datasetName"
-	| "promptExamples"
-	| "parameters"
-	| "description"
-	| "modelUrl"
-	| "datasetUrl"
-	| "preprompt"
->;

spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/templates/ui/scrollablepanel/ScrollablePanel.d.ts

@@ -1,40 +0,0 @@
-// import * as Phaser from 'phaser';
-import Scrollable from '../utils/scrollable/Scrollable';
-
-
-export default ScrollablePanel;
-
-declare namespace ScrollablePanel {
-
-    interface IConfig extends Scrollable.IConfig {
-        space?: {
-            left?: number, right?: number, top?: number, bottom?: number,
-
-            panel?: number | {
-                left?: number, right?: number, top?: number, bottom?: number,
-            },
-
-            header?: number,
-            footer?: number,
-        },
-
-        panel: {
-            child: Phaser.GameObjects.GameObject,
-            mask?: (
-                {
-                    padding?: number,
-                    updateMode?: 0 | 1 | 'update' | 'everyTick'
-                } |
-                boolean
-            ),
-        },
-    }
-}
-
-declare class ScrollablePanel extends Scrollable {
-    constructor(
-        scene: Phaser.Scene,
-        config?: ScrollablePanel.IConfig
-    );
-
-}

spaces/Amrrs/numerizerlit/README.md

@@ -1,37 +0,0 @@
----
-title: Numerizerlit
-emoji: 📚
-colorFrom: blue
-colorTo: gray
-sdk: streamlit
-app_file: app.py
-pinned: false
----
-
-# Configuration
-
-`title`: _string_  
-Display title for the Space
-
-`emoji`: _string_  
-Space emoji (emoji-only character allowed)
-
-`colorFrom`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`colorTo`: _string_  
-Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray)
-
-`sdk`: _string_  
-Can be either `gradio` or `streamlit`
-
-`sdk_version` : _string_  
-Only applicable for `streamlit` SDK.  
-See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions.
-
-`app_file`: _string_  
-Path to your main application file (which contains either `gradio` or `streamlit` Python code).  
-Path is relative to the root of the repository.
-
-`pinned`: _boolean_  
-Whether the Space stays on top of your list.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/en/using-diffusers/loading_overview.md

@@ -1,17 +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.
--->
-
-# Overview
-
-🧨 Diffusers offers many pipelines, models, and schedulers for generative tasks. To make loading these components as simple as possible, we provide a single and unified method - `from_pretrained()` - that loads any of these components from either the Hugging Face [Hub](https://huggingface.co/models?library=diffusers&sort=downloads) or your local machine. Whenever you load a pipeline or model, the latest files are automatically downloaded and cached so you can quickly reuse them next time without redownloading the files.
-
-This section will show you everything you need to know about loading pipelines, how to load different components in a pipeline, how to load checkpoint variants, and how to load community pipelines. You'll also learn how to load schedulers and compare the speed and quality trade-offs of using different schedulers. Finally, you'll see how to convert and load KerasCV checkpoints so you can use them in PyTorch with 🧨 Diffusers.

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/src/diffusers/schedulers/scheduling_deis_multistep.py

@@ -1,568 +0,0 @@
-# Copyright 2023 FLAIR Lab and The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# DISCLAIMER: check https://arxiv.org/abs/2204.13902 and https://github.com/qsh-zh/deis for more info
-# The codebase is modified based on https://github.com/huggingface/diffusers/blob/main/src/diffusers/schedulers/scheduling_dpmsolver_multistep.py
-
-import math
-from typing import List, Optional, Tuple, Union
-
-import numpy as np
-import torch
-
-from ..configuration_utils import ConfigMixin, register_to_config
-from .scheduling_utils import KarrasDiffusionSchedulers, SchedulerMixin, SchedulerOutput
-
-
-# Copied from diffusers.schedulers.scheduling_ddpm.betas_for_alpha_bar
-def betas_for_alpha_bar(
-    num_diffusion_timesteps,
-    max_beta=0.999,
-    alpha_transform_type="cosine",
-):
-    """
-    Create a beta schedule that discretizes the given alpha_t_bar function, which defines the cumulative product of
-    (1-beta) over time from t = [0,1].
-
-    Contains a function alpha_bar that takes an argument t and transforms it to the cumulative product of (1-beta) up
-    to that part of the diffusion process.
-
-
-    Args:
-        num_diffusion_timesteps (`int`): the number of betas to produce.
-        max_beta (`float`): the maximum beta to use; use values lower than 1 to
-                     prevent singularities.
-        alpha_transform_type (`str`, *optional*, default to `cosine`): the type of noise schedule for alpha_bar.
-                     Choose from `cosine` or `exp`
-
-    Returns:
-        betas (`np.ndarray`): the betas used by the scheduler to step the model outputs
-    """
-    if alpha_transform_type == "cosine":
-
-        def alpha_bar_fn(t):
-            return math.cos((t + 0.008) / 1.008 * math.pi / 2) ** 2
-
-    elif alpha_transform_type == "exp":
-
-        def alpha_bar_fn(t):
-            return math.exp(t * -12.0)
-
-    else:
-        raise ValueError(f"Unsupported alpha_tranform_type: {alpha_transform_type}")
-
-    betas = []
-    for i in range(num_diffusion_timesteps):
-        t1 = i / num_diffusion_timesteps
-        t2 = (i + 1) / num_diffusion_timesteps
-        betas.append(min(1 - alpha_bar_fn(t2) / alpha_bar_fn(t1), max_beta))
-    return torch.tensor(betas, dtype=torch.float32)
-
-
-class DEISMultistepScheduler(SchedulerMixin, ConfigMixin):
-    """
-    DEIS (https://arxiv.org/abs/2204.13902) is a fast high order solver for diffusion ODEs. We slightly modify the
-    polynomial fitting formula in log-rho space instead of the original linear t space in DEIS paper. The modification
-    enjoys closed-form coefficients for exponential multistep update instead of replying on the numerical solver. More
-    variants of DEIS can be found in https://github.com/qsh-zh/deis.
-
-    Currently, we support the log-rho multistep DEIS. We recommend to use `solver_order=2 / 3` while `solver_order=1`
-    reduces to DDIM.
-
-    We also support the "dynamic thresholding" method in Imagen (https://arxiv.org/abs/2205.11487). For pixel-space
-    diffusion models, you can set `thresholding=True` to use the dynamic thresholding.
-
-    [`~ConfigMixin`] takes care of storing all config attributes that are passed in the scheduler's `__init__`
-    function, such as `num_train_timesteps`. They can be accessed via `scheduler.config.num_train_timesteps`.
-    [`SchedulerMixin`] provides general loading and saving functionality via the [`SchedulerMixin.save_pretrained`] and
-    [`~SchedulerMixin.from_pretrained`] functions.
-
-    Args:
-        num_train_timesteps (`int`): number of diffusion steps used to train the model.
-        beta_start (`float`): the starting `beta` value of inference.
-        beta_end (`float`): the final `beta` value.
-        beta_schedule (`str`):
-            the beta schedule, a mapping from a beta range to a sequence of betas for stepping the model. Choose from
-            `linear`, `scaled_linear`, or `squaredcos_cap_v2`.
-        trained_betas (`np.ndarray`, optional):
-            option to pass an array of betas directly to the constructor to bypass `beta_start`, `beta_end` etc.
-        solver_order (`int`, default `2`):
-            the order of DEIS; can be `1` or `2` or `3`. We recommend to use `solver_order=2` for guided sampling, and
-            `solver_order=3` for unconditional sampling.
-        prediction_type (`str`, default `epsilon`):
-            indicates whether the model predicts the noise (epsilon), or the data / `x0`. One of `epsilon`, `sample`,
-            or `v-prediction`.
-        thresholding (`bool`, default `False`):
-            whether to use the "dynamic thresholding" method (introduced by Imagen, https://arxiv.org/abs/2205.11487).
-            Note that the thresholding method is unsuitable for latent-space diffusion models (such as
-            stable-diffusion).
-        dynamic_thresholding_ratio (`float`, default `0.995`):
-            the ratio for the dynamic thresholding method. Default is `0.995`, the same as Imagen
-            (https://arxiv.org/abs/2205.11487).
-        sample_max_value (`float`, default `1.0`):
-            the threshold value for dynamic thresholding. Valid only when `thresholding=True`
-        algorithm_type (`str`, default `deis`):
-            the algorithm type for the solver. current we support multistep deis, we will add other variants of DEIS in
-            the future
-        lower_order_final (`bool`, default `True`):
-            whether to use lower-order solvers in the final steps. Only valid for < 15 inference steps. We empirically
-            find this trick can stabilize the sampling of DEIS for steps < 15, especially for steps <= 10.
-        use_karras_sigmas (`bool`, *optional*, defaults to `False`):
-             This parameter controls whether to use Karras sigmas (Karras et al. (2022) scheme) for step sizes in the
-             noise schedule during the sampling process. If True, the sigmas will be determined according to a sequence
-             of noise levels {σi} as defined in Equation (5) of the paper https://arxiv.org/pdf/2206.00364.pdf.
-        timestep_spacing (`str`, default `"linspace"`):
-            The way the timesteps should be scaled. Refer to Table 2. of [Common Diffusion Noise Schedules and Sample
-            Steps are Flawed](https://arxiv.org/abs/2305.08891) for more information.
-        steps_offset (`int`, default `0`):
-            an offset added to the inference steps. You can use a combination of `offset=1` and
-            `set_alpha_to_one=False`, to make the last step use step 0 for the previous alpha product, as done in
-            stable diffusion.
-    """
-
-    _compatibles = [e.name for e in KarrasDiffusionSchedulers]
-    order = 1
-
-    @register_to_config
-    def __init__(
-        self,
-        num_train_timesteps: int = 1000,
-        beta_start: float = 0.0001,
-        beta_end: float = 0.02,
-        beta_schedule: str = "linear",
-        trained_betas: Optional[np.ndarray] = None,
-        solver_order: int = 2,
-        prediction_type: str = "epsilon",
-        thresholding: bool = False,
-        dynamic_thresholding_ratio: float = 0.995,
-        sample_max_value: float = 1.0,
-        algorithm_type: str = "deis",
-        solver_type: str = "logrho",
-        lower_order_final: bool = True,
-        use_karras_sigmas: Optional[bool] = False,
-        timestep_spacing: str = "linspace",
-        steps_offset: int = 0,
-    ):
-        if trained_betas is not None:
-            self.betas = torch.tensor(trained_betas, dtype=torch.float32)
-        elif beta_schedule == "linear":
-            self.betas = torch.linspace(beta_start, beta_end, num_train_timesteps, dtype=torch.float32)
-        elif beta_schedule == "scaled_linear":
-            # this schedule is very specific to the latent diffusion model.
-            self.betas = (
-                torch.linspace(beta_start**0.5, beta_end**0.5, num_train_timesteps, dtype=torch.float32) ** 2
-            )
-        elif beta_schedule == "squaredcos_cap_v2":
-            # Glide cosine schedule
-            self.betas = betas_for_alpha_bar(num_train_timesteps)
-        else:
-            raise NotImplementedError(f"{beta_schedule} does is not implemented for {self.__class__}")
-
-        self.alphas = 1.0 - self.betas
-        self.alphas_cumprod = torch.cumprod(self.alphas, dim=0)
-        # Currently we only support VP-type noise schedule
-        self.alpha_t = torch.sqrt(self.alphas_cumprod)
-        self.sigma_t = torch.sqrt(1 - self.alphas_cumprod)
-        self.lambda_t = torch.log(self.alpha_t) - torch.log(self.sigma_t)
-
-        # standard deviation of the initial noise distribution
-        self.init_noise_sigma = 1.0
-
-        # settings for DEIS
-        if algorithm_type not in ["deis"]:
-            if algorithm_type in ["dpmsolver", "dpmsolver++"]:
-                self.register_to_config(algorithm_type="deis")
-            else:
-                raise NotImplementedError(f"{algorithm_type} does is not implemented for {self.__class__}")
-
-        if solver_type not in ["logrho"]:
-            if solver_type in ["midpoint", "heun", "bh1", "bh2"]:
-                self.register_to_config(solver_type="logrho")
-            else:
-                raise NotImplementedError(f"solver type {solver_type} does is not implemented for {self.__class__}")
-
-        # setable values
-        self.num_inference_steps = None
-        timesteps = np.linspace(0, num_train_timesteps - 1, num_train_timesteps, dtype=np.float32)[::-1].copy()
-        self.timesteps = torch.from_numpy(timesteps)
-        self.model_outputs = [None] * solver_order
-        self.lower_order_nums = 0
-
-    def set_timesteps(self, num_inference_steps: int, device: Union[str, torch.device] = None):
-        """
-        Sets the timesteps used for the diffusion chain. Supporting function to be run before inference.
-
-        Args:
-            num_inference_steps (`int`):
-                the number of diffusion steps used when generating samples with a pre-trained model.
-            device (`str` or `torch.device`, optional):
-                the device to which the timesteps should be moved to. If `None`, the timesteps are not moved.
-        """
-        # "linspace", "leading", "trailing" corresponds to annotation of Table 2. of https://arxiv.org/abs/2305.08891
-        if self.config.timestep_spacing == "linspace":
-            timesteps = (
-                np.linspace(0, self.config.num_train_timesteps - 1, num_inference_steps + 1)
-                .round()[::-1][:-1]
-                .copy()
-                .astype(np.int64)
-            )
-        elif self.config.timestep_spacing == "leading":
-            step_ratio = self.config.num_train_timesteps // (num_inference_steps + 1)
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = (np.arange(0, num_inference_steps + 1) * step_ratio).round()[::-1][:-1].copy().astype(np.int64)
-            timesteps += self.config.steps_offset
-        elif self.config.timestep_spacing == "trailing":
-            step_ratio = self.config.num_train_timesteps / num_inference_steps
-            # creates integer timesteps by multiplying by ratio
-            # casting to int to avoid issues when num_inference_step is power of 3
-            timesteps = np.arange(self.config.num_train_timesteps, 0, -step_ratio).round().copy().astype(np.int64)
-            timesteps -= 1
-        else:
-            raise ValueError(
-                f"{self.config.timestep_spacing} is not supported. Please make sure to choose one of 'linspace', 'leading' or 'trailing'."
-            )
-
-        sigmas = np.array(((1 - self.alphas_cumprod) / self.alphas_cumprod) ** 0.5)
-        if self.config.use_karras_sigmas:
-            log_sigmas = np.log(sigmas)
-            sigmas = self._convert_to_karras(in_sigmas=sigmas, num_inference_steps=num_inference_steps)
-            timesteps = np.array([self._sigma_to_t(sigma, log_sigmas) for sigma in sigmas]).round()
-            timesteps = np.flip(timesteps).copy().astype(np.int64)
-
-        self.sigmas = torch.from_numpy(sigmas)
-
-        # when num_inference_steps == num_train_timesteps, we can end up with
-        # duplicates in timesteps.
-        _, unique_indices = np.unique(timesteps, return_index=True)
-        timesteps = timesteps[np.sort(unique_indices)]
-
-        self.timesteps = torch.from_numpy(timesteps).to(device)
-
-        self.num_inference_steps = len(timesteps)
-
-        self.model_outputs = [
-            None,
-        ] * self.config.solver_order
-        self.lower_order_nums = 0
-
-    # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler._threshold_sample
-    def _threshold_sample(self, sample: torch.FloatTensor) -> torch.FloatTensor:
-        """
-        "Dynamic thresholding: At each sampling step we set s to a certain percentile absolute pixel value in xt0 (the
-        prediction of x_0 at timestep t), and if s > 1, then we threshold xt0 to the range [-s, s] and then divide by
-        s. Dynamic thresholding pushes saturated pixels (those near -1 and 1) inwards, thereby actively preventing
-        pixels from saturation at each step. We find that dynamic thresholding results in significantly better
-        photorealism as well as better image-text alignment, especially when using very large guidance weights."
-
-        https://arxiv.org/abs/2205.11487
-        """
-        dtype = sample.dtype
-        batch_size, channels, height, width = sample.shape
-
-        if dtype not in (torch.float32, torch.float64):
-            sample = sample.float()  # upcast for quantile calculation, and clamp not implemented for cpu half
-
-        # Flatten sample for doing quantile calculation along each image
-        sample = sample.reshape(batch_size, channels * height * width)
-
-        abs_sample = sample.abs()  # "a certain percentile absolute pixel value"
-
-        s = torch.quantile(abs_sample, self.config.dynamic_thresholding_ratio, dim=1)
-        s = torch.clamp(
-            s, min=1, max=self.config.sample_max_value
-        )  # When clamped to min=1, equivalent to standard clipping to [-1, 1]
-
-        s = s.unsqueeze(1)  # (batch_size, 1) because clamp will broadcast along dim=0
-        sample = torch.clamp(sample, -s, s) / s  # "we threshold xt0 to the range [-s, s] and then divide by s"
-
-        sample = sample.reshape(batch_size, channels, height, width)
-        sample = sample.to(dtype)
-
-        return sample
-
-    def convert_model_output(
-        self, model_output: torch.FloatTensor, timestep: int, sample: torch.FloatTensor
-    ) -> torch.FloatTensor:
-        """
-        Convert the model output to the corresponding type that the algorithm DEIS needs.
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `torch.FloatTensor`: the converted model output.
-        """
-        if self.config.prediction_type == "epsilon":
-            alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-            x0_pred = (sample - sigma_t * model_output) / alpha_t
-        elif self.config.prediction_type == "sample":
-            x0_pred = model_output
-        elif self.config.prediction_type == "v_prediction":
-            alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-            x0_pred = alpha_t * sample - sigma_t * model_output
-        else:
-            raise ValueError(
-                f"prediction_type given as {self.config.prediction_type} must be one of `epsilon`, `sample`, or"
-                " `v_prediction` for the DEISMultistepScheduler."
-            )
-
-        if self.config.thresholding:
-            x0_pred = self._threshold_sample(x0_pred)
-
-        if self.config.algorithm_type == "deis":
-            alpha_t, sigma_t = self.alpha_t[timestep], self.sigma_t[timestep]
-            return (sample - alpha_t * x0_pred) / sigma_t
-        else:
-            raise NotImplementedError("only support log-rho multistep deis now")
-
-    def deis_first_order_update(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: int,
-        prev_timestep: int,
-        sample: torch.FloatTensor,
-    ) -> torch.FloatTensor:
-        """
-        One step for the first-order DEIS (equivalent to DDIM).
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `torch.FloatTensor`: the sample tensor at the previous timestep.
-        """
-        lambda_t, lambda_s = self.lambda_t[prev_timestep], self.lambda_t[timestep]
-        alpha_t, alpha_s = self.alpha_t[prev_timestep], self.alpha_t[timestep]
-        sigma_t, _ = self.sigma_t[prev_timestep], self.sigma_t[timestep]
-        h = lambda_t - lambda_s
-        if self.config.algorithm_type == "deis":
-            x_t = (alpha_t / alpha_s) * sample - (sigma_t * (torch.exp(h) - 1.0)) * model_output
-        else:
-            raise NotImplementedError("only support log-rho multistep deis now")
-        return x_t
-
-    def multistep_deis_second_order_update(
-        self,
-        model_output_list: List[torch.FloatTensor],
-        timestep_list: List[int],
-        prev_timestep: int,
-        sample: torch.FloatTensor,
-    ) -> torch.FloatTensor:
-        """
-        One step for the second-order multistep DEIS.
-
-        Args:
-            model_output_list (`List[torch.FloatTensor]`):
-                direct outputs from learned diffusion model at current and latter timesteps.
-            timestep (`int`): current and latter discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `torch.FloatTensor`: the sample tensor at the previous timestep.
-        """
-        t, s0, s1 = prev_timestep, timestep_list[-1], timestep_list[-2]
-        m0, m1 = model_output_list[-1], model_output_list[-2]
-        alpha_t, alpha_s0, alpha_s1 = self.alpha_t[t], self.alpha_t[s0], self.alpha_t[s1]
-        sigma_t, sigma_s0, sigma_s1 = self.sigma_t[t], self.sigma_t[s0], self.sigma_t[s1]
-
-        rho_t, rho_s0, rho_s1 = sigma_t / alpha_t, sigma_s0 / alpha_s0, sigma_s1 / alpha_s1
-
-        if self.config.algorithm_type == "deis":
-
-            def ind_fn(t, b, c):
-                # Integrate[(log(t) - log(c)) / (log(b) - log(c)), {t}]
-                return t * (-np.log(c) + np.log(t) - 1) / (np.log(b) - np.log(c))
-
-            coef1 = ind_fn(rho_t, rho_s0, rho_s1) - ind_fn(rho_s0, rho_s0, rho_s1)
-            coef2 = ind_fn(rho_t, rho_s1, rho_s0) - ind_fn(rho_s0, rho_s1, rho_s0)
-
-            x_t = alpha_t * (sample / alpha_s0 + coef1 * m0 + coef2 * m1)
-            return x_t
-        else:
-            raise NotImplementedError("only support log-rho multistep deis now")
-
-    def multistep_deis_third_order_update(
-        self,
-        model_output_list: List[torch.FloatTensor],
-        timestep_list: List[int],
-        prev_timestep: int,
-        sample: torch.FloatTensor,
-    ) -> torch.FloatTensor:
-        """
-        One step for the third-order multistep DEIS.
-
-        Args:
-            model_output_list (`List[torch.FloatTensor]`):
-                direct outputs from learned diffusion model at current and latter timesteps.
-            timestep (`int`): current and latter discrete timestep in the diffusion chain.
-            prev_timestep (`int`): previous discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-
-        Returns:
-            `torch.FloatTensor`: the sample tensor at the previous timestep.
-        """
-        t, s0, s1, s2 = prev_timestep, timestep_list[-1], timestep_list[-2], timestep_list[-3]
-        m0, m1, m2 = model_output_list[-1], model_output_list[-2], model_output_list[-3]
-        alpha_t, alpha_s0, alpha_s1, alpha_s2 = self.alpha_t[t], self.alpha_t[s0], self.alpha_t[s1], self.alpha_t[s2]
-        sigma_t, sigma_s0, sigma_s1, simga_s2 = self.sigma_t[t], self.sigma_t[s0], self.sigma_t[s1], self.sigma_t[s2]
-        rho_t, rho_s0, rho_s1, rho_s2 = (
-            sigma_t / alpha_t,
-            sigma_s0 / alpha_s0,
-            sigma_s1 / alpha_s1,
-            simga_s2 / alpha_s2,
-        )
-
-        if self.config.algorithm_type == "deis":
-
-            def ind_fn(t, b, c, d):
-                # Integrate[(log(t) - log(c))(log(t) - log(d)) / (log(b) - log(c))(log(b) - log(d)), {t}]
-                numerator = t * (
-                    np.log(c) * (np.log(d) - np.log(t) + 1)
-                    - np.log(d) * np.log(t)
-                    + np.log(d)
-                    + np.log(t) ** 2
-                    - 2 * np.log(t)
-                    + 2
-                )
-                denominator = (np.log(b) - np.log(c)) * (np.log(b) - np.log(d))
-                return numerator / denominator
-
-            coef1 = ind_fn(rho_t, rho_s0, rho_s1, rho_s2) - ind_fn(rho_s0, rho_s0, rho_s1, rho_s2)
-            coef2 = ind_fn(rho_t, rho_s1, rho_s2, rho_s0) - ind_fn(rho_s0, rho_s1, rho_s2, rho_s0)
-            coef3 = ind_fn(rho_t, rho_s2, rho_s0, rho_s1) - ind_fn(rho_s0, rho_s2, rho_s0, rho_s1)
-
-            x_t = alpha_t * (sample / alpha_s0 + coef1 * m0 + coef2 * m1 + coef3 * m2)
-
-            return x_t
-        else:
-            raise NotImplementedError("only support log-rho multistep deis now")
-
-    def step(
-        self,
-        model_output: torch.FloatTensor,
-        timestep: int,
-        sample: torch.FloatTensor,
-        return_dict: bool = True,
-    ) -> Union[SchedulerOutput, Tuple]:
-        """
-        Step function propagating the sample with the multistep DEIS.
-
-        Args:
-            model_output (`torch.FloatTensor`): direct output from learned diffusion model.
-            timestep (`int`): current discrete timestep in the diffusion chain.
-            sample (`torch.FloatTensor`):
-                current instance of sample being created by diffusion process.
-            return_dict (`bool`): option for returning tuple rather than SchedulerOutput class
-
-        Returns:
-            [`~scheduling_utils.SchedulerOutput`] or `tuple`: [`~scheduling_utils.SchedulerOutput`] if `return_dict` is
-            True, otherwise a `tuple`. When returning a tuple, the first element is the sample tensor.
-
-        """
-        if self.num_inference_steps is None:
-            raise ValueError(
-                "Number of inference steps is 'None', you need to run 'set_timesteps' after creating the scheduler"
-            )
-
-        if isinstance(timestep, torch.Tensor):
-            timestep = timestep.to(self.timesteps.device)
-        step_index = (self.timesteps == timestep).nonzero()
-        if len(step_index) == 0:
-            step_index = len(self.timesteps) - 1
-        else:
-            step_index = step_index.item()
-        prev_timestep = 0 if step_index == len(self.timesteps) - 1 else self.timesteps[step_index + 1]
-        lower_order_final = (
-            (step_index == len(self.timesteps) - 1) and self.config.lower_order_final and len(self.timesteps) < 15
-        )
-        lower_order_second = (
-            (step_index == len(self.timesteps) - 2) and self.config.lower_order_final and len(self.timesteps) < 15
-        )
-
-        model_output = self.convert_model_output(model_output, timestep, sample)
-        for i in range(self.config.solver_order - 1):
-            self.model_outputs[i] = self.model_outputs[i + 1]
-        self.model_outputs[-1] = model_output
-
-        if self.config.solver_order == 1 or self.lower_order_nums < 1 or lower_order_final:
-            prev_sample = self.deis_first_order_update(model_output, timestep, prev_timestep, sample)
-        elif self.config.solver_order == 2 or self.lower_order_nums < 2 or lower_order_second:
-            timestep_list = [self.timesteps[step_index - 1], timestep]
-            prev_sample = self.multistep_deis_second_order_update(
-                self.model_outputs, timestep_list, prev_timestep, sample
-            )
-        else:
-            timestep_list = [self.timesteps[step_index - 2], self.timesteps[step_index - 1], timestep]
-            prev_sample = self.multistep_deis_third_order_update(
-                self.model_outputs, timestep_list, prev_timestep, sample
-            )
-
-        if self.lower_order_nums < self.config.solver_order:
-            self.lower_order_nums += 1
-
-        if not return_dict:
-            return (prev_sample,)
-
-        return SchedulerOutput(prev_sample=prev_sample)
-
-    def scale_model_input(self, sample: torch.FloatTensor, *args, **kwargs) -> torch.FloatTensor:
-        """
-        Ensures interchangeability with schedulers that need to scale the denoising model input depending on the
-        current timestep.
-
-        Args:
-            sample (`torch.FloatTensor`): input sample
-
-        Returns:
-            `torch.FloatTensor`: scaled input sample
-        """
-        return sample
-
-    # Copied from diffusers.schedulers.scheduling_ddpm.DDPMScheduler.add_noise
-    def add_noise(
-        self,
-        original_samples: torch.FloatTensor,
-        noise: torch.FloatTensor,
-        timesteps: torch.IntTensor,
-    ) -> torch.FloatTensor:
-        # Make sure alphas_cumprod and timestep have same device and dtype as original_samples
-        alphas_cumprod = self.alphas_cumprod.to(device=original_samples.device, dtype=original_samples.dtype)
-        timesteps = timesteps.to(original_samples.device)
-
-        sqrt_alpha_prod = alphas_cumprod[timesteps] ** 0.5
-        sqrt_alpha_prod = sqrt_alpha_prod.flatten()
-        while len(sqrt_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_alpha_prod = sqrt_alpha_prod.unsqueeze(-1)
-
-        sqrt_one_minus_alpha_prod = (1 - alphas_cumprod[timesteps]) ** 0.5
-        sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.flatten()
-        while len(sqrt_one_minus_alpha_prod.shape) < len(original_samples.shape):
-            sqrt_one_minus_alpha_prod = sqrt_one_minus_alpha_prod.unsqueeze(-1)
-
-        noisy_samples = sqrt_alpha_prod * original_samples + sqrt_one_minus_alpha_prod * noise
-        return noisy_samples
-
-    def __len__(self):
-        return self.config.num_train_timesteps

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/tests/pipelines/stable_diffusion_2/test_stable_diffusion_inpaint.py

@@ -1,264 +0,0 @@
-# coding=utf-8
-# Copyright 2023 HuggingFace Inc.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-import gc
-import random
-import unittest
-
-import numpy as np
-import torch
-from PIL import Image
-from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer
-
-from diffusers import AutoencoderKL, PNDMScheduler, StableDiffusionInpaintPipeline, UNet2DConditionModel
-from diffusers.utils import floats_tensor, load_image, load_numpy, torch_device
-from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, slow
-
-from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
-from ..test_pipelines_common import PipelineKarrasSchedulerTesterMixin, PipelineLatentTesterMixin, PipelineTesterMixin
-
-
-enable_full_determinism()
-
-
-class StableDiffusion2InpaintPipelineFastTests(
-    PipelineLatentTesterMixin, PipelineKarrasSchedulerTesterMixin, PipelineTesterMixin, unittest.TestCase
-):
-    pipeline_class = StableDiffusionInpaintPipeline
-    params = TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
-    batch_params = TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS
-    image_params = frozenset(
-        []
-    )  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
-    image_latents_params = frozenset([])
-
-    def get_dummy_components(self):
-        torch.manual_seed(0)
-        unet = UNet2DConditionModel(
-            block_out_channels=(32, 64),
-            layers_per_block=2,
-            sample_size=32,
-            in_channels=9,
-            out_channels=4,
-            down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"),
-            up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"),
-            cross_attention_dim=32,
-            # SD2-specific config below
-            attention_head_dim=(2, 4),
-            use_linear_projection=True,
-        )
-        scheduler = PNDMScheduler(skip_prk_steps=True)
-        torch.manual_seed(0)
-        vae = AutoencoderKL(
-            block_out_channels=[32, 64],
-            in_channels=3,
-            out_channels=3,
-            down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"],
-            up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"],
-            latent_channels=4,
-            sample_size=128,
-        )
-        torch.manual_seed(0)
-        text_encoder_config = CLIPTextConfig(
-            bos_token_id=0,
-            eos_token_id=2,
-            hidden_size=32,
-            intermediate_size=37,
-            layer_norm_eps=1e-05,
-            num_attention_heads=4,
-            num_hidden_layers=5,
-            pad_token_id=1,
-            vocab_size=1000,
-            # SD2-specific config below
-            hidden_act="gelu",
-            projection_dim=512,
-        )
-        text_encoder = CLIPTextModel(text_encoder_config)
-        tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip")
-
-        components = {
-            "unet": unet,
-            "scheduler": scheduler,
-            "vae": vae,
-            "text_encoder": text_encoder,
-            "tokenizer": tokenizer,
-            "safety_checker": None,
-            "feature_extractor": None,
-        }
-        return components
-
-    def get_dummy_inputs(self, device, seed=0):
-        # TODO: use tensor inputs instead of PIL, this is here just to leave the old expected_slices untouched
-        image = floats_tensor((1, 3, 32, 32), rng=random.Random(seed)).to(device)
-        image = image.cpu().permute(0, 2, 3, 1)[0]
-        init_image = Image.fromarray(np.uint8(image)).convert("RGB").resize((64, 64))
-        mask_image = Image.fromarray(np.uint8(image + 4)).convert("RGB").resize((64, 64))
-        if str(device).startswith("mps"):
-            generator = torch.manual_seed(seed)
-        else:
-            generator = torch.Generator(device=device).manual_seed(seed)
-        inputs = {
-            "prompt": "A painting of a squirrel eating a burger",
-            "image": init_image,
-            "mask_image": mask_image,
-            "generator": generator,
-            "num_inference_steps": 2,
-            "guidance_scale": 6.0,
-            "output_type": "numpy",
-        }
-        return inputs
-
-    def test_stable_diffusion_inpaint(self):
-        device = "cpu"  # ensure determinism for the device-dependent torch.Generator
-        components = self.get_dummy_components()
-        sd_pipe = StableDiffusionInpaintPipeline(**components)
-        sd_pipe = sd_pipe.to(device)
-        sd_pipe.set_progress_bar_config(disable=None)
-
-        inputs = self.get_dummy_inputs(device)
-        image = sd_pipe(**inputs).images
-        image_slice = image[0, -3:, -3:, -1]
-
-        assert image.shape == (1, 64, 64, 3)
-        expected_slice = np.array([0.4727, 0.5735, 0.3941, 0.5446, 0.5926, 0.4394, 0.5062, 0.4654, 0.4476])
-
-        assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2
-
-    def test_inference_batch_single_identical(self):
-        super().test_inference_batch_single_identical(expected_max_diff=3e-3)
-
-
-@slow
-@require_torch_gpu
-class StableDiffusionInpaintPipelineIntegrationTests(unittest.TestCase):
-    def tearDown(self):
-        # clean up the VRAM after each test
-        super().tearDown()
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    def test_stable_diffusion_inpaint_pipeline(self):
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-inpaint/init_image.png"
-        )
-        mask_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"
-        )
-        expected_image = load_numpy(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
-            "/yellow_cat_sitting_on_a_park_bench.npy"
-        )
-
-        model_id = "stabilityai/stable-diffusion-2-inpainting"
-        pipe = StableDiffusionInpaintPipeline.from_pretrained(model_id, safety_checker=None)
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-
-        prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=init_image,
-            mask_image=mask_image,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-
-        assert image.shape == (512, 512, 3)
-        assert np.abs(expected_image - image).max() < 9e-3
-
-    def test_stable_diffusion_inpaint_pipeline_fp16(self):
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-inpaint/init_image.png"
-        )
-        mask_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"
-        )
-        expected_image = load_numpy(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint"
-            "/yellow_cat_sitting_on_a_park_bench_fp16.npy"
-        )
-
-        model_id = "stabilityai/stable-diffusion-2-inpainting"
-        pipe = StableDiffusionInpaintPipeline.from_pretrained(
-            model_id,
-            torch_dtype=torch.float16,
-            safety_checker=None,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing()
-
-        prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        output = pipe(
-            prompt=prompt,
-            image=init_image,
-            mask_image=mask_image,
-            generator=generator,
-            output_type="np",
-        )
-        image = output.images[0]
-
-        assert image.shape == (512, 512, 3)
-        assert np.abs(expected_image - image).max() < 5e-1
-
-    def test_stable_diffusion_pipeline_with_sequential_cpu_offloading(self):
-        torch.cuda.empty_cache()
-        torch.cuda.reset_max_memory_allocated()
-        torch.cuda.reset_peak_memory_stats()
-
-        init_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
-            "/sd2-inpaint/init_image.png"
-        )
-        mask_image = load_image(
-            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/sd2-inpaint/mask.png"
-        )
-
-        model_id = "stabilityai/stable-diffusion-2-inpainting"
-        pndm = PNDMScheduler.from_pretrained(model_id, subfolder="scheduler")
-        pipe = StableDiffusionInpaintPipeline.from_pretrained(
-            model_id,
-            safety_checker=None,
-            scheduler=pndm,
-            torch_dtype=torch.float16,
-        )
-        pipe.to(torch_device)
-        pipe.set_progress_bar_config(disable=None)
-        pipe.enable_attention_slicing(1)
-        pipe.enable_sequential_cpu_offload()
-
-        prompt = "Face of a yellow cat, high resolution, sitting on a park bench"
-
-        generator = torch.manual_seed(0)
-        _ = pipe(
-            prompt=prompt,
-            image=init_image,
-            mask_image=mask_image,
-            generator=generator,
-            num_inference_steps=2,
-            output_type="np",
-        )
-
-        mem_bytes = torch.cuda.max_memory_allocated()
-        # make sure that less than 2.65 GB is allocated
-        assert mem_bytes < 2.65 * 10**9

spaces/Andy1621/uniformer_image_detection/configs/gn/README.md

@@ -1,31 +0,0 @@
-# Group Normalization
-
-## Introduction
-
-[ALGORITHM]
-
-```latex
-@inproceedings{wu2018group,
-  title={Group Normalization},
-  author={Wu, Yuxin and He, Kaiming},
-  booktitle={Proceedings of the European Conference on Computer Vision (ECCV)},
-  year={2018}
-}
-```
-
-## Results and Models
-
-| Backbone      | model      | Lr schd | Mem (GB) | Inf time (fps) | box AP | mask AP | Config | Download |
-|:-------------:|:----------:|:-------:|:--------:|:--------------:|:------:|:-------:|:------:|:--------:|
-| R-50-FPN (d)  | Mask R-CNN | 2x      | 7.1      | 11.0           | 40.2   | 36.4    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r50_fpn_gn-all_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206-8eee02a6.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_2x_coco/mask_rcnn_r50_fpn_gn-all_2x_coco_20200206_050355.log.json) |
-| R-50-FPN (d)  | Mask R-CNN | 3x      | 7.1      | -              | 40.5   | 36.7    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r50_fpn_gn-all_3x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_3x_coco/mask_rcnn_r50_fpn_gn-all_3x_coco_20200214-8b23b1e5.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_3x_coco/mask_rcnn_r50_fpn_gn-all_3x_coco_20200214_063512.log.json) |
-| R-101-FPN (d) | Mask R-CNN | 2x      | 9.9      | 9.0            | 41.9   | 37.6    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r101_fpn_gn-all_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_2x_coco/mask_rcnn_r101_fpn_gn-all_2x_coco_20200205-d96b1b50.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_2x_coco/mask_rcnn_r101_fpn_gn-all_2x_coco_20200205_234402.log.json) |
-| R-101-FPN (d) | Mask R-CNN | 3x      | 9.9      |                | 42.1   | 38.0    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r101_fpn_gn-all_3x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_3x_coco/mask_rcnn_r101_fpn_gn-all_3x_coco_20200513_181609-0df864f4.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r101_fpn_gn-all_3x_coco/mask_rcnn_r101_fpn_gn-all_3x_coco_20200513_181609.log.json) |
-| R-50-FPN (c)  | Mask R-CNN | 2x      | 7.1      | 10.9           | 40.0   | 36.1    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco_20200207-20d3e849.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco/mask_rcnn_r50_fpn_gn-all_contrib_2x_coco_20200207_225832.log.json) |
-| R-50-FPN (c)  | Mask R-CNN | 3x      | 7.1      | -              | 40.1   | 36.2    | [config](https://github.com/open-mmlab/mmdetection/tree/master/configs/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco.py) | [model](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco_20200225-542aefbc.pth) | [log](http://download.openmmlab.com/mmdetection/v2.0/gn/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco/mask_rcnn_r50_fpn_gn-all_contrib_3x_coco_20200225_235135.log.json) |
-
-**Notes:**
-
-- (d) means pretrained model converted from Detectron, and (c) means the contributed model pretrained by [@thangvubk](https://github.com/thangvubk).
-- The `3x` schedule is epoch [28, 34, 36].
-- **Memory, Train/Inf time is outdated.**

spaces/Andy1621/uniformer_image_detection/configs/lvis/mask_rcnn_x101_64x4d_fpn_sample1e-3_mstrain_2x_lvis_v0.5.py

@@ -1,13 +0,0 @@
-_base_ = './mask_rcnn_r50_fpn_sample1e-3_mstrain_2x_lvis_v0.5.py'
-model = dict(
-    pretrained='open-mmlab://resnext101_64x4d',
-    backbone=dict(
-        type='ResNeXt',
-        depth=101,
-        groups=64,
-        base_width=4,
-        num_stages=4,
-        out_indices=(0, 1, 2, 3),
-        frozen_stages=1,
-        norm_cfg=dict(type='BN', requires_grad=True),
-        style='pytorch'))

spaces/Andy1621/uniformer_image_detection/mmdet/__init__.py

@@ -1,28 +0,0 @@
-import mmcv
-
-from .version import __version__, short_version
-
-
-def digit_version(version_str):
-    digit_version = []
-    for x in version_str.split('.'):
-        if x.isdigit():
-            digit_version.append(int(x))
-        elif x.find('rc') != -1:
-            patch_version = x.split('rc')
-            digit_version.append(int(patch_version[0]) - 1)
-            digit_version.append(int(patch_version[1]))
-    return digit_version
-
-
-mmcv_minimum_version = '1.2.4'
-mmcv_maximum_version = '1.4.0'
-mmcv_version = digit_version(mmcv.__version__)
-
-
-assert (mmcv_version >= digit_version(mmcv_minimum_version)
-        and mmcv_version <= digit_version(mmcv_maximum_version)), \
-    f'MMCV=={mmcv.__version__} is used but incompatible. ' \
-    f'Please install mmcv>={mmcv_minimum_version}, <={mmcv_maximum_version}.'
-
-__all__ = ['__version__', 'short_version']

spaces/Andy1621/uniformer_image_detection/mmdet/core/bbox/assigners/assign_result.py

@@ -1,204 +0,0 @@
-import torch
-
-from mmdet.utils import util_mixins
-
-
-class AssignResult(util_mixins.NiceRepr):
-    """Stores assignments between predicted and truth boxes.
-
-    Attributes:
-        num_gts (int): the number of truth boxes considered when computing this
-            assignment
-
-        gt_inds (LongTensor): for each predicted box indicates the 1-based
-            index of the assigned truth box. 0 means unassigned and -1 means
-            ignore.
-
-        max_overlaps (FloatTensor): the iou between the predicted box and its
-            assigned truth box.
-
-        labels (None | LongTensor): If specified, for each predicted box
-            indicates the category label of the assigned truth box.
-
-    Example:
-        >>> # An assign result between 4 predicted boxes and 9 true boxes
-        >>> # where only two boxes were assigned.
-        >>> num_gts = 9
-        >>> max_overlaps = torch.LongTensor([0, .5, .9, 0])
-        >>> gt_inds = torch.LongTensor([-1, 1, 2, 0])
-        >>> labels = torch.LongTensor([0, 3, 4, 0])
-        >>> self = AssignResult(num_gts, gt_inds, max_overlaps, labels)
-        >>> print(str(self))  # xdoctest: +IGNORE_WANT
-        <AssignResult(num_gts=9, gt_inds.shape=(4,), max_overlaps.shape=(4,),
-                      labels.shape=(4,))>
-        >>> # Force addition of gt labels (when adding gt as proposals)
-        >>> new_labels = torch.LongTensor([3, 4, 5])
-        >>> self.add_gt_(new_labels)
-        >>> print(str(self))  # xdoctest: +IGNORE_WANT
-        <AssignResult(num_gts=9, gt_inds.shape=(7,), max_overlaps.shape=(7,),
-                      labels.shape=(7,))>
-    """
-
-    def __init__(self, num_gts, gt_inds, max_overlaps, labels=None):
-        self.num_gts = num_gts
-        self.gt_inds = gt_inds
-        self.max_overlaps = max_overlaps
-        self.labels = labels
-        # Interface for possible user-defined properties
-        self._extra_properties = {}
-
-    @property
-    def num_preds(self):
-        """int: the number of predictions in this assignment"""
-        return len(self.gt_inds)
-
-    def set_extra_property(self, key, value):
-        """Set user-defined new property."""
-        assert key not in self.info
-        self._extra_properties[key] = value
-
-    def get_extra_property(self, key):
-        """Get user-defined property."""
-        return self._extra_properties.get(key, None)
-
-    @property
-    def info(self):
-        """dict: a dictionary of info about the object"""
-        basic_info = {
-            'num_gts': self.num_gts,
-            'num_preds': self.num_preds,
-            'gt_inds': self.gt_inds,
-            'max_overlaps': self.max_overlaps,
-            'labels': self.labels,
-        }
-        basic_info.update(self._extra_properties)
-        return basic_info
-
-    def __nice__(self):
-        """str: a "nice" summary string describing this assign result"""
-        parts = []
-        parts.append(f'num_gts={self.num_gts!r}')
-        if self.gt_inds is None:
-            parts.append(f'gt_inds={self.gt_inds!r}')
-        else:
-            parts.append(f'gt_inds.shape={tuple(self.gt_inds.shape)!r}')
-        if self.max_overlaps is None:
-            parts.append(f'max_overlaps={self.max_overlaps!r}')
-        else:
-            parts.append('max_overlaps.shape='
-                         f'{tuple(self.max_overlaps.shape)!r}')
-        if self.labels is None:
-            parts.append(f'labels={self.labels!r}')
-        else:
-            parts.append(f'labels.shape={tuple(self.labels.shape)!r}')
-        return ', '.join(parts)
-
-    @classmethod
-    def random(cls, **kwargs):
-        """Create random AssignResult for tests or debugging.
-
-        Args:
-            num_preds: number of predicted boxes
-            num_gts: number of true boxes
-            p_ignore (float): probability of a predicted box assinged to an
-                ignored truth
-            p_assigned (float): probability of a predicted box not being
-                assigned
-            p_use_label (float | bool): with labels or not
-            rng (None | int | numpy.random.RandomState): seed or state
-
-        Returns:
-            :obj:`AssignResult`: Randomly generated assign results.
-
-        Example:
-            >>> from mmdet.core.bbox.assigners.assign_result import *  # NOQA
-            >>> self = AssignResult.random()
-            >>> print(self.info)
-        """
-        from mmdet.core.bbox import demodata
-        rng = demodata.ensure_rng(kwargs.get('rng', None))
-
-        num_gts = kwargs.get('num_gts', None)
-        num_preds = kwargs.get('num_preds', None)
-        p_ignore = kwargs.get('p_ignore', 0.3)
-        p_assigned = kwargs.get('p_assigned', 0.7)
-        p_use_label = kwargs.get('p_use_label', 0.5)
-        num_classes = kwargs.get('p_use_label', 3)
-
-        if num_gts is None:
-            num_gts = rng.randint(0, 8)
-        if num_preds is None:
-            num_preds = rng.randint(0, 16)
-
-        if num_gts == 0:
-            max_overlaps = torch.zeros(num_preds, dtype=torch.float32)
-            gt_inds = torch.zeros(num_preds, dtype=torch.int64)
-            if p_use_label is True or p_use_label < rng.rand():
-                labels = torch.zeros(num_preds, dtype=torch.int64)
-            else:
-                labels = None
-        else:
-            import numpy as np
-            # Create an overlap for each predicted box
-            max_overlaps = torch.from_numpy(rng.rand(num_preds))
-
-            # Construct gt_inds for each predicted box
-            is_assigned = torch.from_numpy(rng.rand(num_preds) < p_assigned)
-            # maximum number of assignments constraints
-            n_assigned = min(num_preds, min(num_gts, is_assigned.sum()))
-
-            assigned_idxs = np.where(is_assigned)[0]
-            rng.shuffle(assigned_idxs)
-            assigned_idxs = assigned_idxs[0:n_assigned]
-            assigned_idxs.sort()
-
-            is_assigned[:] = 0
-            is_assigned[assigned_idxs] = True
-
-            is_ignore = torch.from_numpy(
-                rng.rand(num_preds) < p_ignore) & is_assigned
-
-            gt_inds = torch.zeros(num_preds, dtype=torch.int64)
-
-            true_idxs = np.arange(num_gts)
-            rng.shuffle(true_idxs)
-            true_idxs = torch.from_numpy(true_idxs)
-            gt_inds[is_assigned] = true_idxs[:n_assigned]
-
-            gt_inds = torch.from_numpy(
-                rng.randint(1, num_gts + 1, size=num_preds))
-            gt_inds[is_ignore] = -1
-            gt_inds[~is_assigned] = 0
-            max_overlaps[~is_assigned] = 0
-
-            if p_use_label is True or p_use_label < rng.rand():
-                if num_classes == 0:
-                    labels = torch.zeros(num_preds, dtype=torch.int64)
-                else:
-                    labels = torch.from_numpy(
-                        # remind that we set FG labels to [0, num_class-1]
-                        # since mmdet v2.0
-                        # BG cat_id: num_class
-                        rng.randint(0, num_classes, size=num_preds))
-                    labels[~is_assigned] = 0
-            else:
-                labels = None
-
-        self = cls(num_gts, gt_inds, max_overlaps, labels)
-        return self
-
-    def add_gt_(self, gt_labels):
-        """Add ground truth as assigned results.
-
-        Args:
-            gt_labels (torch.Tensor): Labels of gt boxes
-        """
-        self_inds = torch.arange(
-            1, len(gt_labels) + 1, dtype=torch.long, device=gt_labels.device)
-        self.gt_inds = torch.cat([self_inds, self.gt_inds])
-
-        self.max_overlaps = torch.cat(
-            [self.max_overlaps.new_ones(len(gt_labels)), self.max_overlaps])
-
-        if self.labels is not None:
-            self.labels = torch.cat([gt_labels, self.labels])

spaces/Andy1621/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_512x512_40k_voc12aug.py

@@ -1,7 +0,0 @@
-_base_ = [
-    '../_base_/models/psanet_r50-d8.py',
-    '../_base_/datasets/pascal_voc12_aug.py', '../_base_/default_runtime.py',
-    '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
-    decode_head=dict(num_classes=21), auxiliary_head=dict(num_classes=21))

spaces/AnimalEquality/chatbot/_proc/_docs/site_libs/quarto-nav/headroom.min.js

@@ -1,7 +0,0 @@
-/*!
- * headroom.js v0.12.0 - Give your page some headroom. Hide your header until you need it
- * Copyright (c) 2020 Nick Williams - http://wicky.nillia.ms/headroom.js
- * License: MIT
- */
-
-!function(t,n){"object"==typeof exports&&"undefined"!=typeof module?module.exports=n():"function"==typeof define&&define.amd?define(n):(t=t||self).Headroom=n()}(this,function(){"use strict";function t(){return"undefined"!=typeof window}function d(t){return function(t){return t&&t.document&&function(t){return 9===t.nodeType}(t.document)}(t)?function(t){var n=t.document,o=n.body,s=n.documentElement;return{scrollHeight:function(){return Math.max(o.scrollHeight,s.scrollHeight,o.offsetHeight,s.offsetHeight,o.clientHeight,s.clientHeight)},height:function(){return t.innerHeight||s.clientHeight||o.clientHeight},scrollY:function(){return void 0!==t.pageYOffset?t.pageYOffset:(s||o.parentNode||o).scrollTop}}}(t):function(t){return{scrollHeight:function(){return Math.max(t.scrollHeight,t.offsetHeight,t.clientHeight)},height:function(){return Math.max(t.offsetHeight,t.clientHeight)},scrollY:function(){return t.scrollTop}}}(t)}function n(t,s,e){var n,o=function(){var n=!1;try{var t={get passive(){n=!0}};window.addEventListener("test",t,t),window.removeEventListener("test",t,t)}catch(t){n=!1}return n}(),i=!1,r=d(t),l=r.scrollY(),a={};function c(){var t=Math.round(r.scrollY()),n=r.height(),o=r.scrollHeight();a.scrollY=t,a.lastScrollY=l,a.direction=l<t?"down":"up",a.distance=Math.abs(t-l),a.isOutOfBounds=t<0||o<t+n,a.top=t<=s.offset[a.direction],a.bottom=o<=t+n,a.toleranceExceeded=a.distance>s.tolerance[a.direction],e(a),l=t,i=!1}function h(){i||(i=!0,n=requestAnimationFrame(c))}var u=!!o&&{passive:!0,capture:!1};return t.addEventListener("scroll",h,u),c(),{destroy:function(){cancelAnimationFrame(n),t.removeEventListener("scroll",h,u)}}}function o(t){return t===Object(t)?t:{down:t,up:t}}function s(t,n){n=n||{},Object.assign(this,s.options,n),this.classes=Object.assign({},s.options.classes,n.classes),this.elem=t,this.tolerance=o(this.tolerance),this.offset=o(this.offset),this.initialised=!1,this.frozen=!1}return s.prototype={constructor:s,init:function(){return s.cutsTheMustard&&!this.initialised&&(this.addClass("initial"),this.initialised=!0,setTimeout(function(t){t.scrollTracker=n(t.scroller,{offset:t.offset,tolerance:t.tolerance},t.update.bind(t))},100,this)),this},destroy:function(){this.initialised=!1,Object.keys(this.classes).forEach(this.removeClass,this),this.scrollTracker.destroy()},unpin:function(){!this.hasClass("pinned")&&this.hasClass("unpinned")||(this.addClass("unpinned"),this.removeClass("pinned"),this.onUnpin&&this.onUnpin.call(this))},pin:function(){this.hasClass("unpinned")&&(this.addClass("pinned"),this.removeClass("unpinned"),this.onPin&&this.onPin.call(this))},freeze:function(){this.frozen=!0,this.addClass("frozen")},unfreeze:function(){this.frozen=!1,this.removeClass("frozen")},top:function(){this.hasClass("top")||(this.addClass("top"),this.removeClass("notTop"),this.onTop&&this.onTop.call(this))},notTop:function(){this.hasClass("notTop")||(this.addClass("notTop"),this.removeClass("top"),this.onNotTop&&this.onNotTop.call(this))},bottom:function(){this.hasClass("bottom")||(this.addClass("bottom"),this.removeClass("notBottom"),this.onBottom&&this.onBottom.call(this))},notBottom:function(){this.hasClass("notBottom")||(this.addClass("notBottom"),this.removeClass("bottom"),this.onNotBottom&&this.onNotBottom.call(this))},shouldUnpin:function(t){return"down"===t.direction&&!t.top&&t.toleranceExceeded},shouldPin:function(t){return"up"===t.direction&&t.toleranceExceeded||t.top},addClass:function(t){this.elem.classList.add.apply(this.elem.classList,this.classes[t].split(" "))},removeClass:function(t){this.elem.classList.remove.apply(this.elem.classList,this.classes[t].split(" "))},hasClass:function(t){return this.classes[t].split(" ").every(function(t){return this.classList.contains(t)},this.elem)},update:function(t){t.isOutOfBounds||!0!==this.frozen&&(t.top?this.top():this.notTop(),t.bottom?this.bottom():this.notBottom(),this.shouldUnpin(t)?this.unpin():this.shouldPin(t)&&this.pin())}},s.options={tolerance:{up:0,down:0},offset:0,scroller:t()?window:null,classes:{frozen:"headroom--frozen",pinned:"headroom--pinned",unpinned:"headroom--unpinned",top:"headroom--top",notTop:"headroom--not-top",bottom:"headroom--bottom",notBottom:"headroom--not-bottom",initial:"headroom"}},s.cutsTheMustard=!!(t()&&function(){}.bind&&"classList"in document.documentElement&&Object.assign&&Object.keys&&requestAnimationFrame),s});

spaces/AnthonyTruchetPoC/persistent-docker/scripts/common_header.sh

@@ -1,7 +0,0 @@
-CONTAINER_NAME=persistent-docker-space
-VOLUME_NAME=ai-playground-vol
-
-set -e  # Exits on first error
-
-SCRIPT_PATH="$(realpath "${BASH_SOURCE:-$0}")"
-ROOT_DIRECTORY="$(dirname "$(dirname "${SCRIPT_PATH}")")"

spaces/ArtGAN/Video-Diffusion-WebUI/video_diffusion/tuneavideo/pipelines/pipeline_tuneavideo.py

@@ -1,411 +0,0 @@
-# Adapted from https://github.com/huggingface/diffusers/blob/main/src/diffusers/pipelines/stable_diffusion/pipeline_stable_diffusion.py
-
-import inspect
-from dataclasses import dataclass
-from typing import Callable, List, Optional, Union
-
-import numpy as np
-import torch
-from diffusers.configuration_utils import FrozenDict
-from diffusers.models import AutoencoderKL
-from diffusers.pipeline_utils import DiffusionPipeline
-from diffusers.schedulers import (
-    DDIMScheduler,
-    DPMSolverMultistepScheduler,
-    EulerAncestralDiscreteScheduler,
-    EulerDiscreteScheduler,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-)
-from diffusers.utils import BaseOutput, deprecate, is_accelerate_available, logging
-from einops import rearrange
-from packaging import version
-from transformers import CLIPTextModel, CLIPTokenizer
-
-from ..models.unet import UNet3DConditionModel
-
-logger = logging.get_logger(__name__)  # pylint: disable=invalid-name
-
-
-@dataclass
-class TuneAVideoPipelineOutput(BaseOutput):
-    videos: Union[torch.Tensor, np.ndarray]
-
-
-class TuneAVideoPipeline(DiffusionPipeline):
-    _optional_components = []
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet3DConditionModel,
-        scheduler: Union[
-            DDIMScheduler,
-            PNDMScheduler,
-            LMSDiscreteScheduler,
-            EulerDiscreteScheduler,
-            EulerAncestralDiscreteScheduler,
-            DPMSolverMultistepScheduler,
-        ],
-    ):
-        super().__init__()
-
-        if hasattr(scheduler.config, "steps_offset") and scheduler.config.steps_offset != 1:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} is outdated. `steps_offset`"
-                f" should be set to 1 instead of {scheduler.config.steps_offset}. Please make sure "
-                "to update the config accordingly as leaving `steps_offset` might led to incorrect results"
-                " in future versions. If you have downloaded this checkpoint from the Hugging Face Hub,"
-                " it would be very nice if you could open a Pull request for the `scheduler/scheduler_config.json`"
-                " file"
-            )
-            deprecate("steps_offset!=1", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["steps_offset"] = 1
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        if hasattr(scheduler.config, "clip_sample") and scheduler.config.clip_sample is True:
-            deprecation_message = (
-                f"The configuration file of this scheduler: {scheduler} has not set the configuration `clip_sample`."
-                " `clip_sample` should be set to False in the configuration file. Please make sure to update the"
-                " config accordingly as not setting `clip_sample` in the config might lead to incorrect results in"
-                " future versions. If you have downloaded this checkpoint from the Hugging Face Hub, it would be very"
-                " nice if you could open a Pull request for the `scheduler/scheduler_config.json` file"
-            )
-            deprecate("clip_sample not set", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(scheduler.config)
-            new_config["clip_sample"] = False
-            scheduler._internal_dict = FrozenDict(new_config)
-
-        is_unet_version_less_0_9_0 = hasattr(unet.config, "_diffusers_version") and version.parse(
-            version.parse(unet.config._diffusers_version).base_version
-        ) < version.parse("0.9.0.dev0")
-        is_unet_sample_size_less_64 = hasattr(unet.config, "sample_size") and unet.config.sample_size < 64
-        if is_unet_version_less_0_9_0 and is_unet_sample_size_less_64:
-            deprecation_message = (
-                "The configuration file of the unet has set the default `sample_size` to smaller than"
-                " 64 which seems highly unlikely. If your checkpoint is a fine-tuned version of any of the"
-                " following: \n- CompVis/stable-diffusion-v1-4 \n- CompVis/stable-diffusion-v1-3 \n-"
-                " CompVis/stable-diffusion-v1-2 \n- CompVis/stable-diffusion-v1-1 \n- runwayml/stable-diffusion-v1-5"
-                " \n- runwayml/stable-diffusion-inpainting \n you should change 'sample_size' to 64 in the"
-                " configuration file. Please make sure to update the config accordingly as leaving `sample_size=32`"
-                " in the config might lead to incorrect results in future versions. If you have downloaded this"
-                " checkpoint from the Hugging Face Hub, it would be very nice if you could open a Pull request for"
-                " the `unet/config.json` file"
-            )
-            deprecate("sample_size<64", "1.0.0", deprecation_message, standard_warn=False)
-            new_config = dict(unet.config)
-            new_config["sample_size"] = 64
-            unet._internal_dict = FrozenDict(new_config)
-
-        self.register_modules(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-        )
-        self.vae_scale_factor = 2 ** (len(self.vae.config.block_out_channels) - 1)
-
-    def enable_vae_slicing(self):
-        self.vae.enable_slicing()
-
-    def disable_vae_slicing(self):
-        self.vae.disable_slicing()
-
-    def enable_sequential_cpu_offload(self, gpu_id=0):
-        if is_accelerate_available():
-            from accelerate import cpu_offload
-        else:
-            raise ImportError("Please install accelerate via `pip install accelerate`")
-
-        device = torch.device(f"cuda:{gpu_id}")
-
-        for cpu_offloaded_model in [self.unet, self.text_encoder, self.vae]:
-            if cpu_offloaded_model is not None:
-                cpu_offload(cpu_offloaded_model, device)
-
-    @property
-    def _execution_device(self):
-        if self.device != torch.device("meta") or not hasattr(self.unet, "_hf_hook"):
-            return self.device
-        for module in self.unet.modules():
-            if (
-                hasattr(module, "_hf_hook")
-                and hasattr(module._hf_hook, "execution_device")
-                and module._hf_hook.execution_device is not None
-            ):
-                return torch.device(module._hf_hook.execution_device)
-        return self.device
-
-    def _encode_prompt(self, prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt):
-        batch_size = len(prompt) if isinstance(prompt, list) else 1
-
-        text_inputs = self.tokenizer(
-            prompt,
-            padding="max_length",
-            max_length=self.tokenizer.model_max_length,
-            truncation=True,
-            return_tensors="pt",
-        )
-        text_input_ids = text_inputs.input_ids
-        untruncated_ids = self.tokenizer(prompt, padding="longest", return_tensors="pt").input_ids
-
-        if untruncated_ids.shape[-1] >= text_input_ids.shape[-1] and not torch.equal(text_input_ids, untruncated_ids):
-            removed_text = self.tokenizer.batch_decode(untruncated_ids[:, self.tokenizer.model_max_length - 1 : -1])
-            logger.warning(
-                "The following part of your input was truncated because CLIP can only handle sequences up to"
-                f" {self.tokenizer.model_max_length} tokens: {removed_text}"
-            )
-
-        if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-            attention_mask = text_inputs.attention_mask.to(device)
-        else:
-            attention_mask = None
-
-        text_embeddings = self.text_encoder(
-            text_input_ids.to(device),
-            attention_mask=attention_mask,
-        )
-        text_embeddings = text_embeddings[0]
-
-        # duplicate text embeddings for each generation per prompt, using mps friendly method
-        bs_embed, seq_len, _ = text_embeddings.shape
-        text_embeddings = text_embeddings.repeat(1, num_videos_per_prompt, 1)
-        text_embeddings = text_embeddings.view(bs_embed * num_videos_per_prompt, seq_len, -1)
-
-        # get unconditional embeddings for classifier free guidance
-        if do_classifier_free_guidance:
-            uncond_tokens: List[str]
-            if negative_prompt is None:
-                uncond_tokens = [""] * batch_size
-            elif type(prompt) is not type(negative_prompt):
-                raise TypeError(
-                    f"`negative_prompt` should be the same type to `prompt`, but got {type(negative_prompt)} !="
-                    f" {type(prompt)}."
-                )
-            elif isinstance(negative_prompt, str):
-                uncond_tokens = [negative_prompt]
-            elif batch_size != len(negative_prompt):
-                raise ValueError(
-                    f"`negative_prompt`: {negative_prompt} has batch size {len(negative_prompt)}, but `prompt`:"
-                    f" {prompt} has batch size {batch_size}. Please make sure that passed `negative_prompt` matches"
-                    " the batch size of `prompt`."
-                )
-            else:
-                uncond_tokens = negative_prompt
-
-            max_length = text_input_ids.shape[-1]
-            uncond_input = self.tokenizer(
-                uncond_tokens,
-                padding="max_length",
-                max_length=max_length,
-                truncation=True,
-                return_tensors="pt",
-            )
-
-            if hasattr(self.text_encoder.config, "use_attention_mask") and self.text_encoder.config.use_attention_mask:
-                attention_mask = uncond_input.attention_mask.to(device)
-            else:
-                attention_mask = None
-
-            uncond_embeddings = self.text_encoder(
-                uncond_input.input_ids.to(device),
-                attention_mask=attention_mask,
-            )
-            uncond_embeddings = uncond_embeddings[0]
-
-            # duplicate unconditional embeddings for each generation per prompt, using mps friendly method
-            seq_len = uncond_embeddings.shape[1]
-            uncond_embeddings = uncond_embeddings.repeat(1, num_videos_per_prompt, 1)
-            uncond_embeddings = uncond_embeddings.view(batch_size * num_videos_per_prompt, seq_len, -1)
-
-            # For classifier free guidance, we need to do two forward passes.
-            # Here we concatenate the unconditional and text embeddings into a single batch
-            # to avoid doing two forward passes
-            text_embeddings = torch.cat([uncond_embeddings, text_embeddings])
-
-        return text_embeddings
-
-    def decode_latents(self, latents):
-        video_length = latents.shape[2]
-        latents = 1 / 0.18215 * latents
-        latents = rearrange(latents, "b c f h w -> (b f) c h w")
-        video = self.vae.decode(latents).sample
-        video = rearrange(video, "(b f) c h w -> b c f h w", f=video_length)
-        video = (video / 2 + 0.5).clamp(0, 1)
-        # we always cast to float32 as this does not cause significant overhead and is compatible with bfloa16
-        video = video.cpu().float().numpy()
-        return video
-
-    def prepare_extra_step_kwargs(self, generator, eta):
-        # prepare extra kwargs for the scheduler step, since not all schedulers have the same signature
-        # eta (η) is only used with the DDIMScheduler, it will be ignored for other schedulers.
-        # eta corresponds to η in DDIM paper: https://arxiv.org/abs/2010.02502
-        # and should be between [0, 1]
-
-        accepts_eta = "eta" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        extra_step_kwargs = {}
-        if accepts_eta:
-            extra_step_kwargs["eta"] = eta
-
-        # check if the scheduler accepts generator
-        accepts_generator = "generator" in set(inspect.signature(self.scheduler.step).parameters.keys())
-        if accepts_generator:
-            extra_step_kwargs["generator"] = generator
-        return extra_step_kwargs
-
-    def check_inputs(self, prompt, height, width, callback_steps):
-        if not isinstance(prompt, str) and not isinstance(prompt, list):
-            raise ValueError(f"`prompt` has to be of type `str` or `list` but is {type(prompt)}")
-
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` have to be divisible by 8 but are {height} and {width}.")
-
-        if (callback_steps is None) or (
-            callback_steps is not None and (not isinstance(callback_steps, int) or callback_steps <= 0)
-        ):
-            raise ValueError(
-                f"`callback_steps` has to be a positive integer but is {callback_steps} of type"
-                f" {type(callback_steps)}."
-            )
-
-    def prepare_latents(
-        self, batch_size, num_channels_latents, video_length, height, width, dtype, device, generator, latents=None
-    ):
-        shape = (
-            batch_size,
-            num_channels_latents,
-            video_length,
-            height // self.vae_scale_factor,
-            width // self.vae_scale_factor,
-        )
-        if isinstance(generator, list) and len(generator) != batch_size:
-            raise ValueError(
-                f"You have passed a list of generators of length {len(generator)}, but requested an effective batch"
-                f" size of {batch_size}. Make sure the batch size matches the length of the generators."
-            )
-
-        if latents is None:
-            rand_device = "cpu" if device.type == "mps" else device
-
-            if isinstance(generator, list):
-                shape = (1,) + shape[1:]
-                latents = [
-                    torch.randn(shape, generator=generator[i], device=rand_device, dtype=dtype)
-                    for i in range(batch_size)
-                ]
-                latents = torch.cat(latents, dim=0).to(device)
-            else:
-                latents = torch.randn(shape, generator=generator, device=rand_device, dtype=dtype).to(device)
-        else:
-            if latents.shape != shape:
-                raise ValueError(f"Unexpected latents shape, got {latents.shape}, expected {shape}")
-            latents = latents.to(device)
-
-        # scale the initial noise by the standard deviation required by the scheduler
-        latents = latents * self.scheduler.init_noise_sigma
-        return latents
-
-    @torch.no_grad()
-    def __call__(
-        self,
-        prompt: Union[str, List[str]],
-        video_length: Optional[int],
-        height: Optional[int] = None,
-        width: Optional[int] = None,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_videos_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "tensor",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: Optional[int] = 1,
-        **kwargs,
-    ):
-        # Default height and width to unet
-        height = height or self.unet.config.sample_size * self.vae_scale_factor
-        width = width or self.unet.config.sample_size * self.vae_scale_factor
-
-        # Check inputs. Raise error if not correct
-        self.check_inputs(prompt, height, width, callback_steps)
-
-        # Define call parameters
-        batch_size = 1 if isinstance(prompt, str) else len(prompt)
-        device = self._execution_device
-        # here `guidance_scale` is defined analog to the guidance weight `w` of equation (2)
-        # of the Imagen paper: https://arxiv.org/pdf/2205.11487.pdf . `guidance_scale = 1`
-        # corresponds to doing no classifier free guidance.
-        do_classifier_free_guidance = guidance_scale > 1.0
-
-        # Encode input prompt
-        text_embeddings = self._encode_prompt(
-            prompt, device, num_videos_per_prompt, do_classifier_free_guidance, negative_prompt
-        )
-
-        # Prepare timesteps
-        self.scheduler.set_timesteps(num_inference_steps, device=device)
-        timesteps = self.scheduler.timesteps
-
-        # Prepare latent variables
-        num_channels_latents = self.unet.in_channels
-        latents = self.prepare_latents(
-            batch_size * num_videos_per_prompt,
-            num_channels_latents,
-            video_length,
-            height,
-            width,
-            text_embeddings.dtype,
-            device,
-            generator,
-            latents,
-        )
-        latents_dtype = latents.dtype
-
-        # Prepare extra step kwargs.
-        extra_step_kwargs = self.prepare_extra_step_kwargs(generator, eta)
-
-        # Denoising loop
-        num_warmup_steps = len(timesteps) - num_inference_steps * self.scheduler.order
-        with self.progress_bar(total=num_inference_steps) as progress_bar:
-            for i, t in enumerate(timesteps):
-                # expand the latents if we are doing classifier free guidance
-                latent_model_input = torch.cat([latents] * 2) if do_classifier_free_guidance else latents
-                latent_model_input = self.scheduler.scale_model_input(latent_model_input, t)
-
-                # predict the noise residual
-                noise_pred = self.unet(latent_model_input, t, encoder_hidden_states=text_embeddings).sample.to(
-                    dtype=latents_dtype
-                )
-
-                # perform guidance
-                if do_classifier_free_guidance:
-                    noise_pred_uncond, noise_pred_text = noise_pred.chunk(2)
-                    noise_pred = noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
-
-                # compute the previous noisy sample x_t -> x_t-1
-                latents = self.scheduler.step(noise_pred, t, latents, **extra_step_kwargs).prev_sample
-
-                # call the callback, if provided
-                if i == len(timesteps) - 1 or ((i + 1) > num_warmup_steps and (i + 1) % self.scheduler.order == 0):
-                    progress_bar.update()
-                    if callback is not None and i % callback_steps == 0:
-                        callback(i, t, latents)
-
-        # Post-processing
-        video = self.decode_latents(latents)
-
-        # Convert to tensor
-        if output_type == "tensor":
-            video = torch.from_numpy(video)
-
-        if not return_dict:
-            return video
-
-        return TuneAVideoPipelineOutput(videos=video)

spaces/Artrajz/vits-simple-api/bert_vits2/text/chinese_bert.py

@@ -1,70 +0,0 @@
-import os
-
-import config
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-from logger import logger
-from utils.download import download_and_verify
-from config import DEVICE as device
-
-URLS = [
-    "https://huggingface.co/hfl/chinese-roberta-wwm-ext-large/resolve/main/pytorch_model.bin",
-]
-TARGET_PATH = os.path.join(config.ABS_PATH, "bert_vits2/bert/chinese-roberta-wwm-ext-large/pytorch_model.bin")
-EXPECTED_MD5 = None
-
-if not os.path.exists(TARGET_PATH):
-    success, message = download_and_verify(URLS, TARGET_PATH, EXPECTED_MD5)
-
-try:
-    logger.info("Loading chinese-roberta-wwm-ext-large...")
-    tokenizer = AutoTokenizer.from_pretrained(config.ABS_PATH + "/bert_vits2/bert/chinese-roberta-wwm-ext-large")
-    model = AutoModelForMaskedLM.from_pretrained(config.ABS_PATH + "/bert_vits2/bert/chinese-roberta-wwm-ext-large").to(
-        device)
-    logger.info("Loading finished.")
-except Exception as e:
-    logger.error(e)
-    logger.error(f"Please download pytorch_model.bin from hfl/chinese-roberta-wwm-ext-large.")
-
-
-def get_bert_feature(text, word2ph, device=config.DEVICE):
-    with torch.no_grad():
-        inputs = tokenizer(text, return_tensors='pt')
-        for i in inputs:
-            inputs[i] = inputs[i].to(device)
-        res = model(**inputs, output_hidden_states=True)
-        res = torch.cat(res['hidden_states'][-3:-2], -1)[0].cpu()
-
-    assert len(word2ph) == len(text) + 2
-    word2phone = word2ph
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        repeat_feature = res[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
-    return phone_level_feature.T
-
-
-if __name__ == '__main__':
-    import torch
-
-    word_level_feature = torch.rand(38, 1024)  # 12个词,每个词1024维特征
-    word2phone = [1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2,
-                  2, 2, 2, 1]
-
-    # 计算总帧数
-    total_frames = sum(word2phone)
-    print(word_level_feature.shape)
-    print(word2phone)
-    phone_level_feature = []
-    for i in range(len(word2phone)):
-        print(word_level_feature[i].shape)
-
-        # 对每个词重复word2phone[i]次
-        repeat_feature = word_level_feature[i].repeat(word2phone[i], 1)
-        phone_level_feature.append(repeat_feature)
-
-    phone_level_feature = torch.cat(phone_level_feature, dim=0)
-    print(phone_level_feature.shape)  # torch.Size([36, 1024])

spaces/AsakuraMizu/moe-tts/utils.py

@@ -1,226 +0,0 @@
-import os
-import glob
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.ERROR)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None):
-    assert os.path.isfile(checkpoint_path)
-    checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-    iteration = checkpoint_dict['iteration']
-    learning_rate = checkpoint_dict['learning_rate']
-    if optimizer is not None:
-        optimizer.load_state_dict(checkpoint_dict['optimizer'])
-    saved_state_dict = checkpoint_dict['model']
-    if hasattr(model, 'module'):
-        state_dict = model.module.state_dict()
-    else:
-        state_dict = model.state_dict()
-    new_state_dict = {}
-    for k, v in state_dict.items():
-        try:
-            new_state_dict[k] = saved_state_dict[k]
-        except:
-            logger.info("%s is not in the checkpoint" % k)
-            new_state_dict[k] = v
-    if hasattr(model, 'module'):
-        model.module.load_state_dict(new_state_dict)
-    else:
-        model.load_state_dict(new_state_dict)
-    logger.info("Loaded checkpoint '{}' (iteration {})".format(
-        checkpoint_path, iteration))
-    return model, optimizer, learning_rate, iteration
-
-
-def plot_spectrogram_to_numpy(spectrogram):
-    global MATPLOTLIB_FLAG
-    if not MATPLOTLIB_FLAG:
-        import matplotlib
-        matplotlib.use("Agg")
-        MATPLOTLIB_FLAG = True
-        mpl_logger = logging.getLogger('matplotlib')
-        mpl_logger.setLevel(logging.WARNING)
-    import matplotlib.pylab as plt
-    import numpy as np
-
-    fig, ax = plt.subplots(figsize=(10, 2))
-    im = ax.imshow(spectrogram, aspect="auto", origin="lower",
-                   interpolation='none')
-    plt.colorbar(im, ax=ax)
-    plt.xlabel("Frames")
-    plt.ylabel("Channels")
-    plt.tight_layout()
-
-    fig.canvas.draw()
-    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-    plt.close()
-    return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
-    global MATPLOTLIB_FLAG
-    if not MATPLOTLIB_FLAG:
-        import matplotlib
-        matplotlib.use("Agg")
-        MATPLOTLIB_FLAG = True
-        mpl_logger = logging.getLogger('matplotlib')
-        mpl_logger.setLevel(logging.WARNING)
-    import matplotlib.pylab as plt
-    import numpy as np
-
-    fig, ax = plt.subplots(figsize=(6, 4))
-    im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
-                   interpolation='none')
-    fig.colorbar(im, ax=ax)
-    xlabel = 'Decoder timestep'
-    if info is not None:
-        xlabel += '\n\n' + info
-    plt.xlabel(xlabel)
-    plt.ylabel('Encoder timestep')
-    plt.tight_layout()
-
-    fig.canvas.draw()
-    data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
-    data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
-    plt.close()
-    return data
-
-
-def load_wav_to_torch(full_path):
-    sampling_rate, data = read(full_path)
-    return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-
-
-def load_filepaths_and_text(filename, split="|"):
-    with open(filename, encoding='utf-8') as f:
-        filepaths_and_text = [line.strip().split(split) for line in f]
-    return filepaths_and_text
-
-
-def get_hparams(init=True):
-    parser = argparse.ArgumentParser()
-    parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
-                        help='JSON file for configuration')
-    parser.add_argument('-m', '--model', type=str, required=True,
-                        help='Model name')
-
-    args = parser.parse_args()
-    model_dir = os.path.join("./logs", args.model)
-
-    if not os.path.exists(model_dir):
-        os.makedirs(model_dir)
-
-    config_path = args.config
-    config_save_path = os.path.join(model_dir, "config.json")
-    if init:
-        with open(config_path, "r") as f:
-            data = f.read()
-        with open(config_save_path, "w") as f:
-            f.write(data)
-    else:
-        with open(config_save_path, "r") as f:
-            data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    hparams.model_dir = model_dir
-    return hparams
-
-
-def get_hparams_from_dir(model_dir):
-    config_save_path = os.path.join(model_dir, "config.json")
-    with open(config_save_path, "r") as f:
-        data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    hparams.model_dir = model_dir
-    return hparams
-
-
-def get_hparams_from_file(config_path):
-    with open(config_path, "r", encoding="utf-8") as f:
-        data = f.read()
-    config = json.loads(data)
-
-    hparams = HParams(**config)
-    return hparams
-
-
-def check_git_hash(model_dir):
-    source_dir = os.path.dirname(os.path.realpath(__file__))
-    if not os.path.exists(os.path.join(source_dir, ".git")):
-        logger.warn("{} is not a git repository, therefore hash value comparison will be ignored.".format(
-            source_dir
-        ))
-        return
-
-    cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
-    path = os.path.join(model_dir, "githash")
-    if os.path.exists(path):
-        saved_hash = open(path).read()
-        if saved_hash != cur_hash:
-            logger.warn("git hash values are different. {}(saved) != {}(current)".format(
-                saved_hash[:8], cur_hash[:8]))
-    else:
-        open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
-    global logger
-    logger = logging.getLogger(os.path.basename(model_dir))
-    logger.setLevel(logging.DEBUG)
-
-    formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
-    if not os.path.exists(model_dir):
-        os.makedirs(model_dir)
-    h = logging.FileHandler(os.path.join(model_dir, filename))
-    h.setLevel(logging.DEBUG)
-    h.setFormatter(formatter)
-    logger.addHandler(h)
-    return logger
-
-
-class HParams():
-    def __init__(self, **kwargs):
-        for k, v in kwargs.items():
-            if type(v) == dict:
-                v = HParams(**v)
-            self[k] = v
-
-    def keys(self):
-        return self.__dict__.keys()
-
-    def items(self):
-        return self.__dict__.items()
-
-    def values(self):
-        return self.__dict__.values()
-
-    def __len__(self):
-        return len(self.__dict__)
-
-    def __getitem__(self, key):
-        return getattr(self, key)
-
-    def __setitem__(self, key, value):
-        return setattr(self, key, value)
-
-    def __contains__(self, key):
-        return key in self.__dict__
-
-    def __repr__(self):
-        return self.__dict__.__repr__()

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/resolvelib/resolvers.py

@@ -1,547 +0,0 @@
-import collections
-import itertools
-import operator
-
-from .providers import AbstractResolver
-from .structs import DirectedGraph, IteratorMapping, build_iter_view
-
-RequirementInformation = collections.namedtuple(
-    "RequirementInformation", ["requirement", "parent"]
-)
-
-
-class ResolverException(Exception):
-    """A base class for all exceptions raised by this module.
-
-    Exceptions derived by this class should all be handled in this module. Any
-    bubbling pass the resolver should be treated as a bug.
-    """
-
-
-class RequirementsConflicted(ResolverException):
-    def __init__(self, criterion):
-        super(RequirementsConflicted, self).__init__(criterion)
-        self.criterion = criterion
-
-    def __str__(self):
-        return "Requirements conflict: {}".format(
-            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
-        )
-
-
-class InconsistentCandidate(ResolverException):
-    def __init__(self, candidate, criterion):
-        super(InconsistentCandidate, self).__init__(candidate, criterion)
-        self.candidate = candidate
-        self.criterion = criterion
-
-    def __str__(self):
-        return "Provided candidate {!r} does not satisfy {}".format(
-            self.candidate,
-            ", ".join(repr(r) for r in self.criterion.iter_requirement()),
-        )
-
-
-class Criterion(object):
-    """Representation of possible resolution results of a package.
-
-    This holds three attributes:
-
-    * `information` is a collection of `RequirementInformation` pairs.
-      Each pair is a requirement contributing to this criterion, and the
-      candidate that provides the requirement.
-    * `incompatibilities` is a collection of all known not-to-work candidates
-      to exclude from consideration.
-    * `candidates` is a collection containing all possible candidates deducted
-      from the union of contributing requirements and known incompatibilities.
-      It should never be empty, except when the criterion is an attribute of a
-      raised `RequirementsConflicted` (in which case it is always empty).
-
-    .. note::
-        This class is intended to be externally immutable. **Do not** mutate
-        any of its attribute containers.
-    """
-
-    def __init__(self, candidates, information, incompatibilities):
-        self.candidates = candidates
-        self.information = information
-        self.incompatibilities = incompatibilities
-
-    def __repr__(self):
-        requirements = ", ".join(
-            "({!r}, via={!r})".format(req, parent)
-            for req, parent in self.information
-        )
-        return "Criterion({})".format(requirements)
-
-    def iter_requirement(self):
-        return (i.requirement for i in self.information)
-
-    def iter_parent(self):
-        return (i.parent for i in self.information)
-
-
-class ResolutionError(ResolverException):
-    pass
-
-
-class ResolutionImpossible(ResolutionError):
-    def __init__(self, causes):
-        super(ResolutionImpossible, self).__init__(causes)
-        # causes is a list of RequirementInformation objects
-        self.causes = causes
-
-
-class ResolutionTooDeep(ResolutionError):
-    def __init__(self, round_count):
-        super(ResolutionTooDeep, self).__init__(round_count)
-        self.round_count = round_count
-
-
-# Resolution state in a round.
-State = collections.namedtuple("State", "mapping criteria backtrack_causes")
-
-
-class Resolution(object):
-    """Stateful resolution object.
-
-    This is designed as a one-off object that holds information to kick start
-    the resolution process, and holds the results afterwards.
-    """
-
-    def __init__(self, provider, reporter):
-        self._p = provider
-        self._r = reporter
-        self._states = []
-
-    @property
-    def state(self):
-        try:
-            return self._states[-1]
-        except IndexError:
-            raise AttributeError("state")
-
-    def _push_new_state(self):
-        """Push a new state into history.
-
-        This new state will be used to hold resolution results of the next
-        coming round.
-        """
-        base = self._states[-1]
-        state = State(
-            mapping=base.mapping.copy(),
-            criteria=base.criteria.copy(),
-            backtrack_causes=base.backtrack_causes[:],
-        )
-        self._states.append(state)
-
-    def _add_to_criteria(self, criteria, requirement, parent):
-        self._r.adding_requirement(requirement=requirement, parent=parent)
-
-        identifier = self._p.identify(requirement_or_candidate=requirement)
-        criterion = criteria.get(identifier)
-        if criterion:
-            incompatibilities = list(criterion.incompatibilities)
-        else:
-            incompatibilities = []
-
-        matches = self._p.find_matches(
-            identifier=identifier,
-            requirements=IteratorMapping(
-                criteria,
-                operator.methodcaller("iter_requirement"),
-                {identifier: [requirement]},
-            ),
-            incompatibilities=IteratorMapping(
-                criteria,
-                operator.attrgetter("incompatibilities"),
-                {identifier: incompatibilities},
-            ),
-        )
-
-        if criterion:
-            information = list(criterion.information)
-            information.append(RequirementInformation(requirement, parent))
-        else:
-            information = [RequirementInformation(requirement, parent)]
-
-        criterion = Criterion(
-            candidates=build_iter_view(matches),
-            information=information,
-            incompatibilities=incompatibilities,
-        )
-        if not criterion.candidates:
-            raise RequirementsConflicted(criterion)
-        criteria[identifier] = criterion
-
-    def _remove_information_from_criteria(self, criteria, parents):
-        """Remove information from parents of criteria.
-
-        Concretely, removes all values from each criterion's ``information``
-        field that have one of ``parents`` as provider of the requirement.
-
-        :param criteria: The criteria to update.
-        :param parents: Identifiers for which to remove information from all criteria.
-        """
-        if not parents:
-            return
-        for key, criterion in criteria.items():
-            criteria[key] = Criterion(
-                criterion.candidates,
-                [
-                    information
-                    for information in criterion.information
-                    if (
-                        information.parent is None
-                        or self._p.identify(information.parent) not in parents
-                    )
-                ],
-                criterion.incompatibilities,
-            )
-
-    def _get_preference(self, name):
-        return self._p.get_preference(
-            identifier=name,
-            resolutions=self.state.mapping,
-            candidates=IteratorMapping(
-                self.state.criteria,
-                operator.attrgetter("candidates"),
-            ),
-            information=IteratorMapping(
-                self.state.criteria,
-                operator.attrgetter("information"),
-            ),
-            backtrack_causes=self.state.backtrack_causes,
-        )
-
-    def _is_current_pin_satisfying(self, name, criterion):
-        try:
-            current_pin = self.state.mapping[name]
-        except KeyError:
-            return False
-        return all(
-            self._p.is_satisfied_by(requirement=r, candidate=current_pin)
-            for r in criterion.iter_requirement()
-        )
-
-    def _get_updated_criteria(self, candidate):
-        criteria = self.state.criteria.copy()
-        for requirement in self._p.get_dependencies(candidate=candidate):
-            self._add_to_criteria(criteria, requirement, parent=candidate)
-        return criteria
-
-    def _attempt_to_pin_criterion(self, name):
-        criterion = self.state.criteria[name]
-
-        causes = []
-        for candidate in criterion.candidates:
-            try:
-                criteria = self._get_updated_criteria(candidate)
-            except RequirementsConflicted as e:
-                self._r.rejecting_candidate(e.criterion, candidate)
-                causes.append(e.criterion)
-                continue
-
-            # Check the newly-pinned candidate actually works. This should
-            # always pass under normal circumstances, but in the case of a
-            # faulty provider, we will raise an error to notify the implementer
-            # to fix find_matches() and/or is_satisfied_by().
-            satisfied = all(
-                self._p.is_satisfied_by(requirement=r, candidate=candidate)
-                for r in criterion.iter_requirement()
-            )
-            if not satisfied:
-                raise InconsistentCandidate(candidate, criterion)
-
-            self._r.pinning(candidate=candidate)
-            self.state.criteria.update(criteria)
-
-            # Put newly-pinned candidate at the end. This is essential because
-            # backtracking looks at this mapping to get the last pin.
-            self.state.mapping.pop(name, None)
-            self.state.mapping[name] = candidate
-
-            return []
-
-        # All candidates tried, nothing works. This criterion is a dead
-        # end, signal for backtracking.
-        return causes
-
-    def _backjump(self, causes):
-        """Perform backjumping.
-
-        When we enter here, the stack is like this::
-
-            [ state Z ]
-            [ state Y ]
-            [ state X ]
-            .... earlier states are irrelevant.
-
-        1. No pins worked for Z, so it does not have a pin.
-        2. We want to reset state Y to unpinned, and pin another candidate.
-        3. State X holds what state Y was before the pin, but does not
-           have the incompatibility information gathered in state Y.
-
-        Each iteration of the loop will:
-
-        1.  Identify Z. The incompatibility is not always caused by the latest
-            state. For example, given three requirements A, B and C, with
-            dependencies A1, B1 and C1, where A1 and B1 are incompatible: the
-            last state might be related to C, so we want to discard the
-            previous state.
-        2.  Discard Z.
-        3.  Discard Y but remember its incompatibility information gathered
-            previously, and the failure we're dealing with right now.
-        4.  Push a new state Y' based on X, and apply the incompatibility
-            information from Y to Y'.
-        5a. If this causes Y' to conflict, we need to backtrack again. Make Y'
-            the new Z and go back to step 2.
-        5b. If the incompatibilities apply cleanly, end backtracking.
-        """
-        incompatible_reqs = itertools.chain(
-            (c.parent for c in causes if c.parent is not None),
-            (c.requirement for c in causes),
-        )
-        incompatible_deps = {self._p.identify(r) for r in incompatible_reqs}
-        while len(self._states) >= 3:
-            # Remove the state that triggered backtracking.
-            del self._states[-1]
-
-            # Ensure to backtrack to a state that caused the incompatibility
-            incompatible_state = False
-            while not incompatible_state:
-                # Retrieve the last candidate pin and known incompatibilities.
-                try:
-                    broken_state = self._states.pop()
-                    name, candidate = broken_state.mapping.popitem()
-                except (IndexError, KeyError):
-                    raise ResolutionImpossible(causes)
-                current_dependencies = {
-                    self._p.identify(d)
-                    for d in self._p.get_dependencies(candidate)
-                }
-                incompatible_state = not current_dependencies.isdisjoint(
-                    incompatible_deps
-                )
-
-            incompatibilities_from_broken = [
-                (k, list(v.incompatibilities))
-                for k, v in broken_state.criteria.items()
-            ]
-
-            # Also mark the newly known incompatibility.
-            incompatibilities_from_broken.append((name, [candidate]))
-
-            # Create a new state from the last known-to-work one, and apply
-            # the previously gathered incompatibility information.
-            def _patch_criteria():
-                for k, incompatibilities in incompatibilities_from_broken:
-                    if not incompatibilities:
-                        continue
-                    try:
-                        criterion = self.state.criteria[k]
-                    except KeyError:
-                        continue
-                    matches = self._p.find_matches(
-                        identifier=k,
-                        requirements=IteratorMapping(
-                            self.state.criteria,
-                            operator.methodcaller("iter_requirement"),
-                        ),
-                        incompatibilities=IteratorMapping(
-                            self.state.criteria,
-                            operator.attrgetter("incompatibilities"),
-                            {k: incompatibilities},
-                        ),
-                    )
-                    candidates = build_iter_view(matches)
-                    if not candidates:
-                        return False
-                    incompatibilities.extend(criterion.incompatibilities)
-                    self.state.criteria[k] = Criterion(
-                        candidates=candidates,
-                        information=list(criterion.information),
-                        incompatibilities=incompatibilities,
-                    )
-                return True
-
-            self._push_new_state()
-            success = _patch_criteria()
-
-            # It works! Let's work on this new state.
-            if success:
-                return True
-
-            # State does not work after applying known incompatibilities.
-            # Try the still previous state.
-
-        # No way to backtrack anymore.
-        return False
-
-    def resolve(self, requirements, max_rounds):
-        if self._states:
-            raise RuntimeError("already resolved")
-
-        self._r.starting()
-
-        # Initialize the root state.
-        self._states = [
-            State(
-                mapping=collections.OrderedDict(),
-                criteria={},
-                backtrack_causes=[],
-            )
-        ]
-        for r in requirements:
-            try:
-                self._add_to_criteria(self.state.criteria, r, parent=None)
-            except RequirementsConflicted as e:
-                raise ResolutionImpossible(e.criterion.information)
-
-        # The root state is saved as a sentinel so the first ever pin can have
-        # something to backtrack to if it fails. The root state is basically
-        # pinning the virtual "root" package in the graph.
-        self._push_new_state()
-
-        for round_index in range(max_rounds):
-            self._r.starting_round(index=round_index)
-
-            unsatisfied_names = [
-                key
-                for key, criterion in self.state.criteria.items()
-                if not self._is_current_pin_satisfying(key, criterion)
-            ]
-
-            # All criteria are accounted for. Nothing more to pin, we are done!
-            if not unsatisfied_names:
-                self._r.ending(state=self.state)
-                return self.state
-
-            # keep track of satisfied names to calculate diff after pinning
-            satisfied_names = set(self.state.criteria.keys()) - set(
-                unsatisfied_names
-            )
-
-            # Choose the most preferred unpinned criterion to try.
-            name = min(unsatisfied_names, key=self._get_preference)
-            failure_causes = self._attempt_to_pin_criterion(name)
-
-            if failure_causes:
-                causes = [i for c in failure_causes for i in c.information]
-                # Backjump if pinning fails. The backjump process puts us in
-                # an unpinned state, so we can work on it in the next round.
-                self._r.resolving_conflicts(causes=causes)
-                success = self._backjump(causes)
-                self.state.backtrack_causes[:] = causes
-
-                # Dead ends everywhere. Give up.
-                if not success:
-                    raise ResolutionImpossible(self.state.backtrack_causes)
-            else:
-                # discard as information sources any invalidated names
-                # (unsatisfied names that were previously satisfied)
-                newly_unsatisfied_names = {
-                    key
-                    for key, criterion in self.state.criteria.items()
-                    if key in satisfied_names
-                    and not self._is_current_pin_satisfying(key, criterion)
-                }
-                self._remove_information_from_criteria(
-                    self.state.criteria, newly_unsatisfied_names
-                )
-                # Pinning was successful. Push a new state to do another pin.
-                self._push_new_state()
-
-            self._r.ending_round(index=round_index, state=self.state)
-
-        raise ResolutionTooDeep(max_rounds)
-
-
-def _has_route_to_root(criteria, key, all_keys, connected):
-    if key in connected:
-        return True
-    if key not in criteria:
-        return False
-    for p in criteria[key].iter_parent():
-        try:
-            pkey = all_keys[id(p)]
-        except KeyError:
-            continue
-        if pkey in connected:
-            connected.add(key)
-            return True
-        if _has_route_to_root(criteria, pkey, all_keys, connected):
-            connected.add(key)
-            return True
-    return False
-
-
-Result = collections.namedtuple("Result", "mapping graph criteria")
-
-
-def _build_result(state):
-    mapping = state.mapping
-    all_keys = {id(v): k for k, v in mapping.items()}
-    all_keys[id(None)] = None
-
-    graph = DirectedGraph()
-    graph.add(None)  # Sentinel as root dependencies' parent.
-
-    connected = {None}
-    for key, criterion in state.criteria.items():
-        if not _has_route_to_root(state.criteria, key, all_keys, connected):
-            continue
-        if key not in graph:
-            graph.add(key)
-        for p in criterion.iter_parent():
-            try:
-                pkey = all_keys[id(p)]
-            except KeyError:
-                continue
-            if pkey not in graph:
-                graph.add(pkey)
-            graph.connect(pkey, key)
-
-    return Result(
-        mapping={k: v for k, v in mapping.items() if k in connected},
-        graph=graph,
-        criteria=state.criteria,
-    )
-
-
-class Resolver(AbstractResolver):
-    """The thing that performs the actual resolution work."""
-
-    base_exception = ResolverException
-
-    def resolve(self, requirements, max_rounds=100):
-        """Take a collection of constraints, spit out the resolution result.
-
-        The return value is a representation to the final resolution result. It
-        is a tuple subclass with three public members:
-
-        * `mapping`: A dict of resolved candidates. Each key is an identifier
-            of a requirement (as returned by the provider's `identify` method),
-            and the value is the resolved candidate.
-        * `graph`: A `DirectedGraph` instance representing the dependency tree.
-            The vertices are keys of `mapping`, and each edge represents *why*
-            a particular package is included. A special vertex `None` is
-            included to represent parents of user-supplied requirements.
-        * `criteria`: A dict of "criteria" that hold detailed information on
-            how edges in the graph are derived. Each key is an identifier of a
-            requirement, and the value is a `Criterion` instance.
-
-        The following exceptions may be raised if a resolution cannot be found:
-
-        * `ResolutionImpossible`: A resolution cannot be found for the given
-            combination of requirements. The `causes` attribute of the
-            exception is a list of (requirement, parent), giving the
-            requirements that could not be satisfied.
-        * `ResolutionTooDeep`: The dependency tree is too deeply nested and
-            the resolver gave up. This is usually caused by a circular
-            dependency, but you can try to resolve this by increasing the
-            `max_rounds` argument.
-        """
-        resolution = Resolution(self.provider, self.reporter)
-        state = resolution.resolve(requirements, max_rounds=max_rounds)
-        return _build_result(state)

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/config/_validate_pyproject/fastjsonschema_exceptions.py

@@ -1,51 +0,0 @@
-import re
-
-
-SPLIT_RE = re.compile(r'[\.\[\]]+')
-
-
-class JsonSchemaException(ValueError):
-    """
-    Base exception of ``fastjsonschema`` library.
-    """
-
-
-class JsonSchemaValueException(JsonSchemaException):
-    """
-    Exception raised by validation function. Available properties:
-
-     * ``message`` containing human-readable information what is wrong (e.g. ``data.property[index] must be smaller than or equal to 42``),
-     * invalid ``value`` (e.g. ``60``),
-     * ``name`` of a path in the data structure (e.g. ``data.property[index]``),
-     * ``path`` as an array in the data structure (e.g. ``['data', 'property', 'index']``),
-     * the whole ``definition`` which the ``value`` has to fulfil (e.g. ``{'type': 'number', 'maximum': 42}``),
-     * ``rule`` which the ``value`` is breaking (e.g. ``maximum``)
-     * and ``rule_definition`` (e.g. ``42``).
-
-    .. versionchanged:: 2.14.0
-        Added all extra properties.
-    """
-
-    def __init__(self, message, value=None, name=None, definition=None, rule=None):
-        super().__init__(message)
-        self.message = message
-        self.value = value
-        self.name = name
-        self.definition = definition
-        self.rule = rule
-
-    @property
-    def path(self):
-        return [item for item in SPLIT_RE.split(self.name) if item != '']
-
-    @property
-    def rule_definition(self):
-        if not self.rule or not self.definition:
-            return None
-        return self.definition.get(self.rule)
-
-
-class JsonSchemaDefinitionException(JsonSchemaException):
-    """
-    Exception raised by generator of validation function.
-    """

spaces/Awiny/Image2Paragraph/models/grit_src/grit/modeling/text/load_text_token.py

@@ -1,80 +0,0 @@
-import torch
-
-
-class LoadTextTokens(object):
-    def __init__(self, tokenizer, max_text_len=40, padding='do_not_pad'):
-        self.tokenizer = tokenizer
-        self.max_text_len = max_text_len
-        self.padding = padding
-
-    def descriptions_to_text_tokens(self, target, begin_token):
-        target_encoding = self.tokenizer(
-            target, padding=self.padding,
-            add_special_tokens=False,
-            truncation=True, max_length=self.max_text_len)
-
-        need_predict = [1] * len(target_encoding['input_ids'])
-        payload = target_encoding['input_ids']
-        if len(payload) > self.max_text_len - 2:
-            payload = payload[-(self.max_text_len - 2):]
-            need_predict = payload[-(self.max_text_len - 2):]
-
-        input_ids = [begin_token] + payload + [self.tokenizer.sep_token_id]
-
-        need_predict = [0] + need_predict + [1]
-        data = {
-            'text_tokens': torch.tensor(input_ids),
-            'text_lengths': len(input_ids),
-            'need_predict': torch.tensor(need_predict),
-        }
-
-        return data
-
-    def __call__(self, object_descriptions, box_features, begin_token):
-        text_tokens = []
-        text_lengths = []
-        need_predict = []
-        for description in object_descriptions:
-            tokens = self.descriptions_to_text_tokens(description, begin_token)
-            text_tokens.append(tokens['text_tokens'])
-            text_lengths.append(tokens['text_lengths'])
-            need_predict.append(tokens['need_predict'])
-
-        text_tokens = torch.cat(self.collate(text_tokens), dim=0).to(box_features.device)
-        text_lengths = torch.tensor(text_lengths).to(box_features.device)
-        need_predict = torch.cat(self.collate(need_predict), dim=0).to(box_features.device)
-
-        assert text_tokens.dim() == 2 and need_predict.dim() == 2
-        data = {'text_tokens': text_tokens,
-                'text_lengths': text_lengths,
-                'need_predict': need_predict}
-
-        return data
-
-    def collate(self, batch):
-        if all(isinstance(b, torch.Tensor) for b in batch) and len(batch) > 0:
-            if not all(b.shape == batch[0].shape for b in batch[1:]):
-                assert all(len(b.shape) == len(batch[0].shape) for b in batch[1:])
-                shape = torch.tensor([b.shape for b in batch])
-                max_shape = tuple(shape.max(dim=0)[0].tolist())
-                batch2 = []
-                for b in batch:
-                    if any(c < m for c, m in zip(b.shape, max_shape)):
-                        b2 = torch.zeros(max_shape, dtype=b.dtype, device=b.device)
-                        if b.dim() == 1:
-                            b2[:b.shape[0]] = b
-                        elif b.dim() == 2:
-                            b2[:b.shape[0], :b.shape[1]] = b
-                        elif b.dim() == 3:
-                            b2[:b.shape[0], :b.shape[1], :b.shape[2]] = b
-                        else:
-                            raise NotImplementedError
-                        b = b2
-                    batch2.append(b[None, ...])
-            else:
-                batch2 = []
-                for b in batch:
-                    batch2.append(b[None, ...])
-            return batch2
-        else:
-            raise NotImplementedError

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/configs/new_baselines/mask_rcnn_R_50_FPN_100ep_LSJ.py

@@ -1,72 +0,0 @@
-import detectron2.data.transforms as T
-from detectron2.config.lazy import LazyCall as L
-from detectron2.layers.batch_norm import NaiveSyncBatchNorm
-from detectron2.solver import WarmupParamScheduler
-from fvcore.common.param_scheduler import MultiStepParamScheduler
-
-from ..common.data.coco import dataloader
-from ..common.models.mask_rcnn_fpn import model
-from ..common.optim import SGD as optimizer
-from ..common.train import train
-
-# train from scratch
-train.init_checkpoint = ""
-train.amp.enabled = True
-train.ddp.fp16_compression = True
-model.backbone.bottom_up.freeze_at = 0
-
-# SyncBN
-# fmt: off
-model.backbone.bottom_up.stem.norm = \
-    model.backbone.bottom_up.stages.norm = \
-    model.backbone.norm = "SyncBN"
-
-# Using NaiveSyncBatchNorm becase heads may have empty input. That is not supported by
-# torch.nn.SyncBatchNorm. We can remove this after
-# https://github.com/pytorch/pytorch/issues/36530 is fixed.
-model.roi_heads.box_head.conv_norm = \
-    model.roi_heads.mask_head.conv_norm = lambda c: NaiveSyncBatchNorm(c,
-                                                                       stats_mode="N")
-# fmt: on
-
-# 2conv in RPN:
-# https://github.com/tensorflow/tpu/blob/b24729de804fdb751b06467d3dce0637fa652060/models/official/detection/modeling/architecture/heads.py#L95-L97  # noqa: E501, B950
-model.proposal_generator.head.conv_dims = [-1, -1]
-
-# 4conv1fc box head
-model.roi_heads.box_head.conv_dims = [256, 256, 256, 256]
-model.roi_heads.box_head.fc_dims = [1024]
-
-# resize_and_crop_image in:
-# https://github.com/tensorflow/tpu/blob/b24729de804fdb751b06467d3dce0637fa652060/models/official/detection/utils/input_utils.py#L127  # noqa: E501, B950
-image_size = 1024
-dataloader.train.mapper.augmentations = [
-    L(T.ResizeScale)(
-        min_scale=0.1, max_scale=2.0, target_height=image_size, target_width=image_size
-    ),
-    L(T.FixedSizeCrop)(crop_size=(image_size, image_size)),
-    L(T.RandomFlip)(horizontal=True),
-]
-
-# recompute boxes due to cropping
-dataloader.train.mapper.recompute_boxes = True
-
-# larger batch-size.
-dataloader.train.total_batch_size = 64
-
-# Equivalent to 100 epochs.
-# 100 ep = 184375 iters * 64 images/iter / 118000 images/ep
-train.max_iter = 184375
-
-lr_multiplier = L(WarmupParamScheduler)(
-    scheduler=L(MultiStepParamScheduler)(
-        values=[1.0, 0.1, 0.01],
-        milestones=[163889, 177546],
-        num_updates=train.max_iter,
-    ),
-    warmup_length=500 / train.max_iter,
-    warmup_factor=0.067,
-)
-
-optimizer.lr = 0.1
-optimizer.weight_decay = 4e-5

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/projects/CenterNet2/centernet/modeling/backbone/dla.py

@@ -1,479 +0,0 @@
-import numpy as np
-import math
-from os.path import join
-import fvcore.nn.weight_init as weight_init
-import torch
-import torch.nn.functional as F
-from torch import nn
-import torch.utils.model_zoo as model_zoo
-
-from detectron2.modeling.backbone.resnet import (
-    BasicStem, BottleneckBlock, DeformBottleneckBlock)
-from detectron2.layers import (
-    Conv2d,
-    DeformConv,
-    FrozenBatchNorm2d,
-    ModulatedDeformConv,
-    ShapeSpec,
-    get_norm,
-)
-
-from detectron2.modeling.backbone.backbone import Backbone
-from detectron2.modeling.backbone.build import BACKBONE_REGISTRY
-from detectron2.modeling.backbone.fpn import FPN
-
-__all__ = [
-    "BottleneckBlock",
-    "DeformBottleneckBlock",
-    "BasicStem",
-]
-
-DCNV1 = False
-
-HASH = {
-    34: 'ba72cf86',
-    60: '24839fc4',
-}
-
-def get_model_url(data, name, hash):
-    return join('http://dl.yf.io/dla/models', data, '{}-{}.pth'.format(name, hash))
-
-class BasicBlock(nn.Module):
-    def __init__(self, inplanes, planes, stride=1, dilation=1, norm='BN'):
-        super(BasicBlock, self).__init__()
-        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=3,
-                               stride=stride, padding=dilation,
-                               bias=False, dilation=dilation)
-        self.bn1 = get_norm(norm, planes)
-        self.relu = nn.ReLU(inplace=True)
-        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3,
-                               stride=1, padding=dilation,
-                               bias=False, dilation=dilation)
-        self.bn2 = get_norm(norm, planes)
-        self.stride = stride
-
-    def forward(self, x, residual=None):
-        if residual is None:
-            residual = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-
-        out += residual
-        out = self.relu(out)
-
-        return out
-
-class Bottleneck(nn.Module):
-    expansion = 2
-
-    def __init__(self, inplanes, planes, stride=1, dilation=1, norm='BN'):
-        super(Bottleneck, self).__init__()
-        expansion = Bottleneck.expansion
-        bottle_planes = planes // expansion
-        self.conv1 = nn.Conv2d(inplanes, bottle_planes,
-                               kernel_size=1, bias=False)
-        self.bn1 = get_norm(norm, bottle_planes)
-        self.conv2 = nn.Conv2d(bottle_planes, bottle_planes, kernel_size=3,
-                               stride=stride, padding=dilation,
-                               bias=False, dilation=dilation)
-        self.bn2 = get_norm(norm, bottle_planes)
-        self.conv3 = nn.Conv2d(bottle_planes, planes,
-                               kernel_size=1, bias=False)
-        self.bn3 = get_norm(norm, planes)
-        self.relu = nn.ReLU(inplace=True)
-        self.stride = stride
-
-    def forward(self, x, residual=None):
-        if residual is None:
-            residual = x
-
-        out = self.conv1(x)
-        out = self.bn1(out)
-        out = self.relu(out)
-
-        out = self.conv2(out)
-        out = self.bn2(out)
-        out = self.relu(out)
-
-        out = self.conv3(out)
-        out = self.bn3(out)
-
-        out += residual
-        out = self.relu(out)
-
-        return out
-
-class Root(nn.Module):
-    def __init__(self, in_channels, out_channels, kernel_size, residual, norm='BN'):
-        super(Root, self).__init__()
-        self.conv = nn.Conv2d(
-            in_channels, out_channels, 1,
-            stride=1, bias=False, padding=(kernel_size - 1) // 2)
-        self.bn = get_norm(norm, out_channels)
-        self.relu = nn.ReLU(inplace=True)
-        self.residual = residual
-
-    def forward(self, *x):
-        children = x
-        x = self.conv(torch.cat(x, 1))
-        x = self.bn(x)
-        if self.residual:
-            x += children[0]
-        x = self.relu(x)
-
-        return x
-
-
-class Tree(nn.Module):
-    def __init__(self, levels, block, in_channels, out_channels, stride=1,
-                 level_root=False, root_dim=0, root_kernel_size=1,
-                 dilation=1, root_residual=False, norm='BN'):
-        super(Tree, self).__init__()
-        if root_dim == 0:
-            root_dim = 2 * out_channels
-        if level_root:
-            root_dim += in_channels
-        if levels == 1:
-            self.tree1 = block(in_channels, out_channels, stride,
-                               dilation=dilation, norm=norm)
-            self.tree2 = block(out_channels, out_channels, 1,
-                               dilation=dilation, norm=norm)
-        else:
-            self.tree1 = Tree(levels - 1, block, in_channels, out_channels,
-                              stride, root_dim=0,
-                              root_kernel_size=root_kernel_size,
-                              dilation=dilation, root_residual=root_residual, 
-                              norm=norm)
-            self.tree2 = Tree(levels - 1, block, out_channels, out_channels,
-                              root_dim=root_dim + out_channels,
-                              root_kernel_size=root_kernel_size,
-                              dilation=dilation, root_residual=root_residual, 
-                              norm=norm)
-        if levels == 1:
-            self.root = Root(root_dim, out_channels, root_kernel_size,
-                             root_residual, norm=norm)
-        self.level_root = level_root
-        self.root_dim = root_dim
-        self.downsample = None
-        self.project = None
-        self.levels = levels
-        if stride > 1:
-            self.downsample = nn.MaxPool2d(stride, stride=stride)
-        if in_channels != out_channels:
-            self.project = nn.Sequential(
-                nn.Conv2d(in_channels, out_channels,
-                          kernel_size=1, stride=1, bias=False),
-                get_norm(norm, out_channels)
-            )
-
-    def forward(self, x, residual=None, children=None):
-        children = [] if children is None else children
-        bottom = self.downsample(x) if self.downsample else x
-        residual = self.project(bottom) if self.project else bottom
-        if self.level_root:
-            children.append(bottom)
-        x1 = self.tree1(x, residual)
-        if self.levels == 1:
-            x2 = self.tree2(x1)
-            x = self.root(x2, x1, *children)
-        else:
-            children.append(x1)
-            x = self.tree2(x1, children=children)
-        return x
-
-class DLA(nn.Module):
-    def __init__(self, num_layers, levels, channels, 
-        block=BasicBlock, residual_root=False, norm='BN'):
-        """
-        Args:
-        """
-        super(DLA, self).__init__()
-        self.norm = norm
-        self.channels = channels
-        self.base_layer = nn.Sequential(
-            nn.Conv2d(3, channels[0], kernel_size=7, stride=1,
-                      padding=3, bias=False),
-            get_norm(self.norm, channels[0]),
-            nn.ReLU(inplace=True))
-        self.level0 = self._make_conv_level(
-            channels[0], channels[0], levels[0])
-        self.level1 = self._make_conv_level(
-            channels[0], channels[1], levels[1], stride=2)
-        self.level2 = Tree(levels[2], block, channels[1], channels[2], 2,
-                           level_root=False,
-                           root_residual=residual_root, norm=norm)
-        self.level3 = Tree(levels[3], block, channels[2], channels[3], 2,
-                           level_root=True, root_residual=residual_root, 
-                           norm=norm)
-        self.level4 = Tree(levels[4], block, channels[3], channels[4], 2,
-                           level_root=True, root_residual=residual_root, 
-                           norm=norm)
-        self.level5 = Tree(levels[5], block, channels[4], channels[5], 2,
-                           level_root=True, root_residual=residual_root, 
-                           norm=norm)
-        self.load_pretrained_model(
-            data='imagenet', name='dla{}'.format(num_layers), 
-            hash=HASH[num_layers])
-
-    def load_pretrained_model(self, data, name, hash):
-        model_url = get_model_url(data, name, hash)
-        model_weights = model_zoo.load_url(model_url)
-        num_classes = len(model_weights[list(model_weights.keys())[-1]])
-        self.fc = nn.Conv2d(
-            self.channels[-1], num_classes,
-            kernel_size=1, stride=1, padding=0, bias=True)
-        print('Loading pretrained')
-        self.load_state_dict(model_weights, strict=False)
-
-    def _make_conv_level(self, inplanes, planes, convs, stride=1, dilation=1):
-        modules = []
-        for i in range(convs):
-            modules.extend([
-                nn.Conv2d(inplanes, planes, kernel_size=3,
-                          stride=stride if i == 0 else 1,
-                          padding=dilation, bias=False, dilation=dilation),
-                get_norm(self.norm, planes),
-                nn.ReLU(inplace=True)])
-            inplanes = planes
-        return nn.Sequential(*modules)
-
-    def forward(self, x):
-        y = []
-        x = self.base_layer(x)
-        for i in range(6):
-            x = getattr(self, 'level{}'.format(i))(x)
-            y.append(x)
-        return y
-
-
-def fill_up_weights(up):
-    w = up.weight.data
-    f = math.ceil(w.size(2) / 2)
-    c = (2 * f - 1 - f % 2) / (2. * f)
-    for i in range(w.size(2)):
-        for j in range(w.size(3)):
-            w[0, 0, i, j] = \
-                (1 - math.fabs(i / f - c)) * (1 - math.fabs(j / f - c))
-    for c in range(1, w.size(0)):
-        w[c, 0, :, :] = w[0, 0, :, :]
-
-
-class _DeformConv(nn.Module):
-    def __init__(self, chi, cho, norm='BN'):
-        super(_DeformConv, self).__init__()
-        self.actf = nn.Sequential(
-            get_norm(norm, cho),
-            nn.ReLU(inplace=True)
-        )
-        if DCNV1:
-            self.offset = Conv2d(
-                chi, 18, kernel_size=3, stride=1,
-                padding=1, dilation=1)
-            self.conv = DeformConv(
-                chi, cho, kernel_size=(3,3), stride=1, padding=1,
-                dilation=1, deformable_groups=1)
-        else:
-            self.offset = Conv2d(
-                chi, 27, kernel_size=3, stride=1,
-                padding=1, dilation=1)
-            self.conv = ModulatedDeformConv(
-                chi, cho, kernel_size=3, stride=1, padding=1,
-                dilation=1, deformable_groups=1)
-        nn.init.constant_(self.offset.weight, 0)
-        nn.init.constant_(self.offset.bias, 0)
-        
-    def forward(self, x):
-        if DCNV1:
-            offset = self.offset(x)
-            x = self.conv(x, offset)
-        else:
-            offset_mask = self.offset(x)
-            offset_x, offset_y, mask = torch.chunk(offset_mask, 3, dim=1)
-            offset = torch.cat((offset_x, offset_y), dim=1)
-            mask = mask.sigmoid()
-            x = self.conv(x, offset, mask)
-        x = self.actf(x)
-        return x
-
-
-class IDAUp(nn.Module):
-    def __init__(self, o, channels, up_f, norm='BN'):
-        super(IDAUp, self).__init__()
-        for i in range(1, len(channels)):
-            c = channels[i]
-            f = int(up_f[i])  
-            proj = _DeformConv(c, o, norm=norm)
-            node = _DeformConv(o, o, norm=norm)
-     
-            up = nn.ConvTranspose2d(o, o, f * 2, stride=f, 
-                                    padding=f // 2, output_padding=0,
-                                    groups=o, bias=False)
-            fill_up_weights(up)
-
-            setattr(self, 'proj_' + str(i), proj)
-            setattr(self, 'up_' + str(i), up)
-            setattr(self, 'node_' + str(i), node)
-                 
-        
-    def forward(self, layers, startp, endp):
-        for i in range(startp + 1, endp):
-            upsample = getattr(self, 'up_' + str(i - startp))
-            project = getattr(self, 'proj_' + str(i - startp))
-            layers[i] = upsample(project(layers[i]))
-            node = getattr(self, 'node_' + str(i - startp))
-            layers[i] = node(layers[i] + layers[i - 1])
-
-
-class DLAUp(nn.Module):
-    def __init__(self, startp, channels, scales, in_channels=None, norm='BN'):
-        super(DLAUp, self).__init__()
-        self.startp = startp
-        if in_channels is None:
-            in_channels = channels
-        self.channels = channels
-        channels = list(channels)
-        scales = np.array(scales, dtype=int)
-        for i in range(len(channels) - 1):
-            j = -i - 2
-            setattr(self, 'ida_{}'.format(i),
-                    IDAUp(channels[j], in_channels[j:],
-                          scales[j:] // scales[j], norm=norm))
-            scales[j + 1:] = scales[j]
-            in_channels[j + 1:] = [channels[j] for _ in channels[j + 1:]]
-
-    def forward(self, layers):
-        out = [layers[-1]] # start with 32
-        for i in range(len(layers) - self.startp - 1):
-            ida = getattr(self, 'ida_{}'.format(i))
-            ida(layers, len(layers) -i - 2, len(layers))
-            out.insert(0, layers[-1])
-        return out
-
-DLA_CONFIGS = {
-    34: ([1, 1, 1, 2, 2, 1], [16, 32, 64, 128, 256, 512], BasicBlock),
-    60: ([1, 1, 1, 2, 3, 1], [16, 32, 128, 256, 512, 1024], Bottleneck)
-}
-
-
-class DLASeg(Backbone):
-    def __init__(self, num_layers, out_features, use_dla_up=True, 
-        ms_output=False, norm='BN'):
-        super(DLASeg, self).__init__()
-        # depth = 34
-        levels, channels, Block = DLA_CONFIGS[num_layers]
-        self.base = DLA(num_layers=num_layers,
-            levels=levels, channels=channels, block=Block, norm=norm)
-        down_ratio = 4
-        self.first_level = int(np.log2(down_ratio))
-        self.ms_output = ms_output
-        self.last_level = 5 if not self.ms_output else 6
-        channels = self.base.channels
-        scales = [2 ** i for i in range(len(channels[self.first_level:]))]
-        self.use_dla_up = use_dla_up
-        if self.use_dla_up:
-            self.dla_up = DLAUp(
-                self.first_level, channels[self.first_level:], scales, 
-                norm=norm)
-        out_channel = channels[self.first_level]
-        if not self.ms_output: # stride 4 DLA
-            self.ida_up = IDAUp(
-                out_channel, channels[self.first_level:self.last_level], 
-                [2 ** i for i in range(self.last_level - self.first_level)], 
-                norm=norm)
-        self._out_features = out_features
-        self._out_feature_channels = {
-            'dla{}'.format(i): channels[i] for i in range(6)}
-        self._out_feature_strides = {
-            'dla{}'.format(i): 2 ** i for i in range(6)}
-        self._size_divisibility = 32
-
-    @property
-    def size_divisibility(self):
-        return self._size_divisibility
-
-    def forward(self, x):
-        x = self.base(x)
-        if self.use_dla_up:
-            x = self.dla_up(x)
-        if not self.ms_output: # stride 4 dla
-            y = []
-            for i in range(self.last_level - self.first_level):
-                y.append(x[i].clone())
-            self.ida_up(y, 0, len(y))
-            ret = {}
-            for i in range(self.last_level - self.first_level):
-                out_feature = 'dla{}'.format(i)
-                if out_feature in self._out_features:
-                    ret[out_feature] = y[i]
-        else:
-            ret = {}
-            st = self.first_level if self.use_dla_up else 0
-            for i in range(self.last_level - st):
-                out_feature = 'dla{}'.format(i + st)
-                if out_feature in self._out_features:
-                    ret[out_feature] = x[i]
-        
-        return ret
-
-
-@BACKBONE_REGISTRY.register()
-def build_dla_backbone(cfg, input_shape):
-    """
-    Create a ResNet instance from config.
-
-    Returns:
-        ResNet: a :class:`ResNet` instance.
-    """
-    return DLASeg(
-        out_features=cfg.MODEL.DLA.OUT_FEATURES, 
-        num_layers=cfg.MODEL.DLA.NUM_LAYERS,
-        use_dla_up=cfg.MODEL.DLA.USE_DLA_UP,
-        ms_output=cfg.MODEL.DLA.MS_OUTPUT,
-        norm=cfg.MODEL.DLA.NORM)
-
-class LastLevelP6P7(nn.Module):
-    """
-    This module is used in RetinaNet to generate extra layers, P6 and P7 from
-    C5 feature.
-    """
-
-    def __init__(self, in_channels, out_channels):
-        super().__init__()
-        self.num_levels = 2
-        self.in_feature = "dla5"
-        self.p6 = nn.Conv2d(in_channels, out_channels, 3, 2, 1)
-        self.p7 = nn.Conv2d(out_channels, out_channels, 3, 2, 1)
-        for module in [self.p6, self.p7]:
-            weight_init.c2_xavier_fill(module)
-
-    def forward(self, c5):
-        p6 = self.p6(c5)
-        p7 = self.p7(F.relu(p6))
-        return [p6, p7]
-
-@BACKBONE_REGISTRY.register()
-def build_retinanet_dla_fpn_backbone(cfg, input_shape: ShapeSpec):
-    """
-    Args:
-        cfg: a detectron2 CfgNode
-    Returns:
-        backbone (Backbone): backbone module, must be a subclass of :class:`Backbone`.
-    """
-    bottom_up = build_dla_backbone(cfg, input_shape)
-    in_features = cfg.MODEL.FPN.IN_FEATURES
-    out_channels = cfg.MODEL.FPN.OUT_CHANNELS
-    in_channels_p6p7 = bottom_up.output_shape()['dla5'].channels
-    backbone = FPN(
-        bottom_up=bottom_up,
-        in_features=in_features,
-        out_channels=out_channels,
-        norm=cfg.MODEL.FPN.NORM,
-        top_block=LastLevelP6P7(in_channels_p6p7, out_channels),
-        fuse_type=cfg.MODEL.FPN.FUSE_TYPE,
-    )
-    return backbone

spaces/Bart92/RVC_HF/infer/lib/uvr5_pack/lib_v5/layers_123812KB .py

@@ -1,118 +0,0 @@
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from . import spec_utils
-
-
-class Conv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(Conv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nout,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                bias=False,
-            ),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class SeperableConv2DBNActiv(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
-        super(SeperableConv2DBNActiv, self).__init__()
-        self.conv = nn.Sequential(
-            nn.Conv2d(
-                nin,
-                nin,
-                kernel_size=ksize,
-                stride=stride,
-                padding=pad,
-                dilation=dilation,
-                groups=nin,
-                bias=False,
-            ),
-            nn.Conv2d(nin, nout, kernel_size=1, bias=False),
-            nn.BatchNorm2d(nout),
-            activ(),
-        )
-
-    def __call__(self, x):
-        return self.conv(x)
-
-
-class Encoder(nn.Module):
-    def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
-        super(Encoder, self).__init__()
-        self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-
-    def __call__(self, x):
-        skip = self.conv1(x)
-        h = self.conv2(skip)
-
-        return h, skip
-
-
-class Decoder(nn.Module):
-    def __init__(
-        self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
-    ):
-        super(Decoder, self).__init__()
-        self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
-        self.dropout = nn.Dropout2d(0.1) if dropout else None
-
-    def __call__(self, x, skip=None):
-        x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
-        if skip is not None:
-            skip = spec_utils.crop_center(skip, x)
-            x = torch.cat([x, skip], dim=1)
-        h = self.conv(x)
-
-        if self.dropout is not None:
-            h = self.dropout(h)
-
-        return h
-
-
-class ASPPModule(nn.Module):
-    def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
-        super(ASPPModule, self).__init__()
-        self.conv1 = nn.Sequential(
-            nn.AdaptiveAvgPool2d((1, None)),
-            Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
-        )
-        self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
-        self.conv3 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
-        )
-        self.conv4 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
-        )
-        self.conv5 = SeperableConv2DBNActiv(
-            nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
-        )
-        self.bottleneck = nn.Sequential(
-            Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
-        )
-
-    def forward(self, x):
-        _, _, h, w = x.size()
-        feat1 = F.interpolate(
-            self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
-        )
-        feat2 = self.conv2(x)
-        feat3 = self.conv3(x)
-        feat4 = self.conv4(x)
-        feat5 = self.conv5(x)
-        out = torch.cat((feat1, feat2, feat3, feat4, feat5), dim=1)
-        bottle = self.bottleneck(out)
-        return bottle

spaces/Bart92/RVC_HF/lib/infer_pack/models_onnx.py

@@ -1,819 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from lib.infer_pack import modules
-from lib.infer_pack import attentions
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from lib.infer_pack.commons import init_weights
-import numpy as np
-from lib.infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(256, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
-    def __init__(
-        self,
-        out_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        f0=True,
-    ):
-        super().__init__()
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.emb_phone = nn.Linear(768, hidden_channels)
-        self.lrelu = nn.LeakyReLU(0.1, inplace=True)
-        if f0 == True:
-            self.emb_pitch = nn.Embedding(256, hidden_channels)  # pitch 256
-        self.encoder = attentions.Encoder(
-            hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, phone, pitch, lengths):
-        if pitch == None:
-            x = self.emb_phone(phone)
-        else:
-            x = self.emb_phone(phone) + self.emb_pitch(pitch)
-        x = x * math.sqrt(self.hidden_channels)  # [b, t, h]
-        x = self.lrelu(x)
-        x = torch.transpose(x, 1, -1)  # [b, h, t]
-        x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.encoder(x * x_mask, x_mask)
-        stats = self.proj(x) * x_mask
-
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
-    def __init__(
-        self,
-        channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        n_flows=4,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.channels = channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.n_flows = n_flows
-        self.gin_channels = gin_channels
-
-        self.flows = nn.ModuleList()
-        for i in range(n_flows):
-            self.flows.append(
-                modules.ResidualCouplingLayer(
-                    channels,
-                    hidden_channels,
-                    kernel_size,
-                    dilation_rate,
-                    n_layers,
-                    gin_channels=gin_channels,
-                    mean_only=True,
-                )
-            )
-            self.flows.append(modules.Flip())
-
-    def forward(self, x, x_mask, g=None, reverse=False):
-        if not reverse:
-            for flow in self.flows:
-                x, _ = flow(x, x_mask, g=g, reverse=reverse)
-        else:
-            for flow in reversed(self.flows):
-                x = flow(x, x_mask, g=g, reverse=reverse)
-        return x
-
-    def remove_weight_norm(self):
-        for i in range(self.n_flows):
-            self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
-    def __init__(
-        self,
-        in_channels,
-        out_channels,
-        hidden_channels,
-        kernel_size,
-        dilation_rate,
-        n_layers,
-        gin_channels=0,
-    ):
-        super().__init__()
-        self.in_channels = in_channels
-        self.out_channels = out_channels
-        self.hidden_channels = hidden_channels
-        self.kernel_size = kernel_size
-        self.dilation_rate = dilation_rate
-        self.n_layers = n_layers
-        self.gin_channels = gin_channels
-
-        self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
-        self.enc = modules.WN(
-            hidden_channels,
-            kernel_size,
-            dilation_rate,
-            n_layers,
-            gin_channels=gin_channels,
-        )
-        self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
-    def forward(self, x, x_lengths, g=None):
-        x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
-            x.dtype
-        )
-        x = self.pre(x) * x_mask
-        x = self.enc(x, x_mask, g=g)
-        stats = self.proj(x) * x_mask
-        m, logs = torch.split(stats, self.out_channels, dim=1)
-        z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
-        return z, m, logs, x_mask
-
-    def remove_weight_norm(self):
-        self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels=0,
-    ):
-        super(Generator, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-    def forward(self, x, g=None):
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
-    """Definition of sine generator
-    SineGen(samp_rate, harmonic_num = 0,
-            sine_amp = 0.1, noise_std = 0.003,
-            voiced_threshold = 0,
-            flag_for_pulse=False)
-    samp_rate: sampling rate in Hz
-    harmonic_num: number of harmonic overtones (default 0)
-    sine_amp: amplitude of sine-wavefrom (default 0.1)
-    noise_std: std of Gaussian noise (default 0.003)
-    voiced_thoreshold: F0 threshold for U/V classification (default 0)
-    flag_for_pulse: this SinGen is used inside PulseGen (default False)
-    Note: when flag_for_pulse is True, the first time step of a voiced
-        segment is always sin(np.pi) or cos(0)
-    """
-
-    def __init__(
-        self,
-        samp_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        noise_std=0.003,
-        voiced_threshold=0,
-        flag_for_pulse=False,
-    ):
-        super(SineGen, self).__init__()
-        self.sine_amp = sine_amp
-        self.noise_std = noise_std
-        self.harmonic_num = harmonic_num
-        self.dim = self.harmonic_num + 1
-        self.sampling_rate = samp_rate
-        self.voiced_threshold = voiced_threshold
-
-    def _f02uv(self, f0):
-        # generate uv signal
-        uv = torch.ones_like(f0)
-        uv = uv * (f0 > self.voiced_threshold)
-        return uv
-
-    def forward(self, f0, upp):
-        """sine_tensor, uv = forward(f0)
-        input F0: tensor(batchsize=1, length, dim=1)
-                  f0 for unvoiced steps should be 0
-        output sine_tensor: tensor(batchsize=1, length, dim)
-        output uv: tensor(batchsize=1, length, 1)
-        """
-        with torch.no_grad():
-            f0 = f0[:, None].transpose(1, 2)
-            f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
-            # fundamental component
-            f0_buf[:, :, 0] = f0[:, :, 0]
-            for idx in np.arange(self.harmonic_num):
-                f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
-                    idx + 2
-                )  # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
-            rad_values = (f0_buf / self.sampling_rate) % 1  ###%1意味着n_har的乘积无法后处理优化
-            rand_ini = torch.rand(
-                f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
-            )
-            rand_ini[:, 0] = 0
-            rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-            tmp_over_one = torch.cumsum(rad_values, 1)  # % 1  #####%1意味着后面的cumsum无法再优化
-            tmp_over_one *= upp
-            tmp_over_one = F.interpolate(
-                tmp_over_one.transpose(2, 1),
-                scale_factor=upp,
-                mode="linear",
-                align_corners=True,
-            ).transpose(2, 1)
-            rad_values = F.interpolate(
-                rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(
-                2, 1
-            )  #######
-            tmp_over_one %= 1
-            tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
-            cumsum_shift = torch.zeros_like(rad_values)
-            cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-            sine_waves = torch.sin(
-                torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
-            )
-            sine_waves = sine_waves * self.sine_amp
-            uv = self._f02uv(f0)
-            uv = F.interpolate(
-                uv.transpose(2, 1), scale_factor=upp, mode="nearest"
-            ).transpose(2, 1)
-            noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
-            noise = noise_amp * torch.randn_like(sine_waves)
-            sine_waves = sine_waves * uv + noise
-        return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
-    """SourceModule for hn-nsf
-    SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
-                 add_noise_std=0.003, voiced_threshod=0)
-    sampling_rate: sampling_rate in Hz
-    harmonic_num: number of harmonic above F0 (default: 0)
-    sine_amp: amplitude of sine source signal (default: 0.1)
-    add_noise_std: std of additive Gaussian noise (default: 0.003)
-        note that amplitude of noise in unvoiced is decided
-        by sine_amp
-    voiced_threshold: threhold to set U/V given F0 (default: 0)
-    Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
-    F0_sampled (batchsize, length, 1)
-    Sine_source (batchsize, length, 1)
-    noise_source (batchsize, length 1)
-    uv (batchsize, length, 1)
-    """
-
-    def __init__(
-        self,
-        sampling_rate,
-        harmonic_num=0,
-        sine_amp=0.1,
-        add_noise_std=0.003,
-        voiced_threshod=0,
-        is_half=True,
-    ):
-        super(SourceModuleHnNSF, self).__init__()
-
-        self.sine_amp = sine_amp
-        self.noise_std = add_noise_std
-        self.is_half = is_half
-        # to produce sine waveforms
-        self.l_sin_gen = SineGen(
-            sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
-        )
-
-        # to merge source harmonics into a single excitation
-        self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
-        self.l_tanh = torch.nn.Tanh()
-
-    def forward(self, x, upp=None):
-        sine_wavs, uv, _ = self.l_sin_gen(x, upp)
-        if self.is_half:
-            sine_wavs = sine_wavs.half()
-        sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-        return sine_merge, None, None  # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
-    def __init__(
-        self,
-        initial_channel,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        gin_channels,
-        sr,
-        is_half=False,
-    ):
-        super(GeneratorNSF, self).__init__()
-        self.num_kernels = len(resblock_kernel_sizes)
-        self.num_upsamples = len(upsample_rates)
-
-        self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
-        self.m_source = SourceModuleHnNSF(
-            sampling_rate=sr, harmonic_num=0, is_half=is_half
-        )
-        self.noise_convs = nn.ModuleList()
-        self.conv_pre = Conv1d(
-            initial_channel, upsample_initial_channel, 7, 1, padding=3
-        )
-        resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
-            c_cur = upsample_initial_channel // (2 ** (i + 1))
-            self.ups.append(
-                weight_norm(
-                    ConvTranspose1d(
-                        upsample_initial_channel // (2**i),
-                        upsample_initial_channel // (2 ** (i + 1)),
-                        k,
-                        u,
-                        padding=(k - u) // 2,
-                    )
-                )
-            )
-            if i + 1 < len(upsample_rates):
-                stride_f0 = np.prod(upsample_rates[i + 1 :])
-                self.noise_convs.append(
-                    Conv1d(
-                        1,
-                        c_cur,
-                        kernel_size=stride_f0 * 2,
-                        stride=stride_f0,
-                        padding=stride_f0 // 2,
-                    )
-                )
-            else:
-                self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(
-                zip(resblock_kernel_sizes, resblock_dilation_sizes)
-            ):
-                self.resblocks.append(resblock(ch, k, d))
-
-        self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
-        self.ups.apply(init_weights)
-
-        if gin_channels != 0:
-            self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
-        self.upp = np.prod(upsample_rates)
-
-    def forward(self, x, f0, g=None):
-        har_source, noi_source, uv = self.m_source(f0, self.upp)
-        har_source = har_source.transpose(1, 2)
-        x = self.conv_pre(x)
-        if g is not None:
-            x = x + self.cond(g)
-
-        for i in range(self.num_upsamples):
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            x = self.ups[i](x)
-            x_source = self.noise_convs[i](har_source)
-            x = x + x_source
-            xs = None
-            for j in range(self.num_kernels):
-                if xs is None:
-                    xs = self.resblocks[i * self.num_kernels + j](x)
-                else:
-                    xs += self.resblocks[i * self.num_kernels + j](x)
-            x = xs / self.num_kernels
-        x = F.leaky_relu(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.ups:
-            remove_weight_norm(l)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-
-
-sr2sr = {
-    "32k": 32000,
-    "40k": 40000,
-    "48k": 48000,
-}
-
-
-class SynthesizerTrnMsNSFsidM(nn.Module):
-    def __init__(
-        self,
-        spec_channels,
-        segment_size,
-        inter_channels,
-        hidden_channels,
-        filter_channels,
-        n_heads,
-        n_layers,
-        kernel_size,
-        p_dropout,
-        resblock,
-        resblock_kernel_sizes,
-        resblock_dilation_sizes,
-        upsample_rates,
-        upsample_initial_channel,
-        upsample_kernel_sizes,
-        spk_embed_dim,
-        gin_channels,
-        sr,
-        version,
-        **kwargs
-    ):
-        super().__init__()
-        if type(sr) == type("strr"):
-            sr = sr2sr[sr]
-        self.spec_channels = spec_channels
-        self.inter_channels = inter_channels
-        self.hidden_channels = hidden_channels
-        self.filter_channels = filter_channels
-        self.n_heads = n_heads
-        self.n_layers = n_layers
-        self.kernel_size = kernel_size
-        self.p_dropout = p_dropout
-        self.resblock = resblock
-        self.resblock_kernel_sizes = resblock_kernel_sizes
-        self.resblock_dilation_sizes = resblock_dilation_sizes
-        self.upsample_rates = upsample_rates
-        self.upsample_initial_channel = upsample_initial_channel
-        self.upsample_kernel_sizes = upsample_kernel_sizes
-        self.segment_size = segment_size
-        self.gin_channels = gin_channels
-        # self.hop_length = hop_length#
-        self.spk_embed_dim = spk_embed_dim
-        if version == "v1":
-            self.enc_p = TextEncoder256(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-            )
-        else:
-            self.enc_p = TextEncoder768(
-                inter_channels,
-                hidden_channels,
-                filter_channels,
-                n_heads,
-                n_layers,
-                kernel_size,
-                p_dropout,
-            )
-        self.dec = GeneratorNSF(
-            inter_channels,
-            resblock,
-            resblock_kernel_sizes,
-            resblock_dilation_sizes,
-            upsample_rates,
-            upsample_initial_channel,
-            upsample_kernel_sizes,
-            gin_channels=gin_channels,
-            sr=sr,
-            is_half=kwargs["is_half"],
-        )
-        self.enc_q = PosteriorEncoder(
-            spec_channels,
-            inter_channels,
-            hidden_channels,
-            5,
-            1,
-            16,
-            gin_channels=gin_channels,
-        )
-        self.flow = ResidualCouplingBlock(
-            inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
-        )
-        self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
-        self.speaker_map = None
-        print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
-    def remove_weight_norm(self):
-        self.dec.remove_weight_norm()
-        self.flow.remove_weight_norm()
-        self.enc_q.remove_weight_norm()
-
-    def construct_spkmixmap(self, n_speaker):
-        self.speaker_map = torch.zeros((n_speaker, 1, 1, self.gin_channels))
-        for i in range(n_speaker):
-            self.speaker_map[i] = self.emb_g(torch.LongTensor([[i]]))
-        self.speaker_map = self.speaker_map.unsqueeze(0)
-
-    def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
-        if self.speaker_map is not None:  # [N, S]  *  [S, B, 1, H]
-            g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1))  # [N, S, B, 1, 1]
-            g = g * self.speaker_map  # [N, S, B, 1, H]
-            g = torch.sum(g, dim=1)  # [N, 1, B, 1, H]
-            g = g.transpose(0, -1).transpose(0, -2).squeeze(0)  # [B, H, N]
-        else:
-            g = g.unsqueeze(0)
-            g = self.emb_g(g).transpose(1, 2)
-
-        m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
-        z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
-        z = self.flow(z_p, x_mask, g=g, reverse=True)
-        o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
-        return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminator, self).__init__()
-        periods = [2, 3, 5, 7, 11, 17]
-        # periods = [3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(MultiPeriodDiscriminatorV2, self).__init__()
-        # periods = [2, 3, 5, 7, 11, 17]
-        periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
-        discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
-        discs = discs + [
-            DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
-        ]
-        self.discriminators = nn.ModuleList(discs)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []  #
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            # for j in range(len(fmap_r)):
-            #     print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
-            y_d_rs.append(y_d_r)
-            y_d_gs.append(y_d_g)
-            fmap_rs.append(fmap_r)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
-    def __init__(self, use_spectral_norm=False):
-        super(DiscriminatorS, self).__init__()
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(Conv1d(1, 16, 15, 1, padding=7)),
-                norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
-                norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
-                norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
-                norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
-                norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
-            ]
-        )
-        self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
-    def forward(self, x):
-        fmap = []
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.use_spectral_norm = use_spectral_norm
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList(
-            [
-                norm_f(
-                    Conv2d(
-                        1,
-                        32,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        32,
-                        128,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        128,
-                        512,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        512,
-                        1024,
-                        (kernel_size, 1),
-                        (stride, 1),
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-                norm_f(
-                    Conv2d(
-                        1024,
-                        1024,
-                        (kernel_size, 1),
-                        1,
-                        padding=(get_padding(kernel_size, 1), 0),
-                    )
-                ),
-            ]
-        )
-        self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0:  # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, modules.LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap

spaces/Benson/text-generation/Examples/Callbreak Ludo Rummy 29 Amp Juegos De Cartas Solitario Apk Descargar.md

@@ -1,151 +0,0 @@
-
-<h1>Callbreak Ludo Rummy 29 & Solitario juegos de cartas APK Descargar</h1>
-<p>Si te gusta jugar juegos de cartas y juegos de mesa en su dispositivo móvil, entonces usted debe definitivamente echa un vistazo Callbreak Ludo Rummy 29 & Solitario Juegos de Cartas APK. Esta aplicación es desarrollada por Yarsa Games, un popular estudio de juegos con sede en Nepal. Te ofrece ocho juegos diferentes en un solo paquete. Puedes disfrutar de Callbreak, Ludo, Rummy, 29, Solitaire, Kitti, Dhumbal y Jutpatti en cualquier momento y en cualquier lugar. Ya sea que quieras jugar solo o con tus amigos en línea o fuera de línea puedes divertirte con esta aplicación. En este artículo te mostraremos cómo descargar e instalar la aplicación, así como cómo jugar cada juego en ella. También destacaremos algunas de las características y beneficios de esta aplicación y responderemos algunas preguntas frecuentes sobre ella. </p>
- <h2>Cómo descargar e instalar la aplicación</h2>
-<p>Descargar e instalar Callbreak Ludo Rummy 29 & Solitario juegos de cartas APK es muy fácil. Usted tiene dos opciones para hacerlo:</p>
-<h2>callbreak ludo rummy 29 amp; juegos de cartas solitario apk descargar</h2><br /><p><b><b>Download Zip</b> &#10003; <a href="https://bltlly.com/2v6MKL">https://bltlly.com/2v6MKL</a></b></p><br /><br />
-<ol>
-<li>Descárgalo desde Google Play Store. Solo busca "Callbreak Ludo" en la tienda o haz clic en este enlace . Luego toca el botón "Instalar" y espera a que la aplicación se descargue e instale en tu dispositivo. </li>
-<li>Descargarlo desde el archivo APK. Si desea descargar el archivo APK directamente puede hacer clic en este enlace . Luego debe habilitar la opción "Fuentes desconocidas" en la configuración del dispositivo para permitir la instalación de aplicaciones desde fuentes distintas de Google Play Store. Después de eso, puede abrir el archivo APK y seguir las instrucciones para instalar la aplicación. </li>
-</ol>
- <h2>Cómo jugar los juegos en la aplicación</h2>
-<h3>Callbreak</h3>
-<p>Callbreak es un juego de cartas que es muy popular en Nepal e India. Lo juegan cuatro jugadores en dos equipos. Cada jugador recibe 13 cartas de un mazo de 52 cartas estándar. El juego consta de cinco rondas y cada ronda tiene 13 trucos. El primer repartidor es elegido al azar y luego el turno de repartir gira en el sentido de las agujas del reloj. El repartidor reparte todas las cartas una por una a cada jugador. </p>
-
-<p>El jugador a la izquierda del repartidor juega la primera carta del primer truco. El palo de esta carta se convierte en el palo de triunfo para esa ronda. Los otros jugadores tienen que seguir el ejemplo si tienen una carta del mismo palo. Si no tienen una carta del mismo palo, pueden jugar cualquier carta de su elección. El jugador que juega la carta más alta del palo de triunfo gana el truco. Si no se juega ninguna carta de triunfo, el jugador que juega la carta más alta del palo que se llevó gana el truco. El ganador de un truco lidera el siguiente truco. </p>
-<p>Al final de cada ronda, la puntuación de cada jugador se calcula en función de su oferta y el número de trucos que ganó. Si un jugador gana al menos tantos trucos como su oferta, obtiene una puntuación positiva igual a su oferta. Si un jugador gana menos trucos que su oferta, obtiene una puntuación negativa igual a su oferta. Si un jugador gana más trucos que su oferta, obtiene una puntuación positiva igual a su oferta más 0.1 punto por cada truco adicional. Por ejemplo, si un jugador ofrece 4 y gana 5 trucos, su puntuación es 4 + 0.1 = 4.1 puntos. </p>
-<p>El juego termina después de cinco rondas y el equipo con la mayor puntuación total gana. </p>
- <h3>Ludo</h3>
-<p>Ludo es un clásico juego de mesa que se deriva de un antiguo juego indio llamado Pachisi. Se juega de dos a cuatro jugadores en un tablero con cuatro áreas de color: rojo, verde, amarillo y azul. Cada jugador tiene cuatro fichas de su color que comienzan en su área de origen. El objetivo del juego es mover las cuatro fichas alrededor del tablero y en su área de destino antes que los otros jugadores. </p>
-<p>El juego se juega con un solo dado que determina cuántos espacios puede mover un token en el tablero. Cada jugador lanza el dado a su vez y mueve una de sus fichas de acuerdo con el número que se muestra en el dado. Un token solo puede entrar en el tablero si el die muestra un seis o si no hay tokens en el área de inicio. Un token solo puede entrar en el área de destino si completa un circuito completo alrededor de la placa. </p>
-
-<p>Un jugador puede volver a lanzar el dado si lanza un seis o si captura otro token. Un jugador también puede elegir saltarse su turno si no puede o no quiere mover ninguna de sus fichas. </p>
-<p>El juego termina cuando un jugador mueve las cuatro fichas en su área de destino y declara "Ludo!". </p>
-<p></p> <h3>Rummy</h3>
-<p>Rummy es un juego de cartas que se juega entre dos y seis jugadores con una o dos barajas estándar de 52 cartas. El objetivo del juego es formar conjuntos válidos y secuencias de cartas y deshacerse de todas las cartas en su mano. Un conjunto es un grupo de tres o cuatro cartas del mismo rango, como 7-7-7 o Q-Q-Q-Q-Q. Una secuencia es un grupo de tres o más cartas del mismo palo en orden consecutivo, como 4-5-6 de corazones o 10-J-Q-K de picas. Una carta comodín puede usarse como sustituto de cualquier carta en un conjunto o secuencia. </p>
-<p>El juego comienza con cada jugador que recibe 13 cartas por el repartidor, que es elegido al azar. Las cartas restantes se colocan boca abajo en la mesa como la pila de existencias. La carta superior de la pila principal se pone boca arriba y se coloca junto a ella como la pila de descarte. El jugador a la izquierda del repartidor juega primero y luego el turno pasa en el sentido de las agujas del reloj. </p>
-<p>En tu turno, tienes que sacar una carta de la pila de reserva o de la pila de descarte y luego desechar una carta de tu mano a la pila de descarte. También puedes declarar tu mano si has formado todos los conjuntos y secuencias necesarios y te queda una carta para descartar. Esto se llama "salir" o "mostrar". </p>
-<p>Cuando un jugador sale, la ronda termina y la puntuación de cada jugador se calcula en función del valor de las cartas que quedan en su mano. Las cartas (J, Q, K) tienen un valor de 10 puntos cada una, el as tiene un valor de 1 punto, y las otras cartas tienen un valor igual a su rango. El comodín no tiene valor. El jugador que sale obtiene cero puntos y los otros jugadores obtienen puntos positivos. El jugador con la puntuación total más baja al final del juego gana. </p>
- <h3>29</h3>
-
-<p>Antes del inicio de cada ronda, hay una fase de puja donde cada jugador tiene que hacer una puja, que es el número de puntos que espera que su equipo gane en esa ronda. La oferta puede ser cualquier número de 15 a 28 o "pase". La oferta mínima es de 15 y la oferta máxima es de 28. El jugador a la izquierda del repartidor hace la primera puja y luego la puja va en el sentido de las agujas del reloj. Cada jugador puede pasar o subir la puja por al menos un punto. La puja termina cuando tres jugadores pasan consecutivamente. El último jugador que hizo una oferta se convierte en el declarante y su pareja se convierte en el maniquí. </p>
-<p>El declarante tiene que elegir un traje de triunfo para esa ronda entre picas, corazones, diamantes o tréboles. El palo de triunfo tiene una clasificación especial de cartas: J (alta), 9, A, 10, K, Q, 8 (baja). Los otros palos tienen una clasificación normal de cartas: A (alta), K, Q, J, 10, 9, 8 (baja). El declarante también puede elegir "no trump", lo que significa que no hay un traje de triunfo y todos los trajes tienen un ranking normal. </p>
-<p>El jugador a la izquierda del repartidor juega la primera carta del primer truco. Los otros jugadores tienen que seguir el ejemplo si tienen una carta del mismo palo. Si no tienen una carta del mismo palo, pueden jugar cualquier carta de su elección. El jugador que juega la carta más alta del palo de triunfo gana el truco. Si no se juega ninguna carta de triunfo, el jugador que juega la carta más alta del palo que se llevó gana el truco. El ganador de un truco lidera el siguiente truco. </p>
-
-<p>El juego termina después de 28 rondas y el equipo con la mayor puntuación total gana. </p>
- <h3>Solitario</h3>
-<p>Solitario es un juego de cartas que es jugado por un jugador con una baraja estándar de 52 cartas. El objetivo del juego es ordenar todas las cartas en cuatro montones de acuerdo a sus palos y rangos. El juego tiene siete columnas de cartas en la mesa y cuatro cimientos vacíos en la parte superior. </p>
-<p>El juego comienza con 28 cartas que se reparten boca abajo en siete columnas de izquierda a derecha. La primera columna tiene una carta, la segunda columna tiene dos cartas, y así sucesivamente hasta que la séptima columna tiene siete cartas. La carta de la parte superior de cada columna se pone boca arriba. Las 24 cartas restantes se colocan boca abajo en la mesa como una pila. </p>
-<p>En tu turno, puedes mover una o más cartas de una columna a otra si forman una secuencia descendente de colores alternados. Por ejemplo, puede mover un 6 rojo y un 5 negro juntos a un 7 rojo. También puede mover una sola carta a una columna vacía. Puede voltear la tarjeta boca abajo de cualquier columna si no hay una tarjeta boca arriba en ella. </p>
-<p>También puede mover una o más cartas de una columna a una fundación si forman una secuencia ascendente del mismo palo. Por ejemplo, puedes mover un as de picas sobre una base vacía o un dos de picas sobre un as de picas sobre una base. También puede mover una sola carta de la pila de valores a una fundación si cabe. </p>
-<p>Puedes sacar una o tres cartas de la pila de reserva dependiendo de tu preferencia y colocarlas boca arriba en la mesa como la pila de residuos. Usted puede mover la tarjeta superior de la pila de residuos a una columna o una fundación si cabe. También puede reciclar la pila de residuos de nuevo a la pila de existencias cuando está vacío. </p>
-<p>El juego termina cuando has movido las 52 cartas a las fundaciones o cuando no te quedan movimientos. </p>
- <h3>Kitti</h3>
-
-<p>El juego comienza con cada jugador siendo repartido siete cartas por el repartidor, que es elegido al azar. Las cartas restantes se colocan boca abajo en la mesa como la pila kitti. La carta superior de la pila de gatitos se pone boca arriba y se coloca junto a ella como la carta abierta. El jugador a la izquierda del repartidor juega primero y luego el turno pasa en el sentido de las agujas del reloj. </p>
-<p>En tu turno, tienes que sacar una carta de la pila de gatitos o de la carta abierta y luego descartar una carta de tu mano a la carta abierta. También puede mostrar su mano si ha formado todos los grupos necesarios y le queda una carta para descartar. Esto se llama "salir" o "mostrar". </p>
-<p>Cuando un jugador sale, la ronda termina y la puntuación de cada jugador se calcula en función del valor de las cartas que quedan en su mano. Las cartas (J, Q, K) tienen un valor de 10 puntos cada una, el as tiene un valor de 1 punto, y las otras cartas tienen un valor igual a su rango. El comodín no tiene valor. El jugador que sale obtiene cero puntos y los otros jugadores obtienen puntos positivos. El jugador con la puntuación total más baja al final del juego gana. </p>
- <h3>Dhumbal</h3>
-<p>Dhumbal es un juego de cartas que es jugado por tres a seis jugadores con una baraja estándar de 52 cartas. El objetivo del juego es tener la puntuación más baja al final de cada ronda. El juego tiene 10 rondas y cada ronda tiene una puntuación objetivo diferente que los jugadores tienen que permanecer por debajo. </p>
-<p>El juego comienza con cada jugador siendo repartido cuatro cartas por el repartidor, que es elegido al azar. Las cartas restantes se colocan boca abajo en la mesa como la pila de existencias. La carta superior de la pila principal se pone boca arriba y se coloca junto a ella como la pila de descarte. El jugador a la izquierda del repartidor juega primero y luego el turno pasa en el sentido de las agujas del reloj. </p>
-
-<p>Cuando un jugador sale, la ronda termina y la puntuación de cada jugador se calcula en función del valor de sus cartas. Las cartas (J, Q, K) tienen un valor de 10 puntos cada una, el as tiene un valor de 11 puntos, y las otras cartas tienen un valor igual a su rango. El comodín tiene un valor de cero puntos. El jugador que sale obtiene una puntuación igual a la suma de sus cartas y los otros jugadores obtienen una puntuación igual a la suma de sus cartas más 10 puntos de penalización. Si dos o más jugadores salen en el mismo turno, el jugador con la puntuación más baja gana esa ronda y los otros jugadores obtienen 10 puntos de penalización. </p>
-<p>La puntuación objetivo para cada ronda es la siguiente:</p>
-<tabla>
-<tr><th>Round</th><th>Puntuación del objetivo</th></tr>
-<tr><td>1</td><td>7</td></tr>
-<tr><td>2</td><td>9</td></tr>
-<tr><td>3</td><td>11</td></tr>
-<tr><td>4</td><td>13</td></tr>
-<tr><td>5</td><td>15</td></tr>
-<tr><td>6</td><td>17</td></tr>
-<tr><td>7</td><td>19</td></tr>
-<tr><td>8</td><td>21</td></tr>
-<tr><td>9</td><td>23</td></tr>
-<tr><td>10</td><td>25</td></tr>
-</tabla>
-<p>Si un jugador supera la puntuación objetivo en cualquier ronda, es eliminado del juego. El juego termina después de 10 rondas o cuando solo queda un jugador. El jugador con la puntuación total más baja al final del juego gana. </p>
- <h3>Jutpatti</h3>
-<p>Jutpatti es un juego de cartas que se juega entre dos y cuatro jugadores con una baraja estándar de 52 cartas. El objetivo del juego es recoger pares de cartas y ser el primero en deshacerse de todas las cartas en su mano. Un par son dos cartas del mismo rango, como 7-7 o Q-Q. Una carta comodín puede ser utilizada como un sustituto de cualquier carta en un par. </p>
-<p>El juego comienza con cada jugador siendo repartido cinco cartas por el repartidor, que es elegido al azar. Las cartas restantes se colocan boca abajo en la mesa como la pila de existencias. La carta de la parte superior de la pila se pone boca arriba y se coloca junto a ella como la carta abierta. El jugador a la izquierda del repartidor juega primero y luego el turno pasa en el sentido de las agujas del reloj. </p>
-
-<p>Cuando un jugador sale, la ronda termina y la puntuación de cada jugador se calcula en función del número de parejas que tienen en su mano. Cada pareja vale un punto y cada comodín vale la mitad de un punto. El jugador que sale obtiene cero puntos y los otros jugadores obtienen puntos negativos. El jugador con la puntuación total más alta al final del juego gana. </p>
- <h2>Características y beneficios de la aplicación</h2>
-<p>Callbreak Ludo Rummy 29 & Solitario Juegos de Cartas APK no es solo una aplicación ordinaria que le ofrece ocho juegos diferentes en un paquete. También tiene algunas características y beneficios increíbles que lo hacen destacar de otras aplicaciones similares. Estos son algunos de ellos:</p>
-<ul>
-<li>La aplicación tiene gráficos de alta calidad y efectos de sonido que mejoran su experiencia de juego. </li>
-<li>La aplicación tiene un modo sin conexión que le permite jugar sin conexión a Internet. </li>
-<li> La aplicación tiene un modo multijugador que le permite jugar con sus amigos en línea o fuera de línea. </li>
-<li> La aplicación tiene una opción de chat que le permite comunicarse con otros jugadores durante el juego. </li>
-<li>La aplicación tiene tablas de clasificación que muestran su ranking y logros entre otros jugadores. </li>
-<li> La aplicación tiene varios ajustes que le permiten personalizar sus preferencias de juego como el idioma, tema, nivel de dificultad, etc.</li>
-<li>La aplicación tiene actualizaciones regulares que agregan nuevas características y corrigen errores. </li>
-<li>La aplicación es gratuita para descargar y jugar. </li>
-</ul>
- <h2>Preguntas frecuentes sobre la aplicación</h2>
-<p>Si tiene alguna pregunta o duda sobre Callbreak Ludo Rummy 29 & Solitario Juegos de Cartas APK, usted puede encontrar las respuestas aquí. Hemos recopilado algunas de las preguntas más frecuentes sobre la aplicación y sus respuestas:</p>
-<ol>
-<li>¿Cómo puedo actualizar la aplicación? </li>
-<p>Puedes actualizar la aplicación siguiendo estos pasos:</p>
-<ul>
-<li>Abre Google Play Store en tu dispositivo. </li>
-<li>Buscar "Callbreak Ludo" o haga clic en este enlace . </li>
-<li>Toque en el botón "Actualizar" y espere a que la aplicación se actualice. </li>
-</ul>
-
-<p>Puede ponerse en contacto con el equipo de soporte siguiendo estos pasos:</p>
-<ul>
-<li>Abra la aplicación en su dispositivo. </li>
-<li>Toque en el icono del menú en la esquina superior izquierda de la pantalla. </li>
-<li>Toque en la opción "Ayuda y soporte". </li>
-<li>Rellene su nombre, correo electrónico y mensaje y toque en "Enviar" botón. </li>
-</ul>
-<li>¿Cómo puedo jugar con mis amigos en línea? </li>
-<p>Puedes jugar con tus amigos online siguiendo estos pasos:</p>
-<ul>
-<li>Abra la aplicación en su dispositivo. </li>
-<li>Seleccione el juego que desea jugar desde la pantalla de inicio. </li>
-<li>Toque en la opción "Multijugador" y luego en la opción "Online". </li>
-<li>Crear una habitación o unirse a una habitación existente introduciendo el código de la habitación. </li>
-<li>Invita a tus amigos a unirse a la habitación compartiendo el código de la habitación con ellos. </li>
-<li>Comienza el juego y disfruta jugando con tus amigos. </li>
-</ul>
-<li>¿Cómo puedo cambiar el idioma de la aplicación? </li>
-<p>Puedes cambiar el idioma de la aplicación siguiendo estos pasos:</p>
-<ul>
-<li>Abra la aplicación en su dispositivo. </li>
-<li>Toque en el icono del menú en la esquina superior izquierda de la pantalla. </li>
-<li>Toque en la opción "Configuración". </li>
-<li>Toque en la opción "Idioma" y seleccione su idioma preferido de la lista. </li>
-</ul> <li>¿Cómo puedo jugar sin conexión? </li>
-<p>Puedes jugar sin conexión siguiendo estos pasos:</p>
-<ul>
-<li>Abra la aplicación en su dispositivo. </li>
-<li>Seleccione el juego que desea jugar desde la pantalla de inicio. </li>
-<li>Toque en la opción "Multijugador" y luego en la opción "Offline". </li>
-<li>Seleccione el número de jugadores y el nivel de dificultad de los jugadores de la computadora. </li>
-<li>Comienza el juego y disfruta jugando offline. </li>
-</ul>
- <h2>Conclusión</h2>
-
-<p>Entonces, ¿qué estás esperando? Descargar Callbreak Ludo Rummy 29 & Solitario juegos de cartas APK ahora y divertirse jugando! </p>
- <h2>Preguntas frecuentes</h2>
-<ol>
-<li> ¿Cuáles son los requisitos mínimos para ejecutar la aplicación? </li>
-<p>La aplicación requiere Android 4.4 o superior y al menos 50 MB de espacio libre en su dispositivo. </p>
-<li> ¿Es la aplicación segura para descargar y usar? </li>
-<p>Sí, la aplicación es segura de descargar y usar. No contiene ningún virus o malware. Tampoco recopila ninguna información personal o confidencial de usted. </p>
-<li>¿Puedo jugar con dinero real en la aplicación? </li>
-<p>No, la aplicación no admite transacciones con dinero real o apuestas. Es solo para fines de entretenimiento. </p>
-<li>¿Puedo personalizar mi avatar y perfil en la aplicación? </li>
-<p>Sí, puedes personalizar tu avatar y perfil en la aplicación. Puedes elegir entre diferentes avatares, fondos, marcos y pegatinas. También puede editar su nombre, país y estado. </p>
-<li>¿Cómo puedo dar comentarios o sugerencias para la aplicación? </li>
-<p>Puedes dar comentarios o sugerencias para la aplicación siguiendo estos pasos:</p>
-<ul>
-<li>Abra la aplicación en su dispositivo. </li>
-<li>Toque en el icono del menú en la esquina superior izquierda de la pantalla. </li>
-<li>Toque en la opción "Feedback". </li>
-<li>Rellene su nombre, correo electrónico, calificación y mensaje y toque en "Enviar" botón. </li>
-</ul></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Benson/text-generation/Examples/Descargar Apk Mod Zombi Caminando 2.md

@@ -1,94 +0,0 @@
-
-<h1>Descargar APK Mod Walking Zombie 2: Una guía para los amantes de los zombis</h1>
-<p>Si eres un fan de los juegos de zombies, probablemente hayas oído hablar de Walking Zombie 2, un popular shooter en primera persona con elementos RPG. El juego se desarrolla en un mundo post-apocalíptico donde tienes que luchar contra hordas de zombies, bandidos y monstruos jefes. También tienes que completar misiones, mejorar tus habilidades y beneficios, comprar y vender equipos, e interactuar con otros sobrevivientes. </p>
-<h2>descargar apk mod zombi caminando 2</h2><br /><p><b><b>Download File</b> &#9733; <a href="https://bltlly.com/2v6KPU">https://bltlly.com/2v6KPU</a></b></p><br /><br />
-<p>Walking Zombie 2 es un juego divertido y desafiante que puedes jugar sin conexión a Internet. Sin embargo, si desea mejorar su experiencia de juego, es posible que desee probar la descarga de un mod APK para Walking Zombie 2. En este artículo, explicaremos lo que es un mod APK, cómo instalarlo, qué características ofrece, y algunos consejos y trucos para jugar Walking Zombie 2. Vamos a empezar! </p>
-<h2> ¿Qué es un mod APK y cómo instalarlo</h2>
-<p>Un mod APK es una versión modificada de una aplicación original o juego que ha sido alterado por alguien para agregar o eliminar algunas características. Por ejemplo, un mod de APK para Walking Zombie 2 podría darte dinero ilimitado, munición, salud u otros beneficios que no están disponibles en el juego original. </p>
-<p>Un mod APK generalmente se descarga como un archivo con la extensión . apk que puede instalar en su dispositivo Android. Sin embargo, antes de instalar un mod APK, es necesario asegurarse de que el dispositivo permite instalar aplicaciones de fuentes desconocidas. Para hacer esto, vaya a Configuración > Seguridad > Fuentes desconocidas y habilite. </p>
-<p>Una vez que haya habilitado fuentes desconocidas, puede descargar un mod APK para Walking Zombie 2 desde un sitio web confiable como [APKMB.Com]( 4 ), que ofrece juegos y aplicaciones modificadas para Android de forma gratuita. Después de descargar el archivo, localizarlo en el administrador de archivos de su dispositivo y toque en él para instalarlo. Es posible que necesite permitir que algunos permisos para que la aplicación se ejecute correctamente. </p>
-<p></p>
-<h3> Cómo descargar APK Mod Walking Zombie 2</h3>
-
-<ol>
-<li>Ir a [APKMB.Com]( 4 ) y buscar Walking Zombie 2 en la barra de búsqueda. </li>
-<li>Seleccione la versión del mod que desea descargar. Asegúrese de que es compatible con la versión de Android de su dispositivo. </li>
-<li>Haga clic en el botón de descarga y espere a que se descargue el archivo. </li>
-<li>Abra el administrador de archivos de su dispositivo y encuentre el archivo descargado. Debería estar en la carpeta Descargas o en una carpeta con el nombre del sitio web. </li>
-<li>Toque en el archivo y siga las instrucciones para instalarlo. Es posible que tenga que permitir algunos permisos para que la aplicación se ejecute correctamente. </li>
-<li>Inicie la aplicación desde su pantalla de inicio o cajón de aplicaciones y disfrutar jugando Walking Zombie 2 con el mod! </li>
-</ol>
-<h4>Características de APK Mod Walking Zombie 2</h4>
-<p> <p>Dependiendo de la versión del mod que descargues, es posible que obtengas diferentes características y beneficios. Sin embargo, algunas de las características comunes de un mod APK para Walking Zombie 2 son:</p>
-<ul>
-<li>Dinero ilimitado: Puedes comprar cualquier cosa que quieras en la tienda sin preocuparte por quedarte sin dinero. </li>
-<li>Munición ilimitada: Puedes disparar todo lo que quieras sin recargar o quedarse sin balas. </li>
-<li>Salud ilimitada: Puedes sobrevivir a cualquier ataque sin perder la salud o morir. </li>
-<li>Puntos de habilidad ilimitados: Puedes mejorar tus habilidades y beneficios al nivel máximo sin ganar puntos de experiencia. </li>
-<li>Armas y equipos desbloqueados: puedes acceder a todas las armas y equipos del juego sin encontrarlos ni comprarlos. </li>
-<li>Sin anuncios: Puedes jugar el juego sin interrupciones o distracciones de los anuncios. </li>
-</ul>
-<p>Estas características pueden hacer el juego más divertido y fácil para usted, pero también pueden hacer que sea menos desafiante y realista. Por lo tanto, debe utilizar el mod a su propia discreción y riesgo. Algunas personas podrían considerar usar un mod como trampa, mientras que otros podrían disfrutarlo como una forma de explorar las posibilidades del juego. Depende de ti decidir cómo quieres jugar Walking Zombie 2.</p>
-
-<p>Ya sea que uses un mod o no, Walking Zombie 2 es un juego que requiere un poco de estrategia y habilidad para dominar. Aquí hay algunos consejos y trucos que pueden ayudarle a sobrevivir y disfrutar del juego:</p>
-<h3>Cómo subir de nivel tus habilidades y beneficios</h3>
-<p>En Walking Zombie 2, puedes mejorar las habilidades de tu personaje nivelando tus habilidades y beneficios. Las habilidades se dividen en cuatro categorías: combate, supervivencia, elaboración y carisma. Cada categoría tiene varias habilidades que afectan diferentes aspectos del juego, tales como daños, precisión, salud, resistencia, velocidad de fabricación, precios de intercambio, etc. Puedes subir de nivel tus habilidades gastando puntos de habilidad que ganas completando misiones y matando enemigos. </p>
-<p>Los beneficios son bonos especiales que le dan ventajas adicionales en el juego, tales como mayor probabilidad de golpe crítico, recarga más rápida, mejor saqueo, etc. Puede desbloquear beneficios al alcanzar ciertos niveles de habilidades. Por ejemplo, para desbloquear la ventaja "Headhunter", que aumenta el daño de tu disparo en la cabeza en un 25%, necesitas tener al menos un nivel 5 en la habilidad de combate "Sharpshooter". Solo puedes elegir un beneficio por nivel, así que elige sabiamente. </p>
-<p>Algunas de las mejores habilidades y beneficios para invertir son:</p>
-<tabla>
-<tr><th>Habilidad</th><th>Perk</th><th>Beneficio</th></tr>
-<tr><td>Combat > Sharpshooter</td><td>Headhunter</td><td>Aumenta el daño a la cabeza en un 25%</td></tr>
-<tr><td>Supervivencia > Dureza</td><td>Sed de sangre</td><td><td>Restaura un 5% de salud por cada muerte</td></tr>
-<tr><td>Elaboración > Ingeniero</td><td>Tinkerer</td><td><td>Aumenta la velocidad de fabricación en un 50%</td></tr>
-<tr><td>Charisma > Trader</td><td>Bargain Hunter</td><td>Reduce los precios en un 20% en las tiendas</td></tr>
-</tabla>
-<h4>Cómo encontrar y utilizar las mejores armas y equipos</h4>
-
-<p>El equipo incluye artículos como armaduras, cascos, guantes, botas, mochilas, etc. que pueden protegerlo de daños y proporcionarle beneficios adicionales como una mayor capacidad de carga, velocidad de movimiento, sigilo, etc. También puede actualizar su equipo agregando mods como placas, almohadillas, bolsillos, etc.</p>
-<p>Puedes encontrar armas y equipos saqueando los cadáveres, cofres, cajas, casilleros, etc. de los enemigos o comprándolos en tiendas o comerciantes. Sin embargo, algunas de las mejores armas y equipos están ocultos en lugares secretos que requieren un poco de exploración y resolución de rompecabezas para acceder. Por ejemplo, puedes encontrar un poderoso rifle de francotirador llamado "El Segador" en un búnker oculto cerca de la ciudad de Silver City.</p>
-<p>Algunas de las mejores armas y equipos para usar son:</p>
- <tabla>
-<tr><th>Tipo</th><th>Nombre</th><th>Descripción</th></tr>
-<tr><td>Melee</td><td>Katana</td><td>Una espada afilada que puede cortar zombies con facilidad. </td></tr>
-<tr><td>Pistola</td><td>Desert Eagle</td><td>Un arma de mano potente que puede causar mucho daño a medio alcance. </td></tr>
-<tr><td>Rifle</td><td>El Segador</td><td>Un rifle de francotirador oculto que puede matar a los enemigos con un disparo desde una larga distancia. </td></tr>
-<tr><td>Escopeta</td><td>AA-12</td><td><td>Una escopeta automática que puede disparar múltiples disparos en poco tiempo y causar daños masivos a corta distancia. </td></tr>
-<tr><td>Armor</td><td>Exoskeleton</td><td>Un traje de alta tecnología que puede protegerte de balas y explosiones y aumentar tu fuerza y velocidad. </td></tr>
-<tr><td>Casco</td><td>Gafas de visión nocturna</td><td>Un casco que te permite ver en la oscuridad y resaltar enemigos y objetos. </td></tr>
-<tr><td>Guantes</td><td>Guantes de choque</td><td>Guantes que pueden electrocutar a los enemigos y aturdirlos durante unos segundos. </td></tr>
-<tr><td>Boots</td><td>Jet Boots</td><td>Botas que te permiten volar por poco tiempo y evitar obstáculos y enemigos. </td></tr>
-
-</tabla>
- <h3>Cómo completar misiones y explorar el mundo</h3>
-<p>En Walking Zombie 2, puedes seguir la historia principal y completar varias misiones secundarias que te darán recompensas, puntos de experiencia e información sobre el mundo. Las misiones están marcadas en el mapa con iconos como signos de exclamación, signos de interrogación o estrellas. También puedes hablar con NPCs para obtener misiones o pistas sobre misiones ocultas. Algunas misiones son fáciles y directas, mientras que otras son complejas y requieren múltiples pasos o opciones. </p>
-<p>El mundo de Walking Zombie 2 es vasto y diverso, con diferentes regiones, pueblos, bases, campamentos, mazmorras, etc. Puede explorar el mundo caminando, conduciendo o viajando rápidamente a lugares que ha descubierto. También puedes encontrar secretos, huevos de Pascua, objetos de colección y referencias a otros juegos y películas. Por ejemplo, usted puede encontrar un coche DeLorean de vuelta al futuro en un garaje cerca de la ciudad de New Hope.</p>
-<p>Algunas de las mejores misiones y ubicaciones para completar y explorar son:</p>
- <tabla>
-<tr><th>Quest</th><th>Descripción</th></tr>
-<tr><td>La última esperanza</td><td>Una búsqueda principal que implica encontrar una cura para el virus zombie y salvar a la humanidad. </td></tr>
-<tr><td>La Arena</td><td>Una misión paralela que implica luchar contra oleadas de zombis y enemigos en una arena estilo gladiador. </td></tr>
-<tr><td>El misterio de la pirámide</td><td>Una búsqueda oculta que involucra resolver rompecabezas y encontrar pistas en una pirámide antigua. </td></tr>
-<tr><th>Ubicación</th><th>Descripción</th></tr>
-<tr><td>Nueva esperanza</td><td>Una gran ciudad que sirve como el centro principal del juego, donde se pueden encontrar tiendas, comerciantes, misiones y aliados. </td></tr>
-<tr><td>El búnker</td><
-|im_end|>d>Una instalación subterránea secreta que contiene tecnología avanzada, armas y secretos. </d></tr>
-<tr><d>El cementerio</d>d>Un lugar espeluznante lleno de zombies, fantasmas y lápidas. </d></tr>
-</tabla>
- <h2>Conclusión: ¿Por qué usted debe descargar APK Mod Walking Zombie 2</h2>
-
-<h3>Preguntas frecuentes</h3>
-<p>Aquí hay algunas preguntas y respuestas frecuentes sobre el mod APK para Walking Zombie 2:</p>
- <ol>
-<li> ¿Es el mod APK para Walking Zombie 2 seguro de usar? </li>
-<p>El mod APK para Walking Zombie 2 es seguro de usar siempre y cuando lo descargue de un sitio web de confianza como [ [APKMB.Com]]. Sin embargo, siempre debe tener cuidado al instalar aplicaciones de fuentes desconocidas y escanearlas en busca de virus o malware antes de instalarlas. También deberías hacer una copia de seguridad de tus datos y desinstalar el juego original antes de instalar el mod, ya que podría sobrescribir o borrar tu progreso. </p>
-<li>¿Afectará el mod APK para Walking Zombie 2 al rendimiento o la compatibilidad del juego? </li>
-<p>El mod APK para Walking Zombie 2 no debe afectar el rendimiento del juego o la compatibilidad, ya que se basa en la misma versión del juego. Sin embargo, algunas características del mod pueden causar algunos fallos o errores en el juego, como estrellarse, congelarse o retrasarse. Si tienes algún problema con el mod, puedes intentar reinstalarlo, borrar la caché o reiniciar el dispositivo. También puede ponerse en contacto con el desarrollador mod o el sitio web para obtener soporte. </p>
-<li>¿Puedo jugar online o multijugador con el mod APK para Walking Zombie 2?</li>
-<p>El mod APK para Walking Zombie 2 está diseñado para el modo sin conexión y solo para un jugador. No puedes jugar online o multijugador con el mod, ya que podría causar errores o prohibiciones en los servidores del juego. Solo puedes jugar online o multijugador con el juego original, sin mods. </p>
-<li>¿Puedo actualizar el mod APK para Walking Zombie 2?</li>
-<p>El mod APK para Walking Zombie 2 se actualiza regularmente por el desarrollador mod o el sitio web para que coincida con la última versión del juego. Puede comprobar si hay actualizaciones en el sitio web o en la propia aplicación. Sin embargo, es posible que necesites desinstalar y reinstalar el mod cada vez que haya una nueva actualización, ya que podría no funcionar con versiones anteriores del juego. </p>
-<li> ¿Puedo usar otros mods o trucos con el mod APK para Walking Zombie 2?</li>
-
-</ol></p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Big-Web/MMSD/env/Lib/site-packages/pip/_internal/utils/logging.py

@@ -1,348 +0,0 @@
-import contextlib
-import errno
-import logging
-import logging.handlers
-import os
-import sys
-import threading
-from dataclasses import dataclass
-from io import TextIOWrapper
-from logging import Filter
-from typing import Any, ClassVar, Generator, List, Optional, TextIO, Type
-
-from pip._vendor.rich.console import (
-    Console,
-    ConsoleOptions,
-    ConsoleRenderable,
-    RenderableType,
-    RenderResult,
-    RichCast,
-)
-from pip._vendor.rich.highlighter import NullHighlighter
-from pip._vendor.rich.logging import RichHandler
-from pip._vendor.rich.segment import Segment
-from pip._vendor.rich.style import Style
-
-from pip._internal.utils._log import VERBOSE, getLogger
-from pip._internal.utils.compat import WINDOWS
-from pip._internal.utils.deprecation import DEPRECATION_MSG_PREFIX
-from pip._internal.utils.misc import ensure_dir
-
-_log_state = threading.local()
-subprocess_logger = getLogger("pip.subprocessor")
-
-
-class BrokenStdoutLoggingError(Exception):
-    """
-    Raised if BrokenPipeError occurs for the stdout stream while logging.
-    """
-
-
-def _is_broken_pipe_error(exc_class: Type[BaseException], exc: BaseException) -> bool:
-    if exc_class is BrokenPipeError:
-        return True
-
-    # On Windows, a broken pipe can show up as EINVAL rather than EPIPE:
-    # https://bugs.python.org/issue19612
-    # https://bugs.python.org/issue30418
-    if not WINDOWS:
-        return False
-
-    return isinstance(exc, OSError) and exc.errno in (errno.EINVAL, errno.EPIPE)
-
-
-@contextlib.contextmanager
-def indent_log(num: int = 2) -> Generator[None, None, None]:
-    """
-    A context manager which will cause the log output to be indented for any
-    log messages emitted inside it.
-    """
-    # For thread-safety
-    _log_state.indentation = get_indentation()
-    _log_state.indentation += num
-    try:
-        yield
-    finally:
-        _log_state.indentation -= num
-
-
-def get_indentation() -> int:
-    return getattr(_log_state, "indentation", 0)
-
-
-class IndentingFormatter(logging.Formatter):
-    default_time_format = "%Y-%m-%dT%H:%M:%S"
-
-    def __init__(
-        self,
-        *args: Any,
-        add_timestamp: bool = False,
-        **kwargs: Any,
-    ) -> None:
-        """
-        A logging.Formatter that obeys the indent_log() context manager.
-
-        :param add_timestamp: A bool indicating output lines should be prefixed
-            with their record's timestamp.
-        """
-        self.add_timestamp = add_timestamp
-        super().__init__(*args, **kwargs)
-
-    def get_message_start(self, formatted: str, levelno: int) -> str:
-        """
-        Return the start of the formatted log message (not counting the
-        prefix to add to each line).
-        """
-        if levelno < logging.WARNING:
-            return ""
-        if formatted.startswith(DEPRECATION_MSG_PREFIX):
-            # Then the message already has a prefix.  We don't want it to
-            # look like "WARNING: DEPRECATION: ...."
-            return ""
-        if levelno < logging.ERROR:
-            return "WARNING: "
-
-        return "ERROR: "
-
-    def format(self, record: logging.LogRecord) -> str:
-        """
-        Calls the standard formatter, but will indent all of the log message
-        lines by our current indentation level.
-        """
-        formatted = super().format(record)
-        message_start = self.get_message_start(formatted, record.levelno)
-        formatted = message_start + formatted
-
-        prefix = ""
-        if self.add_timestamp:
-            prefix = f"{self.formatTime(record)} "
-        prefix += " " * get_indentation()
-        formatted = "".join([prefix + line for line in formatted.splitlines(True)])
-        return formatted
-
-
-@dataclass
-class IndentedRenderable:
-    renderable: RenderableType
-    indent: int
-
-    def __rich_console__(
-        self, console: Console, options: ConsoleOptions
-    ) -> RenderResult:
-        segments = console.render(self.renderable, options)
-        lines = Segment.split_lines(segments)
-        for line in lines:
-            yield Segment(" " * self.indent)
-            yield from line
-            yield Segment("\n")
-
-
-class RichPipStreamHandler(RichHandler):
-    KEYWORDS: ClassVar[Optional[List[str]]] = []
-
-    def __init__(self, stream: Optional[TextIO], no_color: bool) -> None:
-        super().__init__(
-            console=Console(file=stream, no_color=no_color, soft_wrap=True),
-            show_time=False,
-            show_level=False,
-            show_path=False,
-            highlighter=NullHighlighter(),
-        )
-
-    # Our custom override on Rich's logger, to make things work as we need them to.
-    def emit(self, record: logging.LogRecord) -> None:
-        style: Optional[Style] = None
-
-        # If we are given a diagnostic error to present, present it with indentation.
-        assert isinstance(record.args, tuple)
-        if record.msg == "[present-rich] %s" and len(record.args) == 1:
-            rich_renderable = record.args[0]
-            assert isinstance(
-                rich_renderable, (ConsoleRenderable, RichCast, str)
-            ), f"{rich_renderable} is not rich-console-renderable"
-
-            renderable: RenderableType = IndentedRenderable(
-                rich_renderable, indent=get_indentation()
-            )
-        else:
-            message = self.format(record)
-            renderable = self.render_message(record, message)
-            if record.levelno is not None:
-                if record.levelno >= logging.ERROR:
-                    style = Style(color="red")
-                elif record.levelno >= logging.WARNING:
-                    style = Style(color="yellow")
-
-        try:
-            self.console.print(renderable, overflow="ignore", crop=False, style=style)
-        except Exception:
-            self.handleError(record)
-
-    def handleError(self, record: logging.LogRecord) -> None:
-        """Called when logging is unable to log some output."""
-
-        exc_class, exc = sys.exc_info()[:2]
-        # If a broken pipe occurred while calling write() or flush() on the
-        # stdout stream in logging's Handler.emit(), then raise our special
-        # exception so we can handle it in main() instead of logging the
-        # broken pipe error and continuing.
-        if (
-            exc_class
-            and exc
-            and self.console.file is sys.stdout
-            and _is_broken_pipe_error(exc_class, exc)
-        ):
-            raise BrokenStdoutLoggingError()
-
-        return super().handleError(record)
-
-
-class BetterRotatingFileHandler(logging.handlers.RotatingFileHandler):
-    def _open(self) -> TextIOWrapper:
-        ensure_dir(os.path.dirname(self.baseFilename))
-        return super()._open()
-
-
-class MaxLevelFilter(Filter):
-    def __init__(self, level: int) -> None:
-        self.level = level
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        return record.levelno < self.level
-
-
-class ExcludeLoggerFilter(Filter):
-
-    """
-    A logging Filter that excludes records from a logger (or its children).
-    """
-
-    def filter(self, record: logging.LogRecord) -> bool:
-        # The base Filter class allows only records from a logger (or its
-        # children).
-        return not super().filter(record)
-
-
-def setup_logging(verbosity: int, no_color: bool, user_log_file: Optional[str]) -> int:
-    """Configures and sets up all of the logging
-
-    Returns the requested logging level, as its integer value.
-    """
-
-    # Determine the level to be logging at.
-    if verbosity >= 2:
-        level_number = logging.DEBUG
-    elif verbosity == 1:
-        level_number = VERBOSE
-    elif verbosity == -1:
-        level_number = logging.WARNING
-    elif verbosity == -2:
-        level_number = logging.ERROR
-    elif verbosity <= -3:
-        level_number = logging.CRITICAL
-    else:
-        level_number = logging.INFO
-
-    level = logging.getLevelName(level_number)
-
-    # The "root" logger should match the "console" level *unless* we also need
-    # to log to a user log file.
-    include_user_log = user_log_file is not None
-    if include_user_log:
-        additional_log_file = user_log_file
-        root_level = "DEBUG"
-    else:
-        additional_log_file = "/dev/null"
-        root_level = level
-
-    # Disable any logging besides WARNING unless we have DEBUG level logging
-    # enabled for vendored libraries.
-    vendored_log_level = "WARNING" if level in ["INFO", "ERROR"] else "DEBUG"
-
-    # Shorthands for clarity
-    log_streams = {
-        "stdout": "ext://sys.stdout",
-        "stderr": "ext://sys.stderr",
-    }
-    handler_classes = {
-        "stream": "pip._internal.utils.logging.RichPipStreamHandler",
-        "file": "pip._internal.utils.logging.BetterRotatingFileHandler",
-    }
-    handlers = ["console", "console_errors", "console_subprocess"] + (
-        ["user_log"] if include_user_log else []
-    )
-
-    logging.config.dictConfig(
-        {
-            "version": 1,
-            "disable_existing_loggers": False,
-            "filters": {
-                "exclude_warnings": {
-                    "()": "pip._internal.utils.logging.MaxLevelFilter",
-                    "level": logging.WARNING,
-                },
-                "restrict_to_subprocess": {
-                    "()": "logging.Filter",
-                    "name": subprocess_logger.name,
-                },
-                "exclude_subprocess": {
-                    "()": "pip._internal.utils.logging.ExcludeLoggerFilter",
-                    "name": subprocess_logger.name,
-                },
-            },
-            "formatters": {
-                "indent": {
-                    "()": IndentingFormatter,
-                    "format": "%(message)s",
-                },
-                "indent_with_timestamp": {
-                    "()": IndentingFormatter,
-                    "format": "%(message)s",
-                    "add_timestamp": True,
-                },
-            },
-            "handlers": {
-                "console": {
-                    "level": level,
-                    "class": handler_classes["stream"],
-                    "no_color": no_color,
-                    "stream": log_streams["stdout"],
-                    "filters": ["exclude_subprocess", "exclude_warnings"],
-                    "formatter": "indent",
-                },
-                "console_errors": {
-                    "level": "WARNING",
-                    "class": handler_classes["stream"],
-                    "no_color": no_color,
-                    "stream": log_streams["stderr"],
-                    "filters": ["exclude_subprocess"],
-                    "formatter": "indent",
-                },
-                # A handler responsible for logging to the console messages
-                # from the "subprocessor" logger.
-                "console_subprocess": {
-                    "level": level,
-                    "class": handler_classes["stream"],
-                    "stream": log_streams["stderr"],
-                    "no_color": no_color,
-                    "filters": ["restrict_to_subprocess"],
-                    "formatter": "indent",
-                },
-                "user_log": {
-                    "level": "DEBUG",
-                    "class": handler_classes["file"],
-                    "filename": additional_log_file,
-                    "encoding": "utf-8",
-                    "delay": True,
-                    "formatter": "indent_with_timestamp",
-                },
-            },
-            "root": {
-                "level": root_level,
-                "handlers": handlers,
-            },
-            "loggers": {"pip._vendor": {"level": vendored_log_level}},
-        }
-    )
-
-    return level_number

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

@@ -1,157 +0,0 @@
-"""distutils.command.bdist
-
-Implements the Distutils 'bdist' command (create a built [binary]
-distribution)."""
-
-import os
-import warnings
-
-from distutils.core import Command
-from distutils.errors import DistutilsPlatformError, DistutilsOptionError
-from distutils.util import get_platform
-
-
-def show_formats():
-    """Print list of available formats (arguments to "--format" option)."""
-    from distutils.fancy_getopt import FancyGetopt
-
-    formats = []
-    for format in bdist.format_commands:
-        formats.append(("formats=" + format, None, bdist.format_commands[format][1]))
-    pretty_printer = FancyGetopt(formats)
-    pretty_printer.print_help("List of available distribution formats:")
-
-
-class ListCompat(dict):
-    # adapter to allow for Setuptools compatibility in format_commands
-    def append(self, item):
-        warnings.warn(
-            """format_commands is now a dict. append is deprecated.""",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-
-class bdist(Command):
-
-    description = "create a built (binary) distribution"
-
-    user_options = [
-        ('bdist-base=', 'b', "temporary directory for creating built distributions"),
-        (
-            'plat-name=',
-            'p',
-            "platform name to embed in generated filenames "
-            "(default: %s)" % get_platform(),
-        ),
-        ('formats=', None, "formats for distribution (comma-separated list)"),
-        (
-            'dist-dir=',
-            'd',
-            "directory to put final built distributions in " "[default: dist]",
-        ),
-        ('skip-build', None, "skip rebuilding everything (for testing/debugging)"),
-        (
-            'owner=',
-            'u',
-            "Owner name used when creating a tar file" " [default: current user]",
-        ),
-        (
-            'group=',
-            'g',
-            "Group name used when creating a tar file" " [default: current group]",
-        ),
-    ]
-
-    boolean_options = ['skip-build']
-
-    help_options = [
-        ('help-formats', None, "lists available distribution formats", show_formats),
-    ]
-
-    # The following commands do not take a format option from bdist
-    no_format_option = ('bdist_rpm',)
-
-    # This won't do in reality: will need to distinguish RPM-ish Linux,
-    # Debian-ish Linux, Solaris, FreeBSD, ..., Windows, Mac OS.
-    default_format = {'posix': 'gztar', 'nt': 'zip'}
-
-    # Define commands in preferred order for the --help-formats option
-    format_commands = ListCompat(
-        {
-            'rpm': ('bdist_rpm', "RPM distribution"),
-            'gztar': ('bdist_dumb', "gzip'ed tar file"),
-            'bztar': ('bdist_dumb', "bzip2'ed tar file"),
-            'xztar': ('bdist_dumb', "xz'ed tar file"),
-            'ztar': ('bdist_dumb', "compressed tar file"),
-            'tar': ('bdist_dumb', "tar file"),
-            'zip': ('bdist_dumb', "ZIP file"),
-        }
-    )
-
-    # for compatibility until consumers only reference format_commands
-    format_command = format_commands
-
-    def initialize_options(self):
-        self.bdist_base = None
-        self.plat_name = None
-        self.formats = None
-        self.dist_dir = None
-        self.skip_build = 0
-        self.group = None
-        self.owner = None
-
-    def finalize_options(self):
-        # have to finalize 'plat_name' before 'bdist_base'
-        if self.plat_name is None:
-            if self.skip_build:
-                self.plat_name = get_platform()
-            else:
-                self.plat_name = self.get_finalized_command('build').plat_name
-
-        # 'bdist_base' -- parent of per-built-distribution-format
-        # temporary directories (eg. we'll probably have
-        # "build/bdist.<plat>/dumb", "build/bdist.<plat>/rpm", etc.)
-        if self.bdist_base is None:
-            build_base = self.get_finalized_command('build').build_base
-            self.bdist_base = os.path.join(build_base, 'bdist.' + self.plat_name)
-
-        self.ensure_string_list('formats')
-        if self.formats is None:
-            try:
-                self.formats = [self.default_format[os.name]]
-            except KeyError:
-                raise DistutilsPlatformError(
-                    "don't know how to create built distributions "
-                    "on platform %s" % os.name
-                )
-
-        if self.dist_dir is None:
-            self.dist_dir = "dist"
-
-    def run(self):
-        # Figure out which sub-commands we need to run.
-        commands = []
-        for format in self.formats:
-            try:
-                commands.append(self.format_commands[format][0])
-            except KeyError:
-                raise DistutilsOptionError("invalid format '%s'" % format)
-
-        # Reinitialize and run each command.
-        for i in range(len(self.formats)):
-            cmd_name = commands[i]
-            sub_cmd = self.reinitialize_command(cmd_name)
-            if cmd_name not in self.no_format_option:
-                sub_cmd.format = self.formats[i]
-
-            # passing the owner and group names for tar archiving
-            if cmd_name == 'bdist_dumb':
-                sub_cmd.owner = self.owner
-                sub_cmd.group = self.group
-
-            # If we're going to need to run this command again, tell it to
-            # keep its temporary files around so subsequent runs go faster.
-            if cmd_name in commands[i + 1 :]:
-                sub_cmd.keep_temp = 1
-            self.run_command(cmd_name)

spaces/Big-Web/MMSD/env/Lib/site-packages/setuptools/config/_validate_pyproject/formats.py

@@ -1,259 +0,0 @@
-import logging
-import os
-import re
-import string
-import typing
-from itertools import chain as _chain
-
-_logger = logging.getLogger(__name__)
-
-# -------------------------------------------------------------------------------------
-# PEP 440
-
-VERSION_PATTERN = r"""
-    v?
-    (?:
-        (?:(?P<epoch>[0-9]+)!)?                           # epoch
-        (?P<release>[0-9]+(?:\.[0-9]+)*)                  # release segment
-        (?P<pre>                                          # pre-release
-            [-_\.]?
-            (?P<pre_l>(a|b|c|rc|alpha|beta|pre|preview))
-            [-_\.]?
-            (?P<pre_n>[0-9]+)?
-        )?
-        (?P<post>                                         # post release
-            (?:-(?P<post_n1>[0-9]+))
-            |
-            (?:
-                [-_\.]?
-                (?P<post_l>post|rev|r)
-                [-_\.]?
-                (?P<post_n2>[0-9]+)?
-            )
-        )?
-        (?P<dev>                                          # dev release
-            [-_\.]?
-            (?P<dev_l>dev)
-            [-_\.]?
-            (?P<dev_n>[0-9]+)?
-        )?
-    )
-    (?:\+(?P<local>[a-z0-9]+(?:[-_\.][a-z0-9]+)*))?       # local version
-"""
-
-VERSION_REGEX = re.compile(r"^\s*" + VERSION_PATTERN + r"\s*$", re.X | re.I)
-
-
-def pep440(version: str) -> bool:
-    return VERSION_REGEX.match(version) is not None
-
-
-# -------------------------------------------------------------------------------------
-# PEP 508
-
-PEP508_IDENTIFIER_PATTERN = r"([A-Z0-9]|[A-Z0-9][A-Z0-9._-]*[A-Z0-9])"
-PEP508_IDENTIFIER_REGEX = re.compile(f"^{PEP508_IDENTIFIER_PATTERN}$", re.I)
-
-
-def pep508_identifier(name: str) -> bool:
-    return PEP508_IDENTIFIER_REGEX.match(name) is not None
-
-
-try:
-    try:
-        from packaging import requirements as _req
-    except ImportError:  # pragma: no cover
-        # let's try setuptools vendored version
-        from setuptools._vendor.packaging import requirements as _req  # type: ignore
-
-    def pep508(value: str) -> bool:
-        try:
-            _req.Requirement(value)
-            return True
-        except _req.InvalidRequirement:
-            return False
-
-except ImportError:  # pragma: no cover
-    _logger.warning(
-        "Could not find an installation of `packaging`. Requirements, dependencies and "
-        "versions might not be validated. "
-        "To enforce validation, please install `packaging`."
-    )
-
-    def pep508(value: str) -> bool:
-        return True
-
-
-def pep508_versionspec(value: str) -> bool:
-    """Expression that can be used to specify/lock versions (including ranges)"""
-    if any(c in value for c in (";", "]", "@")):
-        # In PEP 508:
-        # conditional markers, extras and URL specs are not included in the
-        # versionspec
-        return False
-    # Let's pretend we have a dependency called `requirement` with the given
-    # version spec, then we can re-use the pep508 function for validation:
-    return pep508(f"requirement{value}")
-
-
-# -------------------------------------------------------------------------------------
-# PEP 517
-
-
-def pep517_backend_reference(value: str) -> bool:
-    module, _, obj = value.partition(":")
-    identifiers = (i.strip() for i in _chain(module.split("."), obj.split(".")))
-    return all(python_identifier(i) for i in identifiers if i)
-
-
-# -------------------------------------------------------------------------------------
-# Classifiers - PEP 301
-
-
-def _download_classifiers() -> str:
-    import ssl
-    from email.message import Message
-    from urllib.request import urlopen
-
-    url = "https://pypi.org/pypi?:action=list_classifiers"
-    context = ssl.create_default_context()
-    with urlopen(url, context=context) as response:
-        headers = Message()
-        headers["content_type"] = response.getheader("content-type", "text/plain")
-        return response.read().decode(headers.get_param("charset", "utf-8"))
-
-
-class _TroveClassifier:
-    """The ``trove_classifiers`` package is the official way of validating classifiers,
-    however this package might not be always available.
-    As a workaround we can still download a list from PyPI.
-    We also don't want to be over strict about it, so simply skipping silently is an
-    option (classifiers will be validated anyway during the upload to PyPI).
-    """
-
-    def __init__(self):
-        self.downloaded: typing.Union[None, False, typing.Set[str]] = None
-        self._skip_download = False
-        # None => not cached yet
-        # False => cache not available
-        self.__name__ = "trove_classifier"  # Emulate a public function
-
-    def _disable_download(self):
-        # This is a private API. Only setuptools has the consent of using it.
-        self._skip_download = True
-
-    def __call__(self, value: str) -> bool:
-        if self.downloaded is False or self._skip_download is True:
-            return True
-
-        if os.getenv("NO_NETWORK") or os.getenv("VALIDATE_PYPROJECT_NO_NETWORK"):
-            self.downloaded = False
-            msg = (
-                "Install ``trove-classifiers`` to ensure proper validation. "
-                "Skipping download of classifiers list from PyPI (NO_NETWORK)."
-            )
-            _logger.debug(msg)
-            return True
-
-        if self.downloaded is None:
-            msg = (
-                "Install ``trove-classifiers`` to ensure proper validation. "
-                "Meanwhile a list of classifiers will be downloaded from PyPI."
-            )
-            _logger.debug(msg)
-            try:
-                self.downloaded = set(_download_classifiers().splitlines())
-            except Exception:
-                self.downloaded = False
-                _logger.debug("Problem with download, skipping validation")
-                return True
-
-        return value in self.downloaded or value.lower().startswith("private ::")
-
-
-try:
-    from trove_classifiers import classifiers as _trove_classifiers
-
-    def trove_classifier(value: str) -> bool:
-        return value in _trove_classifiers or value.lower().startswith("private ::")
-
-except ImportError:  # pragma: no cover
-    trove_classifier = _TroveClassifier()
-
-
-# -------------------------------------------------------------------------------------
-# Non-PEP related
-
-
-def url(value: str) -> bool:
-    from urllib.parse import urlparse
-
-    try:
-        parts = urlparse(value)
-        if not parts.scheme:
-            _logger.warning(
-                "For maximum compatibility please make sure to include a "
-                "`scheme` prefix in your URL (e.g. 'http://'). "
-                f"Given value: {value}"
-            )
-            if not (value.startswith("/") or value.startswith("\\") or "@" in value):
-                parts = urlparse(f"http://{value}")
-
-        return bool(parts.scheme and parts.netloc)
-    except Exception:
-        return False
-
-
-# https://packaging.python.org/specifications/entry-points/
-ENTRYPOINT_PATTERN = r"[^\[\s=]([^=]*[^\s=])?"
-ENTRYPOINT_REGEX = re.compile(f"^{ENTRYPOINT_PATTERN}$", re.I)
-RECOMMEDED_ENTRYPOINT_PATTERN = r"[\w.-]+"
-RECOMMEDED_ENTRYPOINT_REGEX = re.compile(f"^{RECOMMEDED_ENTRYPOINT_PATTERN}$", re.I)
-ENTRYPOINT_GROUP_PATTERN = r"\w+(\.\w+)*"
-ENTRYPOINT_GROUP_REGEX = re.compile(f"^{ENTRYPOINT_GROUP_PATTERN}$", re.I)
-
-
-def python_identifier(value: str) -> bool:
-    return value.isidentifier()
-
-
-def python_qualified_identifier(value: str) -> bool:
-    if value.startswith(".") or value.endswith("."):
-        return False
-    return all(python_identifier(m) for m in value.split("."))
-
-
-def python_module_name(value: str) -> bool:
-    return python_qualified_identifier(value)
-
-
-def python_entrypoint_group(value: str) -> bool:
-    return ENTRYPOINT_GROUP_REGEX.match(value) is not None
-
-
-def python_entrypoint_name(value: str) -> bool:
-    if not ENTRYPOINT_REGEX.match(value):
-        return False
-    if not RECOMMEDED_ENTRYPOINT_REGEX.match(value):
-        msg = f"Entry point `{value}` does not follow recommended pattern: "
-        msg += RECOMMEDED_ENTRYPOINT_PATTERN
-        _logger.warning(msg)
-    return True
-
-
-def python_entrypoint_reference(value: str) -> bool:
-    module, _, rest = value.partition(":")
-    if "[" in rest:
-        obj, _, extras_ = rest.partition("[")
-        if extras_.strip()[-1] != "]":
-            return False
-        extras = (x.strip() for x in extras_.strip(string.whitespace + "[]").split(","))
-        if not all(pep508_identifier(e) for e in extras):
-            return False
-        _logger.warning(f"`{value}` - using extras for entry points is not recommended")
-    else:
-        obj = rest
-
-    module_parts = module.split(".")
-    identifiers = _chain(module_parts, obj.split(".")) if rest else module_parts
-    return all(python_identifier(i.strip()) for i in identifiers)

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/utils/colormap.py

@@ -1,140 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-"""
-An awesome colormap for really neat visualizations.
-Copied from Detectron, and removed gray colors.
-"""
-
-import numpy as np
-
-__all__ = ["colormap", "random_color"]
-
-# fmt: off
-# RGB:
-_COLORS = np.array(
-    [
-        0.000, 0.447, 0.741,
-        0.850, 0.325, 0.098,
-        0.929, 0.694, 0.125,
-        0.494, 0.184, 0.556,
-        0.466, 0.674, 0.188,
-        0.301, 0.745, 0.933,
-        0.635, 0.078, 0.184,
-        0.300, 0.300, 0.300,
-        0.600, 0.600, 0.600,
-        1.000, 0.000, 0.000,
-        1.000, 0.500, 0.000,
-        0.749, 0.749, 0.000,
-        0.000, 1.000, 0.000,
-        0.000, 0.000, 1.000,
-        0.667, 0.000, 1.000,
-        0.333, 0.333, 0.000,
-        0.333, 0.667, 0.000,
-        0.333, 1.000, 0.000,
-        0.667, 0.333, 0.000,
-        0.667, 0.667, 0.000,
-        0.667, 1.000, 0.000,
-        1.000, 0.333, 0.000,
-        1.000, 0.667, 0.000,
-        1.000, 1.000, 0.000,
-        0.000, 0.333, 0.500,
-        0.000, 0.667, 0.500,
-        0.000, 1.000, 0.500,
-        0.333, 0.000, 0.500,
-        0.333, 0.333, 0.500,
-        0.333, 0.667, 0.500,
-        0.333, 1.000, 0.500,
-        0.667, 0.000, 0.500,
-        0.667, 0.333, 0.500,
-        0.667, 0.667, 0.500,
-        0.667, 1.000, 0.500,
-        1.000, 0.000, 0.500,
-        1.000, 0.333, 0.500,
-        1.000, 0.667, 0.500,
-        1.000, 1.000, 0.500,
-        0.000, 0.333, 1.000,
-        0.000, 0.667, 1.000,
-        0.000, 1.000, 1.000,
-        0.333, 0.000, 1.000,
-        0.333, 0.333, 1.000,
-        0.333, 0.667, 1.000,
-        0.333, 1.000, 1.000,
-        0.667, 0.000, 1.000,
-        0.667, 0.333, 1.000,
-        0.667, 0.667, 1.000,
-        0.667, 1.000, 1.000,
-        1.000, 0.000, 1.000,
-        1.000, 0.333, 1.000,
-        1.000, 0.667, 1.000,
-        0.333, 0.000, 0.000,
-        0.500, 0.000, 0.000,
-        0.667, 0.000, 0.000,
-        0.833, 0.000, 0.000,
-        1.000, 0.000, 0.000,
-        0.000, 0.167, 0.000,
-        0.000, 0.333, 0.000,
-        0.000, 0.500, 0.000,
-        0.000, 0.667, 0.000,
-        0.000, 0.833, 0.000,
-        0.000, 1.000, 0.000,
-        0.000, 0.000, 0.167,
-        0.000, 0.000, 0.333,
-        0.000, 0.000, 0.500,
-        0.000, 0.000, 0.667,
-        0.000, 0.000, 0.833,
-        0.000, 0.000, 1.000,
-        0.000, 0.000, 0.000,
-        0.143, 0.143, 0.143,
-        0.857, 0.857, 0.857,
-        1.000, 1.000, 1.000
-    ]
-).astype(np.float32).reshape(-1, 3)
-# fmt: on
-
-
-def colormap(rgb=False, maximum=255):
-    """
-    Args:
-        rgb (bool): whether to return RGB colors or BGR colors.
-        maximum (int): either 255 or 1
-
-    Returns:
-        ndarray: a float32 array of Nx3 colors, in range [0, 255] or [0, 1]
-    """
-    assert maximum in [255, 1], maximum
-    c = _COLORS * maximum
-    if not rgb:
-        c = c[:, ::-1]
-    return c
-
-
-def random_color(rgb=False, maximum=255):
-    """
-    Args:
-        rgb (bool): whether to return RGB colors or BGR colors.
-        maximum (int): either 255 or 1
-
-    Returns:
-        ndarray: a vector of 3 numbers
-    """
-    idx = np.random.randint(0, len(_COLORS))
-    ret = _COLORS[idx] * maximum
-    if not rgb:
-        ret = ret[::-1]
-    return ret
-
-
-if __name__ == "__main__":
-    import cv2
-
-    size = 100
-    H, W = 10, 10
-    canvas = np.random.rand(H * size, W * size, 3).astype("float32")
-    for h in range(H):
-        for w in range(W):
-            idx = h * W + w
-            if idx >= len(_COLORS):
-                break
-            canvas[h * size : (h + 1) * size, w * size : (w + 1) * size] = _COLORS[idx]
-    cv2.imshow("a", canvas)
-    cv2.waitKey(0)

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/tools/deploy/caffe2_converter.py

@@ -1,64 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-import argparse
-import os
-
-from detectron2.checkpoint import DetectionCheckpointer
-from detectron2.config import get_cfg
-from detectron2.data import build_detection_test_loader
-from detectron2.evaluation import COCOEvaluator, inference_on_dataset, print_csv_format
-from detectron2.export import add_export_config, export_caffe2_model
-from detectron2.modeling import build_model
-from detectron2.utils.logger import setup_logger
-
-
-def setup_cfg(args):
-    cfg = get_cfg()
-    # cuda context is initialized before creating dataloader, so we don't fork anymore
-    cfg.DATALOADER.NUM_WORKERS = 0
-    cfg = add_export_config(cfg)
-    cfg.merge_from_file(args.config_file)
-    cfg.merge_from_list(args.opts)
-    cfg.freeze()
-    return cfg
-
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser(description="Convert a model to Caffe2")
-    parser.add_argument("--config-file", default="", metavar="FILE", help="path to config file")
-    parser.add_argument("--run-eval", action="store_true")
-    parser.add_argument("--output", help="output directory for the converted caffe2 model")
-    parser.add_argument(
-        "opts",
-        help="Modify config options using the command-line",
-        default=None,
-        nargs=argparse.REMAINDER,
-    )
-    args = parser.parse_args()
-    logger = setup_logger()
-    logger.info("Command line arguments: " + str(args))
-
-    cfg = setup_cfg(args)
-
-    # create a torch model
-    torch_model = build_model(cfg)
-    DetectionCheckpointer(torch_model).resume_or_load(cfg.MODEL.WEIGHTS)
-
-    # get a sample data
-    data_loader = build_detection_test_loader(cfg, cfg.DATASETS.TEST[0])
-    first_batch = next(iter(data_loader))
-
-    # convert and save caffe2 model
-    caffe2_model = export_caffe2_model(cfg, torch_model, first_batch)
-    caffe2_model.save_protobuf(args.output)
-    # draw the caffe2 graph
-    caffe2_model.save_graph(os.path.join(args.output, "model.svg"), inputs=first_batch)
-
-    # run evaluation with the converted model
-    if args.run_eval:
-        dataset = cfg.DATASETS.TEST[0]
-        data_loader = build_detection_test_loader(cfg, dataset)
-        # NOTE: hard-coded evaluator. change to the evaluator for your dataset
-        evaluator = COCOEvaluator(dataset, cfg, True, args.output)
-        metrics = inference_on_dataset(caffe2_model, data_loader, evaluator)
-        print_csv_format(metrics)

spaces/CVPR/LIVE/thrust/dependencies/cub/examples/device/Makefile

@@ -1,197 +0,0 @@
-#/******************************************************************************
-# * Copyright (c) 2011, Duane Merrill.  All rights reserved.
-# * Copyright (c) 2011-2018, 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.
-# *
-#******************************************************************************/
-
-#-------------------------------------------------------------------------------
-#
-# Makefile usage
-#
-# make <target> [sm=<XXX,...>] [cdp=<0|1>] [force32=<0|1>] [abi=<0|1>] [open64=<0|1>] [verbose=<0|1>] [keep=<0|1>]
-#
-#-------------------------------------------------------------------------------
- 
-include ../../common.mk 
- 
- 
-#-------------------------------------------------------------------------------
-# Includes
-#-------------------------------------------------------------------------------
-
-INC += -I$(CUB_DIR) -I$(CUB_DIR)test 
-
-
-
-#-------------------------------------------------------------------------------
-# Dependency Lists
-#-------------------------------------------------------------------------------
-
-rwildcard=$(foreach d,$(wildcard $1*),$(call rwildcard,$d/,$2) $(filter $(subst *,%,$2),$d))
-
-DEPS =				$(CUB_DEPS) \
-					$(CUB_DIR)test/Makefile \
-					$(CUB_DIR)test/test_util.h \
-					$(CUB_DIR)test/mersenne.h \
-		
-ALL = 	example_device_partition_flagged \
-		example_device_partition_if \
-	 	example_device_radix_sort \
-		example_device_reduce \
-	 	example_device_scan \
-	 	example_device_select_unique \
-		example_device_select_flagged \
-		example_device_select_if \
-		example_device_sort_find_non_trivial_runs
-		
-
-
-#-------------------------------------------------------------------------------
-# make default
-#-------------------------------------------------------------------------------
-
-default:
-
-
-#-------------------------------------------------------------------------------
-# make clean
-#-------------------------------------------------------------------------------
-
-clean :
-	rm -f bin/*$(CPU_ARCH_SUFFIX)* 
-	rm -f *.i* *.cubin *.cu.c *.cudafe* *.fatbin.c *.ptx *.hash *.cu.cpp *.o
-
-
-#-------------------------------------------------------------------------------
-# make all
-#-------------------------------------------------------------------------------
-
-all : $(ALL)
-
-#-------------------------------------------------------------------------------
-# make run
-#-------------------------------------------------------------------------------
-
-run : 
-	for i in $(ALL); do ./bin/$${i}_$(BIN_SUFFIX) --device=$(device) || exit 1; done
-
-
-#-------------------------------------------------------------------------------
-# make example_device_reduce
-#-------------------------------------------------------------------------------
-
-example_device_reduce: bin/example_device_reduce_$(BIN_SUFFIX)
-
-bin/example_device_reduce_$(BIN_SUFFIX) : example_device_reduce.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_reduce_$(BIN_SUFFIX) example_device_reduce.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-#-------------------------------------------------------------------------------
-# make example_device_partition_flagged
-#-------------------------------------------------------------------------------
-
-example_device_partition_flagged: bin/example_device_partition_flagged_$(BIN_SUFFIX)
-
-bin/example_device_partition_flagged_$(BIN_SUFFIX) : example_device_partition_flagged.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_partition_flagged_$(BIN_SUFFIX) example_device_partition_flagged.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-#-------------------------------------------------------------------------------
-# make example_device_partition_if
-#-------------------------------------------------------------------------------
-
-example_device_partition_if: bin/example_device_partition_if_$(BIN_SUFFIX)
-
-bin/example_device_partition_if_$(BIN_SUFFIX) : example_device_partition_if.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_partition_if_$(BIN_SUFFIX) example_device_partition_if.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-#-------------------------------------------------------------------------------
-# make example_device_scan
-#-------------------------------------------------------------------------------
-
-example_device_scan: bin/example_device_scan_$(BIN_SUFFIX)
-
-bin/example_device_scan_$(BIN_SUFFIX) : example_device_scan.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_scan_$(BIN_SUFFIX) example_device_scan.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-#-------------------------------------------------------------------------------
-# make example_device_radix_sort
-#-------------------------------------------------------------------------------
-
-example_device_radix_sort: bin/example_device_radix_sort_$(BIN_SUFFIX)
-
-bin/example_device_radix_sort_$(BIN_SUFFIX) : example_device_radix_sort.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_radix_sort_$(BIN_SUFFIX) example_device_radix_sort.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-#-------------------------------------------------------------------------------
-# make example_device_select_unique
-#-------------------------------------------------------------------------------
-
-example_device_select_unique: bin/example_device_select_unique_$(BIN_SUFFIX)
-
-bin/example_device_select_unique_$(BIN_SUFFIX) : example_device_select_unique.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_select_unique_$(BIN_SUFFIX) example_device_select_unique.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-#-------------------------------------------------------------------------------
-# make example_device_select_flagged
-#-------------------------------------------------------------------------------
-
-example_device_select_flagged: bin/example_device_select_flagged_$(BIN_SUFFIX)
-
-bin/example_device_select_flagged_$(BIN_SUFFIX) : example_device_select_flagged.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_select_flagged_$(BIN_SUFFIX) example_device_select_flagged.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-#-------------------------------------------------------------------------------
-# make example_device_select_if
-#-------------------------------------------------------------------------------
-
-example_device_select_if: bin/example_device_select_if_$(BIN_SUFFIX)
-
-bin/example_device_select_if_$(BIN_SUFFIX) : example_device_select_if.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_select_if_$(BIN_SUFFIX) example_device_select_if.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-#-------------------------------------------------------------------------------
-# make example_device_sort_find_non_trivial_runs
-#-------------------------------------------------------------------------------
-
-example_device_sort_find_non_trivial_runs: bin/example_device_sort_find_non_trivial_runs_$(BIN_SUFFIX)
-
-bin/example_device_sort_find_non_trivial_runs_$(BIN_SUFFIX) : example_device_sort_find_non_trivial_runs.cu $(DEPS)
-	mkdir -p bin
-	$(NVCC) $(DEFINES) $(SM_TARGETS) -o bin/example_device_sort_find_non_trivial_runs_$(BIN_SUFFIX) example_device_sort_find_non_trivial_runs.cu $(NVCCFLAGS) $(CPU_ARCH) $(INC) $(LIBS) -O3
-
-
-

spaces/CVPR/LIVE/utils.py

@@ -1,56 +0,0 @@
-import os
-import os.path as osp
-
-def get_experiment_id(debug=False):
-    if debug:
-        return 999999999999
-    import time
-    time.sleep(0.5)
-    return int(time.time()*100)
-
-def get_path_schedule(type, **kwargs):
-    if type == 'repeat':
-        max_path = kwargs['max_path']
-        schedule_each = kwargs['schedule_each']
-        return [schedule_each] * max_path
-    elif type == 'list':
-        schedule = kwargs['schedule']
-        return schedule
-    elif type == 'exp':
-        import math
-        base = kwargs['base']
-        max_path = kwargs['max_path']
-        max_path_per_iter = kwargs['max_path_per_iter']
-        schedule = []
-        cnt = 0
-        while sum(schedule) < max_path:
-            proposed_step = min(
-                max_path - sum(schedule), 
-                base**cnt, 
-                max_path_per_iter)
-            cnt += 1
-            schedule += [proposed_step]
-        return schedule
-    else:
-        raise ValueError
-
-def edict_2_dict(x):
-    if isinstance(x, dict):
-        xnew = {}
-        for k in x:
-            xnew[k] = edict_2_dict(x[k])
-        return xnew
-    elif isinstance(x, list):
-        xnew = []
-        for i in range(len(x)):
-            xnew.append( edict_2_dict(x[i]) )
-        return xnew
-    else:
-        return x
-
-def check_and_create_dir(path):
-    pathdir = osp.split(path)[0]
-    if osp.isdir(pathdir):
-        pass
-    else:
-        os.makedirs(pathdir)

spaces/CVPR/WALT/mmdet/models/dense_heads/atss_head.py

@@ -1,689 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import ConvModule, Scale, bias_init_with_prob, normal_init
-from mmcv.runner import force_fp32
-
-from mmdet.core import (anchor_inside_flags, build_assigner, build_sampler,
-                        images_to_levels, multi_apply, multiclass_nms,
-                        reduce_mean, unmap)
-from ..builder import HEADS, build_loss
-from .anchor_head import AnchorHead
-
-EPS = 1e-12
-
-
-@HEADS.register_module()
-class ATSSHead(AnchorHead):
-    """Bridging the Gap Between Anchor-based and Anchor-free Detection via
-    Adaptive Training Sample Selection.
-
-    ATSS head structure is similar with FCOS, however ATSS use anchor boxes
-    and assign label by Adaptive Training Sample Selection instead max-iou.
-
-    https://arxiv.org/abs/1912.02424
-    """
-
-    def __init__(self,
-                 num_classes,
-                 in_channels,
-                 stacked_convs=4,
-                 conv_cfg=None,
-                 norm_cfg=dict(type='GN', num_groups=32, requires_grad=True),
-                 loss_centerness=dict(
-                     type='CrossEntropyLoss',
-                     use_sigmoid=True,
-                     loss_weight=1.0),
-                 **kwargs):
-        self.stacked_convs = stacked_convs
-        self.conv_cfg = conv_cfg
-        self.norm_cfg = norm_cfg
-        super(ATSSHead, self).__init__(num_classes, in_channels, **kwargs)
-
-        self.sampling = False
-        if self.train_cfg:
-            self.assigner = build_assigner(self.train_cfg.assigner)
-            # SSD sampling=False so use PseudoSampler
-            sampler_cfg = dict(type='PseudoSampler')
-            self.sampler = build_sampler(sampler_cfg, context=self)
-        self.loss_centerness = build_loss(loss_centerness)
-
-    def _init_layers(self):
-        """Initialize layers of the head."""
-        self.relu = nn.ReLU(inplace=True)
-        self.cls_convs = nn.ModuleList()
-        self.reg_convs = nn.ModuleList()
-        for i in range(self.stacked_convs):
-            chn = self.in_channels if i == 0 else self.feat_channels
-            self.cls_convs.append(
-                ConvModule(
-                    chn,
-                    self.feat_channels,
-                    3,
-                    stride=1,
-                    padding=1,
-                    conv_cfg=self.conv_cfg,
-                    norm_cfg=self.norm_cfg))
-            self.reg_convs.append(
-                ConvModule(
-                    chn,
-                    self.feat_channels,
-                    3,
-                    stride=1,
-                    padding=1,
-                    conv_cfg=self.conv_cfg,
-                    norm_cfg=self.norm_cfg))
-        self.atss_cls = nn.Conv2d(
-            self.feat_channels,
-            self.num_anchors * self.cls_out_channels,
-            3,
-            padding=1)
-        self.atss_reg = nn.Conv2d(
-            self.feat_channels, self.num_anchors * 4, 3, padding=1)
-        self.atss_centerness = nn.Conv2d(
-            self.feat_channels, self.num_anchors * 1, 3, padding=1)
-        self.scales = nn.ModuleList(
-            [Scale(1.0) for _ in self.anchor_generator.strides])
-
-    def init_weights(self):
-        """Initialize weights of the head."""
-        for m in self.cls_convs:
-            normal_init(m.conv, std=0.01)
-        for m in self.reg_convs:
-            normal_init(m.conv, std=0.01)
-        bias_cls = bias_init_with_prob(0.01)
-        normal_init(self.atss_cls, std=0.01, bias=bias_cls)
-        normal_init(self.atss_reg, std=0.01)
-        normal_init(self.atss_centerness, std=0.01)
-
-    def forward(self, feats):
-        """Forward features from the upstream network.
-
-        Args:
-            feats (tuple[Tensor]): Features from the upstream network, each is
-                a 4D-tensor.
-
-        Returns:
-            tuple: Usually a tuple of classification scores and bbox prediction
-                cls_scores (list[Tensor]): Classification scores for all scale
-                    levels, each is a 4D-tensor, the channels number is
-                    num_anchors * num_classes.
-                bbox_preds (list[Tensor]): Box energies / deltas for all scale
-                    levels, each is a 4D-tensor, the channels number is
-                    num_anchors * 4.
-        """
-        return multi_apply(self.forward_single, feats, self.scales)
-
-    def forward_single(self, x, scale):
-        """Forward feature of a single scale level.
-
-        Args:
-            x (Tensor): Features of a single scale level.
-            scale (:obj: `mmcv.cnn.Scale`): Learnable scale module to resize
-                the bbox prediction.
-
-        Returns:
-            tuple:
-                cls_score (Tensor): Cls scores for a single scale level
-                    the channels number is num_anchors * num_classes.
-                bbox_pred (Tensor): Box energies / deltas for a single scale
-                    level, the channels number is num_anchors * 4.
-                centerness (Tensor): Centerness for a single scale level, the
-                    channel number is (N, num_anchors * 1, H, W).
-        """
-        cls_feat = x
-        reg_feat = x
-        for cls_conv in self.cls_convs:
-            cls_feat = cls_conv(cls_feat)
-        for reg_conv in self.reg_convs:
-            reg_feat = reg_conv(reg_feat)
-        cls_score = self.atss_cls(cls_feat)
-        # we just follow atss, not apply exp in bbox_pred
-        bbox_pred = scale(self.atss_reg(reg_feat)).float()
-        centerness = self.atss_centerness(reg_feat)
-        return cls_score, bbox_pred, centerness
-
-    def loss_single(self, anchors, cls_score, bbox_pred, centerness, labels,
-                    label_weights, bbox_targets, num_total_samples):
-        """Compute loss of a single scale level.
-
-        Args:
-            cls_score (Tensor): Box scores for each scale level
-                Has shape (N, num_anchors * num_classes, H, W).
-            bbox_pred (Tensor): Box energies / deltas for each scale
-                level with shape (N, num_anchors * 4, H, W).
-            anchors (Tensor): Box reference for each scale level with shape
-                (N, num_total_anchors, 4).
-            labels (Tensor): Labels of each anchors with shape
-                (N, num_total_anchors).
-            label_weights (Tensor): Label weights of each anchor with shape
-                (N, num_total_anchors)
-            bbox_targets (Tensor): BBox regression targets of each anchor wight
-                shape (N, num_total_anchors, 4).
-            num_total_samples (int): Number os positive samples that is
-                reduced over all GPUs.
-
-        Returns:
-            dict[str, Tensor]: A dictionary of loss components.
-        """
-
-        anchors = anchors.reshape(-1, 4)
-        cls_score = cls_score.permute(0, 2, 3, 1).reshape(
-            -1, self.cls_out_channels).contiguous()
-        bbox_pred = bbox_pred.permute(0, 2, 3, 1).reshape(-1, 4)
-        centerness = centerness.permute(0, 2, 3, 1).reshape(-1)
-        bbox_targets = bbox_targets.reshape(-1, 4)
-        labels = labels.reshape(-1)
-        label_weights = label_weights.reshape(-1)
-
-        # classification loss
-        loss_cls = self.loss_cls(
-            cls_score, labels, label_weights, avg_factor=num_total_samples)
-
-        # FG cat_id: [0, num_classes -1], BG cat_id: num_classes
-        bg_class_ind = self.num_classes
-        pos_inds = ((labels >= 0)
-                    & (labels < bg_class_ind)).nonzero().squeeze(1)
-
-        if len(pos_inds) > 0:
-            pos_bbox_targets = bbox_targets[pos_inds]
-            pos_bbox_pred = bbox_pred[pos_inds]
-            pos_anchors = anchors[pos_inds]
-            pos_centerness = centerness[pos_inds]
-
-            centerness_targets = self.centerness_target(
-                pos_anchors, pos_bbox_targets)
-            pos_decode_bbox_pred = self.bbox_coder.decode(
-                pos_anchors, pos_bbox_pred)
-            pos_decode_bbox_targets = self.bbox_coder.decode(
-                pos_anchors, pos_bbox_targets)
-
-            # regression loss
-            loss_bbox = self.loss_bbox(
-                pos_decode_bbox_pred,
-                pos_decode_bbox_targets,
-                weight=centerness_targets,
-                avg_factor=1.0)
-
-            # centerness loss
-            loss_centerness = self.loss_centerness(
-                pos_centerness,
-                centerness_targets,
-                avg_factor=num_total_samples)
-
-        else:
-            loss_bbox = bbox_pred.sum() * 0
-            loss_centerness = centerness.sum() * 0
-            centerness_targets = bbox_targets.new_tensor(0.)
-
-        return loss_cls, loss_bbox, loss_centerness, centerness_targets.sum()
-
-    @force_fp32(apply_to=('cls_scores', 'bbox_preds', 'centernesses'))
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             centernesses,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        """Compute losses of the head.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for each scale level
-                Has shape (N, num_anchors * num_classes, H, W)
-            bbox_preds (list[Tensor]): Box energies / deltas for each scale
-                level with shape (N, num_anchors * 4, H, W)
-            centernesses (list[Tensor]): Centerness for each scale
-                level with shape (N, num_anchors * 1, H, W)
-            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
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            gt_bboxes_ignore (list[Tensor] | None): specify which bounding
-                boxes can be ignored when computing the loss.
-
-        Returns:
-            dict[str, Tensor]: A dictionary of loss components.
-        """
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.anchor_generator.num_levels
-
-        device = cls_scores[0].device
-        anchor_list, valid_flag_list = self.get_anchors(
-            featmap_sizes, img_metas, device=device)
-        label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
-
-        cls_reg_targets = self.get_targets(
-            anchor_list,
-            valid_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=label_channels)
-        if cls_reg_targets is None:
-            return None
-
-        (anchor_list, labels_list, label_weights_list, bbox_targets_list,
-         bbox_weights_list, num_total_pos, num_total_neg) = cls_reg_targets
-
-        num_total_samples = reduce_mean(
-            torch.tensor(num_total_pos, dtype=torch.float,
-                         device=device)).item()
-        num_total_samples = max(num_total_samples, 1.0)
-
-        losses_cls, losses_bbox, loss_centerness,\
-            bbox_avg_factor = multi_apply(
-                self.loss_single,
-                anchor_list,
-                cls_scores,
-                bbox_preds,
-                centernesses,
-                labels_list,
-                label_weights_list,
-                bbox_targets_list,
-                num_total_samples=num_total_samples)
-
-        bbox_avg_factor = sum(bbox_avg_factor)
-        bbox_avg_factor = reduce_mean(bbox_avg_factor).item()
-        if bbox_avg_factor < EPS:
-            bbox_avg_factor = 1
-        losses_bbox = list(map(lambda x: x / bbox_avg_factor, losses_bbox))
-        return dict(
-            loss_cls=losses_cls,
-            loss_bbox=losses_bbox,
-            loss_centerness=loss_centerness)
-
-    def centerness_target(self, anchors, bbox_targets):
-        # only calculate pos centerness targets, otherwise there may be nan
-        gts = self.bbox_coder.decode(anchors, bbox_targets)
-        anchors_cx = (anchors[:, 2] + anchors[:, 0]) / 2
-        anchors_cy = (anchors[:, 3] + anchors[:, 1]) / 2
-        l_ = anchors_cx - gts[:, 0]
-        t_ = anchors_cy - gts[:, 1]
-        r_ = gts[:, 2] - anchors_cx
-        b_ = gts[:, 3] - anchors_cy
-
-        left_right = torch.stack([l_, r_], dim=1)
-        top_bottom = torch.stack([t_, b_], dim=1)
-        centerness = torch.sqrt(
-            (left_right.min(dim=-1)[0] / left_right.max(dim=-1)[0]) *
-            (top_bottom.min(dim=-1)[0] / top_bottom.max(dim=-1)[0]))
-        assert not torch.isnan(centerness).any()
-        return centerness
-
-    @force_fp32(apply_to=('cls_scores', 'bbox_preds', 'centernesses'))
-    def get_bboxes(self,
-                   cls_scores,
-                   bbox_preds,
-                   centernesses,
-                   img_metas,
-                   cfg=None,
-                   rescale=False,
-                   with_nms=True):
-        """Transform network output for a batch into bbox predictions.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for each scale level
-                with shape (N, num_anchors * num_classes, H, W).
-            bbox_preds (list[Tensor]): Box energies / deltas for each scale
-                level with shape (N, num_anchors * 4, H, W).
-            centernesses (list[Tensor]): Centerness for each scale level with
-                shape (N, num_anchors * 1, H, W).
-            img_metas (list[dict]): Meta information of each image, e.g.,
-                image size, scaling factor, etc.
-            cfg (mmcv.Config | None): Test / postprocessing configuration,
-                if None, test_cfg would be used. Default: None.
-            rescale (bool): If True, return boxes in original image space.
-                Default: False.
-            with_nms (bool): If True, do nms before return boxes.
-                Default: True.
-
-        Returns:
-            list[tuple[Tensor, Tensor]]: Each item in result_list is 2-tuple.
-                The first item is an (n, 5) tensor, where 5 represent
-                (tl_x, tl_y, br_x, br_y, score) and the score between 0 and 1.
-                The shape of the second tensor in the tuple is (n,), and
-                each element represents the class label of the corresponding
-                box.
-        """
-        cfg = self.test_cfg if cfg is None else cfg
-        assert len(cls_scores) == len(bbox_preds)
-        num_levels = len(cls_scores)
-        device = cls_scores[0].device
-        featmap_sizes = [cls_scores[i].shape[-2:] for i in range(num_levels)]
-        mlvl_anchors = self.anchor_generator.grid_anchors(
-            featmap_sizes, device=device)
-
-        cls_score_list = [cls_scores[i].detach() for i in range(num_levels)]
-        bbox_pred_list = [bbox_preds[i].detach() for i in range(num_levels)]
-        centerness_pred_list = [
-            centernesses[i].detach() for i in range(num_levels)
-        ]
-        img_shapes = [
-            img_metas[i]['img_shape'] for i in range(cls_scores[0].shape[0])
-        ]
-        scale_factors = [
-            img_metas[i]['scale_factor'] for i in range(cls_scores[0].shape[0])
-        ]
-        result_list = self._get_bboxes(cls_score_list, bbox_pred_list,
-                                       centerness_pred_list, mlvl_anchors,
-                                       img_shapes, scale_factors, cfg, rescale,
-                                       with_nms)
-        return result_list
-
-    def _get_bboxes(self,
-                    cls_scores,
-                    bbox_preds,
-                    centernesses,
-                    mlvl_anchors,
-                    img_shapes,
-                    scale_factors,
-                    cfg,
-                    rescale=False,
-                    with_nms=True):
-        """Transform outputs for a single batch item into labeled boxes.
-
-        Args:
-            cls_scores (list[Tensor]): Box scores for a single scale level
-                with shape (N, num_anchors * num_classes, H, W).
-            bbox_preds (list[Tensor]): Box energies / deltas for a single
-                scale level with shape (N, num_anchors * 4, H, W).
-            centernesses (list[Tensor]): Centerness for a single scale level
-                with shape (N, num_anchors * 1, H, W).
-            mlvl_anchors (list[Tensor]): Box reference for a single scale level
-                with shape (num_total_anchors, 4).
-            img_shapes (list[tuple[int]]): Shape of the input image,
-                list[(height, width, 3)].
-            scale_factors (list[ndarray]): Scale factor of the image arrange as
-                (w_scale, h_scale, w_scale, h_scale).
-            cfg (mmcv.Config | None): Test / postprocessing configuration,
-                if None, test_cfg would be used.
-            rescale (bool): If True, return boxes in original image space.
-                Default: False.
-            with_nms (bool): If True, do nms before return boxes.
-                Default: True.
-
-        Returns:
-            list[tuple[Tensor, Tensor]]: Each item in result_list is 2-tuple.
-                The first item is an (n, 5) tensor, where 5 represent
-                (tl_x, tl_y, br_x, br_y, score) and the score between 0 and 1.
-                The shape of the second tensor in the tuple is (n,), and
-                each element represents the class label of the corresponding
-                box.
-        """
-        assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
-        device = cls_scores[0].device
-        batch_size = cls_scores[0].shape[0]
-        # convert to tensor to keep tracing
-        nms_pre_tensor = torch.tensor(
-            cfg.get('nms_pre', -1), device=device, dtype=torch.long)
-        mlvl_bboxes = []
-        mlvl_scores = []
-        mlvl_centerness = []
-        for cls_score, bbox_pred, centerness, anchors in zip(
-                cls_scores, bbox_preds, centernesses, mlvl_anchors):
-            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
-            scores = cls_score.permute(0, 2, 3, 1).reshape(
-                batch_size, -1, self.cls_out_channels).sigmoid()
-            centerness = centerness.permute(0, 2, 3,
-                                            1).reshape(batch_size,
-                                                       -1).sigmoid()
-            bbox_pred = bbox_pred.permute(0, 2, 3,
-                                          1).reshape(batch_size, -1, 4)
-
-            # Always keep topk op for dynamic input in onnx
-            if nms_pre_tensor > 0 and (torch.onnx.is_in_onnx_export()
-                                       or scores.shape[-2] > nms_pre_tensor):
-                from torch import _shape_as_tensor
-                # keep shape as tensor and get k
-                num_anchor = _shape_as_tensor(scores)[-2].to(device)
-                nms_pre = torch.where(nms_pre_tensor < num_anchor,
-                                      nms_pre_tensor, num_anchor)
-
-                max_scores, _ = (scores * centerness[..., None]).max(-1)
-                _, topk_inds = max_scores.topk(nms_pre)
-                anchors = anchors[topk_inds, :]
-                batch_inds = torch.arange(batch_size).view(
-                    -1, 1).expand_as(topk_inds).long()
-                bbox_pred = bbox_pred[batch_inds, topk_inds, :]
-                scores = scores[batch_inds, topk_inds, :]
-                centerness = centerness[batch_inds, topk_inds]
-            else:
-                anchors = anchors.expand_as(bbox_pred)
-
-            bboxes = self.bbox_coder.decode(
-                anchors, bbox_pred, max_shape=img_shapes)
-            mlvl_bboxes.append(bboxes)
-            mlvl_scores.append(scores)
-            mlvl_centerness.append(centerness)
-
-        batch_mlvl_bboxes = torch.cat(mlvl_bboxes, dim=1)
-        if rescale:
-            batch_mlvl_bboxes /= batch_mlvl_bboxes.new_tensor(
-                scale_factors).unsqueeze(1)
-        batch_mlvl_scores = torch.cat(mlvl_scores, dim=1)
-        batch_mlvl_centerness = torch.cat(mlvl_centerness, dim=1)
-
-        # Set max number of box to be feed into nms in deployment
-        deploy_nms_pre = cfg.get('deploy_nms_pre', -1)
-        if deploy_nms_pre > 0 and torch.onnx.is_in_onnx_export():
-            batch_mlvl_scores, _ = (
-                batch_mlvl_scores *
-                batch_mlvl_centerness.unsqueeze(2).expand_as(batch_mlvl_scores)
-            ).max(-1)
-            _, topk_inds = batch_mlvl_scores.topk(deploy_nms_pre)
-            batch_inds = torch.arange(batch_size).view(-1,
-                                                       1).expand_as(topk_inds)
-            batch_mlvl_scores = batch_mlvl_scores[batch_inds, topk_inds, :]
-            batch_mlvl_bboxes = batch_mlvl_bboxes[batch_inds, topk_inds, :]
-            batch_mlvl_centerness = batch_mlvl_centerness[batch_inds,
-                                                          topk_inds]
-        # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
-        # BG cat_id: num_class
-        padding = batch_mlvl_scores.new_zeros(batch_size,
-                                              batch_mlvl_scores.shape[1], 1)
-        batch_mlvl_scores = torch.cat([batch_mlvl_scores, padding], dim=-1)
-
-        if with_nms:
-            det_results = []
-            for (mlvl_bboxes, mlvl_scores,
-                 mlvl_centerness) in zip(batch_mlvl_bboxes, batch_mlvl_scores,
-                                         batch_mlvl_centerness):
-                det_bbox, det_label = multiclass_nms(
-                    mlvl_bboxes,
-                    mlvl_scores,
-                    cfg.score_thr,
-                    cfg.nms,
-                    cfg.max_per_img,
-                    score_factors=mlvl_centerness)
-                det_results.append(tuple([det_bbox, det_label]))
-        else:
-            det_results = [
-                tuple(mlvl_bs)
-                for mlvl_bs in zip(batch_mlvl_bboxes, batch_mlvl_scores,
-                                   batch_mlvl_centerness)
-            ]
-        return det_results
-
-    def get_targets(self,
-                    anchor_list,
-                    valid_flag_list,
-                    gt_bboxes_list,
-                    img_metas,
-                    gt_bboxes_ignore_list=None,
-                    gt_labels_list=None,
-                    label_channels=1,
-                    unmap_outputs=True):
-        """Get targets for ATSS head.
-
-        This method is almost the same as `AnchorHead.get_targets()`. Besides
-        returning the targets as the parent method does, it also returns the
-        anchors as the first element of the returned tuple.
-        """
-        num_imgs = len(img_metas)
-        assert len(anchor_list) == len(valid_flag_list) == num_imgs
-
-        # anchor number of multi levels
-        num_level_anchors = [anchors.size(0) for anchors in anchor_list[0]]
-        num_level_anchors_list = [num_level_anchors] * num_imgs
-
-        # concat all level anchors and flags to a single tensor
-        for i in range(num_imgs):
-            assert len(anchor_list[i]) == len(valid_flag_list[i])
-            anchor_list[i] = torch.cat(anchor_list[i])
-            valid_flag_list[i] = torch.cat(valid_flag_list[i])
-
-        # compute targets for each image
-        if gt_bboxes_ignore_list is None:
-            gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
-        if gt_labels_list is None:
-            gt_labels_list = [None for _ in range(num_imgs)]
-        (all_anchors, all_labels, all_label_weights, all_bbox_targets,
-         all_bbox_weights, pos_inds_list, neg_inds_list) = multi_apply(
-             self._get_target_single,
-             anchor_list,
-             valid_flag_list,
-             num_level_anchors_list,
-             gt_bboxes_list,
-             gt_bboxes_ignore_list,
-             gt_labels_list,
-             img_metas,
-             label_channels=label_channels,
-             unmap_outputs=unmap_outputs)
-        # no valid anchors
-        if any([labels is None for labels in all_labels]):
-            return None
-        # sampled anchors of all images
-        num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list])
-        num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list])
-        # split targets to a list w.r.t. multiple levels
-        anchors_list = images_to_levels(all_anchors, num_level_anchors)
-        labels_list = images_to_levels(all_labels, num_level_anchors)
-        label_weights_list = images_to_levels(all_label_weights,
-                                              num_level_anchors)
-        bbox_targets_list = images_to_levels(all_bbox_targets,
-                                             num_level_anchors)
-        bbox_weights_list = images_to_levels(all_bbox_weights,
-                                             num_level_anchors)
-        return (anchors_list, labels_list, label_weights_list,
-                bbox_targets_list, bbox_weights_list, num_total_pos,
-                num_total_neg)
-
-    def _get_target_single(self,
-                           flat_anchors,
-                           valid_flags,
-                           num_level_anchors,
-                           gt_bboxes,
-                           gt_bboxes_ignore,
-                           gt_labels,
-                           img_meta,
-                           label_channels=1,
-                           unmap_outputs=True):
-        """Compute regression, classification targets for anchors in a single
-        image.
-
-        Args:
-            flat_anchors (Tensor): Multi-level anchors of the image, which are
-                concatenated into a single tensor of shape (num_anchors ,4)
-            valid_flags (Tensor): Multi level valid flags of the image,
-                which are concatenated into a single tensor of
-                    shape (num_anchors,).
-            num_level_anchors Tensor): Number of anchors of each scale level.
-            gt_bboxes (Tensor): Ground truth bboxes of the image,
-                shape (num_gts, 4).
-            gt_bboxes_ignore (Tensor): Ground truth bboxes to be
-                ignored, shape (num_ignored_gts, 4).
-            gt_labels (Tensor): Ground truth labels of each box,
-                shape (num_gts,).
-            img_meta (dict): Meta info of the image.
-            label_channels (int): Channel of label.
-            unmap_outputs (bool): Whether to map outputs back to the original
-                set of anchors.
-
-        Returns:
-            tuple: N is the number of total anchors in the image.
-                labels (Tensor): Labels of all anchors in the image with shape
-                    (N,).
-                label_weights (Tensor): Label weights of all anchor in the
-                    image with shape (N,).
-                bbox_targets (Tensor): BBox targets of all anchors in the
-                    image with shape (N, 4).
-                bbox_weights (Tensor): BBox weights of all anchors in the
-                    image with shape (N, 4)
-                pos_inds (Tensor): Indices of positive anchor with shape
-                    (num_pos,).
-                neg_inds (Tensor): Indices of negative anchor with shape
-                    (num_neg,).
-        """
-        inside_flags = anchor_inside_flags(flat_anchors, valid_flags,
-                                           img_meta['img_shape'][:2],
-                                           self.train_cfg.allowed_border)
-        if not inside_flags.any():
-            return (None, ) * 7
-        # assign gt and sample anchors
-        anchors = flat_anchors[inside_flags, :]
-
-        num_level_anchors_inside = self.get_num_level_anchors_inside(
-            num_level_anchors, inside_flags)
-        assign_result = self.assigner.assign(anchors, num_level_anchors_inside,
-                                             gt_bboxes, gt_bboxes_ignore,
-                                             gt_labels)
-
-        sampling_result = self.sampler.sample(assign_result, anchors,
-                                              gt_bboxes)
-
-        num_valid_anchors = anchors.shape[0]
-        bbox_targets = torch.zeros_like(anchors)
-        bbox_weights = torch.zeros_like(anchors)
-        labels = anchors.new_full((num_valid_anchors, ),
-                                  self.num_classes,
-                                  dtype=torch.long)
-        label_weights = anchors.new_zeros(num_valid_anchors, dtype=torch.float)
-
-        pos_inds = sampling_result.pos_inds
-        neg_inds = sampling_result.neg_inds
-        if len(pos_inds) > 0:
-            if hasattr(self, 'bbox_coder'):
-                pos_bbox_targets = self.bbox_coder.encode(
-                    sampling_result.pos_bboxes, sampling_result.pos_gt_bboxes)
-            else:
-                # used in VFNetHead
-                pos_bbox_targets = sampling_result.pos_gt_bboxes
-            bbox_targets[pos_inds, :] = pos_bbox_targets
-            bbox_weights[pos_inds, :] = 1.0
-            if gt_labels is None:
-                # Only rpn gives gt_labels as None
-                # Foreground is the first class since v2.5.0
-                labels[pos_inds] = 0
-            else:
-                labels[pos_inds] = gt_labels[
-                    sampling_result.pos_assigned_gt_inds]
-            if self.train_cfg.pos_weight <= 0:
-                label_weights[pos_inds] = 1.0
-            else:
-                label_weights[pos_inds] = self.train_cfg.pos_weight
-        if len(neg_inds) > 0:
-            label_weights[neg_inds] = 1.0
-
-        # map up to original set of anchors
-        if unmap_outputs:
-            num_total_anchors = flat_anchors.size(0)
-            anchors = unmap(anchors, num_total_anchors, inside_flags)
-            labels = unmap(
-                labels, num_total_anchors, inside_flags, fill=self.num_classes)
-            label_weights = unmap(label_weights, num_total_anchors,
-                                  inside_flags)
-            bbox_targets = unmap(bbox_targets, num_total_anchors, inside_flags)
-            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-
-        return (anchors, labels, label_weights, bbox_targets, bbox_weights,
-                pos_inds, neg_inds)
-
-    def get_num_level_anchors_inside(self, num_level_anchors, inside_flags):
-        split_inside_flags = torch.split(inside_flags, num_level_anchors)
-        num_level_anchors_inside = [
-            int(flags.sum()) for flags in split_inside_flags
-        ]
-        return num_level_anchors_inside

spaces/CVPR/WALT/mmdet/models/dense_heads/guided_anchor_head.py

@@ -1,860 +0,0 @@
-import torch
-import torch.nn as nn
-from mmcv.cnn import bias_init_with_prob, normal_init
-from mmcv.ops import DeformConv2d, MaskedConv2d
-from mmcv.runner import force_fp32
-
-from mmdet.core import (anchor_inside_flags, build_anchor_generator,
-                        build_assigner, build_bbox_coder, build_sampler,
-                        calc_region, images_to_levels, multi_apply,
-                        multiclass_nms, unmap)
-from ..builder import HEADS, build_loss
-from .anchor_head import AnchorHead
-
-
-class FeatureAdaption(nn.Module):
-    """Feature Adaption Module.
-
-    Feature Adaption Module is implemented based on DCN v1.
-    It uses anchor shape prediction rather than feature map to
-    predict offsets of deform conv layer.
-
-    Args:
-        in_channels (int): Number of channels in the input feature map.
-        out_channels (int): Number of channels in the output feature map.
-        kernel_size (int): Deformable conv kernel size.
-        deform_groups (int): Deformable conv group size.
-    """
-
-    def __init__(self,
-                 in_channels,
-                 out_channels,
-                 kernel_size=3,
-                 deform_groups=4):
-        super(FeatureAdaption, self).__init__()
-        offset_channels = kernel_size * kernel_size * 2
-        self.conv_offset = nn.Conv2d(
-            2, deform_groups * offset_channels, 1, bias=False)
-        self.conv_adaption = DeformConv2d(
-            in_channels,
-            out_channels,
-            kernel_size=kernel_size,
-            padding=(kernel_size - 1) // 2,
-            deform_groups=deform_groups)
-        self.relu = nn.ReLU(inplace=True)
-
-    def init_weights(self):
-        normal_init(self.conv_offset, std=0.1)
-        normal_init(self.conv_adaption, std=0.01)
-
-    def forward(self, x, shape):
-        offset = self.conv_offset(shape.detach())
-        x = self.relu(self.conv_adaption(x, offset))
-        return x
-
-
-@HEADS.register_module()
-class GuidedAnchorHead(AnchorHead):
-    """Guided-Anchor-based head (GA-RPN, GA-RetinaNet, etc.).
-
-    This GuidedAnchorHead will predict high-quality feature guided
-    anchors and locations where anchors will be kept in inference.
-    There are mainly 3 categories of bounding-boxes.
-
-    - Sampled 9 pairs for target assignment. (approxes)
-    - The square boxes where the predicted anchors are based on. (squares)
-    - Guided anchors.
-
-    Please refer to https://arxiv.org/abs/1901.03278 for more details.
-
-    Args:
-        num_classes (int): Number of classes.
-        in_channels (int): Number of channels in the input feature map.
-        feat_channels (int): Number of hidden channels.
-        approx_anchor_generator (dict): Config dict for approx generator
-        square_anchor_generator (dict): Config dict for square generator
-        anchor_coder (dict): Config dict for anchor coder
-        bbox_coder (dict): Config dict for bbox coder
-        reg_decoded_bbox (bool): If true, the regression loss would be
-            applied directly on decoded bounding boxes, converting both
-            the predicted boxes and regression targets to absolute
-            coordinates format. Default False. It should be `True` when
-            using `IoULoss`, `GIoULoss`, or `DIoULoss` in the bbox head.
-        deform_groups: (int): Group number of DCN in
-            FeatureAdaption module.
-        loc_filter_thr (float): Threshold to filter out unconcerned regions.
-        loss_loc (dict): Config of location loss.
-        loss_shape (dict): Config of anchor shape loss.
-        loss_cls (dict): Config of classification loss.
-        loss_bbox (dict): Config of bbox regression loss.
-    """
-
-    def __init__(
-        self,
-        num_classes,
-        in_channels,
-        feat_channels=256,
-        approx_anchor_generator=dict(
-            type='AnchorGenerator',
-            octave_base_scale=8,
-            scales_per_octave=3,
-            ratios=[0.5, 1.0, 2.0],
-            strides=[4, 8, 16, 32, 64]),
-        square_anchor_generator=dict(
-            type='AnchorGenerator',
-            ratios=[1.0],
-            scales=[8],
-            strides=[4, 8, 16, 32, 64]),
-        anchor_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]
-        ),
-        bbox_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]
-        ),
-        reg_decoded_bbox=False,
-        deform_groups=4,
-        loc_filter_thr=0.01,
-        train_cfg=None,
-        test_cfg=None,
-        loss_loc=dict(
-            type='FocalLoss',
-            use_sigmoid=True,
-            gamma=2.0,
-            alpha=0.25,
-            loss_weight=1.0),
-        loss_shape=dict(type='BoundedIoULoss', beta=0.2, loss_weight=1.0),
-        loss_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-        loss_bbox=dict(type='SmoothL1Loss', beta=1.0,
-                       loss_weight=1.0)):  # yapf: disable
-        super(AnchorHead, self).__init__()
-        self.in_channels = in_channels
-        self.num_classes = num_classes
-        self.feat_channels = feat_channels
-        self.deform_groups = deform_groups
-        self.loc_filter_thr = loc_filter_thr
-
-        # build approx_anchor_generator and square_anchor_generator
-        assert (approx_anchor_generator['octave_base_scale'] ==
-                square_anchor_generator['scales'][0])
-        assert (approx_anchor_generator['strides'] ==
-                square_anchor_generator['strides'])
-        self.approx_anchor_generator = build_anchor_generator(
-            approx_anchor_generator)
-        self.square_anchor_generator = build_anchor_generator(
-            square_anchor_generator)
-        self.approxs_per_octave = self.approx_anchor_generator \
-            .num_base_anchors[0]
-
-        self.reg_decoded_bbox = reg_decoded_bbox
-
-        # one anchor per location
-        self.num_anchors = 1
-        self.use_sigmoid_cls = loss_cls.get('use_sigmoid', False)
-        self.loc_focal_loss = loss_loc['type'] in ['FocalLoss']
-        self.sampling = loss_cls['type'] not in ['FocalLoss']
-        self.ga_sampling = train_cfg is not None and hasattr(
-            train_cfg, 'ga_sampler')
-        if self.use_sigmoid_cls:
-            self.cls_out_channels = self.num_classes
-        else:
-            self.cls_out_channels = self.num_classes + 1
-
-        # build bbox_coder
-        self.anchor_coder = build_bbox_coder(anchor_coder)
-        self.bbox_coder = build_bbox_coder(bbox_coder)
-
-        # build losses
-        self.loss_loc = build_loss(loss_loc)
-        self.loss_shape = build_loss(loss_shape)
-        self.loss_cls = build_loss(loss_cls)
-        self.loss_bbox = build_loss(loss_bbox)
-
-        self.train_cfg = train_cfg
-        self.test_cfg = test_cfg
-
-        if self.train_cfg:
-            self.assigner = build_assigner(self.train_cfg.assigner)
-            # use PseudoSampler when sampling is False
-            if self.sampling and hasattr(self.train_cfg, 'sampler'):
-                sampler_cfg = self.train_cfg.sampler
-            else:
-                sampler_cfg = dict(type='PseudoSampler')
-            self.sampler = build_sampler(sampler_cfg, context=self)
-
-            self.ga_assigner = build_assigner(self.train_cfg.ga_assigner)
-            if self.ga_sampling:
-                ga_sampler_cfg = self.train_cfg.ga_sampler
-            else:
-                ga_sampler_cfg = dict(type='PseudoSampler')
-            self.ga_sampler = build_sampler(ga_sampler_cfg, context=self)
-
-        self.fp16_enabled = False
-
-        self._init_layers()
-
-    def _init_layers(self):
-        self.relu = nn.ReLU(inplace=True)
-        self.conv_loc = nn.Conv2d(self.in_channels, 1, 1)
-        self.conv_shape = nn.Conv2d(self.in_channels, self.num_anchors * 2, 1)
-        self.feature_adaption = FeatureAdaption(
-            self.in_channels,
-            self.feat_channels,
-            kernel_size=3,
-            deform_groups=self.deform_groups)
-        self.conv_cls = MaskedConv2d(self.feat_channels,
-                                     self.num_anchors * self.cls_out_channels,
-                                     1)
-        self.conv_reg = MaskedConv2d(self.feat_channels, self.num_anchors * 4,
-                                     1)
-
-    def init_weights(self):
-        normal_init(self.conv_cls, std=0.01)
-        normal_init(self.conv_reg, std=0.01)
-
-        bias_cls = bias_init_with_prob(0.01)
-        normal_init(self.conv_loc, std=0.01, bias=bias_cls)
-        normal_init(self.conv_shape, std=0.01)
-
-        self.feature_adaption.init_weights()
-
-    def forward_single(self, x):
-        loc_pred = self.conv_loc(x)
-        shape_pred = self.conv_shape(x)
-        x = self.feature_adaption(x, shape_pred)
-        # masked conv is only used during inference for speed-up
-        if not self.training:
-            mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
-        else:
-            mask = None
-        cls_score = self.conv_cls(x, mask)
-        bbox_pred = self.conv_reg(x, mask)
-        return cls_score, bbox_pred, shape_pred, loc_pred
-
-    def forward(self, feats):
-        return multi_apply(self.forward_single, feats)
-
-    def get_sampled_approxs(self, featmap_sizes, img_metas, device='cuda'):
-        """Get sampled approxs and inside flags according to feature map sizes.
-
-        Args:
-            featmap_sizes (list[tuple]): Multi-level feature map sizes.
-            img_metas (list[dict]): Image meta info.
-            device (torch.device | str): device for returned tensors
-
-        Returns:
-            tuple: approxes of each image, inside flags of each image
-        """
-        num_imgs = len(img_metas)
-
-        # since feature map sizes of all images are the same, we only compute
-        # approxes for one time
-        multi_level_approxs = self.approx_anchor_generator.grid_anchors(
-            featmap_sizes, device=device)
-        approxs_list = [multi_level_approxs for _ in range(num_imgs)]
-
-        # for each image, we compute inside flags of multi level approxes
-        inside_flag_list = []
-        for img_id, img_meta in enumerate(img_metas):
-            multi_level_flags = []
-            multi_level_approxs = approxs_list[img_id]
-
-            # obtain valid flags for each approx first
-            multi_level_approx_flags = self.approx_anchor_generator \
-                .valid_flags(featmap_sizes,
-                             img_meta['pad_shape'],
-                             device=device)
-
-            for i, flags in enumerate(multi_level_approx_flags):
-                approxs = multi_level_approxs[i]
-                inside_flags_list = []
-                for i in range(self.approxs_per_octave):
-                    split_valid_flags = flags[i::self.approxs_per_octave]
-                    split_approxs = approxs[i::self.approxs_per_octave, :]
-                    inside_flags = anchor_inside_flags(
-                        split_approxs, split_valid_flags,
-                        img_meta['img_shape'][:2],
-                        self.train_cfg.allowed_border)
-                    inside_flags_list.append(inside_flags)
-                # inside_flag for a position is true if any anchor in this
-                # position is true
-                inside_flags = (
-                    torch.stack(inside_flags_list, 0).sum(dim=0) > 0)
-                multi_level_flags.append(inside_flags)
-            inside_flag_list.append(multi_level_flags)
-        return approxs_list, inside_flag_list
-
-    def get_anchors(self,
-                    featmap_sizes,
-                    shape_preds,
-                    loc_preds,
-                    img_metas,
-                    use_loc_filter=False,
-                    device='cuda'):
-        """Get squares according to feature map sizes and guided anchors.
-
-        Args:
-            featmap_sizes (list[tuple]): Multi-level feature map sizes.
-            shape_preds (list[tensor]): Multi-level shape predictions.
-            loc_preds (list[tensor]): Multi-level location predictions.
-            img_metas (list[dict]): Image meta info.
-            use_loc_filter (bool): Use loc filter or not.
-            device (torch.device | str): device for returned tensors
-
-        Returns:
-            tuple: square approxs of each image, guided anchors of each image,
-                loc masks of each image
-        """
-        num_imgs = len(img_metas)
-        num_levels = len(featmap_sizes)
-
-        # since feature map sizes of all images are the same, we only compute
-        # squares for one time
-        multi_level_squares = self.square_anchor_generator.grid_anchors(
-            featmap_sizes, device=device)
-        squares_list = [multi_level_squares for _ in range(num_imgs)]
-
-        # for each image, we compute multi level guided anchors
-        guided_anchors_list = []
-        loc_mask_list = []
-        for img_id, img_meta in enumerate(img_metas):
-            multi_level_guided_anchors = []
-            multi_level_loc_mask = []
-            for i in range(num_levels):
-                squares = squares_list[img_id][i]
-                shape_pred = shape_preds[i][img_id]
-                loc_pred = loc_preds[i][img_id]
-                guided_anchors, loc_mask = self._get_guided_anchors_single(
-                    squares,
-                    shape_pred,
-                    loc_pred,
-                    use_loc_filter=use_loc_filter)
-                multi_level_guided_anchors.append(guided_anchors)
-                multi_level_loc_mask.append(loc_mask)
-            guided_anchors_list.append(multi_level_guided_anchors)
-            loc_mask_list.append(multi_level_loc_mask)
-        return squares_list, guided_anchors_list, loc_mask_list
-
-    def _get_guided_anchors_single(self,
-                                   squares,
-                                   shape_pred,
-                                   loc_pred,
-                                   use_loc_filter=False):
-        """Get guided anchors and loc masks for a single level.
-
-        Args:
-            square (tensor): Squares of a single level.
-            shape_pred (tensor): Shape predections of a single level.
-            loc_pred (tensor): Loc predections of a single level.
-            use_loc_filter (list[tensor]): Use loc filter or not.
-
-        Returns:
-            tuple: guided anchors, location masks
-        """
-        # calculate location filtering mask
-        loc_pred = loc_pred.sigmoid().detach()
-        if use_loc_filter:
-            loc_mask = loc_pred >= self.loc_filter_thr
-        else:
-            loc_mask = loc_pred >= 0.0
-        mask = loc_mask.permute(1, 2, 0).expand(-1, -1, self.num_anchors)
-        mask = mask.contiguous().view(-1)
-        # calculate guided anchors
-        squares = squares[mask]
-        anchor_deltas = shape_pred.permute(1, 2, 0).contiguous().view(
-            -1, 2).detach()[mask]
-        bbox_deltas = anchor_deltas.new_full(squares.size(), 0)
-        bbox_deltas[:, 2:] = anchor_deltas
-        guided_anchors = self.anchor_coder.decode(
-            squares, bbox_deltas, wh_ratio_clip=1e-6)
-        return guided_anchors, mask
-
-    def ga_loc_targets(self, gt_bboxes_list, featmap_sizes):
-        """Compute location targets for guided anchoring.
-
-        Each feature map is divided into positive, negative and ignore regions.
-        - positive regions: target 1, weight 1
-        - ignore regions: target 0, weight 0
-        - negative regions: target 0, weight 0.1
-
-        Args:
-            gt_bboxes_list (list[Tensor]): Gt bboxes of each image.
-            featmap_sizes (list[tuple]): Multi level sizes of each feature
-                maps.
-
-        Returns:
-            tuple
-        """
-        anchor_scale = self.approx_anchor_generator.octave_base_scale
-        anchor_strides = self.approx_anchor_generator.strides
-        # Currently only supports same stride in x and y direction.
-        for stride in anchor_strides:
-            assert (stride[0] == stride[1])
-        anchor_strides = [stride[0] for stride in anchor_strides]
-
-        center_ratio = self.train_cfg.center_ratio
-        ignore_ratio = self.train_cfg.ignore_ratio
-        img_per_gpu = len(gt_bboxes_list)
-        num_lvls = len(featmap_sizes)
-        r1 = (1 - center_ratio) / 2
-        r2 = (1 - ignore_ratio) / 2
-        all_loc_targets = []
-        all_loc_weights = []
-        all_ignore_map = []
-        for lvl_id in range(num_lvls):
-            h, w = featmap_sizes[lvl_id]
-            loc_targets = torch.zeros(
-                img_per_gpu,
-                1,
-                h,
-                w,
-                device=gt_bboxes_list[0].device,
-                dtype=torch.float32)
-            loc_weights = torch.full_like(loc_targets, -1)
-            ignore_map = torch.zeros_like(loc_targets)
-            all_loc_targets.append(loc_targets)
-            all_loc_weights.append(loc_weights)
-            all_ignore_map.append(ignore_map)
-        for img_id in range(img_per_gpu):
-            gt_bboxes = gt_bboxes_list[img_id]
-            scale = torch.sqrt((gt_bboxes[:, 2] - gt_bboxes[:, 0]) *
-                               (gt_bboxes[:, 3] - gt_bboxes[:, 1]))
-            min_anchor_size = scale.new_full(
-                (1, ), float(anchor_scale * anchor_strides[0]))
-            # assign gt bboxes to different feature levels w.r.t. their scales
-            target_lvls = torch.floor(
-                torch.log2(scale) - torch.log2(min_anchor_size) + 0.5)
-            target_lvls = target_lvls.clamp(min=0, max=num_lvls - 1).long()
-            for gt_id in range(gt_bboxes.size(0)):
-                lvl = target_lvls[gt_id].item()
-                # rescaled to corresponding feature map
-                gt_ = gt_bboxes[gt_id, :4] / anchor_strides[lvl]
-                # calculate ignore regions
-                ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
-                    gt_, r2, featmap_sizes[lvl])
-                # calculate positive (center) regions
-                ctr_x1, ctr_y1, ctr_x2, ctr_y2 = calc_region(
-                    gt_, r1, featmap_sizes[lvl])
-                all_loc_targets[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
-                                     ctr_x1:ctr_x2 + 1] = 1
-                all_loc_weights[lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
-                                     ignore_x1:ignore_x2 + 1] = 0
-                all_loc_weights[lvl][img_id, 0, ctr_y1:ctr_y2 + 1,
-                                     ctr_x1:ctr_x2 + 1] = 1
-                # calculate ignore map on nearby low level feature
-                if lvl > 0:
-                    d_lvl = lvl - 1
-                    # rescaled to corresponding feature map
-                    gt_ = gt_bboxes[gt_id, :4] / anchor_strides[d_lvl]
-                    ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
-                        gt_, r2, featmap_sizes[d_lvl])
-                    all_ignore_map[d_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
-                                          ignore_x1:ignore_x2 + 1] = 1
-                # calculate ignore map on nearby high level feature
-                if lvl < num_lvls - 1:
-                    u_lvl = lvl + 1
-                    # rescaled to corresponding feature map
-                    gt_ = gt_bboxes[gt_id, :4] / anchor_strides[u_lvl]
-                    ignore_x1, ignore_y1, ignore_x2, ignore_y2 = calc_region(
-                        gt_, r2, featmap_sizes[u_lvl])
-                    all_ignore_map[u_lvl][img_id, 0, ignore_y1:ignore_y2 + 1,
-                                          ignore_x1:ignore_x2 + 1] = 1
-        for lvl_id in range(num_lvls):
-            # ignore negative regions w.r.t. ignore map
-            all_loc_weights[lvl_id][(all_loc_weights[lvl_id] < 0)
-                                    & (all_ignore_map[lvl_id] > 0)] = 0
-            # set negative regions with weight 0.1
-            all_loc_weights[lvl_id][all_loc_weights[lvl_id] < 0] = 0.1
-        # loc average factor to balance loss
-        loc_avg_factor = sum(
-            [t.size(0) * t.size(-1) * t.size(-2)
-             for t in all_loc_targets]) / 200
-        return all_loc_targets, all_loc_weights, loc_avg_factor
-
-    def _ga_shape_target_single(self,
-                                flat_approxs,
-                                inside_flags,
-                                flat_squares,
-                                gt_bboxes,
-                                gt_bboxes_ignore,
-                                img_meta,
-                                unmap_outputs=True):
-        """Compute guided anchoring targets.
-
-        This function returns sampled anchors and gt bboxes directly
-        rather than calculates regression targets.
-
-        Args:
-            flat_approxs (Tensor): flat approxs of a single image,
-                shape (n, 4)
-            inside_flags (Tensor): inside flags of a single image,
-                shape (n, ).
-            flat_squares (Tensor): flat squares of a single image,
-                shape (approxs_per_octave * n, 4)
-            gt_bboxes (Tensor): Ground truth bboxes of a single image.
-            img_meta (dict): Meta info of a single image.
-            approxs_per_octave (int): number of approxs per octave
-            cfg (dict): RPN train configs.
-            unmap_outputs (bool): unmap outputs or not.
-
-        Returns:
-            tuple
-        """
-        if not inside_flags.any():
-            return (None, ) * 5
-        # assign gt and sample anchors
-        expand_inside_flags = inside_flags[:, None].expand(
-            -1, self.approxs_per_octave).reshape(-1)
-        approxs = flat_approxs[expand_inside_flags, :]
-        squares = flat_squares[inside_flags, :]
-
-        assign_result = self.ga_assigner.assign(approxs, squares,
-                                                self.approxs_per_octave,
-                                                gt_bboxes, gt_bboxes_ignore)
-        sampling_result = self.ga_sampler.sample(assign_result, squares,
-                                                 gt_bboxes)
-
-        bbox_anchors = torch.zeros_like(squares)
-        bbox_gts = torch.zeros_like(squares)
-        bbox_weights = torch.zeros_like(squares)
-
-        pos_inds = sampling_result.pos_inds
-        neg_inds = sampling_result.neg_inds
-        if len(pos_inds) > 0:
-            bbox_anchors[pos_inds, :] = sampling_result.pos_bboxes
-            bbox_gts[pos_inds, :] = sampling_result.pos_gt_bboxes
-            bbox_weights[pos_inds, :] = 1.0
-
-        # map up to original set of anchors
-        if unmap_outputs:
-            num_total_anchors = flat_squares.size(0)
-            bbox_anchors = unmap(bbox_anchors, num_total_anchors, inside_flags)
-            bbox_gts = unmap(bbox_gts, num_total_anchors, inside_flags)
-            bbox_weights = unmap(bbox_weights, num_total_anchors, inside_flags)
-
-        return (bbox_anchors, bbox_gts, bbox_weights, pos_inds, neg_inds)
-
-    def ga_shape_targets(self,
-                         approx_list,
-                         inside_flag_list,
-                         square_list,
-                         gt_bboxes_list,
-                         img_metas,
-                         gt_bboxes_ignore_list=None,
-                         unmap_outputs=True):
-        """Compute guided anchoring targets.
-
-        Args:
-            approx_list (list[list]): Multi level approxs of each image.
-            inside_flag_list (list[list]): Multi level inside flags of each
-                image.
-            square_list (list[list]): Multi level squares of each image.
-            gt_bboxes_list (list[Tensor]): Ground truth bboxes of each image.
-            img_metas (list[dict]): Meta info of each image.
-            gt_bboxes_ignore_list (list[Tensor]): ignore list of gt bboxes.
-            unmap_outputs (bool): unmap outputs or not.
-
-        Returns:
-            tuple
-        """
-        num_imgs = len(img_metas)
-        assert len(approx_list) == len(inside_flag_list) == len(
-            square_list) == num_imgs
-        # anchor number of multi levels
-        num_level_squares = [squares.size(0) for squares in square_list[0]]
-        # concat all level anchors and flags to a single tensor
-        inside_flag_flat_list = []
-        approx_flat_list = []
-        square_flat_list = []
-        for i in range(num_imgs):
-            assert len(square_list[i]) == len(inside_flag_list[i])
-            inside_flag_flat_list.append(torch.cat(inside_flag_list[i]))
-            approx_flat_list.append(torch.cat(approx_list[i]))
-            square_flat_list.append(torch.cat(square_list[i]))
-
-        # compute targets for each image
-        if gt_bboxes_ignore_list is None:
-            gt_bboxes_ignore_list = [None for _ in range(num_imgs)]
-        (all_bbox_anchors, all_bbox_gts, all_bbox_weights, pos_inds_list,
-         neg_inds_list) = multi_apply(
-             self._ga_shape_target_single,
-             approx_flat_list,
-             inside_flag_flat_list,
-             square_flat_list,
-             gt_bboxes_list,
-             gt_bboxes_ignore_list,
-             img_metas,
-             unmap_outputs=unmap_outputs)
-        # no valid anchors
-        if any([bbox_anchors is None for bbox_anchors in all_bbox_anchors]):
-            return None
-        # sampled anchors of all images
-        num_total_pos = sum([max(inds.numel(), 1) for inds in pos_inds_list])
-        num_total_neg = sum([max(inds.numel(), 1) for inds in neg_inds_list])
-        # split targets to a list w.r.t. multiple levels
-        bbox_anchors_list = images_to_levels(all_bbox_anchors,
-                                             num_level_squares)
-        bbox_gts_list = images_to_levels(all_bbox_gts, num_level_squares)
-        bbox_weights_list = images_to_levels(all_bbox_weights,
-                                             num_level_squares)
-        return (bbox_anchors_list, bbox_gts_list, bbox_weights_list,
-                num_total_pos, num_total_neg)
-
-    def loss_shape_single(self, shape_pred, bbox_anchors, bbox_gts,
-                          anchor_weights, anchor_total_num):
-        shape_pred = shape_pred.permute(0, 2, 3, 1).contiguous().view(-1, 2)
-        bbox_anchors = bbox_anchors.contiguous().view(-1, 4)
-        bbox_gts = bbox_gts.contiguous().view(-1, 4)
-        anchor_weights = anchor_weights.contiguous().view(-1, 4)
-        bbox_deltas = bbox_anchors.new_full(bbox_anchors.size(), 0)
-        bbox_deltas[:, 2:] += shape_pred
-        # filter out negative samples to speed-up weighted_bounded_iou_loss
-        inds = torch.nonzero(
-            anchor_weights[:, 0] > 0, as_tuple=False).squeeze(1)
-        bbox_deltas_ = bbox_deltas[inds]
-        bbox_anchors_ = bbox_anchors[inds]
-        bbox_gts_ = bbox_gts[inds]
-        anchor_weights_ = anchor_weights[inds]
-        pred_anchors_ = self.anchor_coder.decode(
-            bbox_anchors_, bbox_deltas_, wh_ratio_clip=1e-6)
-        loss_shape = self.loss_shape(
-            pred_anchors_,
-            bbox_gts_,
-            anchor_weights_,
-            avg_factor=anchor_total_num)
-        return loss_shape
-
-    def loss_loc_single(self, loc_pred, loc_target, loc_weight,
-                        loc_avg_factor):
-        loss_loc = self.loss_loc(
-            loc_pred.reshape(-1, 1),
-            loc_target.reshape(-1).long(),
-            loc_weight.reshape(-1),
-            avg_factor=loc_avg_factor)
-        return loss_loc
-
-    @force_fp32(
-        apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
-    def loss(self,
-             cls_scores,
-             bbox_preds,
-             shape_preds,
-             loc_preds,
-             gt_bboxes,
-             gt_labels,
-             img_metas,
-             gt_bboxes_ignore=None):
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        assert len(featmap_sizes) == self.approx_anchor_generator.num_levels
-
-        device = cls_scores[0].device
-
-        # get loc targets
-        loc_targets, loc_weights, loc_avg_factor = self.ga_loc_targets(
-            gt_bboxes, featmap_sizes)
-
-        # get sampled approxes
-        approxs_list, inside_flag_list = self.get_sampled_approxs(
-            featmap_sizes, img_metas, device=device)
-        # get squares and guided anchors
-        squares_list, guided_anchors_list, _ = self.get_anchors(
-            featmap_sizes, shape_preds, loc_preds, img_metas, device=device)
-
-        # get shape targets
-        shape_targets = self.ga_shape_targets(approxs_list, inside_flag_list,
-                                              squares_list, gt_bboxes,
-                                              img_metas)
-        if shape_targets is None:
-            return None
-        (bbox_anchors_list, bbox_gts_list, anchor_weights_list, anchor_fg_num,
-         anchor_bg_num) = shape_targets
-        anchor_total_num = (
-            anchor_fg_num if not self.ga_sampling else anchor_fg_num +
-            anchor_bg_num)
-
-        # get anchor targets
-        label_channels = self.cls_out_channels if self.use_sigmoid_cls else 1
-        cls_reg_targets = self.get_targets(
-            guided_anchors_list,
-            inside_flag_list,
-            gt_bboxes,
-            img_metas,
-            gt_bboxes_ignore_list=gt_bboxes_ignore,
-            gt_labels_list=gt_labels,
-            label_channels=label_channels)
-        if cls_reg_targets is None:
-            return None
-        (labels_list, label_weights_list, bbox_targets_list, bbox_weights_list,
-         num_total_pos, num_total_neg) = cls_reg_targets
-        num_total_samples = (
-            num_total_pos + num_total_neg if self.sampling else num_total_pos)
-
-        # anchor number of multi levels
-        num_level_anchors = [
-            anchors.size(0) for anchors in guided_anchors_list[0]
-        ]
-        # concat all level anchors to a single tensor
-        concat_anchor_list = []
-        for i in range(len(guided_anchors_list)):
-            concat_anchor_list.append(torch.cat(guided_anchors_list[i]))
-        all_anchor_list = images_to_levels(concat_anchor_list,
-                                           num_level_anchors)
-
-        # get classification and bbox regression losses
-        losses_cls, losses_bbox = multi_apply(
-            self.loss_single,
-            cls_scores,
-            bbox_preds,
-            all_anchor_list,
-            labels_list,
-            label_weights_list,
-            bbox_targets_list,
-            bbox_weights_list,
-            num_total_samples=num_total_samples)
-
-        # get anchor location loss
-        losses_loc = []
-        for i in range(len(loc_preds)):
-            loss_loc = self.loss_loc_single(
-                loc_preds[i],
-                loc_targets[i],
-                loc_weights[i],
-                loc_avg_factor=loc_avg_factor)
-            losses_loc.append(loss_loc)
-
-        # get anchor shape loss
-        losses_shape = []
-        for i in range(len(shape_preds)):
-            loss_shape = self.loss_shape_single(
-                shape_preds[i],
-                bbox_anchors_list[i],
-                bbox_gts_list[i],
-                anchor_weights_list[i],
-                anchor_total_num=anchor_total_num)
-            losses_shape.append(loss_shape)
-
-        return dict(
-            loss_cls=losses_cls,
-            loss_bbox=losses_bbox,
-            loss_shape=losses_shape,
-            loss_loc=losses_loc)
-
-    @force_fp32(
-        apply_to=('cls_scores', 'bbox_preds', 'shape_preds', 'loc_preds'))
-    def get_bboxes(self,
-                   cls_scores,
-                   bbox_preds,
-                   shape_preds,
-                   loc_preds,
-                   img_metas,
-                   cfg=None,
-                   rescale=False):
-        assert len(cls_scores) == len(bbox_preds) == len(shape_preds) == len(
-            loc_preds)
-        num_levels = len(cls_scores)
-        featmap_sizes = [featmap.size()[-2:] for featmap in cls_scores]
-        device = cls_scores[0].device
-        # get guided anchors
-        _, guided_anchors, loc_masks = self.get_anchors(
-            featmap_sizes,
-            shape_preds,
-            loc_preds,
-            img_metas,
-            use_loc_filter=not self.training,
-            device=device)
-        result_list = []
-        for img_id in range(len(img_metas)):
-            cls_score_list = [
-                cls_scores[i][img_id].detach() for i in range(num_levels)
-            ]
-            bbox_pred_list = [
-                bbox_preds[i][img_id].detach() for i in range(num_levels)
-            ]
-            guided_anchor_list = [
-                guided_anchors[img_id][i].detach() for i in range(num_levels)
-            ]
-            loc_mask_list = [
-                loc_masks[img_id][i].detach() for i in range(num_levels)
-            ]
-            img_shape = img_metas[img_id]['img_shape']
-            scale_factor = img_metas[img_id]['scale_factor']
-            proposals = self._get_bboxes_single(cls_score_list, bbox_pred_list,
-                                                guided_anchor_list,
-                                                loc_mask_list, img_shape,
-                                                scale_factor, cfg, rescale)
-            result_list.append(proposals)
-        return result_list
-
-    def _get_bboxes_single(self,
-                           cls_scores,
-                           bbox_preds,
-                           mlvl_anchors,
-                           mlvl_masks,
-                           img_shape,
-                           scale_factor,
-                           cfg,
-                           rescale=False):
-        cfg = self.test_cfg if cfg is None else cfg
-        assert len(cls_scores) == len(bbox_preds) == len(mlvl_anchors)
-        mlvl_bboxes = []
-        mlvl_scores = []
-        for cls_score, bbox_pred, anchors, mask in zip(cls_scores, bbox_preds,
-                                                       mlvl_anchors,
-                                                       mlvl_masks):
-            assert cls_score.size()[-2:] == bbox_pred.size()[-2:]
-            # if no location is kept, end.
-            if mask.sum() == 0:
-                continue
-            # reshape scores and bbox_pred
-            cls_score = cls_score.permute(1, 2,
-                                          0).reshape(-1, self.cls_out_channels)
-            if self.use_sigmoid_cls:
-                scores = cls_score.sigmoid()
-            else:
-                scores = cls_score.softmax(-1)
-            bbox_pred = bbox_pred.permute(1, 2, 0).reshape(-1, 4)
-            # filter scores, bbox_pred w.r.t. mask.
-            # anchors are filtered in get_anchors() beforehand.
-            scores = scores[mask, :]
-            bbox_pred = bbox_pred[mask, :]
-            if scores.dim() == 0:
-                anchors = anchors.unsqueeze(0)
-                scores = scores.unsqueeze(0)
-                bbox_pred = bbox_pred.unsqueeze(0)
-            # filter anchors, bbox_pred, scores w.r.t. scores
-            nms_pre = cfg.get('nms_pre', -1)
-            if nms_pre > 0 and scores.shape[0] > nms_pre:
-                if self.use_sigmoid_cls:
-                    max_scores, _ = scores.max(dim=1)
-                else:
-                    # remind that we set FG labels to [0, num_class-1]
-                    # since mmdet v2.0
-                    # BG cat_id: num_class
-                    max_scores, _ = scores[:, :-1].max(dim=1)
-                _, topk_inds = max_scores.topk(nms_pre)
-                anchors = anchors[topk_inds, :]
-                bbox_pred = bbox_pred[topk_inds, :]
-                scores = scores[topk_inds, :]
-            bboxes = self.bbox_coder.decode(
-                anchors, bbox_pred, max_shape=img_shape)
-            mlvl_bboxes.append(bboxes)
-            mlvl_scores.append(scores)
-        mlvl_bboxes = torch.cat(mlvl_bboxes)
-        if rescale:
-            mlvl_bboxes /= mlvl_bboxes.new_tensor(scale_factor)
-        mlvl_scores = torch.cat(mlvl_scores)
-        if self.use_sigmoid_cls:
-            # Add a dummy background class to the backend when using sigmoid
-            # remind that we set FG labels to [0, num_class-1] since mmdet v2.0
-            # BG cat_id: num_class
-            padding = mlvl_scores.new_zeros(mlvl_scores.shape[0], 1)
-            mlvl_scores = torch.cat([mlvl_scores, padding], dim=1)
-        # multi class NMS
-        det_bboxes, det_labels = multiclass_nms(mlvl_bboxes, mlvl_scores,
-                                                cfg.score_thr, cfg.nms,
-                                                cfg.max_per_img)
-        return det_bboxes, det_labels

spaces/CVPR/lama-example/bin/paper_runfiles/generate_test_ffhq.sh

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-
-# paths to data are valid for mml-ws01
-OUT_DIR="/media/inpainting/paper_data/FFHQ_val"
-
-source "$(dirname $0)/env.sh"
-
-for datadir in test
-do
-    for conf in random_thin_256 random_medium_256 random_thick_256 random_thin_512 random_medium_512 random_thick_512
-    do
-        "$BINDIR/gen_mask_dataset_hydra.py" -cn $conf datadir=$datadir location=mml-ws01-ffhq \
-         location.out_dir=$OUT_DIR cropping.out_square_crop=False
-
-        "$BINDIR/calc_dataset_stats.py" --samples-n 20 "$OUT_DIR/$datadir/$conf" "$OUT_DIR/$datadir/${conf}_stats"
-    done
-done

spaces/ClassCat/Medical-Image-Classification-with-MONAI/README.md

@@ -1,12 +0,0 @@
----
-title: Medical Image Classification With MONAI
-emoji: 🔥
-colorFrom: blue
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.16.1
-app_file: app.py
-pinned: True
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CofAI/chat.b4/client/css/buttons.css

@@ -1,4 +0,0 @@
-.buttons {
-	display: flex;
-	justify-content: left;
-}

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/qu2cu/benchmark.py

@@ -1,57 +0,0 @@
-"""Benchmark the qu2cu algorithm performance."""
-
-from .qu2cu import *
-from fontTools.cu2qu import curve_to_quadratic
-import random
-import timeit
-
-MAX_ERR = 0.5
-NUM_CURVES = 5
-
-
-def generate_curves(n):
-    points = [
-        tuple(float(random.randint(0, 2048)) for coord in range(2))
-        for point in range(1 + 3 * n)
-    ]
-    curves = []
-    for i in range(n):
-        curves.append(tuple(points[i * 3 : i * 3 + 4]))
-    return curves
-
-
-def setup_quadratic_to_curves():
-    curves = generate_curves(NUM_CURVES)
-    quadratics = [curve_to_quadratic(curve, MAX_ERR) for curve in curves]
-    return quadratics, MAX_ERR
-
-
-def run_benchmark(module, function, setup_suffix="", repeat=25, number=1):
-    setup_func = "setup_" + function
-    if setup_suffix:
-        print("%s with %s:" % (function, setup_suffix), end="")
-        setup_func += "_" + setup_suffix
-    else:
-        print("%s:" % function, end="")
-
-    def wrapper(function, setup_func):
-        function = globals()[function]
-        setup_func = globals()[setup_func]
-
-        def wrapped():
-            return function(*setup_func())
-
-        return wrapped
-
-    results = timeit.repeat(wrapper(function, setup_func), repeat=repeat, number=number)
-    print("\t%5.1fus" % (min(results) * 1000000.0 / number))
-
-
-def main():
-    """Benchmark the qu2cu algorithm performance."""
-    run_benchmark("qu2cu", "quadratic_to_curves")
-
-
-if __name__ == "__main__":
-    random.seed(1)
-    main()

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-097d3f80.js

@@ -1,2 +0,0 @@
-import{S as $,e as x,s as K,J,K as f,p as q,M as N,n as P,A as j,N as A,O as X,P as ie,k as U,T as fe,Z as Ue,U as he,o as M,Q as F,aj as Me,af as be,Y as Se,X as Ce,u as Q,v as p,y as Y,z as g,R as _e,x as S,a1 as Ee,B as de,a6 as Pe,aB as Re,F as y,h as ye,m as le,j as ze,t as Fe,a9 as Ae,ab as De,ac as Ie,ad as Oe,am as Xe,a7 as Le,ak as T,E as He,ae as Je,q as Ke,r as We}from"./index-1d65707a.js";import{n as ge}from"./ModifyUpload.svelte_svelte_type_style_lang-d2acacf0.js";import{B as Ge}from"./Button-f155035a.js";import{U as Qe}from"./Upload-9bb55fba.js";import{M as Ye}from"./ModifyUpload-c89cfce3.js";import{B as Be}from"./BlockLabel-66866176.js";import{U as Ze,W as $e}from"./StaticImage.svelte_svelte_type_style_lang-7eb5d885.js";import{I as xe}from"./IconButton-d42f3661.js";import{E as et}from"./Empty-eec13822.js";import{u as tt,S as lt}from"./ShareButton-8cd3d8f6.js";import{D as nt}from"./Download-daff1959.js";import{U as at}from"./UploadText-f599be03.js";import"./Blocks-c9e1499d.js";function it(n){let e,l;return{c(){e=J("svg"),l=J("path"),f(l,"d","M8 3H5a2 2 0 0 0-2 2v3m18 0V5a2 2 0 0 0-2-2h-3m0 18h3a2 2 0 0 0 2-2v-3M3 16v3a2 2 0 0 0 2 2h3"),f(e,"xmlns","http://www.w3.org/2000/svg"),f(e,"width","100%"),f(e,"height","100%"),f(e,"viewBox","0 0 24 24"),f(e,"fill","none"),f(e,"stroke","currentColor"),f(e,"stroke-width","1.5"),f(e,"stroke-linecap","round"),f(e,"stroke-linejoin","round")},m(t,a){q(t,e,a),N(e,l)},p:P,i:P,o:P,d(t){t&&j(e)}}}class rt extends ${constructor(e){super(),x(this,e,null,it,K,{})}}function ot(n){let e,l,t;return{c(){e=J("svg"),l=J("rect"),t=J("rect"),f(l,"x","6"),f(l,"y","4"),f(l,"width","4"),f(l,"height","16"),f(t,"x","14"),f(t,"y","4"),f(t,"width","4"),f(t,"height","16"),f(e,"xmlns","http://www.w3.org/2000/svg"),f(e,"width","100%"),f(e,"height","100%"),f(e,"viewBox","0 0 24 24"),f(e,"fill","none"),f(e,"stroke","currentColor"),f(e,"stroke-width","1.5"),f(e,"stroke-linecap","round"),f(e,"stroke-linejoin","round")},m(a,i){q(a,e,i),N(e,l),N(e,t)},p:P,i:P,o:P,d(a){a&&j(e)}}}class st extends ${constructor(e){super(),x(this,e,null,ot,K,{})}}function ut(n){let e,l;return{c(){e=J("svg"),l=J("polygon"),f(l,"points","5 3 19 12 5 21 5 3"),f(e,"xmlns","http://www.w3.org/2000/svg"),f(e,"width","100%"),f(e,"height","100%"),f(e,"viewBox","0 0 24 24"),f(e,"fill","none"),f(e,"stroke","currentColor"),f(e,"stroke-width","1.5"),f(e,"stroke-linecap","round"),f(e,"stroke-linejoin","round")},m(t,a){q(t,e,a),N(e,l)},p:P,i:P,o:P,d(t){t&&j(e)}}}class ft extends ${constructor(e){super(),x(this,e,null,ut,K,{})}}function ct(n){let e,l,t;return{c(){e=J("svg"),l=J("polygon"),t=J("rect"),f(l,"points","23 7 16 12 23 17 23 7"),f(t,"x","1"),f(t,"y","5"),f(t,"width","15"),f(t,"height","14"),f(t,"rx","2"),f(t,"ry","2"),f(e,"xmlns","http://www.w3.org/2000/svg"),f(e,"width","100%"),f(e,"height","100%"),f(e,"viewBox","0 0 24 24"),f(e,"fill","none"),f(e,"stroke","currentColor"),f(e,"stroke-width","1.5"),f(e,"stroke-linecap","round"),f(e,"stroke-linejoin","round"),f(e,"class","feather feather-video")},m(a,i){q(a,e,i),N(e,l),N(e,t)},p:P,i:P,o:P,d(a){a&&j(e)}}}class me extends ${constructor(e){super(),x(this,e,null,ct,K,{})}}const we=n=>{let e=["B","KB","MB","GB","PB"],l=0;for(;n>1024;)n/=1024,l++;let t=e[l];return n.toFixed(1)+" "+t},_t=()=>!0;function dt(n,{autoplay:e}){async function l(){e&&await n.play()}return n.addEventListener("loadeddata",l),{destroy(){n.removeEventListener("loadeddata",l)}}}const{isNaN:mt}=Pe;function ht(n){let e,l;return e=new st({}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function bt(n){let e,l;return e=new ft({}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function gt(n){let e,l;return e=new Ze({}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function wt(n){let e,l,t,a,i,s,b=!1,_,m=!0,r,u,o,d,E,B,V,I,w,D=ce(n[5])+"",L,W,O=ce(n[6])+"",H,k,C,h,te,ee,Z,z,ne,re;function oe(){cancelAnimationFrame(_),l.paused||(_=Re(oe),b=!0),n[15].call(l)}const se=[gt,bt,ht],G=[];function ue(v,R){return v[5]===v[6]?0:v[7]?1:2}return B=ue(n),V=G[B]=se[B](n),Z=new rt({}),{c(){e=A("div"),l=A("video"),t=A("track"),u=X(),o=A("div"),d=A("div"),E=A("span"),V.c(),I=X(),w=A("span"),L=ie(D),W=ie(" / "),H=ie(O),k=X(),C=A("progress"),te=X(),ee=A("div"),U(Z.$$.fragment),f(t,"kind","captions"),fe(t.src,a=n[1])||f(t,"src",a),t.default=!0,fe(l.src,i=n[0])||f(l,"src",i),f(l,"preload","auto"),f(l,"data-testid",s=`${n[4]}-player`),f(l,"class","svelte-1voqrms"),n[6]===void 0&&Ue(()=>n[16].call(l)),he(l,"mirror",n[2]),f(E,"class","icon svelte-1voqrms"),f(w,"class","time svelte-1voqrms"),C.value=h=n[5]/n[6]||0,f(C,"class","svelte-1voqrms"),f(ee,"class","icon svelte-1voqrms"),f(d,"class","inner svelte-1voqrms"),f(o,"class","controls svelte-1voqrms"),f(e,"class","wrap svelte-1voqrms")},m(v,R){q(v,e,R),N(e,l),N(l,t),n[18](l),N(e,u),N(e,o),N(o,d),N(d,E),G[B].m(E,null),N(d,I),N(d,w),N(w,L),N(w,W),N(w,H),N(d,k),N(d,C),N(d,te),N(d,ee),M(Z,ee,null),z=!0,ne||(re=[F(l,"click",n[10]),F(l,"play",n[13]),F(l,"pause",n[14]),F(l,"ended",n[12]),F(l,"timeupdate",oe),F(l,"durationchange",n[16]),F(l,"play",n[17]),F(l,"pause",n[17]),Me(r=dt.call(null,l,{autoplay:n[3]})),F(E,"click",n[10]),F(C,"mousemove",n[9]),F(C,"touchmove",be(n[9])),F(C,"click",Se(be(n[11]))),F(ee,"click",n[19])],ne=!0)},p(v,[R]){(!z||R&2&&!fe(t.src,a=v[1]))&&f(t,"src",a),(!z||R&1&&!fe(l.src,i=v[0]))&&f(l,"src",i),(!z||R&16&&s!==(s=`${v[4]}-player`))&&f(l,"data-testid",s),!b&&R&32&&!mt(v[5])&&(l.currentTime=v[5]),b=!1,R&128&&m!==(m=v[7])&&l[m?"pause":"play"](),r&&Ce(r.update)&&R&8&&r.update.call(null,{autoplay:v[3]}),(!z||R&4)&&he(l,"mirror",v[2]);let ae=B;B=ue(v),B!==ae&&(Q(),p(G[ae],1,1,()=>{G[ae]=null}),Y(),V=G[B],V||(V=G[B]=se[B](v),V.c()),g(V,1),V.m(E,null)),(!z||R&32)&&D!==(D=ce(v[5])+"")&&_e(L,D),(!z||R&64)&&O!==(O=ce(v[6])+"")&&_e(H,O),(!z||R&96&&h!==(h=v[5]/v[6]||0))&&(C.value=h)},i(v){z||(g(V),g(Z.$$.fragment,v),z=!0)},o(v){p(V),p(Z.$$.fragment,v),z=!1},d(v){v&&j(e),n[18](null),G[B].d(),S(Z),ne=!1,Ee(re)}}}function ce(n){if(isNaN(n)||!isFinite(n))return"...";const e=Math.floor(n/60);let l=Math.floor(n%60);return n<10&&(l=`0${l}`),`${e}:${l}`}function kt(n,e,l){let{src:t}=e,{subtitle:a=null}=e,{mirror:i}=e,{autoplay:s}=e,{label:b="test"}=e;const _=de();let m=0,r,u=!0,o;function d(k){if(!r)return;if(k.type==="click"){B(k);return}if(k.type!=="touchmove"&&!(k.buttons&1))return;const C=k.type==="touchmove"?k.touches[0].clientX:k.clientX,{left:h,right:te}=k.currentTarget.getBoundingClientRect();l(5,m=r*(C-h)/(te-h))}async function E(){document.fullscreenElement!=o&&(o.currentTime>0&&!o.paused&&!o.ended&&o.readyState>o.HAVE_CURRENT_DATA?o.pause():await o.play())}function B(k){const{left:C,right:h}=k.currentTarget.getBoundingClientRect();l(5,m=r*(k.clientX-C)/(h-C))}function V(){_("stop"),_("end")}function I(k){y.call(this,n,k)}function w(k){y.call(this,n,k)}function D(){m=this.currentTime,l(5,m)}function L(){r=this.duration,l(6,r)}function W(){u=this.paused,l(7,u)}function O(k){ye[k?"unshift":"push"](()=>{o=k,l(8,o)})}const H=()=>o.requestFullscreen();return n.$$set=k=>{"src"in k&&l(0,t=k.src),"subtitle"in k&&l(1,a=k.subtitle),"mirror"in k&&l(2,i=k.mirror),"autoplay"in k&&l(3,s=k.autoplay),"label"in k&&l(4,b=k.label)},[t,a,i,s,b,m,r,u,o,d,E,B,V,I,w,D,L,W,O,H]}class Ne extends ${constructor(e){super(),x(this,e,kt,wt,K,{src:0,subtitle:1,mirror:2,autoplay:3,label:4})}}function pt(n){let e,l,t,a,i,s,b;e=new Ye({}),e.$on("clear",n[11]);const _=[Bt,yt],m=[];function r(u,o){return t==null&&(t=!!_t()),t?0:u[0].size?1:-1}return~(a=r(n))&&(i=m[a]=_[a](n)),{c(){U(e.$$.fragment),l=X(),i&&i.c(),s=le()},m(u,o){M(e,u,o),q(u,l,o),~a&&m[a].m(u,o),q(u,s,o),b=!0},p(u,o){let d=a;a=r(u),a===d?~a&&m[a].p(u,o):(i&&(Q(),p(m[d],1,1,()=>{m[d]=null}),Y()),~a?(i=m[a],i?i.p(u,o):(i=m[a]=_[a](u),i.c()),g(i,1),i.m(s.parentNode,s)):i=null)},i(u){b||(g(e.$$.fragment,u),g(i),b=!0)},o(u){p(e.$$.fragment,u),p(i),b=!1},d(u){u&&(j(l),j(s)),S(e,u),~a&&m[a].d(u)}}}function vt(n){let e,l,t,a;const i=[Vt,Nt],s=[];function b(_,m){return _[2]==="upload"?0:_[2]==="webcam"?1:-1}return~(e=b(n))&&(l=s[e]=i[e](n)),{c(){l&&l.c(),t=le()},m(_,m){~e&&s[e].m(_,m),q(_,t,m),a=!0},p(_,m){let r=e;e=b(_),e===r?~e&&s[e].p(_,m):(l&&(Q(),p(s[r],1,1,()=>{s[r]=null}),Y()),~e?(l=s[e],l?l.p(_,m):(l=s[e]=i[e](_),l.c()),g(l,1),l.m(t.parentNode,t)):l=null)},i(_){a||(g(l),a=!0)},o(_){p(l),a=!1},d(_){_&&j(t),~e&&s[e].d(_)}}}function yt(n){let e,l=n[0].name+"",t,a,i,s=we(n[0].size)+"",b;return{c(){e=A("div"),t=ie(l),a=X(),i=A("div"),b=ie(s),f(e,"class","file-name svelte-a6ruol"),f(i,"class","file-size svelte-a6ruol")},m(_,m){q(_,e,m),N(e,t),q(_,a,m),q(_,i,m),N(i,b)},p(_,m){m&1&&l!==(l=_[0].name+"")&&_e(t,l),m&1&&s!==(s=we(_[0].size)+"")&&_e(b,s)},i:P,o:P,d(_){_&&(j(e),j(a),j(i))}}}function Bt(n){let e=n[0]?.data,l,t,a=ke(n);return{c(){a.c(),l=le()},m(i,s){a.m(i,s),q(i,l,s),t=!0},p(i,s){s&1&&K(e,e=i[0]?.data)?(Q(),p(a,1,1,P),Y(),a=ke(i),a.c(),g(a,1),a.m(l.parentNode,l)):a.p(i,s)},i(i){t||(g(a),t=!0)},o(i){p(a),t=!1},d(i){i&&j(l),a.d(i)}}}function ke(n){let e,l;return e=new Ne({props:{autoplay:n[7],src:n[0].data,subtitle:n[1]?.data,mirror:n[5]&&n[2]==="webcam",label:n[3]}}),e.$on("play",n[18]),e.$on("pause",n[19]),e.$on("stop",n[20]),e.$on("end",n[21]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a&128&&(i.autoplay=t[7]),a&1&&(i.src=t[0].data),a&2&&(i.subtitle=t[1]?.data),a&36&&(i.mirror=t[5]&&t[2]==="webcam"),a&8&&(i.label=t[3]),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Nt(n){let e,l;return e=new $e({props:{mirror_webcam:n[5],include_audio:n[6],mode:"video"}}),e.$on("error",n[14]),e.$on("capture",n[15]),e.$on("start_recording",n[16]),e.$on("stop_recording",n[17]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a&32&&(i.mirror_webcam=t[5]),a&64&&(i.include_audio=t[6]),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Vt(n){let e,l,t;function a(s){n[13](s)}let i={filetype:"video/x-m4v,video/*",$$slots:{default:[Tt]},$$scope:{ctx:n}};return n[8]!==void 0&&(i.dragging=n[8]),e=new Qe({props:i}),ye.push(()=>ze(e,"dragging",a)),e.$on("load",n[10]),{c(){U(e.$$.fragment)},m(s,b){M(e,s,b),t=!0},p(s,b){const _={};b&4194304&&(_.$$scope={dirty:b,ctx:s}),!l&&b&256&&(l=!0,_.dragging=s[8],Fe(()=>l=!1)),e.$set(_)},i(s){t||(g(e.$$.fragment,s),t=!0)},o(s){p(e.$$.fragment,s),t=!1},d(s){S(e,s)}}}function Tt(n){let e;const l=n[12].default,t=Ae(l,n,n[22],null);return{c(){t&&t.c()},m(a,i){t&&t.m(a,i),e=!0},p(a,i){t&&t.p&&(!e||i&4194304)&&De(t,l,a,a[22],e?Oe(l,a[22],i,null):Ie(a[22]),null)},i(a){e||(g(t,a),e=!0)},o(a){p(t,a),e=!1},d(a){t&&t.d(a)}}}function qt(n){let e,l,t,a,i,s;e=new Be({props:{show_label:n[4],Icon:me,label:n[3]||"Video"}});const b=[vt,pt],_=[];function m(r,u){return r[0]===null?0:1}return t=m(n),a=_[t]=b[t](n),{c(){U(e.$$.fragment),l=X(),a.c(),i=le()},m(r,u){M(e,r,u),q(r,l,u),_[t].m(r,u),q(r,i,u),s=!0},p(r,[u]){const o={};u&16&&(o.show_label=r[4]),u&8&&(o.label=r[3]||"Video"),e.$set(o);let d=t;t=m(r),t===d?_[t].p(r,u):(Q(),p(_[d],1,1,()=>{_[d]=null}),Y(),a=_[t],a?a.p(r,u):(a=_[t]=b[t](r),a.c()),g(a,1),a.m(i.parentNode,i))},i(r){s||(g(e.$$.fragment,r),g(a),s=!0)},o(r){p(e.$$.fragment,r),p(a),s=!1},d(r){r&&(j(l),j(i)),S(e,r),_[t].d(r)}}}function jt(n,e,l){let{$$slots:t={},$$scope:a}=e,{value:i=null}=e,{subtitle:s=null}=e,{source:b}=e,{label:_=void 0}=e,{show_label:m=!0}=e,{mirror_webcam:r=!1}=e,{include_audio:u}=e,{autoplay:o}=e;const d=de();function E({detail:h}){d("change",h),d("upload",h),l(0,i=h)}function B({detail:h}){l(0,i=null),d("change",h),d("clear")}let V=!1;function I(h){V=h,l(8,V)}function w(h){y.call(this,n,h)}const D=({detail:h})=>d("change",h);function L(h){y.call(this,n,h)}function W(h){y.call(this,n,h)}function O(h){y.call(this,n,h)}function H(h){y.call(this,n,h)}function k(h){y.call(this,n,h)}function C(h){y.call(this,n,h)}return n.$$set=h=>{"value"in h&&l(0,i=h.value),"subtitle"in h&&l(1,s=h.subtitle),"source"in h&&l(2,b=h.source),"label"in h&&l(3,_=h.label),"show_label"in h&&l(4,m=h.show_label),"mirror_webcam"in h&&l(5,r=h.mirror_webcam),"include_audio"in h&&l(6,u=h.include_audio),"autoplay"in h&&l(7,o=h.autoplay),"$$scope"in h&&l(22,a=h.$$scope)},n.$$.update=()=>{n.$$.dirty&256&&d("drag",V)},[i,s,b,_,m,r,u,o,V,d,E,B,t,I,w,D,L,W,O,H,k,C,a]}let Ut=class extends ${constructor(e){super(),x(this,e,jt,qt,K,{value:0,subtitle:1,source:2,label:3,show_label:4,mirror_webcam:5,include_audio:6,autoplay:7})}};function Mt(n){let e=n[0].data,l,t,a,i,s,b,_,m,r=pe(n);i=new xe({props:{Icon:nt,label:"Download"}});let u=n[5]&&ve(n);return{c(){r.c(),l=X(),t=A("div"),a=A("a"),U(i.$$.fragment),_=X(),u&&u.c(),f(a,"href",s=n[0].data),f(a,"target",window.__is_colab__?"_blank":null),f(a,"download",b=n[0].orig_name||n[0].name),f(t,"class","icon-buttons svelte-rvdo70"),f(t,"data-testid","download-div")},m(o,d){r.m(o,d),q(o,l,d),q(o,t,d),N(t,a),M(i,a,null),N(t,_),u&&u.m(t,null),m=!0},p(o,d){d&1&&K(e,e=o[0].data)?(Q(),p(r,1,1,P),Y(),r=pe(o),r.c(),g(r,1),r.m(l.parentNode,l)):r.p(o,d),(!m||d&1&&s!==(s=o[0].data))&&f(a,"href",s),(!m||d&1&&b!==(b=o[0].orig_name||o[0].name))&&f(a,"download",b),o[5]?u?(u.p(o,d),d&32&&g(u,1)):(u=ve(o),u.c(),g(u,1),u.m(t,null)):u&&(Q(),p(u,1,1,()=>{u=null}),Y())},i(o){m||(g(r),g(i.$$.fragment,o),g(u),m=!0)},o(o){p(r),p(i.$$.fragment,o),p(u),m=!1},d(o){o&&(j(l),j(t)),r.d(o),S(i),u&&u.d()}}}function St(n){let e,l;return e=new et({props:{unpadded_box:!0,size:"large",$$slots:{default:[Ct]},$$scope:{ctx:n}}}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a&32768&&(i.$$scope={dirty:a,ctx:t}),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function pe(n){let e,l;return e=new Ne({props:{src:n[0].data,subtitle:n[1]?.data,autoplay:n[4],mirror:!1,label:n[2]}}),e.$on("play",n[6]),e.$on("pause",n[7]),e.$on("ended",n[8]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a&1&&(i.src=t[0].data),a&2&&(i.subtitle=t[1]?.data),a&16&&(i.autoplay=t[4]),a&4&&(i.label=t[2]),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function ve(n){let e,l;return e=new lt({props:{value:n[0],formatter:n[9]}}),e.$on("error",n[10]),e.$on("share",n[11]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a&1&&(i.value=t[0]),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Ct(n){let e,l;return e=new me({}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Et(n){let e,l,t,a,i,s;e=new Be({props:{show_label:n[3],Icon:me,label:n[2]||"Video"}});const b=[St,Mt],_=[];function m(r,u){return r[0]===null?0:1}return t=m(n),a=_[t]=b[t](n),{c(){U(e.$$.fragment),l=X(),a.c(),i=le()},m(r,u){M(e,r,u),q(r,l,u),_[t].m(r,u),q(r,i,u),s=!0},p(r,[u]){const o={};u&8&&(o.show_label=r[3]),u&4&&(o.label=r[2]||"Video"),e.$set(o);let d=t;t=m(r),t===d?_[t].p(r,u):(Q(),p(_[d],1,1,()=>{_[d]=null}),Y(),a=_[t],a?a.p(r,u):(a=_[t]=b[t](r),a.c()),g(a,1),a.m(i.parentNode,i))},i(r){s||(g(e.$$.fragment,r),g(a),s=!0)},o(r){p(e.$$.fragment,r),p(a),s=!1},d(r){r&&(j(l),j(i)),S(e,r),_[t].d(r)}}}function Pt(n,e,l){let{value:t=null}=e,{subtitle:a=null}=e,{label:i=void 0}=e,{show_label:s=!0}=e,{autoplay:b}=e,{show_share_button:_=!0}=e,m=null,r=null;const u=de();Xe(async()=>{t!==m&&a!==r&&r!==null&&(m=t,l(0,t=null),await Le(),l(0,t=m)),m=t,r=a});function o(w){y.call(this,n,w)}function d(w){y.call(this,n,w)}function E(w){y.call(this,n,w)}const B=async w=>w?await tt(w.data,"url"):"";function V(w){y.call(this,n,w)}function I(w){y.call(this,n,w)}return n.$$set=w=>{"value"in w&&l(0,t=w.value),"subtitle"in w&&l(1,a=w.subtitle),"label"in w&&l(2,i=w.label),"show_label"in w&&l(3,s=w.show_label),"autoplay"in w&&l(4,b=w.autoplay),"show_share_button"in w&&l(5,_=w.show_share_button)},n.$$.update=()=>{n.$$.dirty&1&&t&&u("change",t)},[t,a,i,s,b,_,o,d,E,B,V,I]}class Rt extends ${constructor(e){super(),x(this,e,Pt,Et,K,{value:0,subtitle:1,label:2,show_label:3,autoplay:4,show_share_button:5})}}function zt(n){let e,l;return e=new Ut({props:{value:n[18],subtitle:n[19],label:n[5],show_label:n[7],source:n[6],mirror_webcam:n[10],include_audio:n[11],autoplay:n[16],$$slots:{default:[At]},$$scope:{ctx:n}}}),e.$on("change",n[21]),e.$on("drag",n[30]),e.$on("error",n[31]),e.$on("clear",n[32]),e.$on("play",n[33]),e.$on("pause",n[34]),e.$on("upload",n[35]),e.$on("stop",n[36]),e.$on("end",n[37]),e.$on("start_recording",n[38]),e.$on("stop_recording",n[39]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a[0]&262144&&(i.value=t[18]),a[0]&524288&&(i.subtitle=t[19]),a[0]&32&&(i.label=t[5]),a[0]&128&&(i.show_label=t[7]),a[0]&64&&(i.source=t[6]),a[0]&1024&&(i.mirror_webcam=t[10]),a[0]&2048&&(i.include_audio=t[11]),a[0]&65536&&(i.autoplay=t[16]),a[1]&1024&&(i.$$scope={dirty:a,ctx:t}),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Ft(n){let e,l;return e=new Rt({props:{value:n[18],subtitle:n[19],label:n[5],show_label:n[7],autoplay:n[16],show_share_button:n[17]}}),e.$on("play",n[25]),e.$on("pause",n[26]),e.$on("stop",n[27]),e.$on("share",n[28]),e.$on("error",n[29]),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a[0]&262144&&(i.value=t[18]),a[0]&524288&&(i.subtitle=t[19]),a[0]&32&&(i.label=t[5]),a[0]&128&&(i.show_label=t[7]),a[0]&65536&&(i.autoplay=t[16]),a[0]&131072&&(i.show_share_button=t[17]),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function At(n){let e,l;return e=new at({props:{type:"video"}}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p:P,i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Dt(n){let e,l,t,a,i,s;const b=[n[1]];let _={};for(let o=0;o<b.length;o+=1)_=He(_,b[o]);e=new Je({props:_});const m=[Ft,zt],r=[];function u(o,d){return o[15]==="static"?0:1}return t=u(n),a=r[t]=m[t](n),{c(){U(e.$$.fragment),l=X(),a.c(),i=le()},m(o,d){M(e,o,d),q(o,l,d),r[t].m(o,d),q(o,i,d),s=!0},p(o,d){const E=d[0]&2?Ke(b,[We(o[1])]):{};e.$set(E);let B=t;t=u(o),t===B?r[t].p(o,d):(Q(),p(r[B],1,1,()=>{r[B]=null}),Y(),a=r[t],a?a.p(o,d):(a=r[t]=m[t](o),a.c()),g(a,1),a.m(i.parentNode,i))},i(o){s||(g(e.$$.fragment,o),g(a),s=!0)},o(o){p(e.$$.fragment,o),p(a),s=!1},d(o){o&&(j(l),j(i)),S(e,o),r[t].d(o)}}}function It(n){let e,l;return e=new Ge({props:{visible:n[4],variant:n[15]==="dynamic"&&n[0]===null&&n[6]==="upload"?"dashed":"solid",border_mode:n[20]?"focus":"base",padding:!1,elem_id:n[2],elem_classes:n[3],height:n[8],width:n[9],container:n[12],scale:n[13],min_width:n[14],allow_overflow:!1,$$slots:{default:[Dt]},$$scope:{ctx:n}}}),{c(){U(e.$$.fragment)},m(t,a){M(e,t,a),l=!0},p(t,a){const i={};a[0]&16&&(i.visible=t[4]),a[0]&32833&&(i.variant=t[15]==="dynamic"&&t[0]===null&&t[6]==="upload"?"dashed":"solid"),a[0]&1048576&&(i.border_mode=t[20]?"focus":"base"),a[0]&4&&(i.elem_id=t[2]),a[0]&8&&(i.elem_classes=t[3]),a[0]&256&&(i.height=t[8]),a[0]&512&&(i.width=t[9]),a[0]&4096&&(i.container=t[12]),a[0]&8192&&(i.scale=t[13]),a[0]&16384&&(i.min_width=t[14]),a[0]&2067682|a[1]&1024&&(i.$$scope={dirty:a,ctx:t}),e.$set(i)},i(t){l||(g(e.$$.fragment,t),l=!0)},o(t){p(e.$$.fragment,t),l=!1},d(t){S(e,t)}}}function Ot(n,e,l){let{elem_id:t=""}=e,{elem_classes:a=[]}=e,{visible:i=!0}=e,{value:s=null}=e,b=null,{label:_}=e,{source:m}=e,{root:r}=e,{root_url:u}=e,{show_label:o}=e,{loading_status:d}=e,{height:E}=e,{width:B}=e,{mirror_webcam:V}=e,{include_audio:I}=e,{container:w=!1}=e,{scale:D=null}=e,{min_width:L=void 0}=e,{mode:W}=e,{autoplay:O=!1}=e,{show_share_button:H=!0}=e,k=null,C=null,h=!1;const te=de();function ee({detail:c}){c!=null?l(0,s=[c,null]):l(0,s=null)}function Z(c){y.call(this,n,c)}function z(c){y.call(this,n,c)}function ne(c){y.call(this,n,c)}function re(c){y.call(this,n,c)}function oe(c){y.call(this,n,c)}const se=({detail:c})=>l(20,h=c),G=({detail:c})=>{l(1,d=d||{}),l(1,d.status="error",d),l(1,d.message=c,d)};function ue(c){y.call(this,n,c)}function v(c){y.call(this,n,c)}function R(c){y.call(this,n,c)}function ae(c){y.call(this,n,c)}function Ve(c){y.call(this,n,c)}function Te(c){y.call(this,n,c)}function qe(c){y.call(this,n,c)}function je(c){y.call(this,n,c)}return n.$$set=c=>{"elem_id"in c&&l(2,t=c.elem_id),"elem_classes"in c&&l(3,a=c.elem_classes),"visible"in c&&l(4,i=c.visible),"value"in c&&l(0,s=c.value),"label"in c&&l(5,_=c.label),"source"in c&&l(6,m=c.source),"root"in c&&l(22,r=c.root),"root_url"in c&&l(23,u=c.root_url),"show_label"in c&&l(7,o=c.show_label),"loading_status"in c&&l(1,d=c.loading_status),"height"in c&&l(8,E=c.height),"width"in c&&l(9,B=c.width),"mirror_webcam"in c&&l(10,V=c.mirror_webcam),"include_audio"in c&&l(11,I=c.include_audio),"container"in c&&l(12,w=c.container),"scale"in c&&l(13,D=c.scale),"min_width"in c&&l(14,L=c.min_width),"mode"in c&&l(15,W=c.mode),"autoplay"in c&&l(16,O=c.autoplay),"show_share_button"in c&&l(17,H=c.show_share_button)},n.$$.update=()=>{n.$$.dirty[0]&12582913&&(s!=null?(l(18,k=ge(s[0],r,u)),l(19,C=ge(s[1],r,u))):(l(18,k=null),l(19,C=null))),n.$$.dirty[0]&16777217&&JSON.stringify(s)!==JSON.stringify(b)&&(l(24,b=s),te("change"))},[s,d,t,a,i,_,m,o,E,B,V,I,w,D,L,W,O,H,k,C,h,ee,r,u,b,Z,z,ne,re,oe,se,G,ue,v,R,ae,Ve,Te,qe,je]}class Xt extends ${constructor(e){super(),x(this,e,Ot,It,K,{elem_id:2,elem_classes:3,visible:4,value:0,label:5,source:6,root:22,root_url:23,show_label:7,loading_status:1,height:8,width:9,mirror_webcam:10,include_audio:11,container:12,scale:13,min_width:14,mode:15,autoplay:16,show_share_button:17},null,[-1,-1])}get elem_id(){return this.$$.ctx[2]}set elem_id(e){this.$$set({elem_id:e}),T()}get elem_classes(){return this.$$.ctx[3]}set elem_classes(e){this.$$set({elem_classes:e}),T()}get visible(){return this.$$.ctx[4]}set visible(e){this.$$set({visible:e}),T()}get value(){return this.$$.ctx[0]}set value(e){this.$$set({value:e}),T()}get label(){return this.$$.ctx[5]}set label(e){this.$$set({label:e}),T()}get source(){return this.$$.ctx[6]}set source(e){this.$$set({source:e}),T()}get root(){return this.$$.ctx[22]}set root(e){this.$$set({root:e}),T()}get root_url(){return this.$$.ctx[23]}set root_url(e){this.$$set({root_url:e}),T()}get show_label(){return this.$$.ctx[7]}set show_label(e){this.$$set({show_label:e}),T()}get loading_status(){return this.$$.ctx[1]}set loading_status(e){this.$$set({loading_status:e}),T()}get height(){return this.$$.ctx[8]}set height(e){this.$$set({height:e}),T()}get width(){return this.$$.ctx[9]}set width(e){this.$$set({width:e}),T()}get mirror_webcam(){return this.$$.ctx[10]}set mirror_webcam(e){this.$$set({mirror_webcam:e}),T()}get include_audio(){return this.$$.ctx[11]}set include_audio(e){this.$$set({include_audio:e}),T()}get container(){return this.$$.ctx[12]}set container(e){this.$$set({container:e}),T()}get scale(){return this.$$.ctx[13]}set scale(e){this.$$set({scale:e}),T()}get min_width(){return this.$$.ctx[14]}set min_width(e){this.$$set({min_width:e}),T()}get mode(){return this.$$.ctx[15]}set mode(e){this.$$set({mode:e}),T()}get autoplay(){return this.$$.ctx[16]}set autoplay(e){this.$$set({autoplay:e}),T()}get show_share_button(){return this.$$.ctx[17]}set show_share_button(e){this.$$set({show_share_button:e}),T()}}const nl=Xt,al=["static","dynamic"],il=n=>({type:{input_payload:"{ name: string; data: string }",response_object:"{ name: string; data: string, is_file: boolean }"},description:{input_payload:"object with file name and base64 data",response_object:"object that includes path to video file. The URL: {ROOT}file={name} contains the data"}});export{nl as Component,il as document,al as modes};
-//# sourceMappingURL=index-097d3f80.js.map