Update parquet files (step 11 of 296)

spaces/1acneusushi/gradio-2dmoleculeeditor/data/Download and Install Guitar Rig 5 for Free A Step-by-Step Tutorial.md

@@ -1,61 +0,0 @@
-
-<h1>Guitar Rig 5 Full Download: How to Get It for Free</h1>
-<p>If you are a guitarist who wants to create and experiment with different tones and effects on your computer, you may have heard of Guitar Rig 5. Guitar Rig 5 is a software solution that simulates various amps, cabinets, pedals, and microphones, and lets you mix and match them to create your own custom sound. Guitar Rig 5 can also be used as a standalone application or as a plugin in your DAW.</p>
-<h2>guitar rig 5 full download</h2><br /><p><b><b>Download File</b> &#128279; <a href="https://byltly.com/2uKx7R">https://byltly.com/2uKx7R</a></b></p><br /><br />
-<p>But how can you get Guitar Rig 5 full download for free? Is it even possible? In this article, we will answer these questions and show you how to download and install Guitar Rig 5 for free on your PC.</p>
-<h2>What is Guitar Rig 5?</h2>
-<p>Guitar Rig 5 is a product of Native Instruments, a leading manufacturer of software and hardware for music production and DJing. Guitar Rig 5 was released in 2011 as the successor of Guitar Rig 4, and it has many new features and improvements, such as:</p>
-<ul>
-<li>Two new high-gain amps: Van 51 and Hot Solo+</li>
-<li>Six new effects: Resochord, Vintage Compressor, Skreamer, Limiter, Stereo Tune, and Container</li>
-<li>19 additional cabinets in the all-new Control Room Pro</li>
-<li>A new sidechaining feature that allows you to modulate any parameter with any input signal</li>
-<li>A new container module that lets you create multi-effects chains with drag-and-drop</li>
-<li>A redesigned user interface with improved graphics and workflow</li>
-<li>A new preset browser with tags and ratings</li>
-<li>A new tape deck module that lets you record and play back your performance</li>
-<li>A new metronome module that helps you keep time</li>
-<li>A new tuner module that helps you tune your guitar</li>
-</ul>
-<p>Guitar Rig 5 is suitable for guitarists of any genre and skill level who want to explore the possibilities of digital sound processing. It can also be used for other instruments such as bass, keyboards, vocals, drums, etc. It can run on any PC that meets the minimum system requirements:</p>
-<ul>
-<li>Windows 7 or later (64-bit)</li>
-<li>Intel Core 2 Duo or AMD Athlon 64 X2 processor</li>
-<li>4 GB RAM or more</li>
-<li>1 GB free disk space or more</li>
-<li>An ASIO compatible sound card</li>
-<li>A MIDI controller (optional)</li>
-</ul>
-
-<h2>How to Download Guitar Rig 5 Full Version for Free?</h2>
-
-<p>To download Guitar Rig 5 full version for free, you need to have an account on the Native Instruments website. If you don't have one, you can create one for free by following these steps:</p>
-
-<ol>
-
-<li>Go to <a href="https://www.native-instruments.com/en/my-account/create-account/">https://www.native-instruments.com/en/my-account/create-account/</a> on your web browser.</li>
-
-<li>Fill in your personal details and choose a password.</li>
-
-<li>Check the box to agree to the terms and conditions and click Create Account.</li>
-
-<li>You will receive a confirmation email with a link to activate your account. Click on the link to complete the registration.</li>
-
-</ol>
-
-<p>Once you have an account on the Native Instruments website, you can download Guitar Rig 5 full version for free by following these steps:</p>
-
-<ol>
-
-<li>Go to <a href="https://www.native-instruments.com/en/specials/download-free-software-and-demo-versions/">https://www.native-instruments.com/en/specials/download-free-software-and-demo-versions/</a> on your web browser.</li>
-
-<li>Scroll down to the section where it says GUITAR RIG 6 PRO and click on DOWNLOAD MORE INFO.</li>
-
-<li>You will be redirected to the product page of Guitar Rig 6 Pro. Scroll down to the section where it says TRY IT FREE FOR 30 DAYS and click on DOWNLOAD DEMO.</li>
-
-<li>You will be asked to log in with your Native Instruments account. Enter your email and password and click Log In.</li>
-
-<li>You will be taken to the download page of Guitar Rig 6 Pro. Click on DOWNLOAD</p>
-<p></p> ddb901b051<br />
-<br />
-<br />

spaces/1gistliPinn/ChatGPT4/Examples/Chillar Party Full Movie In Hindi Dubbed Free Download Hd [EXCLUSIVE].md

@@ -1,6 +0,0 @@
-<h2>Chillar Party Full Movie In Hindi Dubbed Free Download Hd</h2><br /><p><b><b>Download File</b> &#10004; <a href="https://imgfil.com/2uy0zJ">https://imgfil.com/2uy0zJ</a></b></p><br /><br />
-
- aaccfb2cb3<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Contabilidad Intermedia De Juan Funes Orellana Pdf 181.md

@@ -1,80 +0,0 @@
-<h2>Contabilidad Intermedia De Juan Funes Orellana Pdf 181</h2><br /><p><b><b>Download File</b> &#10001; <a href="https://imgfil.com/2uxYeC">https://imgfil.com/2uxYeC</a></b></p><br /><br />
-
-,746 6.
-
-Pero si pensamos en una sola serie de promedios,
-
-tendremos que esperar
-
-solo un poco más de 10.000 años.
-
-En efecto, la serie de promedios
-
-de las pruebas de capacidad de Juan,
-
-tras su procesamiento,
-
-es solo de 19.737.
-
-¿Ya pueden imaginarse que es
-
-una gran cifra, una cifra pequeña,
-
-pero, desde luego, una gran cifra
-
-para una serie de promedios.
-
-Es decir, tanto hoy como
-
-cincuenta años atrás,
-
-French: 
-
-Et je vais prouver que la fonction d'étalonnage
-
-joue un rôle crucial dans le succès des prévisions.
-
-Nous savons que c'est une prédiction
-
-fondée sur l'étalonnage, la fonction d'étalonnage.
-
-Qu'est-ce que cela signifie?
-
-Eh bien, il n'y a qu'une forme
-
-d'étalonnage qui a été étudiée avec rigueur.
-
-Et il est possible de l'étudier parce que
-
-j'ai fait l'expérience d'étalonner
-
-une famille d'organismes.
-
-Je fais du bétail ou du porc.
-
-J'ai essayé d'étalonner
-
-le succès des vins.
-
-J'étais professeur, et il y avait des étudiants.
-
-Et je leur ai demandé de mesurer
-
-la fonction d'étalonnage de la vigne.
-
-Et ils ont réalisé de grosses études.
-
-Ils ont mesuré
-
-Mais pourquoi?
-
-Portuguese: 
-
-E eu vou provar que a função
-
-de calibragem, que todos nós
-
-conhece 4fefd39f24<br />
-<br />
-<br />
-<p></p>

spaces/1gistliPinn/ChatGPT4/Examples/Euro Truck Simulator 2 Going East Dlc Activation Code.md

@@ -1,6 +0,0 @@
-<h2>euro truck simulator 2 going east dlc activation code</h2><br /><p><b><b>Download</b> &#128279; <a href="https://imgfil.com/2uxZLZ">https://imgfil.com/2uxZLZ</a></b></p><br /><br />
-
-Brought to you by Steam Labs. Filter reviews by the user's playtime when the review was written:. Going East Download. No minimum to No maximum. Off-topic ... 1fdad05405<br />
-<br />
-<br />
-<p></p>

spaces/1phancelerku/anime-remove-background/Download Temple Run for Android in Browser No Play Store Needed.md

@@ -1,126 +0,0 @@
-<br />
-<h1>How to Download Temple Run Without Play Store</h1>
-<p>Temple Run is one of the most popular and addictive games on Android. It is an endless runner game where you have to escape from a horde of evil monkeys while avoiding obstacles and collecting coins. But what if you want to download Temple Run without Play Store? Maybe you don't have access to the Play Store, or you want to try a different version of the game, or you just want to have more control over your app installation. Whatever your reason, there is a way to download Temple Run without Play Store, and it's not too difficult. In this article, we will show you how to do it step by step.</p>
- <h2>What is Temple Run and Why You Might Want to Download It</h2>
-<h3>Temple Run is a popular endless runner game</h3>
-<p>Temple Run was released in 2011 by Imangi Studios and quickly became a hit among mobile gamers. The game has been downloaded over a billion times and has spawned several sequels and spin-offs. The gameplay is simple but addictive: you control a treasure hunter who has stolen a cursed idol from a temple and must run for his life while being chased by angry monkeys. Along the way, you have to swipe, tilt, and tap your device to turn, jump, slide, and use power-ups. The game features stunning graphics, smooth animations, and catchy sound effects that make you feel like you are in an adventure movie.</p>
-<h2>download temple run without play store</h2><br /><p><b><b>DOWNLOAD</b> &mdash; <a href="https://jinyurl.com/2uNQK8">https://jinyurl.com/2uNQK8</a></b></p><br /><br />
- <h3>You might want to download it without Play Store for various reasons</h3>
-<p>While Temple Run is available for free on the Google Play Store, there are some reasons why you might want to download it without using the Play Store. For example:</p>
-<ul>
-<li>You don't have access to the Play Store because of your location, device, or network restrictions.</li>
-<li>You want to try an older or newer version of the game that is not available on the Play Store.</li>
-<li>You want to avoid ads or in-app purchases that are present in the Play Store version.</li>
-<li>You want to have more control over your app installation and updates.</li>
-<li>You want to backup or share the APK file with others.</li>
-</ul>
-<p>Whatever your reason, downloading Temple Run without Play Store is possible and safe if you follow the right steps.</p>
- <h2>How to Download APK Files from the Web</h2>
-<h3>APK files are the packages for Android apps</h3>
-<p>The first step to download Temple Run without Play Store is to get the APK file of the game. APK stands for Android Package Kit, and it is the file format that Android uses to distribute and install apps. An APK file contains all the code, resources, and metadata that an app needs to run on your device. When you download an app from the Play Store, you are actually downloading an APK file that is then installed on your device. But you can also download APK files from other sources on the web.</p>
- <h3>You can use a web tool or an APK extractor app to get APK files from Google Play URLs</h3>
-<p>There are two main ways to get APK files from Google Play URLs. One way is to use a web tool that generates download links for APK files by pasting Google Play URLs. There are many websites that offer this service, such as APKPure, APKMirror, APKCombo, and Evozi. These websites are usually safe and reliable, but you should always check the ratings, reviews, and permissions of the apps before downloading them. Another way is to use an APK extractor app that can extract APK files from any app installed on your device. There are many apps that can do this, such as APK Extractor, ML Manager, and App Backup & Restore. These apps are useful if you want to backup or share the APK files of the apps you already have on your device.</p>
- <h3>You need to allow unknown apps on your device before installing APK files</h3>
-<p>Before you can install APK files on your device, you need to enable the option to allow unknown apps on your device. Unknown apps are apps that are not from the Play Store or other trusted sources. By default, Android blocks the installation of unknown apps for security reasons. However, you can change this setting by following these steps:</p>
-<ol>
-<li>Go to Settings > Apps & notifications > Advanced > Special app access > Install unknown apps.</li>
-<li>Select the app that you want to use to install APK files, such as your browser or file manager.</li>
-<li>Toggle on the option to Allow from this source.</li>
-</ol>
-<p>Alternatively, you can also enable this option when you try to install an APK file for the first time. You will see a pop-up asking you to allow unknown apps from that source. Tap on Settings and then toggle on the option to Allow from this source.</p>
-<p>How to download temple run on PC without play store<br />
-Temple run apk download for android without play store<br />
-Play temple run online for free in browser without downloading<br />
-Temple run game download for mobile without play store<br />
-Download temple run 2 without play store<br />
-Temple run mod apk download without play store<br />
-Download temple run oz without play store<br />
-Temple run free download for laptop without play store<br />
-Download temple run brave without play store<br />
-Play temple run 2 online for free without downloading<br />
-Download temple run for windows 10 without play store<br />
-Temple run download for iphone without app store<br />
-Download temple run for java phone without play store<br />
-Temple run game download for pc offline without play store<br />
-Download temple run 3 without play store<br />
-Temple run game download for tablet without play store<br />
-Download temple run for mac without play store<br />
-Temple run game download for jio phone without play store<br />
-Download temple run for nokia lumia without play store<br />
-Play temple run online unblocked without downloading<br />
-Download temple run for samsung galaxy without play store<br />
-Temple run game download for blackberry without play store<br />
-Download temple run for fire tablet without play store<br />
-Temple run game download for windows phone without play store<br />
-Download temple run for chromebook without play store<br />
-Temple run game download for kindle fire without play store<br />
-Download temple run for ios without app store<br />
-Temple run game download for android tv without play store<br />
-Download temple run for linux without play store<br />
-Temple run game download for smartwatch without play store<br />
-Download temple run hacked version without play store<br />
-Temple run game download for mi tv without play store<br />
-Download temple run old version without play store<br />
-Temple run game download for ps4 without play store<br />
-Download temple run unlimited coins and gems without play store<br />
-Temple run game download for xbox one without play store<br />
-Download temple run frozen shadows without play store<br />
-Temple run game download for nintendo switch without play store<br />
-Download temple run bluestacks edition without play store<br />
-Temple run game download for vr headset without play store</p>
- <h2>How to Install APK Files on Your Android Device</h2>
-<h3>You can use a file manager app or an APK installer app to locate and install APK files</h3>
-<p>Once you have downloaded the APK file of Temple Run, you need to locate and install it on your device. You can use a file manager app or an APK installer app to do this. A file manager app is an app that lets you browse and manage the files and folders on your device. You can use any file manager app that you have on your device, such as Files by Google, ES File Explorer, or Solid Explorer. An APK installer app is an app that simplifies the process of installing APK files by scanning your device for them and showing them in a list. You can use any APK installer app that you like, such as Installer, Easy Installer, or SAI (Split APKs Installer). Here are the steps to install APK files using either method:</p>
-<ul>
-<li>Open the file manager or APK installer app and navigate to the folder where you downloaded or extracted the APK file of Temple Run.</li>
-<li>Tap on the APK file and then tap on Install.</li>
-<li>Wait for the installation to complete and then tap on Open to launch the game.</li>
-</ul>
- <h3>You may need to accept some permissions or pop-ups before installing the file</h3>
-<p>Depending on your device and Android version, you may need to accept some permissions or pop-ups before installing the APK file of Temple Run. For example:</p>
-<ul>
-<li>You may see a warning message saying that installing unknown apps can harm your device. Tap on Install anyway (unsafe) to proceed.</li>
-<li>You may see a pop-up asking you to confirm the installation of Temple Run. Tap on Install to continue.</li>
-<li>You may see a list of permissions that Temple Run requires to access your device's features and data. Tap on Accept or Allow to grant them.</li>
-</ul>
- <h3>You can also transfer the APK file from your computer to your device via USB</h3>
-<p>If you don't want to download the APK file of Temple Run directly from your device, you can also transfer it from your computer to your device via USB. Here are the steps to do this:</p>
-<ol>
-<li>Download the APK file of Temple Run from a web tool or an APK extractor app on your computer.</li>
-<li>Connect your device to your computer via USB cable and make sure it is in file transfer mode.</li>
-<li>Copy and paste the APK file of Temple Run from your computer to a folder on your device's internal storage or SD card.</li>
-<li>Disconnect your device from your computer and follow the steps above to locate and install the APK file using a file manager or an APK installer app.</li>
-</ol>
- <h2>Conclusion and FAQs</h2>
-<h3>Conclusion: Downloading Temple Run without Play Store is easy and safe if you follow the steps above</h3>
-<p>In conclusion, downloading Temple Run without Play Store is not a difficult task if you follow the steps above. You just need to get the APK file of Temple Run from a web tool or an APK extractor app, enable unknown apps on your device, and install the APK file using a file manager or an APK installer app. This way, you can enjoy Temple Run without Play Store and have more control over your app installation and updates. Downloading Temple Run without Play Store is also safe and legal, as long as you download the APK file from a trusted source and do not modify or distribute it without permission. However, you should always be careful when installing unknown apps on your device, as they may contain malware or viruses that can harm your device or data. Always check the ratings, reviews, and permissions of the apps before downloading them, and scan them with an antivirus app if possible.</p>
- <h3>FAQs: Five common questions and answers about downloading Temple Run without Play Store</h3>
-<p>Here are some of the most frequently asked questions and answers about downloading Temple Run without Play Store:</p>
-<table>
-<tr>
-<th>Question</th>
-<th>Answer</th>
-</tr>
-<tr>
-<td>Can I download Temple Run without Play Store on any Android device?</td>
-<td>Yes, you can download Temple Run without Play Store on any Android device that supports the game's minimum requirements. The game requires Android 4.1 or higher and at least 50 MB of free space.</td>
-</tr>
-<tr>
-<td>Can I update Temple Run without Play Store?</td>
-<td>Yes, you can update Temple Run without Play Store by downloading and installing the latest APK file of the game from a web tool or an APK extractor app. However, you will not receive automatic notifications when a new update is available, so you will have to check manually.</td>
-</tr>
-<tr>
-<td>Can I play Temple Run offline without Play Store?</td>
-<td>Yes, you can play Temple Run offline without Play Store, as the game does not require an internet connection to run. However, you will not be able to access some features that require an internet connection, such as leaderboards, achievements, and cloud save.</td>
-</tr>
-<tr>
-<td>Can I restore my progress in Temple Run without Play Store?</td>
-<td>Yes, you can restore your progress in Temple Run without Play Store by using a backup app or a cloud service. You can use a backup app such as Helium or Titanium Backup to backup and restore your app data on your device. You can also use a cloud service such as Google Drive or Dropbox to sync and restore your app data across devices.</td>
-</tr>
-<tr>
-<td>Can I get banned from Temple Run for downloading it without Play Store?</td>
-<td>No, you will not get banned from Temple Run for downloading it without Play Store, as long as you do not use any cheats, hacks, or mods that violate the game's terms of service. Downloading Temple Run without Play Store is not illegal or unethical, as long as you respect the rights of the developers and do not distribute or modify the APK file without permission.</td>
-</tr>
-</table></p> 197e85843d<br />
-<br />
-<br />

spaces/1vash/demo-flask-docker-template/static/script.js

@@ -1,30 +0,0 @@
-//const textGenForm = document.querySelector('.text-gen-form');
-//
-//const translateText = async (text) => {
-//    const inferResponse = await fetch(`infer_t5?input=${text}`);
-//    const inferJson = await inferResponse.json();
-//
-//    return inferJson.output;
-//};
-//
-//textGenForm.addEventListener('submit', async (event) => {
-//  event.preventDefault();
-//
-//  const textGenInput = document.getElementById('text-gen-input');
-//  const textGenParagraph = document.querySelector('.text-gen-output');
-//
-//  try {
-//    textGenParagraph.textContent = await translateText(textGenInput.value);
-//  } catch (err) {
-//    console.error(err);
-//  }
-//});
-
-document.addEventListener("DOMContentLoaded", () => {
-  const uploadForm = document.querySelector(".image-upload-form");
-  const uploadButton = document.querySelector("#image-upload-submit");
-
-  uploadButton.addEventListener("click", () => {
-    uploadForm.submit();
-  });
-});

spaces/2023Liu2023/bingo/src/lib/utils.ts

@@ -1,138 +0,0 @@
-import { clsx, type ClassValue } from 'clsx'
-import { customAlphabet } from 'nanoid'
-import { twMerge } from 'tailwind-merge'
-
-export function cn(...inputs: ClassValue[]) {
-  return twMerge(clsx(inputs))
-}
-
-export const nanoid = customAlphabet(
-  '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
-  7
-) // 7-character random string
-
-export function createChunkDecoder() {
-  const decoder = new TextDecoder()
-  return function (chunk: Uint8Array | undefined): string {
-    if (!chunk) return ''
-    return decoder.decode(chunk, { stream: true })
-  }
-}
-
-export function random (start: number, end: number) {
-  return start + Math.ceil(Math.random() * (end - start))
-}
-
-export function randomIP() {
-  return `11.${random(104, 107)}.${random(1, 255)}.${random(1, 255)}`
-}
-
-export function parseHeadersFromCurl(content: string) {
-  const re = /-H '([^:]+):\s*([^']+)/mg
-  const headers: HeadersInit = {}
-  content = content.replaceAll('-H "', '-H \'').replaceAll('" ^', '\'\\').replaceAll('^\\^"', '"') // 将 cmd curl 转成 bash curl
-  content.replace(re, (_: string, key: string, value: string) => {
-    headers[key] = value
-    return ''
-  })
-
-  return headers
-}
-
-export const ChunkKeys = ['BING_HEADER', 'BING_HEADER1', 'BING_HEADER2']
-export function encodeHeadersToCookie(content: string) {
-  const base64Content = btoa(content)
-  const contentChunks = base64Content.match(/.{1,4000}/g) || []
-  return ChunkKeys.map((key, index) => `${key}=${contentChunks[index] ?? ''}`)
-}
-
-export function extraCurlFromCookie(cookies: Partial<{ [key: string]: string }>) {
-  let base64Content = ''
-  ChunkKeys.forEach((key) => {
-    base64Content += (cookies[key] || '')
-  })
-  try {
-    return atob(base64Content)
-  } catch(e) {
-    return ''
-  }
-}
-
-export function extraHeadersFromCookie(cookies: Partial<{ [key: string]: string }>) {
-  return parseHeadersFromCurl(extraCurlFromCookie(cookies))
-}
-
-export function formatDate(input: string | number | Date): string {
-  const date = new Date(input)
-  return date.toLocaleDateString('en-US', {
-    month: 'long',
-    day: 'numeric',
-    year: 'numeric'
-  })
-}
-
-export function parseCookie(cookie: string, cookieName: string) {
-  const targetCookie = new RegExp(`(?:[; ]|^)${cookieName}=([^;]*)`).test(cookie) ? RegExp.$1 : cookie
-  return targetCookie ? decodeURIComponent(targetCookie).trim() : cookie.indexOf('=') === -1 ? cookie.trim() : ''
-}
-
-export function parseCookies(cookie: string, cookieNames: string[]) {
-  const cookies: { [key: string]: string } = {}
-  cookieNames.forEach(cookieName => {
-    cookies[cookieName] = parseCookie(cookie, cookieName)
-  })
-  return cookies
-}
-
-export const DEFAULT_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.0.0'
-export const DEFAULT_IP = process.env.BING_IP || randomIP()
-
-export function parseUA(ua?: string, default_ua = DEFAULT_UA) {
-  return / EDGE?/i.test(decodeURIComponent(ua || '')) ? decodeURIComponent(ua!.trim()) : default_ua
-}
-
-export function createHeaders(cookies: Partial<{ [key: string]: string }>, defaultHeaders?: Partial<{ [key: string]: string }>) {
-  let {
-    BING_COOKIE = process.env.BING_COOKIE,
-    BING_UA = process.env.BING_UA,
-    BING_IP = process.env.BING_IP,
-    BING_HEADER = process.env.BING_HEADER,
-  } = cookies
-
-  if (BING_HEADER) {
-    return extraHeadersFromCookie({
-      BING_HEADER,
-      ...cookies,
-    })
-  }
-
-  const ua = parseUA(BING_UA)
-
-  if (!BING_COOKIE) {
-    BING_COOKIE = defaultHeaders?.IMAGE_BING_COOKIE || 'xxx' // hf 暂时不用 Cookie 也可以正常使用
-  }
-
-  const parsedCookie = parseCookie(BING_COOKIE, '_U')
-  if (!parsedCookie) {
-    throw new Error('Invalid Cookie')
-  }
-  return {
-    'x-forwarded-for': BING_IP || DEFAULT_IP,
-    'Accept-Encoding': 'gzip, deflate, br',
-    'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
-    'User-Agent': ua!,
-    'x-ms-useragent': 'azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.0 OS/Win32',
-    cookie: `_U=${parsedCookie}` || '',
-  }
-}
-
-export class WatchDog {
-  private tid = 0
-  watch(fn: Function, timeout = 2000) {
-    clearTimeout(this.tid)
-    this.tid = setTimeout(fn, timeout + Math.random() * 1000)
-  }
-  reset() {
-    clearTimeout(this.tid)
-  }
-}

spaces/AI-Hobbyist/Hoyo-RVC/extract_feature_print.py

@@ -1,123 +0,0 @@
-import os, sys, traceback
-
-# device=sys.argv[1]
-n_part = int(sys.argv[2])
-i_part = int(sys.argv[3])
-if len(sys.argv) == 5:
-    exp_dir = sys.argv[4]
-    version = sys.argv[5]
-else:
-    i_gpu = sys.argv[4]
-    exp_dir = sys.argv[5]
-    os.environ["CUDA_VISIBLE_DEVICES"] = str(i_gpu)
-    version = sys.argv[6]
-import torch
-import torch.nn.functional as F
-import soundfile as sf
-import numpy as np
-from fairseq import checkpoint_utils
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-if torch.cuda.is_available():
-    device = "cuda"
-elif torch.backends.mps.is_available():
-    device = "mps"
-else:
-    device = "cpu"
-
-f = open("%s/extract_f0_feature.log" % exp_dir, "a+")
-
-
-def printt(strr):
-    print(strr)
-    f.write("%s\n" % strr)
-    f.flush()
-
-
-printt(sys.argv)
-model_path = "hubert_base.pt"
-
-printt(exp_dir)
-wavPath = "%s/1_16k_wavs" % exp_dir
-outPath = (
-    "%s/3_feature256" % exp_dir if version == "v1" else "%s/3_feature768" % exp_dir
-)
-os.makedirs(outPath, exist_ok=True)
-
-
-# wave must be 16k, hop_size=320
-def readwave(wav_path, normalize=False):
-    wav, sr = sf.read(wav_path)
-    assert sr == 16000
-    feats = torch.from_numpy(wav).float()
-    if feats.dim() == 2:  # double channels
-        feats = feats.mean(-1)
-    assert feats.dim() == 1, feats.dim()
-    if normalize:
-        with torch.no_grad():
-            feats = F.layer_norm(feats, feats.shape)
-    feats = feats.view(1, -1)
-    return feats
-
-
-# HuBERT model
-printt("load model(s) from {}".format(model_path))
-# if hubert model is exist
-if os.access(model_path, os.F_OK) == False:
-    printt(
-        "Error: Extracting is shut down because %s does not exist, you may download it from https://huggingface.co/lj1995/VoiceConversionWebUI/tree/main"
-        % model_path
-    )
-    exit(0)
-models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
-    [model_path],
-    suffix="",
-)
-model = models[0]
-model = model.to(device)
-printt("move model to %s" % device)
-if device not in ["mps", "cpu"]:
-    model = model.half()
-model.eval()
-
-todo = sorted(list(os.listdir(wavPath)))[i_part::n_part]
-n = max(1, len(todo) // 10)  # 最多打印十条
-if len(todo) == 0:
-    printt("no-feature-todo")
-else:
-    printt("all-feature-%s" % len(todo))
-    for idx, file in enumerate(todo):
-        try:
-            if file.endswith(".wav"):
-                wav_path = "%s/%s" % (wavPath, file)
-                out_path = "%s/%s" % (outPath, file.replace("wav", "npy"))
-
-                if os.path.exists(out_path):
-                    continue
-
-                feats = readwave(wav_path, normalize=saved_cfg.task.normalize)
-                padding_mask = torch.BoolTensor(feats.shape).fill_(False)
-                inputs = {
-                    "source": feats.half().to(device)
-                    if device not in ["mps", "cpu"]
-                    else feats.to(device),
-                    "padding_mask": padding_mask.to(device),
-                    "output_layer": 9 if version == "v1" else 12,  # layer 9
-                }
-                with torch.no_grad():
-                    logits = model.extract_features(**inputs)
-                    feats = (
-                        model.final_proj(logits[0]) if version == "v1" else logits[0]
-                    )
-
-                feats = feats.squeeze(0).float().cpu().numpy()
-                if np.isnan(feats).sum() == 0:
-                    np.save(out_path, feats, allow_pickle=False)
-                else:
-                    printt("%s-contains nan" % file)
-                if idx % n == 0:
-                    printt("now-%s,all-%s,%s,%s" % (len(todo), idx, file, feats.shape))
-        except:
-            printt(traceback.format_exc())
-    printt("all-feature-done")

spaces/AIFILMS/generate_human_motion/pyrender/tests/unit/test_lights.py

@@ -1,104 +0,0 @@
-import numpy as np
-import pytest
-
-from pyrender import (DirectionalLight, SpotLight, PointLight, Texture,
-                      PerspectiveCamera, OrthographicCamera)
-from pyrender.constants import SHADOW_TEX_SZ
-
-
-def test_directional_light():
-
-    d = DirectionalLight()
-    assert d.name is None
-    assert np.all(d.color == 1.0)
-    assert d.intensity == 1.0
-
-    d.name = 'direc'
-    with pytest.raises(ValueError):
-        d.color = None
-    with pytest.raises(TypeError):
-        d.intensity = None
-
-    d = DirectionalLight(color=[0.0, 0.0, 0.0])
-    assert np.all(d.color == 0.0)
-
-    d._generate_shadow_texture()
-    st = d.shadow_texture
-    assert isinstance(st, Texture)
-    assert st.width == st.height == SHADOW_TEX_SZ
-
-    sc = d._get_shadow_camera(scene_scale=5.0)
-    assert isinstance(sc, OrthographicCamera)
-    assert sc.xmag == sc.ymag == 5.0
-    assert sc.znear == 0.01 * 5.0
-    assert sc.zfar == 10 * 5.0
-
-
-def test_spot_light():
-
-    s = SpotLight()
-    assert s.name is None
-    assert np.all(s.color == 1.0)
-    assert s.intensity == 1.0
-    assert s.innerConeAngle == 0.0
-    assert s.outerConeAngle == np.pi / 4.0
-    assert s.range is None
-
-    with pytest.raises(ValueError):
-        s.range = -1.0
-
-    with pytest.raises(ValueError):
-        s.range = 0.0
-
-    with pytest.raises(ValueError):
-        s.innerConeAngle = -1.0
-
-    with pytest.raises(ValueError):
-        s.innerConeAngle = np.pi / 3.0
-
-    with pytest.raises(ValueError):
-        s.outerConeAngle = -1.0
-
-    with pytest.raises(ValueError):
-        s.outerConeAngle = np.pi
-
-    s.range = 5.0
-    s.outerConeAngle = np.pi / 2 - 0.05
-    s.innerConeAngle = np.pi / 3
-    s.innerConeAngle = 0.0
-    s.outerConeAngle = np.pi / 4.0
-
-    s._generate_shadow_texture()
-    st = s.shadow_texture
-    assert isinstance(st, Texture)
-    assert st.width == st.height == SHADOW_TEX_SZ
-
-    sc = s._get_shadow_camera(scene_scale=5.0)
-    assert isinstance(sc, PerspectiveCamera)
-    assert sc.znear == 0.01 * 5.0
-    assert sc.zfar == 10 * 5.0
-    assert sc.aspectRatio == 1.0
-    assert np.allclose(sc.yfov, np.pi / 16.0 * 9.0)  # Plus pi / 16
-
-
-def test_point_light():
-
-    s = PointLight()
-    assert s.name is None
-    assert np.all(s.color == 1.0)
-    assert s.intensity == 1.0
-    assert s.range is None
-
-    with pytest.raises(ValueError):
-        s.range = -1.0
-
-    with pytest.raises(ValueError):
-        s.range = 0.0
-
-    s.range = 5.0
-
-    with pytest.raises(NotImplementedError):
-        s._generate_shadow_texture()
-
-    with pytest.raises(NotImplementedError):
-        s._get_shadow_camera(scene_scale=5.0)

spaces/AIGC-Audio/AudioGPT/text_to_audio/Make_An_Audio/ldm/modules/losses_audio/vggishish/model.py

@@ -1,77 +0,0 @@
-import torch
-import torch.nn as nn
-
-
-class VGGishish(nn.Module):
-
-    def __init__(self, conv_layers, use_bn, num_classes):
-        '''
-        Mostly from
-            https://pytorch.org/vision/0.8/_modules/torchvision/models/vgg.html
-        '''
-        super().__init__()
-        layers = []
-        in_channels = 1
-
-        # a list of channels with 'MP' (maxpool) from config
-        for v in conv_layers:
-            if v == 'MP':
-                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
-            else:
-                conv2d = nn.Conv2d(in_channels, v, kernel_size=3, padding=1, stride=1)
-                if use_bn:
-                    layers += [conv2d, nn.BatchNorm2d(v), nn.ReLU(inplace=True)]
-                else:
-                    layers += [conv2d, nn.ReLU(inplace=True)]
-                in_channels = v
-        self.features = nn.Sequential(*layers)
-
-        self.avgpool = nn.AdaptiveAvgPool2d((5, 10))
-
-        self.flatten = nn.Flatten()
-        self.classifier = nn.Sequential(
-            nn.Linear(512 * 5 * 10, 4096),
-            nn.ReLU(True),
-            nn.Linear(4096, 4096),
-            nn.ReLU(True),
-            nn.Linear(4096, num_classes)
-        )
-
-        # weight init
-        self.reset_parameters()
-
-    def forward(self, x):
-        # adding channel dim for conv2d (B, 1, F, T) <-
-        x = x.unsqueeze(1)
-        # backbone (B, 1, 5, 53) <- (B, 1, 80, 860)
-        x = self.features(x)
-        # adaptive avg pooling (B, 1, 5, 10) <- (B, 1, 5, 53) – if no MP is used as the end of VGG
-        x = self.avgpool(x)
-        # flatten
-        x = self.flatten(x)
-        # classify
-        x = self.classifier(x)
-        return x
-
-    def reset_parameters(self):
-        for m in self.modules():
-            if isinstance(m, nn.Conv2d):
-                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
-                if m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.BatchNorm2d):
-                nn.init.constant_(m.weight, 1)
-                nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.Linear):
-                nn.init.normal_(m.weight, 0, 0.01)
-                nn.init.constant_(m.bias, 0)
-
-
-if __name__ == '__main__':
-    num_classes = 309
-    inputs = torch.rand(3, 80, 848)
-    conv_layers = [64, 64, 'MP', 128, 128, 'MP', 256, 256, 256, 'MP', 512, 512, 512, 'MP', 512, 512, 512]
-    # conv_layers = [64, 'MP', 128, 'MP', 256, 256, 'MP', 512, 512, 'MP']
-    model = VGGishish(conv_layers, use_bn=False, num_classes=num_classes)
-    outputs = model(inputs)
-    print(outputs.shape)

spaces/AIGC-Audio/AudioGPT/text_to_speech/utils/commons/ckpt_utils.py

@@ -1,66 +0,0 @@
-import glob
-import os
-import re
-import torch
-
-
-def get_last_checkpoint(work_dir, steps=None):
-    checkpoint = None
-    last_ckpt_path = None
-    ckpt_paths = get_all_ckpts(work_dir, steps)
-    if len(ckpt_paths) > 0:
-        last_ckpt_path = ckpt_paths[0]
-        checkpoint = torch.load(last_ckpt_path, map_location='cpu')
-    return checkpoint, last_ckpt_path
-
-
-def get_all_ckpts(work_dir, steps=None):
-    if steps is None:
-        ckpt_path_pattern = f'{work_dir}/model_ckpt_steps_*.ckpt'
-    else:
-        ckpt_path_pattern = f'{work_dir}/model_ckpt_steps_{steps}.ckpt'
-    return sorted(glob.glob(ckpt_path_pattern),
-                  key=lambda x: -int(re.findall('.*steps\_(\d+)\.ckpt', x)[0]))
-
-
-def load_ckpt(cur_model, ckpt_base_dir, model_name='model', force=True, strict=True):
-    if os.path.isfile(ckpt_base_dir):
-        base_dir = os.path.dirname(ckpt_base_dir)
-        ckpt_path = ckpt_base_dir
-        checkpoint = torch.load(ckpt_base_dir, map_location='cpu')
-    else:
-        base_dir = ckpt_base_dir
-        checkpoint, ckpt_path = get_last_checkpoint(ckpt_base_dir)
-    if checkpoint is not None:
-        state_dict = checkpoint["state_dict"]
-        if len([k for k in state_dict.keys() if '.' in k]) > 0:
-            state_dict = {k[len(model_name) + 1:]: v for k, v in state_dict.items()
-                          if k.startswith(f'{model_name}.')}
-        else:
-            if '.' not in model_name:
-                state_dict = state_dict[model_name]
-            else:
-                base_model_name = model_name.split('.')[0]
-                rest_model_name = model_name[len(base_model_name) + 1:]
-                state_dict = {
-                    k[len(rest_model_name) + 1:]: v for k, v in state_dict[base_model_name].items()
-                    if k.startswith(f'{rest_model_name}.')}
-        if not strict:
-            cur_model_state_dict = cur_model.state_dict()
-            unmatched_keys = []
-            for key, param in state_dict.items():
-                if key in cur_model_state_dict:
-                    new_param = cur_model_state_dict[key]
-                    if new_param.shape != param.shape:
-                        unmatched_keys.append(key)
-                        print("| Unmatched keys: ", key, new_param.shape, param.shape)
-            for key in unmatched_keys:
-                del state_dict[key]
-        cur_model.load_state_dict(state_dict, strict=strict)
-        print(f"| load '{model_name}' from '{ckpt_path}'.")
-    else:
-        e_msg = f"| ckpt not found in {base_dir}."
-        if force:
-            assert False, e_msg
-        else:
-            print(e_msg)

spaces/AIGC-Audio/Make_An_Audio/vocoder/bigvgan/activations.py

@@ -1,120 +0,0 @@
-# Implementation adapted from https://github.com/EdwardDixon/snake under the MIT license.
-#   LICENSE is in incl_licenses directory.
-
-import torch
-from torch import nn, sin, pow
-from torch.nn import Parameter
-
-
-class Snake(nn.Module):
-    '''
-    Implementation of a sine-based periodic activation function
-    Shape:
-        - Input: (B, C, T)
-        - Output: (B, C, T), same shape as the input
-    Parameters:
-        - alpha - trainable parameter
-    References:
-        - This activation function is from this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
-        https://arxiv.org/abs/2006.08195
-    Examples:
-        >>> a1 = snake(256)
-        >>> x = torch.randn(256)
-        >>> x = a1(x)
-    '''
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        '''
-        Initialization.
-        INPUT:
-            - in_features: shape of the input
-            - alpha: trainable parameter
-            alpha is initialized to 1 by default, higher values = higher-frequency.
-            alpha will be trained along with the rest of your model.
-        '''
-        super(Snake, self).__init__()
-        self.in_features = in_features
-
-        # initialize alpha
-        self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale: # log scale alphas initialized to zeros
-            self.alpha = Parameter(torch.zeros(in_features) * alpha)
-        else: # linear scale alphas initialized to ones
-            self.alpha = Parameter(torch.ones(in_features) * alpha)
-
-        self.alpha.requires_grad = alpha_trainable
-
-        self.no_div_by_zero = 0.000000001
-
-    def forward(self, x):
-        '''
-        Forward pass of the function.
-        Applies the function to the input elementwise.
-        Snake ∶= x + 1/a * sin^2 (xa)
-        '''
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
-        if self.alpha_logscale:
-            alpha = torch.exp(alpha)
-        x = x + (1.0 / (alpha + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
-        return x
-
-
-class SnakeBeta(nn.Module):
-    '''
-    A modified Snake function which uses separate parameters for the magnitude of the periodic components
-    Shape:
-        - Input: (B, C, T)
-        - Output: (B, C, T), same shape as the input
-    Parameters:
-        - alpha - trainable parameter that controls frequency
-        - beta - trainable parameter that controls magnitude
-    References:
-        - This activation function is a modified version based on this paper by Liu Ziyin, Tilman Hartwig, Masahito Ueda:
-        https://arxiv.org/abs/2006.08195
-    Examples:
-        >>> a1 = snakebeta(256)
-        >>> x = torch.randn(256)
-        >>> x = a1(x)
-    '''
-    def __init__(self, in_features, alpha=1.0, alpha_trainable=True, alpha_logscale=False):
-        '''
-        Initialization.
-        INPUT:
-            - in_features: shape of the input
-            - alpha - trainable parameter that controls frequency
-            - beta - trainable parameter that controls magnitude
-            alpha is initialized to 1 by default, higher values = higher-frequency.
-            beta is initialized to 1 by default, higher values = higher-magnitude.
-            alpha will be trained along with the rest of your model.
-        '''
-        super(SnakeBeta, self).__init__()
-        self.in_features = in_features
-
-        # initialize alpha
-        self.alpha_logscale = alpha_logscale
-        if self.alpha_logscale: # log scale alphas initialized to zeros
-            self.alpha = Parameter(torch.zeros(in_features) * alpha)
-            self.beta = Parameter(torch.zeros(in_features) * alpha)
-        else: # linear scale alphas initialized to ones
-            self.alpha = Parameter(torch.ones(in_features) * alpha)
-            self.beta = Parameter(torch.ones(in_features) * alpha)
-
-        self.alpha.requires_grad = alpha_trainable
-        self.beta.requires_grad = alpha_trainable
-
-        self.no_div_by_zero = 0.000000001
-
-    def forward(self, x):
-        '''
-        Forward pass of the function.
-        Applies the function to the input elementwise.
-        SnakeBeta ∶= x + 1/b * sin^2 (xa)
-        '''
-        alpha = self.alpha.unsqueeze(0).unsqueeze(-1) # line up with x to [B, C, T]
-        beta = self.beta.unsqueeze(0).unsqueeze(-1)
-        if self.alpha_logscale:
-            alpha = torch.exp(alpha)
-            beta = torch.exp(beta)
-        x = x + (1.0 / (beta + self.no_div_by_zero)) * pow(sin(x * alpha), 2)
-
-        return x

spaces/AIGC-Audio/Make_An_Audio/vocoder/bigvgan/models.py

@@ -1,414 +0,0 @@
-# Copyright (c) 2022 NVIDIA CORPORATION. 
-#   Licensed under the MIT license.
-
-# Adapted from https://github.com/jik876/hifi-gan under the MIT license.
-#   LICENSE is in incl_licenses directory.
-
-
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-from torch.nn import Conv1d, ConvTranspose1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-import numpy as np
-from .activations import Snake,SnakeBeta
-from .alias_free_torch import *
-import os
-from omegaconf import OmegaConf
-
-LRELU_SLOPE = 0.1
-
-def init_weights(m, mean=0.0, std=0.01):
-    classname = m.__class__.__name__
-    if classname.find("Conv") != -1:
-        m.weight.data.normal_(mean, std)
-
-
-def get_padding(kernel_size, dilation=1):
-    return int((kernel_size*dilation - dilation)/2)
-
-class AMPBlock1(torch.nn.Module):
-    def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5), activation=None):
-        super(AMPBlock1, self).__init__()
-        self.h = h
-
-        self.convs1 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
-                               padding=get_padding(kernel_size, dilation[2])))
-        ])
-        self.convs1.apply(init_weights)
-
-        self.convs2 = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
-                               padding=get_padding(kernel_size, 1)))
-        ])
-        self.convs2.apply(init_weights)
-
-        self.num_layers = len(self.convs1) + len(self.convs2) # total number of conv layers
-
-        if activation == 'snake': # periodic nonlinearity with snake function and anti-aliasing
-            self.activations = nn.ModuleList([
-                Activation1d(
-                    activation=Snake(channels, alpha_logscale=h.snake_logscale))
-                for _ in range(self.num_layers)
-            ])
-        elif activation == 'snakebeta': # periodic nonlinearity with snakebeta function and anti-aliasing
-            self.activations = nn.ModuleList([
-                Activation1d(
-                    activation=SnakeBeta(channels, alpha_logscale=h.snake_logscale))
-                 for _ in range(self.num_layers)
-            ])
-        else:
-            raise NotImplementedError("activation incorrectly specified. check the config file and look for 'activation'.")
-
-    def forward(self, x):
-        acts1, acts2 = self.activations[::2], self.activations[1::2]
-        for c1, c2, a1, a2 in zip(self.convs1, self.convs2, acts1, acts2):
-            xt = a1(x)
-            xt = c1(xt)
-            xt = a2(xt)
-            xt = c2(xt)
-            x = xt + x
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs1:
-            remove_weight_norm(l)
-        for l in self.convs2:
-            remove_weight_norm(l)
-
-
-class AMPBlock2(torch.nn.Module):
-    def __init__(self, h, channels, kernel_size=3, dilation=(1, 3), activation=None):
-        super(AMPBlock2, self).__init__()
-        self.h = h
-
-        self.convs = nn.ModuleList([
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
-                               padding=get_padding(kernel_size, dilation[0]))),
-            weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
-                               padding=get_padding(kernel_size, dilation[1])))
-        ])
-        self.convs.apply(init_weights)
-
-        self.num_layers = len(self.convs) # total number of conv layers
-
-        if activation == 'snake': # periodic nonlinearity with snake function and anti-aliasing
-            self.activations = nn.ModuleList([
-                Activation1d(
-                    activation=Snake(channels, alpha_logscale=h.snake_logscale))
-                for _ in range(self.num_layers)
-            ])
-        elif activation == 'snakebeta': # periodic nonlinearity with snakebeta function and anti-aliasing
-            self.activations = nn.ModuleList([
-                Activation1d(
-                    activation=SnakeBeta(channels, alpha_logscale=h.snake_logscale))
-                 for _ in range(self.num_layers)
-            ])
-        else:
-            raise NotImplementedError("activation incorrectly specified. check the config file and look for 'activation'.")
-
-    def forward(self, x):
-        for c, a in zip (self.convs, self.activations):
-            xt = a(x)
-            xt = c(xt)
-            x = xt + x
-
-        return x
-
-    def remove_weight_norm(self):
-        for l in self.convs:
-            remove_weight_norm(l)
-
-
-class BigVGAN(torch.nn.Module):
-    # this is our main BigVGAN model. Applies anti-aliased periodic activation for resblocks.
-    def __init__(self, h):
-        super(BigVGAN, self).__init__()
-        self.h = h
-
-        self.num_kernels = len(h.resblock_kernel_sizes)
-        self.num_upsamples = len(h.upsample_rates)
-
-        # pre conv
-        self.conv_pre = weight_norm(Conv1d(h.num_mels, h.upsample_initial_channel, 7, 1, padding=3))
-
-        # define which AMPBlock to use. BigVGAN uses AMPBlock1 as default
-        resblock = AMPBlock1 if h.resblock == '1' else AMPBlock2
-
-        # transposed conv-based upsamplers. does not apply anti-aliasing
-        self.ups = nn.ModuleList()
-        for i, (u, k) in enumerate(zip(h.upsample_rates, h.upsample_kernel_sizes)):
-            self.ups.append(nn.ModuleList([
-                weight_norm(ConvTranspose1d(h.upsample_initial_channel // (2 ** i),
-                                            h.upsample_initial_channel // (2 ** (i + 1)),
-                                            k, u, padding=(k - u) // 2))
-            ]))
-
-        # residual blocks using anti-aliased multi-periodicity composition modules (AMP)
-        self.resblocks = nn.ModuleList()
-        for i in range(len(self.ups)):
-            ch = h.upsample_initial_channel // (2 ** (i + 1))
-            for j, (k, d) in enumerate(zip(h.resblock_kernel_sizes, h.resblock_dilation_sizes)):
-                self.resblocks.append(resblock(h, ch, k, d, activation=h.activation))
-
-        # post conv
-        if h.activation == "snake": # periodic nonlinearity with snake function and anti-aliasing
-            activation_post = Snake(ch, alpha_logscale=h.snake_logscale)
-            self.activation_post = Activation1d(activation=activation_post)
-        elif h.activation == "snakebeta": # periodic nonlinearity with snakebeta function and anti-aliasing
-            activation_post = SnakeBeta(ch, alpha_logscale=h.snake_logscale)
-            self.activation_post = Activation1d(activation=activation_post)
-        else:
-            raise NotImplementedError("activation incorrectly specified. check the config file and look for 'activation'.")
-
-        self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3))
-
-        # weight initialization
-        for i in range(len(self.ups)):
-            self.ups[i].apply(init_weights)
-        self.conv_post.apply(init_weights)
-
-    def forward(self, x):
-        # pre conv
-        x = self.conv_pre(x)
-
-        for i in range(self.num_upsamples):
-            # upsampling
-            for i_up in range(len(self.ups[i])):
-                x = self.ups[i][i_up](x)
-            # AMP blocks
-            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
-
-        # post conv
-        x = self.activation_post(x)
-        x = self.conv_post(x)
-        x = torch.tanh(x)
-
-        return x
-
-    def remove_weight_norm(self):
-        print('Removing weight norm...')
-        for l in self.ups:
-            for l_i in l:
-                remove_weight_norm(l_i)
-        for l in self.resblocks:
-            l.remove_weight_norm()
-        remove_weight_norm(self.conv_pre)
-        remove_weight_norm(self.conv_post)
-
-
-class DiscriminatorP(torch.nn.Module):
-    def __init__(self, h, period, kernel_size=5, stride=3, use_spectral_norm=False):
-        super(DiscriminatorP, self).__init__()
-        self.period = period
-        self.d_mult = h.discriminator_channel_mult
-        norm_f = weight_norm if use_spectral_norm == False else spectral_norm
-        self.convs = nn.ModuleList([
-            norm_f(Conv2d(1, int(32*self.d_mult), (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
-            norm_f(Conv2d(int(32*self.d_mult), int(128*self.d_mult), (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
-            norm_f(Conv2d(int(128*self.d_mult), int(512*self.d_mult), (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
-            norm_f(Conv2d(int(512*self.d_mult), int(1024*self.d_mult), (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
-            norm_f(Conv2d(int(1024*self.d_mult), int(1024*self.d_mult), (kernel_size, 1), 1, padding=(2, 0))),
-        ])
-        self.conv_post = norm_f(Conv2d(int(1024*self.d_mult), 1, (3, 1), 1, padding=(1, 0)))
-
-    def forward(self, x):
-        fmap = []
-
-        # 1d to 2d
-        b, c, t = x.shape
-        if t % self.period != 0: # pad first
-            n_pad = self.period - (t % self.period)
-            x = F.pad(x, (0, n_pad), "reflect")
-            t = t + n_pad
-        x = x.view(b, c, t // self.period, self.period)
-
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, LRELU_SLOPE)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
-    def __init__(self, h):
-        super(MultiPeriodDiscriminator, self).__init__()
-        self.mpd_reshapes = h.mpd_reshapes
-        print("mpd_reshapes: {}".format(self.mpd_reshapes))
-        discriminators = [DiscriminatorP(h, rs, use_spectral_norm=h.use_spectral_norm) for rs in self.mpd_reshapes]
-        self.discriminators = nn.ModuleList(discriminators)
-
-    def forward(self, y, y_hat):
-        y_d_rs = []
-        y_d_gs = []
-        fmap_rs = []
-        fmap_gs = []
-        for i, d in enumerate(self.discriminators):
-            y_d_r, fmap_r = d(y)
-            y_d_g, fmap_g = d(y_hat)
-            y_d_rs.append(y_d_r)
-            fmap_rs.append(fmap_r)
-            y_d_gs.append(y_d_g)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorR(nn.Module):
-    def __init__(self, cfg, resolution):
-        super().__init__()
-
-        self.resolution = resolution
-        assert len(self.resolution) == 3, \
-            "MRD layer requires list with len=3, got {}".format(self.resolution)
-        self.lrelu_slope = LRELU_SLOPE
-
-        norm_f = weight_norm if cfg.use_spectral_norm == False else spectral_norm
-        if hasattr(cfg, "mrd_use_spectral_norm"):
-            print("INFO: overriding MRD use_spectral_norm as {}".format(cfg.mrd_use_spectral_norm))
-            norm_f = weight_norm if cfg.mrd_use_spectral_norm == False else spectral_norm
-        self.d_mult = cfg.discriminator_channel_mult
-        if hasattr(cfg, "mrd_channel_mult"):
-            print("INFO: overriding mrd channel multiplier as {}".format(cfg.mrd_channel_mult))
-            self.d_mult = cfg.mrd_channel_mult
-
-        self.convs = nn.ModuleList([
-            norm_f(nn.Conv2d(1, int(32*self.d_mult), (3, 9), padding=(1, 4))),
-            norm_f(nn.Conv2d(int(32*self.d_mult), int(32*self.d_mult), (3, 9), stride=(1, 2), padding=(1, 4))),
-            norm_f(nn.Conv2d(int(32*self.d_mult), int(32*self.d_mult), (3, 9), stride=(1, 2), padding=(1, 4))),
-            norm_f(nn.Conv2d(int(32*self.d_mult), int(32*self.d_mult), (3, 9), stride=(1, 2), padding=(1, 4))),
-            norm_f(nn.Conv2d(int(32*self.d_mult), int(32*self.d_mult), (3, 3), padding=(1, 1))),
-        ])
-        self.conv_post = norm_f(nn.Conv2d(int(32 * self.d_mult), 1, (3, 3), padding=(1, 1)))
-
-    def forward(self, x):
-        fmap = []
-
-        x = self.spectrogram(x)
-        x = x.unsqueeze(1)
-        for l in self.convs:
-            x = l(x)
-            x = F.leaky_relu(x, self.lrelu_slope)
-            fmap.append(x)
-        x = self.conv_post(x)
-        fmap.append(x)
-        x = torch.flatten(x, 1, -1)
-
-        return x, fmap
-
-    def spectrogram(self, x):
-        n_fft, hop_length, win_length = self.resolution
-        x = F.pad(x, (int((n_fft - hop_length) / 2), int((n_fft - hop_length) / 2)), mode='reflect')
-        x = x.squeeze(1)
-        x = torch.stft(x, n_fft=n_fft, hop_length=hop_length, win_length=win_length, center=False, return_complex=True)
-        x = torch.view_as_real(x)  # [B, F, TT, 2]
-        mag = torch.norm(x, p=2, dim =-1) #[B, F, TT]
-
-        return mag
-
-
-class MultiResolutionDiscriminator(nn.Module):
-    def __init__(self, cfg, debug=False):
-        super().__init__()
-        self.resolutions = cfg.resolutions
-        assert len(self.resolutions) == 3,\
-            "MRD requires list of list with len=3, each element having a list with len=3. got {}".\
-                format(self.resolutions)
-        self.discriminators = nn.ModuleList(
-            [DiscriminatorR(cfg, resolution) for resolution in self.resolutions]
-        )
-
-    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(x=y)
-            y_d_g, fmap_g = d(x=y_hat)
-            y_d_rs.append(y_d_r)
-            fmap_rs.append(fmap_r)
-            y_d_gs.append(y_d_g)
-            fmap_gs.append(fmap_g)
-
-        return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-def feature_loss(fmap_r, fmap_g):
-    loss = 0
-    for dr, dg in zip(fmap_r, fmap_g):
-        for rl, gl in zip(dr, dg):
-            loss += torch.mean(torch.abs(rl - gl))
-
-    return loss*2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
-    loss = 0
-    r_losses = []
-    g_losses = []
-    for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
-        r_loss = torch.mean((1-dr)**2)
-        g_loss = torch.mean(dg**2)
-        loss += (r_loss + g_loss)
-        r_losses.append(r_loss.item())
-        g_losses.append(g_loss.item())
-
-    return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
-    loss = 0
-    gen_losses = []
-    for dg in disc_outputs:
-        l = torch.mean((1-dg)**2)
-        gen_losses.append(l)
-        loss += l
-
-    return loss, gen_losses
-
-
-
-class VocoderBigVGAN(object):
-    def __init__(self, ckpt_vocoder,device='cuda'):
-        vocoder_sd = torch.load(os.path.join(ckpt_vocoder,'best_netG.pt'), map_location='cpu')
-
-        vocoder_args = OmegaConf.load(os.path.join(ckpt_vocoder,'args.yml'))
-
-        self.generator = BigVGAN(vocoder_args)
-        self.generator.load_state_dict(vocoder_sd['generator'])
-        self.generator.eval()
-
-        self.device = device
-        self.generator.to(self.device)
-
-    def vocode(self, spec):
-        with torch.no_grad():
-            if isinstance(spec,np.ndarray):
-                spec = torch.from_numpy(spec).unsqueeze(0)
-            spec = spec.to(dtype=torch.float32,device=self.device)
-            return self.generator(spec).squeeze().cpu().numpy()
-
-    def __call__(self, wav):
-        return self.vocode(wav)

spaces/AIGText/GlyphControl/cldm/ddim_hacked.py

@@ -1,318 +0,0 @@
-"""SAMPLING ONLY."""
-
-import torch
-import numpy as np
-from tqdm import tqdm
-
-from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like, extract_into_tensor
-
-
-class DDIMSampler(object):
-    def __init__(self, model, schedule="linear", **kwargs):
-        super().__init__()
-        self.model = model
-        self.ddpm_num_timesteps = model.num_timesteps
-        self.schedule = schedule
-
-    def register_buffer(self, name, attr):
-        if type(attr) == torch.Tensor:
-            if attr.device != torch.device("cuda") and torch.cuda.is_available():
-                attr = attr.to(torch.device("cuda"))
-        setattr(self, name, attr)
-
-    def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
-        self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
-                                                  num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
-        alphas_cumprod = self.model.alphas_cumprod
-        assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
-        to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
-
-        self.register_buffer('betas', to_torch(self.model.betas))
-        self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
-        self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
-
-        # calculations for diffusion q(x_t | x_{t-1}) and others
-        self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
-        self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
-        self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
-
-        # ddim sampling parameters
-        ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
-                                                                                   ddim_timesteps=self.ddim_timesteps,
-                                                                                   eta=ddim_eta,verbose=verbose)
-        self.register_buffer('ddim_sigmas', ddim_sigmas)
-        self.register_buffer('ddim_alphas', ddim_alphas)
-        self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
-        self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
-        sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
-            (1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
-                        1 - self.alphas_cumprod / self.alphas_cumprod_prev))
-        self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
-
-    @torch.no_grad()
-    def sample(self,
-               S,
-               batch_size,
-               shape,
-               conditioning=None,
-               callback=None,
-               normals_sequence=None,
-               img_callback=None,
-               quantize_x0=False,
-               eta=0.,
-               mask=None,
-               x0=None,
-               temperature=1.,
-               noise_dropout=0.,
-               score_corrector=None,
-               corrector_kwargs=None,
-               verbose=True,
-               x_T=None,
-               log_every_t=100,
-               unconditional_guidance_scale=1.,
-               unconditional_conditioning=None, # this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
-               dynamic_threshold=None,
-               ucg_schedule=None,
-               **kwargs
-               ):
-        if conditioning is not None:
-            if isinstance(conditioning, dict):
-                for key, ctmp in conditioning.items():
-                    if ctmp is None:
-                        continue
-                    else:
-                        while isinstance(ctmp, list): ctmp = ctmp[0]
-                        if ctmp.shape[0] != batch_size:
-                            print(f"Warning: Got {ctmp.shape[0]} conditionings but batch-size is {batch_size}")
-
-            elif isinstance(conditioning, list):
-                for ctmp in conditioning:
-                    if ctmp is not None and ctmp.shape[0] != batch_size:
-                        print(f"Warning: Got {ctmp.shape[0]} conditionings but batch-size is {batch_size}")
-
-            else:
-                if conditioning.shape[0] != batch_size:
-                    print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
-
-        self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)
-        # sampling
-        C, H, W = shape
-        size = (batch_size, C, H, W)
-        print(f'Data shape for DDIM sampling is {size}, eta {eta}')
-
-        samples, intermediates = self.ddim_sampling(conditioning, size,
-                                                    callback=callback,
-                                                    img_callback=img_callback,
-                                                    quantize_denoised=quantize_x0,
-                                                    mask=mask, x0=x0,
-                                                    ddim_use_original_steps=False,
-                                                    noise_dropout=noise_dropout,
-                                                    temperature=temperature,
-                                                    score_corrector=score_corrector,
-                                                    corrector_kwargs=corrector_kwargs,
-                                                    x_T=x_T,
-                                                    log_every_t=log_every_t,
-                                                    unconditional_guidance_scale=unconditional_guidance_scale,
-                                                    unconditional_conditioning=unconditional_conditioning,
-                                                    dynamic_threshold=dynamic_threshold,
-                                                    ucg_schedule=ucg_schedule
-                                                    )
-        return samples, intermediates
-
-    @torch.no_grad()
-    def ddim_sampling(self, cond, shape,
-                      x_T=None, ddim_use_original_steps=False,
-                      callback=None, timesteps=None, quantize_denoised=False,
-                      mask=None, x0=None, img_callback=None, log_every_t=100,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None, dynamic_threshold=None,
-                      ucg_schedule=None):
-        device = self.model.betas.device
-        b = shape[0]
-        if x_T is None:
-            img = torch.randn(shape, device=device)
-        else:
-            img = x_T
-
-        if timesteps is None:
-            timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
-        elif timesteps is not None and not ddim_use_original_steps:
-            subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
-            timesteps = self.ddim_timesteps[:subset_end]
-
-        intermediates = {'x_inter': [img], 'pred_x0': [img]}
-        time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
-        total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
-        print(f"Running DDIM Sampling with {total_steps} timesteps")
-
-        iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
-
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((b,), step, device=device, dtype=torch.long)
-
-            if mask is not None:
-                assert x0 is not None
-                img_orig = self.model.q_sample(x0, ts)  # TODO: deterministic forward pass?
-                img = img_orig * mask + (1. - mask) * img
-
-            if ucg_schedule is not None:
-                assert len(ucg_schedule) == len(time_range)
-                unconditional_guidance_scale = ucg_schedule[i]
-
-            outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
-                                      quantize_denoised=quantize_denoised, temperature=temperature,
-                                      noise_dropout=noise_dropout, score_corrector=score_corrector,
-                                      corrector_kwargs=corrector_kwargs,
-                                      unconditional_guidance_scale=unconditional_guidance_scale,
-                                      unconditional_conditioning=unconditional_conditioning,
-                                      dynamic_threshold=dynamic_threshold)
-            img, pred_x0 = outs
-            if callback: callback(i)
-            if img_callback: img_callback(pred_x0, i)
-
-            if index % log_every_t == 0 or index == total_steps - 1:
-                intermediates['x_inter'].append(img)
-                intermediates['pred_x0'].append(pred_x0)
-
-        return img, intermediates
-
-    @torch.no_grad()
-    def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
-                      temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
-                      unconditional_guidance_scale=1., unconditional_conditioning=None,
-                      dynamic_threshold=None):
-        b, *_, device = *x.shape, x.device
-
-        if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
-            model_output = self.model.apply_model(x, t, c)
-        else:
-            model_t = self.model.apply_model(x, t, c)
-            model_uncond = self.model.apply_model(x, t, unconditional_conditioning)
-            model_output = model_uncond + unconditional_guidance_scale * (model_t - model_uncond)
-
-        if self.model.parameterization == "v":
-            e_t = self.model.predict_eps_from_z_and_v(x, t, model_output)
-        else:
-            e_t = model_output
-
-        if score_corrector is not None:
-            assert self.model.parameterization == "eps", 'not implemented'
-            e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
-
-        alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
-        alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
-        sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
-        sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
-        # select parameters corresponding to the currently considered timestep
-        a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)
-        a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)
-        sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)
-        sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)
-
-        # current prediction for x_0
-        if self.model.parameterization != "v":
-            pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
-        else:
-            pred_x0 = self.model.predict_start_from_z_and_v(x, t, model_output)
-
-        if quantize_denoised:
-            pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
-
-        if dynamic_threshold is not None:
-            raise NotImplementedError()
-
-        # direction pointing to x_t
-        dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
-        noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
-        if noise_dropout > 0.:
-            noise = torch.nn.functional.dropout(noise, p=noise_dropout)
-        x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
-        return x_prev, pred_x0
-
-    @torch.no_grad()
-    def encode(self, x0, c, t_enc, use_original_steps=False, return_intermediates=None,
-               unconditional_guidance_scale=1.0, unconditional_conditioning=None, callback=None):
-        num_reference_steps = self.ddpm_num_timesteps if use_original_steps else self.ddim_timesteps.shape[0]
-
-        assert t_enc <= num_reference_steps
-        num_steps = t_enc
-
-        if use_original_steps:
-            alphas_next = self.alphas_cumprod[:num_steps]
-            alphas = self.alphas_cumprod_prev[:num_steps]
-        else:
-            alphas_next = self.ddim_alphas[:num_steps]
-            alphas = torch.tensor(self.ddim_alphas_prev[:num_steps])
-
-        x_next = x0
-        intermediates = []
-        inter_steps = []
-        for i in tqdm(range(num_steps), desc='Encoding Image'):
-            t = torch.full((x0.shape[0],), i, device=self.model.device, dtype=torch.long)
-            if unconditional_guidance_scale == 1.:
-                noise_pred = self.model.apply_model(x_next, t, c)
-            else:
-                assert unconditional_conditioning is not None
-                e_t_uncond, noise_pred = torch.chunk(
-                    self.model.apply_model(torch.cat((x_next, x_next)), torch.cat((t, t)),
-                                           torch.cat((unconditional_conditioning, c))), 2)
-                noise_pred = e_t_uncond + unconditional_guidance_scale * (noise_pred - e_t_uncond)
-
-            xt_weighted = (alphas_next[i] / alphas[i]).sqrt() * x_next
-            weighted_noise_pred = alphas_next[i].sqrt() * (
-                    (1 / alphas_next[i] - 1).sqrt() - (1 / alphas[i] - 1).sqrt()) * noise_pred
-            x_next = xt_weighted + weighted_noise_pred
-            if return_intermediates and i % (
-                    num_steps // return_intermediates) == 0 and i < num_steps - 1:
-                intermediates.append(x_next)
-                inter_steps.append(i)
-            elif return_intermediates and i >= num_steps - 2:
-                intermediates.append(x_next)
-                inter_steps.append(i)
-            if callback: callback(i)
-
-        out = {'x_encoded': x_next, 'intermediate_steps': inter_steps}
-        if return_intermediates:
-            out.update({'intermediates': intermediates})
-        return x_next, out
-
-    @torch.no_grad()
-    def stochastic_encode(self, x0, t, use_original_steps=False, noise=None):
-        # fast, but does not allow for exact reconstruction
-        # t serves as an index to gather the correct alphas
-        if use_original_steps:
-            sqrt_alphas_cumprod = self.sqrt_alphas_cumprod
-            sqrt_one_minus_alphas_cumprod = self.sqrt_one_minus_alphas_cumprod
-        else:
-            sqrt_alphas_cumprod = torch.sqrt(self.ddim_alphas)
-            sqrt_one_minus_alphas_cumprod = self.ddim_sqrt_one_minus_alphas
-
-        if noise is None:
-            noise = torch.randn_like(x0)
-        return (extract_into_tensor(sqrt_alphas_cumprod, t, x0.shape) * x0 +
-                extract_into_tensor(sqrt_one_minus_alphas_cumprod, t, x0.shape) * noise)
-
-    @torch.no_grad()
-    def decode(self, x_latent, cond, t_start, unconditional_guidance_scale=1.0, unconditional_conditioning=None,
-               use_original_steps=False, callback=None):
-
-        timesteps = np.arange(self.ddpm_num_timesteps) if use_original_steps else self.ddim_timesteps
-        timesteps = timesteps[:t_start]
-
-        time_range = np.flip(timesteps)
-        total_steps = timesteps.shape[0]
-        print(f"Running DDIM Sampling with {total_steps} timesteps")
-
-        iterator = tqdm(time_range, desc='Decoding image', total=total_steps)
-        x_dec = x_latent
-        for i, step in enumerate(iterator):
-            index = total_steps - i - 1
-            ts = torch.full((x_latent.shape[0],), step, device=x_latent.device, dtype=torch.long)
-            x_dec, _ = self.p_sample_ddim(x_dec, cond, ts, index=index, use_original_steps=use_original_steps,
-                                          unconditional_guidance_scale=unconditional_guidance_scale,
-                                          unconditional_conditioning=unconditional_conditioning)
-            if callback: callback(i)
-        return x_dec

spaces/Aabbhishekk/MistralQnA/app.py

@@ -1,60 +0,0 @@
-import streamlit as st
-
-st.title("Mistral QA")
-
-# import chainlit as cl
-
-import os
-huggingfacehub_api_token = st.secrets["hf_token"]
-
-from langchain import HuggingFaceHub, PromptTemplate, LLMChain
-
-repo_id = "mistralai/Mistral-7B-v0.1"
-llm = HuggingFaceHub(huggingfacehub_api_token=huggingfacehub_api_token, 
-                     repo_id=repo_id, 
-                     model_kwargs={"temperature":0.2, "max_new_tokens":200})
-
-template = """Give answer for the question. 
-question: {question}
-
-At the end of the answer, just say, 'Thanks for asking'
-
-"""
-# input = st.text_input("What do you want to ask about", placeholder="Input your question here")
-
-
-# # @cl.langchain_factory
-# def factory():
-#     prompt = PromptTemplate(template=template, input_variables=['question'])
-#     llm_chain = LLMChain(prompt=prompt, llm=llm, verbose=True)
-
-#     return llm_chain
-
-
-prompt = PromptTemplate(template=template, input_variables=["question"])
-llm_chain = LLMChain(prompt=prompt,verbose=True,llm=llm)
-
-# result = llm_chain.predict(question=input)
-
-# print(result)
-
-def chat(query):
-    # prompt = PromptTemplate(template=template, input_variables=["question"])
-    # llm_chain = LLMChain(prompt=prompt,verbose=True,llm=llm)
-
-    result = llm_chain.predict(question=query)
-
-    return result
-
-
-
-
-def main():
-    input = st.text_input("What do you want to ask about", placeholder="Input your question here")
-    if input:
-        output = chat(input)
-        st.write(output,unsafe_allow_html=True)
-
-
-if __name__ == '__main__':
-    main()

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

@@ -1,27 +0,0 @@
-var RotateAround = Phaser.Math.RotateAround;
-var LocalToWorld = function (gameObject, localX, localY, out) {
-    if (out === undefined) {
-        out = {};
-    } else if (out === true) {
-        if (GlobOut === undefined) {
-            GlobOut = {};
-        }
-        out = GlobOut;
-    }
-
-    localX -= (gameObject.width * gameObject.originX);
-    localY -= (gameObject.height * gameObject.originY);
-    var point = {
-        x: localX * gameObject.scaleX,
-        y: localY * gameObject.scaleY
-    };
-    RotateAround(point, 0, 0, -gameObject.rotation);
-
-    out.x = gameObject.x + localX;
-    out.y = gameObject.y + localY;
-
-    return out;
-}
-
-var GlobOut;
-export { LocalToWorld };

spaces/AleksBlacky/Arxiv_paper_classifier/README.md

@@ -1,14 +0,0 @@
----
-title: Arxiv_paper_classifier
-emoji: 📉
-colorFrom: gray
-colorTo: pink
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
-

spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/examples/community/stable_diffusion_comparison.py

@@ -1,405 +0,0 @@
-from typing import Any, Callable, Dict, List, Optional, Union
-
-import torch
-from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTokenizer
-
-from diffusers import (
-    AutoencoderKL,
-    DDIMScheduler,
-    DiffusionPipeline,
-    LMSDiscreteScheduler,
-    PNDMScheduler,
-    StableDiffusionPipeline,
-    UNet2DConditionModel,
-)
-from diffusers.pipelines.stable_diffusion import StableDiffusionPipelineOutput
-from diffusers.pipelines.stable_diffusion.safety_checker import StableDiffusionSafetyChecker
-
-
-pipe1_model_id = "CompVis/stable-diffusion-v1-1"
-pipe2_model_id = "CompVis/stable-diffusion-v1-2"
-pipe3_model_id = "CompVis/stable-diffusion-v1-3"
-pipe4_model_id = "CompVis/stable-diffusion-v1-4"
-
-
-class StableDiffusionComparisonPipeline(DiffusionPipeline):
-    r"""
-    Pipeline for parallel comparison of Stable Diffusion v1-v4
-    This pipeline inherits from DiffusionPipeline and depends on the use of an Auth Token for
-    downloading pre-trained checkpoints from Hugging Face Hub.
-    If using Hugging Face Hub, pass the Model ID for Stable Diffusion v1.4 as the previous 3 checkpoints will be loaded
-    automatically.
-    Args:
-        vae ([`AutoencoderKL`]):
-            Variational Auto-Encoder (VAE) Model to encode and decode images to and from latent representations.
-        text_encoder ([`CLIPTextModel`]):
-            Frozen text-encoder. Stable Diffusion uses the text portion of
-            [CLIP](https://huggingface.co/docs/transformers/model_doc/clip#transformers.CLIPTextModel), specifically
-            the [clip-vit-large-patch14](https://huggingface.co/openai/clip-vit-large-patch14) variant.
-        tokenizer (`CLIPTokenizer`):
-            Tokenizer of class
-            [CLIPTokenizer](https://huggingface.co/docs/transformers/v4.21.0/en/model_doc/clip#transformers.CLIPTokenizer).
-        unet ([`UNet2DConditionModel`]): Conditional U-Net architecture to denoise the encoded image latents.
-        scheduler ([`SchedulerMixin`]):
-            A scheduler to be used in combination with `unet` to denoise the encoded image latents. Can be one of
-            [`DDIMScheduler`], [`LMSDiscreteScheduler`], or [`PNDMScheduler`].
-        safety_checker ([`StableDiffusionMegaSafetyChecker`]):
-            Classification module that estimates whether generated images could be considered offensive or harmful.
-            Please, refer to the [model card](https://huggingface.co/runwayml/stable-diffusion-v1-5) for details.
-        feature_extractor ([`CLIPImageProcessor`]):
-            Model that extracts features from generated images to be used as inputs for the `safety_checker`.
-    """
-
-    def __init__(
-        self,
-        vae: AutoencoderKL,
-        text_encoder: CLIPTextModel,
-        tokenizer: CLIPTokenizer,
-        unet: UNet2DConditionModel,
-        scheduler: Union[DDIMScheduler, PNDMScheduler, LMSDiscreteScheduler],
-        safety_checker: StableDiffusionSafetyChecker,
-        feature_extractor: CLIPImageProcessor,
-        requires_safety_checker: bool = True,
-    ):
-        super()._init_()
-
-        self.pipe1 = StableDiffusionPipeline.from_pretrained(pipe1_model_id)
-        self.pipe2 = StableDiffusionPipeline.from_pretrained(pipe2_model_id)
-        self.pipe3 = StableDiffusionPipeline.from_pretrained(pipe3_model_id)
-        self.pipe4 = StableDiffusionPipeline(
-            vae=vae,
-            text_encoder=text_encoder,
-            tokenizer=tokenizer,
-            unet=unet,
-            scheduler=scheduler,
-            safety_checker=safety_checker,
-            feature_extractor=feature_extractor,
-            requires_safety_checker=requires_safety_checker,
-        )
-
-        self.register_modules(pipeline1=self.pipe1, pipeline2=self.pipe2, pipeline3=self.pipe3, pipeline4=self.pipe4)
-
-    @property
-    def layers(self) -> Dict[str, Any]:
-        return {k: getattr(self, k) for k in self.config.keys() if not k.startswith("_")}
-
-    def enable_attention_slicing(self, slice_size: Optional[Union[str, int]] = "auto"):
-        r"""
-        Enable sliced attention computation.
-        When this option is enabled, the attention module will split the input tensor in slices, to compute attention
-        in several steps. This is useful to save some memory in exchange for a small speed decrease.
-        Args:
-            slice_size (`str` or `int`, *optional*, defaults to `"auto"`):
-                When `"auto"`, halves the input to the attention heads, so attention will be computed in two steps. If
-                a number is provided, uses as many slices as `attention_head_dim // slice_size`. In this case,
-                `attention_head_dim` must be a multiple of `slice_size`.
-        """
-        if slice_size == "auto":
-            # half the attention head size is usually a good trade-off between
-            # speed and memory
-            slice_size = self.unet.config.attention_head_dim // 2
-        self.unet.set_attention_slice(slice_size)
-
-    def disable_attention_slicing(self):
-        r"""
-        Disable sliced attention computation. If `enable_attention_slicing` was previously invoked, this method will go
-        back to computing attention in one step.
-        """
-        # set slice_size = `None` to disable `attention slicing`
-        self.enable_attention_slicing(None)
-
-    @torch.no_grad()
-    def text2img_sd1_1(
-        self,
-        prompt: Union[str, List[str]],
-        height: int = 512,
-        width: int = 512,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        **kwargs,
-    ):
-        return self.pipe1(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-    @torch.no_grad()
-    def text2img_sd1_2(
-        self,
-        prompt: Union[str, List[str]],
-        height: int = 512,
-        width: int = 512,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        **kwargs,
-    ):
-        return self.pipe2(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-    @torch.no_grad()
-    def text2img_sd1_3(
-        self,
-        prompt: Union[str, List[str]],
-        height: int = 512,
-        width: int = 512,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        **kwargs,
-    ):
-        return self.pipe3(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-    @torch.no_grad()
-    def text2img_sd1_4(
-        self,
-        prompt: Union[str, List[str]],
-        height: int = 512,
-        width: int = 512,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        **kwargs,
-    ):
-        return self.pipe4(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-    @torch.no_grad()
-    def _call_(
-        self,
-        prompt: Union[str, List[str]],
-        height: int = 512,
-        width: int = 512,
-        num_inference_steps: int = 50,
-        guidance_scale: float = 7.5,
-        negative_prompt: Optional[Union[str, List[str]]] = None,
-        num_images_per_prompt: Optional[int] = 1,
-        eta: float = 0.0,
-        generator: Optional[torch.Generator] = None,
-        latents: Optional[torch.FloatTensor] = None,
-        output_type: Optional[str] = "pil",
-        return_dict: bool = True,
-        callback: Optional[Callable[[int, int, torch.FloatTensor], None]] = None,
-        callback_steps: int = 1,
-        **kwargs,
-    ):
-        r"""
-        Function invoked when calling the pipeline for generation. This function will generate 4 results as part
-        of running all the 4 pipelines for SD1.1-1.4 together in a serial-processing, parallel-invocation fashion.
-        Args:
-            prompt (`str` or `List[str]`):
-                The prompt or prompts to guide the image generation.
-            height (`int`, optional, defaults to 512):
-                The height in pixels of the generated image.
-            width (`int`, optional, defaults to 512):
-                The width in pixels of the generated image.
-            num_inference_steps (`int`, optional, defaults to 50):
-                The number of denoising steps. More denoising steps usually lead to a higher quality image at the
-                expense of slower inference.
-            guidance_scale (`float`, optional, defaults to 7.5):
-                Guidance scale as defined in [Classifier-Free Diffusion Guidance](https://arxiv.org/abs/2207.12598).
-                `guidance_scale` is defined as `w` of equation 2. of [Imagen
-                Paper](https://arxiv.org/pdf/2205.11487.pdf). Guidance scale is enabled by setting `guidance_scale >
-                1`. Higher guidance scale encourages to generate images that are closely linked to the text `prompt`,
-                usually at the expense of lower image quality.
-            eta (`float`, optional, defaults to 0.0):
-                Corresponds to parameter eta (η) in the DDIM paper: https://arxiv.org/abs/2010.02502. Only applies to
-                [`schedulers.DDIMScheduler`], will be ignored for others.
-            generator (`torch.Generator`, optional):
-                A [torch generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make generation
-                deterministic.
-            latents (`torch.FloatTensor`, optional):
-                Pre-generated noisy latents, sampled from a Gaussian distribution, to be used as inputs for image
-                generation. Can be used to tweak the same generation with different prompts. If not provided, a latents
-                tensor will ge generated by sampling using the supplied random `generator`.
-            output_type (`str`, optional, defaults to `"pil"`):
-                The output format of the generate image. Choose between
-                [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
-            return_dict (`bool`, optional, defaults to `True`):
-                Whether or not to return a [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] instead of a
-                plain tuple.
-        Returns:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] or `tuple`:
-            [`~pipelines.stable_diffusion.StableDiffusionPipelineOutput`] if `return_dict` is True, otherwise a `tuple.
-            When returning a tuple, the first element is a list with the generated images, and the second element is a
-            list of `bool`s denoting whether the corresponding generated image likely represents "not-safe-for-work"
-            (nsfw) content, according to the `safety_checker`.
-        """
-
-        device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.to(device)
-
-        # Checks if the height and width are divisible by 8 or not
-        if height % 8 != 0 or width % 8 != 0:
-            raise ValueError(f"`height` and `width` must be divisible by 8 but are {height} and {width}.")
-
-        # Get first result from Stable Diffusion Checkpoint v1.1
-        res1 = self.text2img_sd1_1(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-        # Get first result from Stable Diffusion Checkpoint v1.2
-        res2 = self.text2img_sd1_2(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-        # Get first result from Stable Diffusion Checkpoint v1.3
-        res3 = self.text2img_sd1_3(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-        # Get first result from Stable Diffusion Checkpoint v1.4
-        res4 = self.text2img_sd1_4(
-            prompt=prompt,
-            height=height,
-            width=width,
-            num_inference_steps=num_inference_steps,
-            guidance_scale=guidance_scale,
-            negative_prompt=negative_prompt,
-            num_images_per_prompt=num_images_per_prompt,
-            eta=eta,
-            generator=generator,
-            latents=latents,
-            output_type=output_type,
-            return_dict=return_dict,
-            callback=callback,
-            callback_steps=callback_steps,
-            **kwargs,
-        )
-
-        # Get all result images into a single list and pass it via StableDiffusionPipelineOutput for final result
-        return StableDiffusionPipelineOutput([res1[0], res2[0], res3[0], res4[0]])

spaces/Andy1621/uniformer_image_detection/configs/_base_/models/mask_rcnn_r50_caffe_c4.py

@@ -1,123 +0,0 @@
-# model settings
-norm_cfg = dict(type='BN', requires_grad=False)
-model = dict(
-    type='MaskRCNN',
-    pretrained='open-mmlab://detectron2/resnet50_caffe',
-    backbone=dict(
-        type='ResNet',
-        depth=50,
-        num_stages=3,
-        strides=(1, 2, 2),
-        dilations=(1, 1, 1),
-        out_indices=(2, ),
-        frozen_stages=1,
-        norm_cfg=norm_cfg,
-        norm_eval=True,
-        style='caffe'),
-    rpn_head=dict(
-        type='RPNHead',
-        in_channels=1024,
-        feat_channels=1024,
-        anchor_generator=dict(
-            type='AnchorGenerator',
-            scales=[2, 4, 8, 16, 32],
-            ratios=[0.5, 1.0, 2.0],
-            strides=[16]),
-        bbox_coder=dict(
-            type='DeltaXYWHBBoxCoder',
-            target_means=[.0, .0, .0, .0],
-            target_stds=[1.0, 1.0, 1.0, 1.0]),
-        loss_cls=dict(
-            type='CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
-        loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-    roi_head=dict(
-        type='StandardRoIHead',
-        shared_head=dict(
-            type='ResLayer',
-            depth=50,
-            stage=3,
-            stride=2,
-            dilation=1,
-            style='caffe',
-            norm_cfg=norm_cfg,
-            norm_eval=True),
-        bbox_roi_extractor=dict(
-            type='SingleRoIExtractor',
-            roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
-            out_channels=1024,
-            featmap_strides=[16]),
-        bbox_head=dict(
-            type='BBoxHead',
-            with_avg_pool=True,
-            roi_feat_size=7,
-            in_channels=2048,
-            num_classes=80,
-            bbox_coder=dict(
-                type='DeltaXYWHBBoxCoder',
-                target_means=[0., 0., 0., 0.],
-                target_stds=[0.1, 0.1, 0.2, 0.2]),
-            reg_class_agnostic=False,
-            loss_cls=dict(
-                type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
-            loss_bbox=dict(type='L1Loss', loss_weight=1.0)),
-        mask_roi_extractor=None,
-        mask_head=dict(
-            type='FCNMaskHead',
-            num_convs=0,
-            in_channels=2048,
-            conv_out_channels=256,
-            num_classes=80,
-            loss_mask=dict(
-                type='CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
-    # model training and testing settings
-    train_cfg=dict(
-        rpn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.7,
-                neg_iou_thr=0.3,
-                min_pos_iou=0.3,
-                match_low_quality=True,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=256,
-                pos_fraction=0.5,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=False),
-            allowed_border=0,
-            pos_weight=-1,
-            debug=False),
-        rpn_proposal=dict(
-            nms_pre=12000,
-            max_per_img=2000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            min_bbox_size=0),
-        rcnn=dict(
-            assigner=dict(
-                type='MaxIoUAssigner',
-                pos_iou_thr=0.5,
-                neg_iou_thr=0.5,
-                min_pos_iou=0.5,
-                match_low_quality=False,
-                ignore_iof_thr=-1),
-            sampler=dict(
-                type='RandomSampler',
-                num=512,
-                pos_fraction=0.25,
-                neg_pos_ub=-1,
-                add_gt_as_proposals=True),
-            mask_size=14,
-            pos_weight=-1,
-            debug=False)),
-    test_cfg=dict(
-        rpn=dict(
-            nms_pre=6000,
-            nms=dict(type='nms', iou_threshold=0.7),
-            max_per_img=1000,
-            min_bbox_size=0),
-        rcnn=dict(
-            score_thr=0.05,
-            nms=dict(type='nms', iou_threshold=0.5),
-            max_per_img=100,
-            mask_thr_binary=0.5)))

spaces/Andy1621/uniformer_image_detection/mmdet/models/backbones/swin_transformer.py

@@ -1,630 +0,0 @@
-# --------------------------------------------------------
-# Swin Transformer
-# Copyright (c) 2021 Microsoft
-# Licensed under The MIT License [see LICENSE for details]
-# Written by Ze Liu, Yutong Lin, Yixuan Wei
-# --------------------------------------------------------
-
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import torch.utils.checkpoint as checkpoint
-import numpy as np
-from timm.models.layers import DropPath, to_2tuple, trunc_normal_
-
-from mmcv_custom import load_checkpoint
-from mmdet.utils import get_root_logger
-from ..builder import BACKBONES
-
-
-class Mlp(nn.Module):
-    """ Multilayer perceptron."""
-
-    def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
-        super().__init__()
-        out_features = out_features or in_features
-        hidden_features = hidden_features or in_features
-        self.fc1 = nn.Linear(in_features, hidden_features)
-        self.act = act_layer()
-        self.fc2 = nn.Linear(hidden_features, out_features)
-        self.drop = nn.Dropout(drop)
-
-    def forward(self, x):
-        x = self.fc1(x)
-        x = self.act(x)
-        x = self.drop(x)
-        x = self.fc2(x)
-        x = self.drop(x)
-        return x
-
-
-def window_partition(x, window_size):
-    """
-    Args:
-        x: (B, H, W, C)
-        window_size (int): window size
-
-    Returns:
-        windows: (num_windows*B, window_size, window_size, C)
-    """
-    B, H, W, C = x.shape
-    x = x.view(B, H // window_size, window_size, W // window_size, window_size, C)
-    windows = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(-1, window_size, window_size, C)
-    return windows
-
-
-def window_reverse(windows, window_size, H, W):
-    """
-    Args:
-        windows: (num_windows*B, window_size, window_size, C)
-        window_size (int): Window size
-        H (int): Height of image
-        W (int): Width of image
-
-    Returns:
-        x: (B, H, W, C)
-    """
-    B = int(windows.shape[0] / (H * W / window_size / window_size))
-    x = windows.view(B, H // window_size, W // window_size, window_size, window_size, -1)
-    x = x.permute(0, 1, 3, 2, 4, 5).contiguous().view(B, H, W, -1)
-    return x
-
-
-class WindowAttention(nn.Module):
-    """ Window based multi-head self attention (W-MSA) module with relative position bias.
-    It supports both of shifted and non-shifted window.
-
-    Args:
-        dim (int): Number of input channels.
-        window_size (tuple[int]): The height and width of the window.
-        num_heads (int): Number of attention heads.
-        qkv_bias (bool, optional):  If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set
-        attn_drop (float, optional): Dropout ratio of attention weight. Default: 0.0
-        proj_drop (float, optional): Dropout ratio of output. Default: 0.0
-    """
-
-    def __init__(self, dim, window_size, num_heads, qkv_bias=True, qk_scale=None, attn_drop=0., proj_drop=0.):
-
-        super().__init__()
-        self.dim = dim
-        self.window_size = window_size  # Wh, Ww
-        self.num_heads = num_heads
-        head_dim = dim // num_heads
-        self.scale = qk_scale or head_dim ** -0.5
-
-        # define a parameter table of relative position bias
-        self.relative_position_bias_table = nn.Parameter(
-            torch.zeros((2 * window_size[0] - 1) * (2 * window_size[1] - 1), num_heads))  # 2*Wh-1 * 2*Ww-1, nH
-
-        # get pair-wise relative position index for each token inside the window
-        coords_h = torch.arange(self.window_size[0])
-        coords_w = torch.arange(self.window_size[1])
-        coords = torch.stack(torch.meshgrid([coords_h, coords_w]))  # 2, Wh, Ww
-        coords_flatten = torch.flatten(coords, 1)  # 2, Wh*Ww
-        relative_coords = coords_flatten[:, :, None] - coords_flatten[:, None, :]  # 2, Wh*Ww, Wh*Ww
-        relative_coords = relative_coords.permute(1, 2, 0).contiguous()  # Wh*Ww, Wh*Ww, 2
-        relative_coords[:, :, 0] += self.window_size[0] - 1  # shift to start from 0
-        relative_coords[:, :, 1] += self.window_size[1] - 1
-        relative_coords[:, :, 0] *= 2 * self.window_size[1] - 1
-        relative_position_index = relative_coords.sum(-1)  # Wh*Ww, Wh*Ww
-        self.register_buffer("relative_position_index", relative_position_index)
-
-        self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
-        self.attn_drop = nn.Dropout(attn_drop)
-        self.proj = nn.Linear(dim, dim)
-        self.proj_drop = nn.Dropout(proj_drop)
-
-        trunc_normal_(self.relative_position_bias_table, std=.02)
-        self.softmax = nn.Softmax(dim=-1)
-
-    def forward(self, x, mask=None):
-        """ Forward function.
-
-        Args:
-            x: input features with shape of (num_windows*B, N, C)
-            mask: (0/-inf) mask with shape of (num_windows, Wh*Ww, Wh*Ww) or None
-        """
-        B_, N, C = x.shape
-        qkv = self.qkv(x).reshape(B_, N, 3, self.num_heads, C // self.num_heads).permute(2, 0, 3, 1, 4)
-        q, k, v = qkv[0], qkv[1], qkv[2]  # make torchscript happy (cannot use tensor as tuple)
-
-        q = q * self.scale
-        attn = (q @ k.transpose(-2, -1))
-
-        relative_position_bias = self.relative_position_bias_table[self.relative_position_index.view(-1)].view(
-            self.window_size[0] * self.window_size[1], self.window_size[0] * self.window_size[1], -1)  # Wh*Ww,Wh*Ww,nH
-        relative_position_bias = relative_position_bias.permute(2, 0, 1).contiguous()  # nH, Wh*Ww, Wh*Ww
-        attn = attn + relative_position_bias.unsqueeze(0)
-
-        if mask is not None:
-            nW = mask.shape[0]
-            attn = attn.view(B_ // nW, nW, self.num_heads, N, N) + mask.unsqueeze(1).unsqueeze(0)
-            attn = attn.view(-1, self.num_heads, N, N)
-            attn = self.softmax(attn)
-        else:
-            attn = self.softmax(attn)
-
-        attn = self.attn_drop(attn)
-
-        x = (attn @ v).transpose(1, 2).reshape(B_, N, C)
-        x = self.proj(x)
-        x = self.proj_drop(x)
-        return x
-
-
-class SwinTransformerBlock(nn.Module):
-    """ Swin Transformer Block.
-
-    Args:
-        dim (int): Number of input channels.
-        num_heads (int): Number of attention heads.
-        window_size (int): Window size.
-        shift_size (int): Shift size for SW-MSA.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float, optional): Stochastic depth rate. Default: 0.0
-        act_layer (nn.Module, optional): Activation layer. Default: nn.GELU
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-
-    def __init__(self, dim, num_heads, window_size=7, shift_size=0,
-                 mlp_ratio=4., qkv_bias=True, qk_scale=None, drop=0., attn_drop=0., drop_path=0.,
-                 act_layer=nn.GELU, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.dim = dim
-        self.num_heads = num_heads
-        self.window_size = window_size
-        self.shift_size = shift_size
-        self.mlp_ratio = mlp_ratio
-        assert 0 <= self.shift_size < self.window_size, "shift_size must in 0-window_size"
-
-        self.norm1 = norm_layer(dim)
-        self.attn = WindowAttention(
-            dim, window_size=to_2tuple(self.window_size), num_heads=num_heads,
-            qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
-
-        self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
-        self.norm2 = norm_layer(dim)
-        mlp_hidden_dim = int(dim * mlp_ratio)
-        self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
-
-        self.H = None
-        self.W = None
-
-    def forward(self, x, mask_matrix):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-            mask_matrix: Attention mask for cyclic shift.
-        """
-        B, L, C = x.shape
-        H, W = self.H, self.W
-        assert L == H * W, "input feature has wrong size"
-
-        shortcut = x
-        x = self.norm1(x)
-        x = x.view(B, H, W, C)
-
-        # pad feature maps to multiples of window size
-        pad_l = pad_t = 0
-        pad_r = (self.window_size - W % self.window_size) % self.window_size
-        pad_b = (self.window_size - H % self.window_size) % self.window_size
-        x = F.pad(x, (0, 0, pad_l, pad_r, pad_t, pad_b))
-        _, Hp, Wp, _ = x.shape
-
-        # cyclic shift
-        if self.shift_size > 0:
-            shifted_x = torch.roll(x, shifts=(-self.shift_size, -self.shift_size), dims=(1, 2))
-            attn_mask = mask_matrix
-        else:
-            shifted_x = x
-            attn_mask = None
-
-        # partition windows
-        x_windows = window_partition(shifted_x, self.window_size)  # nW*B, window_size, window_size, C
-        x_windows = x_windows.view(-1, self.window_size * self.window_size, C)  # nW*B, window_size*window_size, C
-
-        # W-MSA/SW-MSA
-        attn_windows = self.attn(x_windows, mask=attn_mask)  # nW*B, window_size*window_size, C
-
-        # merge windows
-        attn_windows = attn_windows.view(-1, self.window_size, self.window_size, C)
-        shifted_x = window_reverse(attn_windows, self.window_size, Hp, Wp)  # B H' W' C
-
-        # reverse cyclic shift
-        if self.shift_size > 0:
-            x = torch.roll(shifted_x, shifts=(self.shift_size, self.shift_size), dims=(1, 2))
-        else:
-            x = shifted_x
-
-        if pad_r > 0 or pad_b > 0:
-            x = x[:, :H, :W, :].contiguous()
-
-        x = x.view(B, H * W, C)
-
-        # FFN
-        x = shortcut + self.drop_path(x)
-        x = x + self.drop_path(self.mlp(self.norm2(x)))
-
-        return x
-
-
-class PatchMerging(nn.Module):
-    """ Patch Merging Layer
-
-    Args:
-        dim (int): Number of input channels.
-        norm_layer (nn.Module, optional): Normalization layer.  Default: nn.LayerNorm
-    """
-    def __init__(self, dim, norm_layer=nn.LayerNorm):
-        super().__init__()
-        self.dim = dim
-        self.reduction = nn.Linear(4 * dim, 2 * dim, bias=False)
-        self.norm = norm_layer(4 * dim)
-
-    def forward(self, x, H, W):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-        """
-        B, L, C = x.shape
-        assert L == H * W, "input feature has wrong size"
-
-        x = x.view(B, H, W, C)
-
-        # padding
-        pad_input = (H % 2 == 1) or (W % 2 == 1)
-        if pad_input:
-            x = F.pad(x, (0, 0, 0, W % 2, 0, H % 2))
-
-        x0 = x[:, 0::2, 0::2, :]  # B H/2 W/2 C
-        x1 = x[:, 1::2, 0::2, :]  # B H/2 W/2 C
-        x2 = x[:, 0::2, 1::2, :]  # B H/2 W/2 C
-        x3 = x[:, 1::2, 1::2, :]  # B H/2 W/2 C
-        x = torch.cat([x0, x1, x2, x3], -1)  # B H/2 W/2 4*C
-        x = x.view(B, -1, 4 * C)  # B H/2*W/2 4*C
-
-        x = self.norm(x)
-        x = self.reduction(x)
-
-        return x
-
-
-class BasicLayer(nn.Module):
-    """ A basic Swin Transformer layer for one stage.
-
-    Args:
-        dim (int): Number of feature channels
-        depth (int): Depths of this stage.
-        num_heads (int): Number of attention head.
-        window_size (int): Local window size. Default: 7.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
-        qkv_bias (bool, optional): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float | None, optional): Override default qk scale of head_dim ** -0.5 if set.
-        drop (float, optional): Dropout rate. Default: 0.0
-        attn_drop (float, optional): Attention dropout rate. Default: 0.0
-        drop_path (float | tuple[float], optional): Stochastic depth rate. Default: 0.0
-        norm_layer (nn.Module, optional): Normalization layer. Default: nn.LayerNorm
-        downsample (nn.Module | None, optional): Downsample layer at the end of the layer. Default: None
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
-    """
-
-    def __init__(self,
-                 dim,
-                 depth,
-                 num_heads,
-                 window_size=7,
-                 mlp_ratio=4.,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 drop=0.,
-                 attn_drop=0.,
-                 drop_path=0.,
-                 norm_layer=nn.LayerNorm,
-                 downsample=None,
-                 use_checkpoint=False):
-        super().__init__()
-        self.window_size = window_size
-        self.shift_size = window_size // 2
-        self.depth = depth
-        self.use_checkpoint = use_checkpoint
-
-        # build blocks
-        self.blocks = nn.ModuleList([
-            SwinTransformerBlock(
-                dim=dim,
-                num_heads=num_heads,
-                window_size=window_size,
-                shift_size=0 if (i % 2 == 0) else window_size // 2,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop,
-                attn_drop=attn_drop,
-                drop_path=drop_path[i] if isinstance(drop_path, list) else drop_path,
-                norm_layer=norm_layer)
-            for i in range(depth)])
-
-        # patch merging layer
-        if downsample is not None:
-            self.downsample = downsample(dim=dim, norm_layer=norm_layer)
-        else:
-            self.downsample = None
-
-    def forward(self, x, H, W):
-        """ Forward function.
-
-        Args:
-            x: Input feature, tensor size (B, H*W, C).
-            H, W: Spatial resolution of the input feature.
-        """
-
-        # calculate attention mask for SW-MSA
-        Hp = int(np.ceil(H / self.window_size)) * self.window_size
-        Wp = int(np.ceil(W / self.window_size)) * self.window_size
-        img_mask = torch.zeros((1, Hp, Wp, 1), device=x.device)  # 1 Hp Wp 1
-        h_slices = (slice(0, -self.window_size),
-                    slice(-self.window_size, -self.shift_size),
-                    slice(-self.shift_size, None))
-        w_slices = (slice(0, -self.window_size),
-                    slice(-self.window_size, -self.shift_size),
-                    slice(-self.shift_size, None))
-        cnt = 0
-        for h in h_slices:
-            for w in w_slices:
-                img_mask[:, h, w, :] = cnt
-                cnt += 1
-
-        mask_windows = window_partition(img_mask, self.window_size)  # nW, window_size, window_size, 1
-        mask_windows = mask_windows.view(-1, self.window_size * self.window_size)
-        attn_mask = mask_windows.unsqueeze(1) - mask_windows.unsqueeze(2)
-        attn_mask = attn_mask.masked_fill(attn_mask != 0, float(-100.0)).masked_fill(attn_mask == 0, float(0.0))
-
-        for blk in self.blocks:
-            blk.H, blk.W = H, W
-            if self.use_checkpoint:
-                x = checkpoint.checkpoint(blk, x, attn_mask)
-            else:
-                x = blk(x, attn_mask)
-        if self.downsample is not None:
-            x_down = self.downsample(x, H, W)
-            Wh, Ww = (H + 1) // 2, (W + 1) // 2
-            return x, H, W, x_down, Wh, Ww
-        else:
-            return x, H, W, x, H, W
-
-
-class PatchEmbed(nn.Module):
-    """ Image to Patch Embedding
-
-    Args:
-        patch_size (int): Patch token size. Default: 4.
-        in_chans (int): Number of input image channels. Default: 3.
-        embed_dim (int): Number of linear projection output channels. Default: 96.
-        norm_layer (nn.Module, optional): Normalization layer. Default: None
-    """
-
-    def __init__(self, patch_size=4, in_chans=3, embed_dim=96, norm_layer=None):
-        super().__init__()
-        patch_size = to_2tuple(patch_size)
-        self.patch_size = patch_size
-
-        self.in_chans = in_chans
-        self.embed_dim = embed_dim
-
-        self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
-        if norm_layer is not None:
-            self.norm = norm_layer(embed_dim)
-        else:
-            self.norm = None
-
-    def forward(self, x):
-        """Forward function."""
-        # padding
-        _, _, H, W = x.size()
-        if W % self.patch_size[1] != 0:
-            x = F.pad(x, (0, self.patch_size[1] - W % self.patch_size[1]))
-        if H % self.patch_size[0] != 0:
-            x = F.pad(x, (0, 0, 0, self.patch_size[0] - H % self.patch_size[0]))
-
-        x = self.proj(x)  # B C Wh Ww
-        if self.norm is not None:
-            Wh, Ww = x.size(2), x.size(3)
-            x = x.flatten(2).transpose(1, 2)
-            x = self.norm(x)
-            x = x.transpose(1, 2).view(-1, self.embed_dim, Wh, Ww)
-
-        return x
-
-
-@BACKBONES.register_module()
-class SwinTransformer(nn.Module):
-    """ Swin Transformer backbone.
-        A PyTorch impl of : `Swin Transformer: Hierarchical Vision Transformer using Shifted Windows`  -
-          https://arxiv.org/pdf/2103.14030
-
-    Args:
-        pretrain_img_size (int): Input image size for training the pretrained model,
-            used in absolute postion embedding. Default 224.
-        patch_size (int | tuple(int)): Patch size. Default: 4.
-        in_chans (int): Number of input image channels. Default: 3.
-        embed_dim (int): Number of linear projection output channels. Default: 96.
-        depths (tuple[int]): Depths of each Swin Transformer stage.
-        num_heads (tuple[int]): Number of attention head of each stage.
-        window_size (int): Window size. Default: 7.
-        mlp_ratio (float): Ratio of mlp hidden dim to embedding dim. Default: 4.
-        qkv_bias (bool): If True, add a learnable bias to query, key, value. Default: True
-        qk_scale (float): Override default qk scale of head_dim ** -0.5 if set.
-        drop_rate (float): Dropout rate.
-        attn_drop_rate (float): Attention dropout rate. Default: 0.
-        drop_path_rate (float): Stochastic depth rate. Default: 0.2.
-        norm_layer (nn.Module): Normalization layer. Default: nn.LayerNorm.
-        ape (bool): If True, add absolute position embedding to the patch embedding. Default: False.
-        patch_norm (bool): If True, add normalization after patch embedding. Default: True.
-        out_indices (Sequence[int]): Output from which stages.
-        frozen_stages (int): Stages to be frozen (stop grad and set eval mode).
-            -1 means not freezing any parameters.
-        use_checkpoint (bool): Whether to use checkpointing to save memory. Default: False.
-    """
-
-    def __init__(self,
-                 pretrain_img_size=224,
-                 patch_size=4,
-                 in_chans=3,
-                 embed_dim=96,
-                 depths=[2, 2, 6, 2],
-                 num_heads=[3, 6, 12, 24],
-                 window_size=7,
-                 mlp_ratio=4.,
-                 qkv_bias=True,
-                 qk_scale=None,
-                 drop_rate=0.,
-                 attn_drop_rate=0.,
-                 drop_path_rate=0.2,
-                 norm_layer=nn.LayerNorm,
-                 ape=False,
-                 patch_norm=True,
-                 out_indices=(0, 1, 2, 3),
-                 frozen_stages=-1,
-                 use_checkpoint=False):
-        super().__init__()
-
-        self.pretrain_img_size = pretrain_img_size
-        self.num_layers = len(depths)
-        self.embed_dim = embed_dim
-        self.ape = ape
-        self.patch_norm = patch_norm
-        self.out_indices = out_indices
-        self.frozen_stages = frozen_stages
-
-        # split image into non-overlapping patches
-        self.patch_embed = PatchEmbed(
-            patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim,
-            norm_layer=norm_layer if self.patch_norm else None)
-
-        # absolute position embedding
-        if self.ape:
-            pretrain_img_size = to_2tuple(pretrain_img_size)
-            patch_size = to_2tuple(patch_size)
-            patches_resolution = [pretrain_img_size[0] // patch_size[0], pretrain_img_size[1] // patch_size[1]]
-
-            self.absolute_pos_embed = nn.Parameter(torch.zeros(1, embed_dim, patches_resolution[0], patches_resolution[1]))
-            trunc_normal_(self.absolute_pos_embed, std=.02)
-
-        self.pos_drop = nn.Dropout(p=drop_rate)
-
-        # stochastic depth
-        dpr = [x.item() for x in torch.linspace(0, drop_path_rate, sum(depths))]  # stochastic depth decay rule
-
-        # build layers
-        self.layers = nn.ModuleList()
-        for i_layer in range(self.num_layers):
-            layer = BasicLayer(
-                dim=int(embed_dim * 2 ** i_layer),
-                depth=depths[i_layer],
-                num_heads=num_heads[i_layer],
-                window_size=window_size,
-                mlp_ratio=mlp_ratio,
-                qkv_bias=qkv_bias,
-                qk_scale=qk_scale,
-                drop=drop_rate,
-                attn_drop=attn_drop_rate,
-                drop_path=dpr[sum(depths[:i_layer]):sum(depths[:i_layer + 1])],
-                norm_layer=norm_layer,
-                downsample=PatchMerging if (i_layer < self.num_layers - 1) else None,
-                use_checkpoint=use_checkpoint)
-            self.layers.append(layer)
-
-        num_features = [int(embed_dim * 2 ** i) for i in range(self.num_layers)]
-        self.num_features = num_features
-
-        # add a norm layer for each output
-        for i_layer in out_indices:
-            layer = norm_layer(num_features[i_layer])
-            layer_name = f'norm{i_layer}'
-            self.add_module(layer_name, layer)
-
-        self._freeze_stages()
-
-    def _freeze_stages(self):
-        if self.frozen_stages >= 0:
-            self.patch_embed.eval()
-            for param in self.patch_embed.parameters():
-                param.requires_grad = False
-
-        if self.frozen_stages >= 1 and self.ape:
-            self.absolute_pos_embed.requires_grad = False
-
-        if self.frozen_stages >= 2:
-            self.pos_drop.eval()
-            for i in range(0, self.frozen_stages - 1):
-                m = self.layers[i]
-                m.eval()
-                for param in m.parameters():
-                    param.requires_grad = False
-
-    def init_weights(self, pretrained=None):
-        """Initialize the weights in backbone.
-
-        Args:
-            pretrained (str, optional): Path to pre-trained weights.
-                Defaults to None.
-        """
-
-        def _init_weights(m):
-            if isinstance(m, nn.Linear):
-                trunc_normal_(m.weight, std=.02)
-                if isinstance(m, nn.Linear) and m.bias is not None:
-                    nn.init.constant_(m.bias, 0)
-            elif isinstance(m, nn.LayerNorm):
-                nn.init.constant_(m.bias, 0)
-                nn.init.constant_(m.weight, 1.0)
-
-        if isinstance(pretrained, str):
-            self.apply(_init_weights)
-            logger = get_root_logger()
-            load_checkpoint(self, pretrained, strict=False, logger=logger)
-        elif pretrained is None:
-            self.apply(_init_weights)
-        else:
-            raise TypeError('pretrained must be a str or None')
-
-    def forward(self, x):
-        """Forward function."""
-        x = self.patch_embed(x)
-
-        Wh, Ww = x.size(2), x.size(3)
-        if self.ape:
-            # interpolate the position embedding to the corresponding size
-            absolute_pos_embed = F.interpolate(self.absolute_pos_embed, size=(Wh, Ww), mode='bicubic')
-            x = (x + absolute_pos_embed).flatten(2).transpose(1, 2)  # B Wh*Ww C
-        else:
-            x = x.flatten(2).transpose(1, 2)
-        x = self.pos_drop(x)
-
-        outs = []
-        for i in range(self.num_layers):
-            layer = self.layers[i]
-            x_out, H, W, x, Wh, Ww = layer(x, Wh, Ww)
-
-            if i in self.out_indices:
-                norm_layer = getattr(self, f'norm{i}')
-                x_out = norm_layer(x_out)
-
-                out = x_out.view(-1, H, W, self.num_features[i]).permute(0, 3, 1, 2).contiguous()
-                outs.append(out)
-
-        return tuple(outs)
-
-    def train(self, mode=True):
-        """Convert the model into training mode while keep layers freezed."""
-        super(SwinTransformer, self).train(mode)
-        self._freeze_stages()

spaces/Andy1621/uniformer_image_detection/mmdet/models/dense_heads/ga_retina_head.py

@@ -1,109 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, bias_init_with_prob, normal_init
-from mmcv.ops import MaskedConv2d
-
-from ..builder import HEADS
-from .guided_anchor_head import FeatureAdaption, GuidedAnchorHead
-
-
-@HEADS.register_module()
-class GARetinaHead(GuidedAnchorHead):
-    """Guided-Anchor-based RetinaNet head."""
-
-    def __init__(self,
-                 num_classes,
-                 in_channels,
-                 stacked_convs=4,
-                 conv_cfg=None,
-                 norm_cfg=None,
-                 **kwargs):
-        self.stacked_convs = stacked_convs
-        self.conv_cfg = conv_cfg
-        self.norm_cfg = norm_cfg
-        super(GARetinaHead, self).__init__(num_classes, in_channels, **kwargs)
-
-    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.conv_loc = nn.Conv2d(self.feat_channels, 1, 1)
-        self.conv_shape = nn.Conv2d(self.feat_channels, self.num_anchors * 2,
-                                    1)
-        self.feature_adaption_cls = FeatureAdaption(
-            self.feat_channels,
-            self.feat_channels,
-            kernel_size=3,
-            deform_groups=self.deform_groups)
-        self.feature_adaption_reg = FeatureAdaption(
-            self.feat_channels,
-            self.feat_channels,
-            kernel_size=3,
-            deform_groups=self.deform_groups)
-        self.retina_cls = MaskedConv2d(
-            self.feat_channels,
-            self.num_anchors * self.cls_out_channels,
-            3,
-            padding=1)
-        self.retina_reg = MaskedConv2d(
-            self.feat_channels, self.num_anchors * 4, 3, padding=1)
-
-    def init_weights(self):
-        """Initialize weights of the layer."""
-        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)
-
-        self.feature_adaption_cls.init_weights()
-        self.feature_adaption_reg.init_weights()
-
-        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)
-        normal_init(self.retina_cls, std=0.01, bias=bias_cls)
-        normal_init(self.retina_reg, std=0.01)
-
-    def forward_single(self, x):
-        """Forward feature map of a single scale level."""
-        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)
-
-        loc_pred = self.conv_loc(cls_feat)
-        shape_pred = self.conv_shape(reg_feat)
-
-        cls_feat = self.feature_adaption_cls(cls_feat, shape_pred)
-        reg_feat = self.feature_adaption_reg(reg_feat, shape_pred)
-
-        if not self.training:
-            mask = loc_pred.sigmoid()[0] >= self.loc_filter_thr
-        else:
-            mask = None
-        cls_score = self.retina_cls(cls_feat, mask)
-        bbox_pred = self.retina_reg(reg_feat, mask)
-        return cls_score, bbox_pred, shape_pred, loc_pred

spaces/AnishKumbhar/ChatBot/text-generation-webui-main/extensions/api/streaming_api.py

@@ -1,124 +0,0 @@
-import asyncio
-import json
-from threading import Thread
-
-from extensions.api.util import (
-    build_parameters,
-    try_start_cloudflared,
-    with_api_lock
-)
-from modules import shared
-from modules.chat import generate_chat_reply
-from modules.text_generation import generate_reply
-from websockets.server import serve
-
-PATH = '/api/v1/stream'
-
-
-@with_api_lock
-async def _handle_stream_message(websocket, message):
-    message = json.loads(message)
-
-    prompt = message['prompt']
-    generate_params = build_parameters(message)
-    stopping_strings = generate_params.pop('stopping_strings')
-    generate_params['stream'] = True
-
-    generator = generate_reply(
-        prompt, generate_params, stopping_strings=stopping_strings, is_chat=False)
-
-    # As we stream, only send the new bytes.
-    skip_index = 0
-    message_num = 0
-
-    for a in generator:
-        to_send = a[skip_index:]
-        if to_send is None or chr(0xfffd) in to_send:  # partial unicode character, don't send it yet.
-            continue
-
-        await websocket.send(json.dumps({
-            'event': 'text_stream',
-            'message_num': message_num,
-            'text': to_send
-        }))
-
-        await asyncio.sleep(0)
-        skip_index += len(to_send)
-        message_num += 1
-
-    await websocket.send(json.dumps({
-        'event': 'stream_end',
-        'message_num': message_num
-    }))
-
-
-@with_api_lock
-async def _handle_chat_stream_message(websocket, message):
-    body = json.loads(message)
-
-    user_input = body['user_input']
-    generate_params = build_parameters(body, chat=True)
-    generate_params['stream'] = True
-    regenerate = body.get('regenerate', False)
-    _continue = body.get('_continue', False)
-
-    generator = generate_chat_reply(
-        user_input, generate_params, regenerate=regenerate, _continue=_continue, loading_message=False)
-
-    message_num = 0
-    for a in generator:
-        await websocket.send(json.dumps({
-            'event': 'text_stream',
-            'message_num': message_num,
-            'history': a
-        }))
-
-        await asyncio.sleep(0)
-        message_num += 1
-
-    await websocket.send(json.dumps({
-        'event': 'stream_end',
-        'message_num': message_num
-    }))
-
-
-async def _handle_connection(websocket, path):
-
-    if path == '/api/v1/stream':
-        async for message in websocket:
-            await _handle_stream_message(websocket, message)
-
-    elif path == '/api/v1/chat-stream':
-        async for message in websocket:
-            await _handle_chat_stream_message(websocket, message)
-
-    else:
-        print(f'Streaming api: unknown path: {path}')
-        return
-
-
-async def _run(host: str, port: int):
-    async with serve(_handle_connection, host, port, ping_interval=None):
-        await asyncio.Future()  # run forever
-
-
-def _run_server(port: int, share: bool = False, tunnel_id=str):
-    address = '0.0.0.0' if shared.args.listen else '127.0.0.1'
-
-    def on_start(public_url: str):
-        public_url = public_url.replace('https://', 'wss://')
-        print(f'Starting streaming server at public url {public_url}{PATH}')
-
-    if share:
-        try:
-            try_start_cloudflared(port, tunnel_id, max_attempts=3, on_start=on_start)
-        except Exception as e:
-            print(e)
-    else:
-        print(f'Starting streaming server at ws://{address}:{port}{PATH}')
-
-    asyncio.run(_run(host=address, port=port))
-
-
-def start_server(port: int, share: bool = False, tunnel_id=str):
-    Thread(target=_run_server, args=[port, share, tunnel_id], daemon=True).start()

spaces/Arafath10/chatcode/cleaner.py

@@ -1,57 +0,0 @@
-import re
-
-
-def clean_corpus(chat_export_file):
-    """Prepare a WhatsApp chat export for training with chatterbot."""
-    message_corpus = remove_chat_metadata(chat_export_file)
-    cleaned_corpus = remove_non_message_text(message_corpus)
-    return cleaned_corpus
-
-
-def remove_chat_metadata(chat_export_file):
-    """Remove WhatsApp chat metadata.
-
-    WhatsApp chat exports come with metadata about each message:
-
-     date    time    username  message
-    ---------------------------------------
-    8/26/22, 17:47 - Jane Doe: Message text
-
-    This function removes all the metadata up to the text of each message.
-
-    Args:
-        chat_export_file (str): The name of the chat export file
-
-    Returns:
-        tuple: The text of each message in the conversation
-    """
-    date_time = r"(\d+\/\d+\/\d+,\s\d+:\d+)"  # e.g. "8/26/22, 17:47"
-    dash_whitespace = r"\s-\s"  # " - "
-    username = r"([\w\s]+)"  # e.g. "Jane Doe"
-    metadata_end = r":\s"  # ": "
-    pattern = date_time + dash_whitespace + username + metadata_end
-
-    with open(chat_export_file, "r") as corpus_file:
-        content = corpus_file.read()
-    cleaned_corpus = re.sub(pattern, "", content)
-    return tuple(cleaned_corpus.split("\n"))
-
-
-def remove_non_message_text(export_text_lines):
-    """Remove conversation-irrelevant text from chat export.
-
-    WhatsApp chat exports come with a standardized intro line,
-    and an empty line at the end of the file.
-    Text exports also replace media messages with text that isn't
-    relevant for the conversation. This function removes all that.
-
-    Args:
-        export_text_lines (tuple): All lines from the export file
-
-    Returns:
-        tuple: Messages that are a relevant part of the conversation
-    """
-    messages = export_text_lines[1:-1]
-
-    filter_out_msgs = ("<Media omitted>",)
-    return tuple((msg for msg in messages if msg not in filter_out_msgs))

spaces/Arthur678/vits-uma-genshin-honkai/text/__init__.py

@@ -1,57 +0,0 @@
-""" from https://github.com/keithito/tacotron """
-from text import cleaners
-from text.symbols import symbols
-
-
-# Mappings from symbol to numeric ID and vice versa:
-_symbol_to_id = {s: i for i, s in enumerate(symbols)}
-_id_to_symbol = {i: s for i, s in enumerate(symbols)}
-
-
-def text_to_sequence(text, symbols, cleaner_names):
-  '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
-    Args:
-      text: string to convert to a sequence
-      cleaner_names: names of the cleaner functions to run the text through
-    Returns:
-      List of integers corresponding to the symbols in the text
-  '''
-  _symbol_to_id = {s: i for i, s in enumerate(symbols)}
-  sequence = []
-
-  clean_text = _clean_text(text, cleaner_names)
-  for symbol in clean_text:
-    if symbol not in _symbol_to_id.keys():
-      continue
-    symbol_id = _symbol_to_id[symbol]
-    sequence += [symbol_id]
-  return sequence, clean_text
-
-
-def cleaned_text_to_sequence(cleaned_text):
-  '''Converts a string of text to a sequence of IDs corresponding to the symbols in the text.
-    Args:
-      text: string to convert to a sequence
-    Returns:
-      List of integers corresponding to the symbols in the text
-  '''
-  sequence = [_symbol_to_id[symbol] for symbol in cleaned_text if symbol in _symbol_to_id.keys()]
-  return sequence
-
-
-def sequence_to_text(sequence):
-  '''Converts a sequence of IDs back to a string'''
-  result = ''
-  for symbol_id in sequence:
-    s = _id_to_symbol[symbol_id]
-    result += s
-  return result
-
-
-def _clean_text(text, cleaner_names):
-  for name in cleaner_names:
-    cleaner = getattr(cleaners, name)
-    if not cleaner:
-      raise Exception('Unknown cleaner: %s' % name)
-    text = cleaner(text)
-  return text

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/pip/_vendor/urllib3/util/ssltransport.py

@@ -1,221 +0,0 @@
-import io
-import socket
-import ssl
-
-from ..exceptions import ProxySchemeUnsupported
-from ..packages import six
-
-SSL_BLOCKSIZE = 16384
-
-
-class SSLTransport:
-    """
-    The SSLTransport wraps an existing socket and establishes an SSL connection.
-
-    Contrary to Python's implementation of SSLSocket, it allows you to chain
-    multiple TLS connections together. It's particularly useful if you need to
-    implement TLS within TLS.
-
-    The class supports most of the socket API operations.
-    """
-
-    @staticmethod
-    def _validate_ssl_context_for_tls_in_tls(ssl_context):
-        """
-        Raises a ProxySchemeUnsupported if the provided ssl_context can't be used
-        for TLS in TLS.
-
-        The only requirement is that the ssl_context provides the 'wrap_bio'
-        methods.
-        """
-
-        if not hasattr(ssl_context, "wrap_bio"):
-            if six.PY2:
-                raise ProxySchemeUnsupported(
-                    "TLS in TLS requires SSLContext.wrap_bio() which isn't "
-                    "supported on Python 2"
-                )
-            else:
-                raise ProxySchemeUnsupported(
-                    "TLS in TLS requires SSLContext.wrap_bio() which isn't "
-                    "available on non-native SSLContext"
-                )
-
-    def __init__(
-        self, socket, ssl_context, server_hostname=None, suppress_ragged_eofs=True
-    ):
-        """
-        Create an SSLTransport around socket using the provided ssl_context.
-        """
-        self.incoming = ssl.MemoryBIO()
-        self.outgoing = ssl.MemoryBIO()
-
-        self.suppress_ragged_eofs = suppress_ragged_eofs
-        self.socket = socket
-
-        self.sslobj = ssl_context.wrap_bio(
-            self.incoming, self.outgoing, server_hostname=server_hostname
-        )
-
-        # Perform initial handshake.
-        self._ssl_io_loop(self.sslobj.do_handshake)
-
-    def __enter__(self):
-        return self
-
-    def __exit__(self, *_):
-        self.close()
-
-    def fileno(self):
-        return self.socket.fileno()
-
-    def read(self, len=1024, buffer=None):
-        return self._wrap_ssl_read(len, buffer)
-
-    def recv(self, len=1024, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to recv")
-        return self._wrap_ssl_read(len)
-
-    def recv_into(self, buffer, nbytes=None, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to recv_into")
-        if buffer and (nbytes is None):
-            nbytes = len(buffer)
-        elif nbytes is None:
-            nbytes = 1024
-        return self.read(nbytes, buffer)
-
-    def sendall(self, data, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to sendall")
-        count = 0
-        with memoryview(data) as view, view.cast("B") as byte_view:
-            amount = len(byte_view)
-            while count < amount:
-                v = self.send(byte_view[count:])
-                count += v
-
-    def send(self, data, flags=0):
-        if flags != 0:
-            raise ValueError("non-zero flags not allowed in calls to send")
-        response = self._ssl_io_loop(self.sslobj.write, data)
-        return response
-
-    def makefile(
-        self, mode="r", buffering=None, encoding=None, errors=None, newline=None
-    ):
-        """
-        Python's httpclient uses makefile and buffered io when reading HTTP
-        messages and we need to support it.
-
-        This is unfortunately a copy and paste of socket.py makefile with small
-        changes to point to the socket directly.
-        """
-        if not set(mode) <= {"r", "w", "b"}:
-            raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,))
-
-        writing = "w" in mode
-        reading = "r" in mode or not writing
-        assert reading or writing
-        binary = "b" in mode
-        rawmode = ""
-        if reading:
-            rawmode += "r"
-        if writing:
-            rawmode += "w"
-        raw = socket.SocketIO(self, rawmode)
-        self.socket._io_refs += 1
-        if buffering is None:
-            buffering = -1
-        if buffering < 0:
-            buffering = io.DEFAULT_BUFFER_SIZE
-        if buffering == 0:
-            if not binary:
-                raise ValueError("unbuffered streams must be binary")
-            return raw
-        if reading and writing:
-            buffer = io.BufferedRWPair(raw, raw, buffering)
-        elif reading:
-            buffer = io.BufferedReader(raw, buffering)
-        else:
-            assert writing
-            buffer = io.BufferedWriter(raw, buffering)
-        if binary:
-            return buffer
-        text = io.TextIOWrapper(buffer, encoding, errors, newline)
-        text.mode = mode
-        return text
-
-    def unwrap(self):
-        self._ssl_io_loop(self.sslobj.unwrap)
-
-    def close(self):
-        self.socket.close()
-
-    def getpeercert(self, binary_form=False):
-        return self.sslobj.getpeercert(binary_form)
-
-    def version(self):
-        return self.sslobj.version()
-
-    def cipher(self):
-        return self.sslobj.cipher()
-
-    def selected_alpn_protocol(self):
-        return self.sslobj.selected_alpn_protocol()
-
-    def selected_npn_protocol(self):
-        return self.sslobj.selected_npn_protocol()
-
-    def shared_ciphers(self):
-        return self.sslobj.shared_ciphers()
-
-    def compression(self):
-        return self.sslobj.compression()
-
-    def settimeout(self, value):
-        self.socket.settimeout(value)
-
-    def gettimeout(self):
-        return self.socket.gettimeout()
-
-    def _decref_socketios(self):
-        self.socket._decref_socketios()
-
-    def _wrap_ssl_read(self, len, buffer=None):
-        try:
-            return self._ssl_io_loop(self.sslobj.read, len, buffer)
-        except ssl.SSLError as e:
-            if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs:
-                return 0  # eof, return 0.
-            else:
-                raise
-
-    def _ssl_io_loop(self, func, *args):
-        """Performs an I/O loop between incoming/outgoing and the socket."""
-        should_loop = True
-        ret = None
-
-        while should_loop:
-            errno = None
-            try:
-                ret = func(*args)
-            except ssl.SSLError as e:
-                if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE):
-                    # WANT_READ, and WANT_WRITE are expected, others are not.
-                    raise e
-                errno = e.errno
-
-            buf = self.outgoing.read()
-            self.socket.sendall(buf)
-
-            if errno is None:
-                should_loop = False
-            elif errno == ssl.SSL_ERROR_WANT_READ:
-                buf = self.socket.recv(SSL_BLOCKSIZE)
-                if buf:
-                    self.incoming.write(buf)
-                else:
-                    self.incoming.write_eof()
-        return ret

spaces/Ataturk-Chatbot/HuggingFaceChat/venv/lib/python3.11/site-packages/setuptools/_distutils/py39compat.py

@@ -1,22 +0,0 @@
-import sys
-import platform
-
-
-def add_ext_suffix_39(vars):
-    """
-    Ensure vars contains 'EXT_SUFFIX'. pypa/distutils#130
-    """
-    import _imp
-
-    ext_suffix = _imp.extension_suffixes()[0]
-    vars.update(
-        EXT_SUFFIX=ext_suffix,
-        # sysconfig sets SO to match EXT_SUFFIX, so maintain
-        # that expectation.
-        # https://github.com/python/cpython/blob/785cc6770588de087d09e89a69110af2542be208/Lib/sysconfig.py#L671-L673
-        SO=ext_suffix,
-    )
-
-
-needs_ext_suffix = sys.version_info < (3, 10) and platform.system() == 'Windows'
-add_ext_suffix = add_ext_suffix_39 if needs_ext_suffix else lambda vars: None

spaces/AvinashRamesh23/AIEditor/stable_whisper.py

@@ -1,1491 +0,0 @@
-
-import ffmpeg
-import whisper
-import warnings
-import numpy as np
-import torch
-from torch import Tensor
-from torch.nn import functional as F
-from torch.distributions import Categorical
-from typing import List, Optional, Tuple, Union
-from whisper.audio import SAMPLE_RATE, N_FRAMES, HOP_LENGTH, pad_or_trim, log_mel_spectrogram
-from whisper.decoding import DecodingOptions, DecodingResult
-from whisper.tokenizer import LANGUAGES
-from whisper.utils import exact_div, format_timestamp, compression_ratio
-from whisper.model import Whisper
-from whisper.decoding import DecodingTask, BeamSearchDecoder, GreedyDecoder
-from whisper.tokenizer import Tokenizer, get_tokenizer
-from types import MethodType
-from itertools import chain, repeat
-from copy import deepcopy
-import os
-import json
-
-
-# no_caption changed to no_speech newer commits
-def get_new_attrs(obj_, attr: str):
-    if attr == 'no_caption_probs':
-        return getattr(obj_, attr) if hasattr(obj_, 'no_caption_probs') else getattr(obj_, 'no_speech_probs')
-    elif attr == 'no_caption_prob':
-        return getattr(obj_, attr) if hasattr(obj_, 'no_caption_prob') else getattr(obj_, 'no_speech_prob')
-    elif attr == 'no_captions':
-        return getattr(obj_, attr) if hasattr(obj_, 'no_captions') else getattr(obj_, 'no_speech')
-    else:
-        raise NotImplementedError(attr)
-
-
-def check_ascending_sequence(seq: Union[List[Union[int, float]], np.ndarray], verbose=True) -> bool:
-    """
-    check if a sequence of numbers are in ascending order
-    """
-    is_ascending = True
-    for idx, (i, j) in enumerate(zip(seq[:-1], seq[1:])):
-        if i > j:
-            is_ascending = False
-            if verbose:
-                print(f'[Index{idx}]:{i} > [Index{idx + 1}]:{j}')
-            else:
-                break
-
-    return is_ascending
-
-
-def check_ascending_sentence_ts(res: (dict, list)) -> bool:
-    segs = res['segments'] if isinstance(res, dict) else res
-    return check_ascending_sequence(list(chain.from_iterable((float(i['start']), float(i['end']))
-                                                             for i in segs)))
-
-
-def check_ascending_word_ts(res: (dict, list)) -> bool:
-    cc = group_word_timestamps(res['segments'] if isinstance(res, dict) else res, ts_key='word_timestamps')
-    return check_ascending_sequence((list(chain.from_iterable((float(i['start']), float(i['end']))
-                                                              for i in cc))))
-
-
-def is_equal_ts(a: (float, int, np.ndarray), b: (float, int, np.ndarray), rtol=1e-03):
-    """
-    check if timestamp a and timestamp b are equal within the relative tolerance (rtol)
-    """
-    return np.isclose(a, b, rtol=rtol)
-
-
-def check_is_same_results(res0: (dict, list), res1: (dict, list), check_unstable=False) -> bool:
-    """
-    check if res0 and res1 have same timestamps
-    """
-    if isinstance(res0, dict):
-        res0 = res0['segments']
-    if isinstance(res1, dict):
-        res1 = res1['segments']
-    ts_key = 'unstable_word_timestamps' if check_unstable else 'word_timestamps'
-    inner_ts_key = 'timestamps' if check_unstable else 'timestamp'
-
-    def _reduce(x):
-        if isinstance(x, np.ndarray):
-            return set(tuple(x)) == {True}
-        return x
-
-    t = set(set(_reduce(is_equal_ts(a[inner_ts_key], b[inner_ts_key])) for a, b in zip(i[ts_key], j[ts_key])) == {True}
-            for i, j in zip(res0['segments'], res1['segments']))
-    return t == {True}
-
-
-def to_srt(lines: List[dict], save_path: str = None, strip=False) -> str:
-    """
-    lines: List[dict]
-        [{start:<start-timestamp-of-text>, end:<end-timestamp-of-text>, text:<str-of-text>}, ...]
-    """
-
-    def secs_to_hhmmss(secs: (float, int)):
-        mm, ss = divmod(secs, 60)
-        hh, mm = divmod(mm, 60)
-        return f'{hh:0>2.0f}:{mm:0>2.0f}:{ss:0>6.3f}'.replace(".", ",")
-
-    srt_str = '\n'.join(
-        f'{i}\n'
-        f'{secs_to_hhmmss(sub["start"])} --> {secs_to_hhmmss(sub["end"])}\n'
-        f'{sub["text"].strip() if strip else sub["text"]}\n'
-        for i, sub in enumerate(lines, 1))
-
-    if save_path:
-        with open(save_path, 'w', encoding='utf-8') as f:
-            f.write(srt_str)
-        print(f'Saved: {os.path.abspath(save_path)}')
-
-    return srt_str
-
-
-def group_word_timestamps(res: (dict, list), one_group=True, combine_compound=False,
-                          ts_key='whole_word_timestamps', min_dur: float = None):
-
-    if min_dur is None:
-        min_dur = 0.02
-
-    def group_ts(ts_: List[dict], start) -> List[dict]:
-        first_group: List[dict] = []
-        for w_ts in ts_:
-            if first_group:
-                if (not combine_compound or w_ts['word'].startswith(' ')) and \
-                        (w_ts['timestamp'] - first_group[-1]['start']) >= min_dur and \
-                        first_group[-1]['end'] < w_ts['timestamp']:
-                    first_group.append(dict(start=first_group[-1]['end'],
-                                            end=w_ts['timestamp'],
-                                            text=w_ts['word']))
-                else:
-                    first_group[-1]['end'] = max(first_group[-1]['end'], w_ts['timestamp'])
-                    first_group[-1]['text'] += w_ts['word']
-            else:
-                first_group.append(dict(start=start,
-                                        end=w_ts['timestamp'],
-                                        text=w_ts['word']))
-
-        return first_group
-
-    def group_zero_duration(first_group: List[dict]) -> List[dict]:
-        final_group: List[dict] = []
-        for ts_dict in first_group:
-            if not final_group or (ts_dict['end'] - ts_dict['start']) > 0:
-                final_group.append(ts_dict)
-            else:
-                final_group[-1]['end'] = ts_dict['end']
-                final_group[-1]['text'] += ts_dict['text']
-
-        return final_group
-
-    segs: List[dict] = res['segments'] if isinstance(res, dict) else res
-    assert set(ts_key in seg for seg in segs) == {True}, f'input contains missing {ts_key}'
-
-    grouped = (group_ts(seg[ts_key], seg['start']) for seg in segs)
-    return group_zero_duration(list(chain.from_iterable(grouped))) if one_group else list(grouped)
-
-
-def tighten_timestamps(res: dict, end_at_last_word=True, end_before_period=False, start_at_first_word=False) -> dict:
-    res = deepcopy(res)
-    for i in range(len(res['segments'])):
-        if start_at_first_word:
-            res['segments'][i]['start'] = res['segments'][i]['word_timestamps'][0]['timestamp']
-        if end_before_period and \
-                res['segments'][i]['word_timestamps'][-1] == '.' and \
-                len(res['segments'][i]['word_timestamps']) > 1:
-            res['segments'][i]['end'] = res['segments'][i]['word_timestamps'][-2]['timestamp']
-        elif end_at_last_word:
-            res['segments'][i]['end'] = res['segments'][i]['word_timestamps'][-1]['timestamp']
-
-    return res
-
-
-def results_to_srt(res: dict, srt_path, word_level=True, combine_compound=False,
-                   end_at_last_word=False, end_before_period=False, start_at_first_word=False, strip=False):
-    if word_level:
-        results_to_word_srt(res, srt_path, combine_compound=combine_compound, strip=strip)
-    else:
-        results_to_sentence_srt(res, srt_path,
-                                end_at_last_word=end_at_last_word,
-                                end_before_period=end_before_period,
-                                start_at_first_word=start_at_first_word,
-                                strip=strip)
-
-
-def results_to_sentence_srt(res: dict, srt_path,
-                            end_at_last_word=False,
-                            end_before_period=False,
-                            start_at_first_word=False,
-                            strip=True):
-    """
-
-    Parameters
-    ----------
-    res: dict
-        results from modified model
-    srt_path: str
-        output path of srt
-    end_at_last_word: bool
-        set end-of-sentence to timestamp-of-last-token
-    end_before_period: bool
-        set end-of-sentence to timestamp-of-last-non-period-token
-    start_at_first_word: bool
-        set start-of-sentence to timestamp-of-first-token
-    strip: bool
-        perform strip() on each sentence
-
-    """
-    strict = any((end_at_last_word, end_before_period, start_at_first_word))
-    segs = tighten_timestamps(res,
-                              end_at_last_word=end_at_last_word,
-                              end_before_period=end_before_period,
-                              start_at_first_word=start_at_first_word)['segments'] \
-        if strict else res['segments']
-
-    max_idx = len(segs) - 1
-    i = 1
-    while i <= max_idx:
-        if not (segs[i]['end'] - segs[i]['start']):
-            if segs[i - 1]['end'] == segs[i]['end']:
-                segs[i - 1]['text'] += (' ' + segs[i]['text'].strip())
-                del segs[i]
-                max_idx -= 1
-                continue
-            else:
-                segs[i]['start'] = segs[i - 1]['end']
-        i += 1
-
-    to_srt(segs, srt_path, strip=strip)
-
-
-def results_to_word_srt(res: dict, srt_path, combine_compound=False, strip=False, min_dur: float = None):
-    """
-
-    Parameters
-    ----------
-    res: dict
-        results from modified model
-    srt_path: str
-        output path of srt
-    combine_compound: bool
-        concatenate words without inbetween spacing
-    strip: bool
-        perform strip() on each word
-    min_dur: bool
-        minimum duration for each word (i.e. concat the words if it is less than specified value; Default 0.02)
-
-    """
-    to_srt(group_word_timestamps(res, combine_compound=combine_compound, min_dur=min_dur),
-           srt_path, strip=strip)
-
-
-def results_to_token_srt(res: dict, srt_path, combine_compound=False, strip=False, min_dur: float = None):
-    """
-
-    Parameters
-    ----------
-    res: dict
-        results from modified model
-    srt_path: str
-        output path of srt
-    combine_compound: bool
-        concatenate words without inbetween spacing
-    strip: bool
-        perform strip() on each token
-    min_dur: bool
-        minimum duration for each token (i.e. concat the tokens if it is less than specified value; Default 0.02)
-
-    """
-    to_srt(group_word_timestamps(res, combine_compound=combine_compound, ts_key='word_timestamps', min_dur=min_dur),
-           srt_path, strip=strip)
-
-
-def _get_min_estimation(estimations: List[Union[list, np.ndarray]],
-                        min_: (int, float) = None,
-                        max_: (int, float) = None) -> np.ndarray:
-    estimations = deepcopy(estimations)
-    estimations = list(map(lambda est_: np.array(est_) if isinstance(est_, list) else est_, estimations))
-    prev_min = min_ or 0
-    curr_max = max_ or np.max(estimations[-1])
-
-    min_est = []
-    for curr_est in estimations:
-        curr_min = curr_est[np.logical_and(curr_max > curr_est, curr_est > prev_min)]
-        curr_min = np.min(curr_min) if curr_min.shape[0] else prev_min
-        min_est.append(curr_min)
-        prev_min = curr_min
-
-    return np.array(min_est)
-
-
-def _get_max_estimation(estimations: List[Union[list, np.ndarray]],
-                        max_: (int, float) = None,
-                        min_: (int, float) = None) -> np.ndarray:
-    estimations = deepcopy(estimations)
-    estimations = list(map(lambda est_: np.array(est_) if isinstance(est_, list) else est_, estimations))
-    prev_max = max_ or np.max(estimations[-1])
-    curr_min = np.min(estimations[0]) if min_ is None else min_
-
-    max_est = []
-    for curr_est in reversed(estimations):
-        curr_max = curr_est[np.logical_and(prev_max > curr_est, curr_est > curr_min)]
-        curr_max = np.max(curr_max) if curr_max.shape[0] else prev_max
-        max_est.append(curr_max)
-        prev_max = curr_max
-
-    max_est.reverse()
-    return np.array(max_est)
-
-
-def _remove_overestimation(x: Union[np.ndarray, List[Union[int, float]]], alt_est: List[Union[list, np.ndarray]] = None,
-                           max_: (int, float) = None, min_: (int, float) = None,
-                           aggressive=False) -> np.ndarray:
-    x = np.array(x) if isinstance(x, list) else deepcopy(x)
-    if alt_est is not None:
-        alt_est = list(map(lambda est_: np.array(est_) if isinstance(est_, list) else est_, alt_est))
-    assert x.ndim == 1
-    assert alt_est is None or len(alt_est) == x.shape[0]
-    max_val = x[-1] if max_ is None else max_
-    min_val = x[0] if min_ is None else min_
-
-    def curr_max_min(val):
-        if min_ is None:
-            return val
-        return max(min_, val)
-
-    if min_ is not None:
-        x[x < min_] = min_
-    reduce_ = np.min if aggressive else np.mean
-    for i in range(x.shape[-1] - 1, -1, -1):
-        if x[i] > max_val or (i > 1 and x[i] < reduce_(x[:i])):  # spikes or dips
-            if alt_est is None or alt_est[i] is None:
-                x[i] = max_val
-            else:
-                tmp_min = min_val if i < 2 else curr_max_min(np.mean(x[:i]))
-                alt_ = alt_est[i][np.logical_and(alt_est[i] < max_val, alt_est[i] > tmp_min)]
-                x[i] = max_val if alt_.shape[0] == 0 else alt_[0]
-        max_val = x[i]
-    return x
-
-
-def _remove_underestimation(x: Union[np.ndarray, List[Union[int, float]]],
-                            alt_est: List[Union[list, np.ndarray]] = None,
-                            min_: (int, float) = None, max_: (int, float) = None,
-                            aggressive=False) -> np.ndarray:
-    x = np.array(x) if isinstance(x, list) else deepcopy(x)
-    if alt_est is not None:
-        alt_est = list(map(lambda est_: np.array(est_) if isinstance(est_, list) else est_, alt_est))
-    assert x.ndim == 1
-    assert alt_est is None or len(alt_est) == x.shape[0]
-    min_val = x[0] if min_ is None else min_
-    max_val = x[-1] if max_ is None else max_
-
-    def curr_min_max(val):
-        if max_ is None:
-            return val
-        return min(max_, val)
-
-    if max_ is not None:
-        x[x > max_] = max_
-    reduce_ = np.max if aggressive else np.mean
-    max_i_reduce = x.shape[-1] - 2
-    for i in range(0, x.shape[-1]):
-        if x[i] < min_val or (i < max_i_reduce and x[i] > reduce_(x[i + 1:])):  # dips or spikes
-            if alt_est is None or alt_est[i] is None:
-                x[i] = min_val
-            else:
-                tmp_max = max_val if i >= max_i_reduce else curr_min_max(np.mean(x[i + 1:]))
-                alt_ = alt_est[i][np.logical_and(alt_est[i] > min_val, alt_est[i] < tmp_max)]
-                x[i] = min_val if alt_.shape[0] == 0 else alt_[0]
-        min_val = x[i]
-    return x
-
-
-def _merge_max_min_estimation(mx: Union[np.ndarray, List[Union[int, float]]],
-                              mn: Union[np.ndarray, List[Union[int, float]]],
-                              alt_est: List[Union[list, np.ndarray]] = None) -> np.ndarray:
-    mx = np.array(mx) if isinstance(mx, list) else deepcopy(mx)
-    mn = np.array(mn) if isinstance(mn, list) else deepcopy(mn)
-    if alt_est is not None:
-        alt_est = list(map(lambda est_: np.array(est_) if isinstance(est_, list) else est_, alt_est))
-    assert mx.ndim == 1 and mn.ndim == 1
-    assert mx.shape[0] == mn.shape[0]
-    assert alt_est is None or len(alt_est) == mx.shape[0]
-
-    pref_mx = np.var(mx) > np.var(mn)
-    if pref_mx:
-        mn[0] = mx[0]
-    prev_min = mn[0]
-    for i in range(1, mn.shape[0]):
-        if prev_min > mn[i]:
-            if mn[i] > mx[i]:  # prev_min > mn[i] > mx[i]
-                mn[i] = prev_min
-            elif mx[i] > mn[i]:
-                if prev_min > mx[i]:  # prev_min > mx[i] > mn[i]
-                    mn[i] = prev_min
-                else:  # mx[i] > prev_min > mn[i]
-                    alt_ = alt_est[i][np.logical_and(alt_est[i] > prev_min, alt_est[i] < mx[i])]
-                    mn[i] = (mx[i] if pref_mx else prev_min) if alt_.shape[0] == 0 else alt_[0]
-            else:  # prev_min > mn[i] == mx[i]
-                mn[i] = prev_min
-        elif mn[i] > prev_min:
-            # if prev_min > mx[i]:  # mn[i] > prev_min > mx[i]
-            #     pass
-            if mx[i] > prev_min:
-                if mn[i] > mx[i]:  # mn[i] > mx[i] > prev_min
-                    pass
-                elif mx[i] > mn[i]:  # mx[i] > mn[i] > prev_min
-                    alt_ = alt_est[i][np.logical_and(alt_est[i] > mn[i], alt_est[i] < mx[i])]
-                    if alt_.shape[0]:
-                        mn[i] = alt_[0]
-                    elif pref_mx:
-                        mn[i] = mx[i]
-            #     else:  # mx[i] == mn[i] > prev_min
-            #         pass
-            # else:  # mn[i] > mx[i] == prev_min
-            #     pass
-        else:  # mn[i] == prev_min
-            if mx[i] > mn[i]:  # mx[i] > mn[i] == prev_min
-                alt_ = alt_est[i][np.logical_and(alt_est[i] > mn[i], alt_est[i] < mx[i])]
-                if alt_.shape[0]:
-                    mn[i] = alt_[0]
-                elif pref_mx:
-                    mn[i] = mx[i]
-            # elif mn[i] > mx[i]:  # mn[i] == prev_min > mx[i]
-            #     pass
-            # else:  # mn[i] == prev_min == mx[i]
-            #     pass
-
-        prev_min = mn[i]
-
-    return mn
-
-
-def _avg_merge_min_max(mx: Union[np.ndarray, List[Union[int, float]]],
-                       mn: Union[np.ndarray, List[Union[int, float]]],
-                       alt_timestamps: List[Union[List[Union[int, float]], np.ndarray]] = None,
-                       max_: (int, float) = None, min_: (int, float) = None):
-    mx = np.array(mx) if isinstance(mx, list) else deepcopy(mx)
-    mn = np.array(mn) if isinstance(mn, list) else deepcopy(mn)
-    assert mx.ndim == mn.ndim == 1
-    assert mx.shape[0] == mn.shape[0]
-
-    avg_ = (mx + mn) / 2
-
-    if check_ascending_sequence(avg_, verbose=False):
-        return avg_
-
-    if not max_:
-        max_ = max(mx[-1], mn[-1])
-    if min_ is None:
-        min_ = min(mn[0], mx[0])
-
-    return _stabilize_timestamps(avg_, alt_timestamps, max_=max_, min_=min_)
-
-
-def _stabilize_timestamps(timestamps: Union[np.ndarray, List[Union[int, float]]],
-                          alt_timestamps: List[Union[List[Union[int, float]], np.ndarray]] = None,
-                          max_: (int, float) = None, min_: (int, float) = None, aggressive=False) -> np.ndarray:
-    mx = _remove_overestimation(timestamps, alt_est=alt_timestamps, max_=max_, min_=min_, aggressive=aggressive)
-    mn = _remove_underestimation(timestamps, alt_est=alt_timestamps, max_=max_, min_=min_, aggressive=aggressive)
-    return _merge_max_min_estimation(mx, mn, alt_timestamps)
-
-
-def _stabilize_more_timestamps(timestamps: List[Union[list, np.ndarray]],
-                               max_: (int, float) = None, min_: (int, float) = None, average=True) -> np.ndarray:
-    mx = _get_max_estimation(timestamps, max_=max_, min_=min_)
-    mn = _get_min_estimation(timestamps, max_=max_, min_=min_)
-    if average:
-        return _avg_merge_min_max(mx, mn, timestamps, max_=max_, min_=min_)
-    return _merge_max_min_estimation(mx, mn, timestamps)
-
-
-def stabilize_timestamps(segments: Union[List[dict], dict],
-                         top_focus=False, aggressive=False, average=True) -> List[dict]:
-    """
-
-    Parameters
-    ----------
-    segments: Union[List[dict], dict]
-        result['segments'] or result
-    top_focus: bool
-        adhere closely to the top predictions for word timestamps
-    aggressive: bool
-        only if top_focus=True,
-        allow greater variation in word_timestamps/whole_word_timestamps
-    average: bool
-        only if top_focus=False,
-        average min and max of unstable_word_timestamps to get word_timestamps/whole_word_timestamps
-
-    """
-    if isinstance(segments, dict):
-        segments = segments['segments']
-    if not segments:
-        warnings.warn('No Segments Found')
-        return []
-    missing_ts_idx = set(map(lambda x: None if x[1].get('unstable_word_timestamps') else x[0], enumerate(segments))) - {
-        None}
-    no_word_timestamps = len(missing_ts_idx) == len(segments)
-    if not no_word_timestamps and missing_ts_idx:
-        warnings.warn(f'Segments {list(missing_ts_idx)} are missing unstable_word_timestamps. '
-                      f'Word-level timestamp stabilization will skipped')
-
-    segments = deepcopy(segments)
-    sectioned_segments: List[List] = [[]]
-    for i, seg in enumerate(segments, 1):
-        sectioned_segments[-1].append(seg)
-        if seg['anchor_point']:
-            if i < len(segments):
-                sectioned_segments.append([])
-
-    assert all(set(len(set(s['offset'] for s in segs)) == 1 for segs in sectioned_segments))
-
-    sectioned_segments_timestamps = [dict(min_=segs[-1]['offset'],
-                                          max_=segs[-1]['next_offset'],
-                                          timestamps=list(chain.from_iterable((s['start'], s['end']) for s in segs)),
-                                          alt_timestamps=list(chain.from_iterable((s['alt_start_timestamps'],
-                                                                                   s['alt_end_timestamps'])
-                                                                                  for s in segs)))
-                                     for segs in sectioned_segments]
-
-    sectioned_stab_timestamps = [_stabilize_timestamps(**kwargs).reshape(-1, 2) for kwargs in
-                                 sectioned_segments_timestamps]
-
-    for i in range(len(sectioned_segments)):
-        for j in range(len(sectioned_segments[i])):
-            sectioned_segments[i][j]['start'], sectioned_segments[i][j]['end'] = sectioned_stab_timestamps[i][j]
-
-            if not missing_ts_idx:
-                if top_focus:
-                    top_word_ts = [ts_['timestamps'][0] for ts_ in
-                                   sectioned_segments[i][j]['unstable_word_timestamps']]
-                    alt_word_ts = [ts_['timestamps'][1:] for ts_ in
-                                   sectioned_segments[i][j]['unstable_word_timestamps']]
-                    temp_stab_word_ts = _stabilize_timestamps(top_word_ts, alt_word_ts,
-                                                              max_=sectioned_segments[i][j]['end'],
-                                                              min_=sectioned_segments[i][j]['start'],
-                                                              aggressive=aggressive)
-                else:
-                    word_ts = [ts_['timestamps'] for ts_ in sectioned_segments[i][j]['unstable_word_timestamps']]
-                    temp_stab_word_ts = _stabilize_more_timestamps(word_ts,
-                                                                   max_=sectioned_segments[i][j]['end'],
-                                                                   min_=sectioned_segments[i][j]['start'],
-                                                                   average=average)
-
-                temp_stab_word_ts = [{'word': sectioned_segments[i][j]['unstable_word_timestamps'][k]['word'],
-                                      'token': sectioned_segments[i][j]['unstable_word_timestamps'][k]['token'],
-                                      'timestamp': temp_stab_word_ts[k]}
-                                     for k in range(temp_stab_word_ts.shape[0])]
-
-                sectioned_segments[i][j]['word_timestamps'] = temp_stab_word_ts
-
-    return list(chain.from_iterable(sectioned_segments))
-
-
-def save_as_json(results, path):
-    with open(path, 'w', encoding='utf-8') as f:
-        json.dump(results, f)
-
-
-def add_whole_word_ts(tokenizer: Tokenizer, segments: Union[List[dict], dict], merge_non_space: bool = None,
-                      prepend_punctuations: Union[List[str], Tuple[str]] = None,
-                      append_punctuations: Union[List[str], Tuple[str]] = None):
-    merge_non_space = (tokenizer.language in ['en'] or tokenizer.language is None) \
-        if merge_non_space is None else merge_non_space
-    if prepend_punctuations is None:
-        prepend_punctuations = r'“¿([{'
-    if append_punctuations is None:
-        append_punctuations = r'.。,，!！?？:：”)]}、'
-    if isinstance(segments, dict):
-        segments = segments['segments']
-    if not segments:
-        print('No segments found, whole-word timestamps cannot be added.')
-        return
-
-    missing_idx = set(-1 if seg.get('word_timestamps') else i for i, seg in enumerate(segments)) - {-1}
-
-    if missing_idx:
-        if len(missing_idx) == len(segments):
-            print('No word_timestamps found, whole-word timestamps cannot be added.')
-            return
-        print(f'Some word_timestamps not found, '
-              f'whole-word timestamps cannot be added to the following segments: {tuple(missing_idx)}')
-
-    failed_idx = []
-
-    for seg_idx, seg in enumerate(segments):
-        if seg.get('word_timestamps'):
-            prev_idx = 0
-            remaining_text = seg['text']
-            has_prepend = False
-            whole_word_timestamps: List[dict] = []
-            for wts_idx in range(1, len(seg['word_timestamps']) + 1):
-                max_ts = seg['word_timestamps'][wts_idx - 1]['timestamp']
-                tokens = [wts['token'] for wts in seg['word_timestamps'][prev_idx: wts_idx]]
-                temp_whole_word = tokenizer.decode(tokens)
-                if temp_whole_word == remaining_text[:len(temp_whole_word)]:
-                    prev_idx = wts_idx
-                    remaining_text = remaining_text[len(temp_whole_word):]
-                    if (not merge_non_space or temp_whole_word.startswith(' ') or not whole_word_timestamps) and \
-                            temp_whole_word not in append_punctuations and \
-                            not has_prepend:
-                        has_prepend = temp_whole_word.strip() in prepend_punctuations
-                        whole_word_timestamps.append(dict(word=temp_whole_word, timestamp=max_ts))
-                    else:
-                        has_prepend = False
-                        whole_word_timestamps[-1]['word'] += temp_whole_word
-                        whole_word_timestamps[-1]['timestamp'] = max_ts
-            if remaining_text:
-                failed_idx.append(seg_idx)
-                whole_word_timestamps = []
-            seg['whole_word_timestamps'] = whole_word_timestamps or None
-        else:
-            seg['whole_word_timestamps'] = None
-
-    if failed_idx:
-        print(f'Failed to add whole-word timestamps to the following segments: {tuple(failed_idx)}')
-
-
-def _load_audio_waveform(audio: Union[str, bytes, np.ndarray, torch.Tensor], h: int, w: int) -> np.ndarray:
-    """
-
-    Parameters
-    ----------
-    audio: Union[str, bytes, np.ndarray, torch.Tensor], shape = (*)
-        The path to audio or bytes of audio file or a NumPy array or Tensor containing the audio waveform in 16 kHz
-    h: int
-        Height of waveform image
-    w: int
-        Width of waveform image
-
-    Returns
-    -------
-    Audio waveform image as a NumPy array, in uint8 dtype.
-    """
-
-    try:
-        if isinstance(audio, str):
-            stream = ffmpeg.input(audio, threads=0)
-            inp = None
-
-        else:
-            if isinstance(audio, bytes):
-                stream = ffmpeg.input('pipe:', threads=0)
-                inp = audio
-            else:
-                warnings.warn('A resampled input causes an unexplained temporal shift in waveform image '
-                              'that will skew the timestamp suppression and may result in inaccurate timestamps.\n'
-                              'Use audio_for_mask for transcribe() to provide the original audio track '
-                              'as the path or bytes of the audio file.',
-                              stacklevel=2)
-                stream = ffmpeg.input('pipe:', threads=0, ac=1, format='s16le')
-                if isinstance(audio, torch.Tensor):
-                    audio = np.array(audio)
-                inp = (audio * 32768.0).astype(np.int16).tobytes()
-
-        waveform, err = (
-            stream.filter('aformat', channel_layouts='mono')
-                .filter('highpass', f='200').filter('lowpass', f='3000')
-                .filter('showwavespic', s=f'{w}x{h}')
-                .output('-', pix_fmt='gray', format='rawvideo')
-                .run(cmd="ffmpeg", capture_stdout=True, capture_stderr=True, input=inp)
-        )
-    except ffmpeg.Error as e:
-        raise RuntimeError(f"Failed to load audio in waveform: {e.stderr.decode()}") from e
-    else:
-        if not waveform:
-            partial_file = b'partial file' in err and b'Output file is empty' in err
-            add_msg = '\nMetadata for decoding are likely at end of file, try to use path of audio instead.' \
-                if partial_file and isinstance(audio, bytes) else ''
-            raise RuntimeError(f"Failed to load audio in waveform: {err.decode()}" + add_msg)
-        return np.frombuffer(waveform, dtype=np.uint8).reshape(h, w)
-
-
-def _remove_lower_quantile(waveform: np.ndarray,
-                           upper_quantile: float = None,
-                           lower_quantile: float = None,
-                           lower_threshold: float = None) -> np.ndarray:
-    """
-    Removes lower quantile of amplitude from waveform image
-    """
-    if upper_quantile is None:
-        upper_quantile = 0.85
-    if lower_quantile is None:
-        lower_quantile = 0.15
-    if lower_threshold is None:
-        lower_threshold = 0.15
-    waveform = deepcopy(waveform)
-    wave_sums = waveform.sum(0)
-    mx = np.quantile(wave_sums, upper_quantile, -1)
-    mn = np.quantile(wave_sums, lower_quantile, -1)
-    mn_threshold = (mx - mn) * lower_threshold + mn
-    waveform[:, wave_sums < mn_threshold] = 0
-    return waveform
-
-
-def _wave_to_ts_filter(waveform: np.ndarray, suppress_middle=True,
-                       max_index: (list, int) = None) -> np.ndarray:
-    """
-    Returns A NumPy array mask of sections with amplitude zero
-    """
-    assert waveform.ndim <= 2, f'waveform have at most 2 dims but found {waveform.ndim}'
-    if waveform.ndim == 1:
-        wave_sum = waveform
-    else:
-        wave_sum = waveform.sum(-2)
-
-    wave_filter = wave_sum.astype(bool)
-
-    if not suppress_middle:
-        nonzero_indices = wave_filter.nonzero()[0]
-        wave_filter[nonzero_indices[0]:nonzero_indices[-1] + 1] = True
-    if max_index is not None:
-        wave_filter[max_index + 1:] = False
-
-    return ~wave_filter
-
-
-# modified version of whisper.transcribe.transcribe
-def transcribe_word_level(
-        model: "Whisper",
-        audio: Union[str, np.ndarray, torch.Tensor],
-        *,
-        verbose: bool = False,
-        temperature: Union[float, Tuple[float, ...]] = (0.0, 0.2, 0.4, 0.6, 0.8, 1.0),
-        compression_ratio_threshold: Optional[float] = 2.4,
-        logprob_threshold: Optional[float] = -1.0,
-        no_speech_threshold: Optional[float] = 0.6,
-        condition_on_previous_text: bool = True,
-        stab=True, top_focus=False, ts_num: int = 10,
-        alpha: float = None, print_unstab=False,
-        suppress_silence: bool = True,
-        suppress_middle: bool = True,
-        suppress_word_ts: bool = True,
-        remove_background: bool = True,
-        silence_threshold: float = 0.1,
-        prepend_punctuations: Union[List[str], Tuple[str]] = None,
-        append_punctuations: Union[List[str], Tuple[str]] = None,
-        audio_for_mask: (str, bytes) = None,
-        **decode_options):
-    """
-    Transcribe an audio file using Whisper
-
-    Parameters
-    ----------
-    model: Whisper
-        The Whisper model instance
-
-    audio: Union[str, np.ndarray, torch.Tensor]
-        The path to the audio file to open, or the audio waveform
-
-    verbose: bool
-        Whether to display the decoded text (with finalized timestamps) to the console
-
-    temperature: Union[float, Tuple[float, ...]]
-        Temperature for sampling. It can be a tuple of temperatures, which will be successfully used
-        upon failures according to either `compression_ratio_threshold` or `logprob_threshold`.
-
-    compression_ratio_threshold: float
-        If the gzip compression ratio is above this value, treat as failed
-
-    logprob_threshold: float
-        If the average log probability over sampled tokens is below this value, treat as failed
-
-    no_speech_threshold: float
-        If the no_speech probability is higher than this value AND the average log probability
-        over sampled tokens is below `logprob_threshold`, consider the segment as silent
-
-    condition_on_previous_text: bool
-        if True, the previous output of the model is provided as a prompt for the next window;
-        disabling may make the text inconsistent across windows, but the model becomes less prone to
-        getting stuck in a failure loop, such as repetition looping or timestamps going out of sync.
-
-    stab: bool
-        Stabilizing timestamps by cross compare timestamps and using additional top timestamp predictions
-        to fill in when appropriate to ensure timestamps are chronological.
-
-    top_focus: bool
-        Adhere closely to the top predictions for token timestamps stabilization
-
-    ts_num: int
-        Number of top timestamp predictions to save for each word for postprocessing stabilization (default: 10).
-
-    alpha: float
-        Amount of noise to add to audio to produce slightly difference results.
-        audio_features *= torch.rand_like(audio_features) * alpha + 1
-
-    print_unstab: bool
-        Whether to display the text (without stabilize timestamps) being decoded to the console
-        (i.e. behaves like verbose before model was modified)
-
-    suppress_silence: bool
-        Suppress timestamp tokens that are marked as silent
-
-    suppress_middle: bool
-        Suppress any silent timestamps tokens of middle of the segment instead of only beginning and ending
-
-    suppress_word_ts: bool
-        Suppress timestamp tokens of words that are marked as silent
-
-    remove_background: bool
-        Whether to remove background noise from waveform so that it is marked silent.
-        Determined by parameters part of decode_options (i.e. specify like other options here):
-            upper_quantile: float
-                The upper quantile of amplitude to determine a max amplitude, mx (Default: 0.85)
-            lower_quantile: float
-                The lower quantile of amplitude to determine a min amplitude, mn (Default: 0.15)
-            lower_threshold: float
-                Suppressed sections of waveform where amplitude < lower_threshold*(mx-mn) + mn. (Default: 0.15)
-
-    silence_threshold: float:
-        Audio segments silence average >= silence_threshold
-        then that segment will not have background removed even if remove_background=True.
-        e.g. 0.5 means if less than half of the audio segment is silent then background will be removed accordingly
-
-    prepend_punctuations: Union[List[str], Tuple[str]]
-        Punctuations to prepend to next word (Default: “¿([{)
-
-    append_punctuations: Union[List[str], Tuple[str]]
-        Punctuations to append to previous word (Default: .。,，!！?？:：”)]}、)
-
-    audio_for_mask: (str, bytes)
-        Original audio track as path or bytes of audio file.
-        Since resampled audio may shift the waveform image,
-        this is an alternative to 'audio' option to generate suppression mask from the original audio.
-
-    decode_options: dict
-        Keyword arguments to construct `DecodingOptions` instances
-
-    Returns
-    -------
-    A dictionary containing the resulting text ("text") and segment-level details ("segments"), and
-    the spoken language ("language"), which is detected when `decode_options["language"]` is None.
-    """
-
-    if 'no_captions_threshold' in decode_options:
-        warnings.warn('no_captions_threshold is deprecated. '
-                      'Please use no_speech_threshold instead.', DeprecationWarning, stacklevel=2)
-        no_speech_threshold = decode_options.pop('no_captions_threshold')
-
-    dtype = torch.float16 if decode_options.get("fp16", True) else torch.float32
-    if model.device == torch.device("cpu"):
-        if torch.cuda.is_available():
-            warnings.warn("Performing inference on CPU when CUDA is available")
-        if dtype == torch.float16:
-            warnings.warn("FP16 is not supported on CPU; using FP32 instead")
-            dtype = torch.float32
-
-    if dtype == torch.float32:
-        decode_options["fp16"] = False
-
-    if 'max_initial_timestamp' not in decode_options:
-        decode_options['max_initial_timestamp'] = None
-
-    mel = log_mel_spectrogram(audio)
-
-    if decode_options.get("language", None) is None:
-        if verbose:
-            print("Detecting language using up to the first 30 seconds. Use `--language` to specify the language")
-        segment = pad_or_trim(mel, N_FRAMES).to(model.device).to(dtype)
-        _, probs = model.detect_language(segment)
-        decode_options["language"] = max(probs, key=probs.get)
-        print(f"Detected language: {LANGUAGES[decode_options['language']]}")
-
-    mel = mel.unsqueeze(0)
-    language = decode_options["language"]
-    task = decode_options.get("task", "transcribe")
-    tokenizer = get_tokenizer(model.is_multilingual, language=language, task=task)
-
-    def decode_with_fallback(segment: torch.Tensor, suppress_ts_mask: Tensor = None) \
-            -> Union[List[DecodingResult], tuple]:
-        temperatures = [temperature] if isinstance(temperature, (int, float)) else temperature
-        kwargs = {**decode_options}
-        t = temperatures[0]
-        if t == 0:
-            best_of = kwargs.pop("best_of", None)
-        else:
-            best_of = kwargs.get("best_of", None)
-
-        options = DecodingOptions(**kwargs, temperature=t)
-        results, ts_tokens, ts_logits_ = model.decode(segment, options, ts_num=ts_num, alpha=alpha,
-                                                      suppress_ts_mask=suppress_ts_mask,
-                                                      suppress_word_ts=suppress_word_ts)
-
-        kwargs.pop("beam_size", None)  # no beam search for t > 0
-        kwargs.pop("patience", None)  # no patience for t > 0
-        kwargs["best_of"] = best_of  # enable best_of for t > 0
-        for t in temperatures[1:]:
-            needs_fallback = [
-                compression_ratio_threshold is not None
-                and result.compression_ratio > compression_ratio_threshold
-                or logprob_threshold is not None
-                and result.avg_logprob < logprob_threshold
-                for result in results
-            ]
-            if any(needs_fallback):
-                options = DecodingOptions(**kwargs, temperature=t)
-                retries, r_ts_tokens, r_ts_logits = model.decode(segment[needs_fallback], options,
-                                                                 ts_num=ts_num, alpha=alpha,
-                                                                 suppress_ts_mask=suppress_ts_mask,
-                                                                 suppress_word_ts=suppress_word_ts)
-                for retry_index, original_index in enumerate(np.nonzero(needs_fallback)[0]):
-                    results[original_index] = retries[retry_index]
-                    ts_tokens[original_index] = r_ts_tokens[retry_index]
-                    ts_logits_[original_index] = r_ts_logits[retry_index]
-
-        return results, ts_tokens, ts_logits_
-
-    seek = 0
-    input_stride = exact_div(
-        N_FRAMES, model.dims.n_audio_ctx
-    )  # mel frames per output token: 2
-    time_precision = (
-            input_stride * HOP_LENGTH / SAMPLE_RATE
-    )  # time per output token: 0.02 (seconds)
-    all_tokens = []
-    all_segments = []
-    prompt_reset_since = 0
-
-    initial_prompt = decode_options.pop("initial_prompt", None) or []
-    if initial_prompt:
-        initial_prompt = tokenizer.encode(" " + initial_prompt.strip())
-        all_tokens.extend(initial_prompt)
-
-    def _to_list(x: (Tensor, None)):
-        if x is None:
-            return x
-        return x.tolist()
-
-    def add_segment(
-            *, offset: float, start: float, end: float, text_tokens: Tensor, result: DecodingResult,
-            start_timestamps: list = None, end_timestamps: list = None, word_timestamps: Tensor = None,
-            start_ts_logits: list = None, end_ts_logits: list = None, word_ts_logits: Tensor = None
-    ):
-        no_eot_mask = text_tokens < tokenizer.eot
-        text_tokens_no_eot = text_tokens[no_eot_mask]
-        text = tokenizer.decode(text_tokens_no_eot)
-
-        if len(text.strip()) == 0:  # skip empty text output
-            return
-
-        if word_timestamps is not None:
-            assert word_timestamps.shape[0] == text_tokens.shape[0]
-            if word_ts_logits is None:
-                word_ts_fields = zip(text_tokens_no_eot, word_timestamps[no_eot_mask], repeat(None))
-            else:
-                assert word_ts_logits.shape[0] == text_tokens.shape[0]
-                word_ts_fields = zip(text_tokens_no_eot, word_timestamps[no_eot_mask], word_ts_logits[no_eot_mask])
-
-            word_timestamps = [dict(word=tokenizer.decode([token]),
-                                    token=token.item(),
-                                    timestamps=timestamps_.tolist(),
-                                    timestamp_logits=_to_list(ts_logits_))
-                               for token, timestamps_, ts_logits_ in word_ts_fields]
-
-        all_segments.append(
-            {
-                "id": len(all_segments),
-                "seek": seek,
-                'offset': offset,  # offset = float(seek * HOP_LENGTH / SAMPLE_RATE)
-                "start": start,
-                "end": end,
-                "text": text,
-                "tokens": result.tokens,
-                "temperature": result.temperature,
-                "avg_logprob": result.avg_logprob,
-                "compression_ratio": result.compression_ratio,
-                "no_speech_prob": get_new_attrs(result, 'no_caption_prob'),
-                "alt_start_timestamps": start_timestamps,
-                "start_ts_logits": start_ts_logits,
-                "alt_end_timestamps": end_timestamps,
-                "end_ts_logits": end_ts_logits,
-                "unstable_word_timestamps": word_timestamps,
-                'anchor_point': False
-            }
-        )
-        if print_unstab or (verbose and not stab):
-            print(f'[{format_timestamp(start)} --> {format_timestamp(end)}] "{text}"')
-            if word_timestamps is not None:
-                ts_str = (f' ->[{format_timestamp(ts_["timestamps"][0])}] "{ts_["word"].strip()}"' for ts_ in
-                          word_timestamps)
-                print('\n'.join(ts_str), end='\n\n')
-
-    if suppress_silence:
-        ts_scale = HOP_LENGTH / SAMPLE_RATE / time_precision
-        wf = _load_audio_waveform(audio_for_mask or audio, 100, int(mel.shape[-1] * ts_scale))
-
-    upper_quantile = decode_options.pop('upper_quantile', 0.85)
-    lower_quantile = decode_options.pop('lower_quantile', 0.15)
-    lower_threshold = decode_options.pop('lower_threshold', 0.15)
-
-    while seek < mel.shape[-1]:
-        timestamp_offset = float(seek * HOP_LENGTH / SAMPLE_RATE)
-        remaining_duration = float((mel.shape[-1] - seek) * HOP_LENGTH / SAMPLE_RATE)
-        segment = pad_or_trim(mel[:, :, seek:], N_FRAMES).to(model.device).to(dtype)
-        segment_duration = min(float(segment.shape[-1] * HOP_LENGTH / SAMPLE_RATE), remaining_duration)
-        segment_max_ts = segment_duration / time_precision
-
-        if suppress_silence:
-            wf_seek = int(seek * ts_scale)
-            segment_wf = wf[..., wf_seek:wf_seek + 1501]
-            if remove_background and \
-                    (1 - segment_wf.sum(0).clip(max=1).mean()) < silence_threshold:
-                segment_wf = _remove_lower_quantile(segment_wf.astype(np.float32),
-                                                    upper_quantile=upper_quantile,
-                                                    lower_quantile=lower_quantile,
-                                                    lower_threshold=lower_threshold)
-            segment_wf = pad_or_trim(segment_wf, 1501)
-            suppress_ts_mask = torch.from_numpy(_wave_to_ts_filter(segment_wf,
-                                                                   suppress_middle=suppress_middle,
-                                                                   max_index=int(segment_max_ts)))
-
-            if suppress_ts_mask.all():  # segment is silent
-                seek += segment.shape[-1]  # fast-forward to the next segment boundary
-                continue
-        else:
-            suppress_ts_mask = None
-
-        decode_options["prompt"] = all_tokens[prompt_reset_since:]
-        result, finalized_ts_tokens, ts_logits = decode_with_fallback(segment,
-                                                                      suppress_ts_mask=suppress_ts_mask)
-
-        result = result[0]
-        tokens = torch.tensor(result.tokens)
-        finalized_ts_tokens = torch.tensor(finalized_ts_tokens[0])
-        ts_logits = torch.tensor(ts_logits[0])
-
-        if no_speech_threshold is not None:
-            # no voice activity check
-            should_skip = get_new_attrs(result, 'no_caption_prob') > no_speech_threshold
-            if logprob_threshold is not None and result.avg_logprob > logprob_threshold:
-                # don't skip if the logprob is high enough, despite the no_speech_prob
-                should_skip = False
-
-            if should_skip:
-                seek += segment.shape[-1]  # fast-forward to the next segment boundary
-                continue
-
-        timestamp_tokens: torch.Tensor = tokens.ge(tokenizer.timestamp_begin)
-        consecutive = torch.where(timestamp_tokens[:-1] & timestamp_tokens[1:])[0].add_(1)
-        if len(consecutive) > 0:  # if the output contains two consecutive timestamp tokens
-            last_slice = 0
-            for current_slice in consecutive:
-                sliced_tokens = tokens[last_slice:current_slice]
-                sliced_ts_tokens = finalized_ts_tokens[last_slice:current_slice]
-                sliced_ts_logits = ts_logits[last_slice:current_slice]
-                start_timestamp_position = (
-                        sliced_tokens[0].item() - tokenizer.timestamp_begin
-                )
-                end_timestamp_position = (
-                        sliced_tokens[-1].item() - tokenizer.timestamp_begin
-                )
-
-                word_ts = timestamp_offset + sliced_ts_tokens * time_precision
-
-                add_segment(
-                    offset=timestamp_offset,
-                    start=timestamp_offset + start_timestamp_position * time_precision,
-                    end=min(timestamp_offset + end_timestamp_position * time_precision,
-                            timestamp_offset + segment_duration),
-                    text_tokens=sliced_tokens[1:-1],
-                    result=result,
-                    start_timestamps=word_ts[0].tolist(),
-                    end_timestamps=word_ts[-1].tolist(),
-                    word_timestamps=word_ts[1:-1],
-                    start_ts_logits=sliced_ts_logits[0].tolist(),
-                    end_ts_logits=sliced_ts_logits[-1].tolist(),
-                    word_ts_logits=sliced_ts_logits[1:-1]
-                )
-                last_slice = current_slice
-            last_timestamp_position = (
-                min(tokens[last_slice - 1].item() - tokenizer.timestamp_begin, segment_max_ts)
-            )
-            seek += last_timestamp_position * input_stride
-            all_tokens.extend(tokens[: last_slice + 1].tolist())
-        else:
-            duration = segment_duration
-            timestamps = tokens[timestamp_tokens.nonzero().flatten()]
-            if len(timestamps) > 0:
-                # no consecutive timestamps but it has a timestamp; use the last one.
-                # single timestamp at the end means no speech after the last timestamp.
-                last_timestamp_position = min(timestamps[-1].item() - tokenizer.timestamp_begin, segment_max_ts)
-                duration = last_timestamp_position * time_precision
-
-            word_ts = timestamp_offset + finalized_ts_tokens * time_precision
-
-            add_segment(
-                offset=timestamp_offset,
-                start=timestamp_offset,
-                end=timestamp_offset + duration,
-                text_tokens=tokens,
-                result=result,
-                word_timestamps=word_ts,
-                word_ts_logits=ts_logits
-            )
-
-            seek += segment.shape[-1]
-            all_tokens.extend(tokens.tolist())
-
-        if all_segments:
-            all_segments[-1]['anchor_point'] = True
-            all_segments[-1]['next_offset'] = float(seek * HOP_LENGTH / SAMPLE_RATE)
-        if not condition_on_previous_text or result.temperature > 0.5:
-            # do not feed the prompt tokens if a high temperature was used
-            prompt_reset_since = len(all_tokens)
-
-    if len(all_segments) > 1 and all_segments[-1]['alt_start_timestamps'] is None:
-        all_segments[-1]['alt_start_timestamps'] = all_segments[-2]['alt_end_timestamps']
-
-    if stab:
-        all_segments = stabilize_timestamps(all_segments, top_focus=top_focus)
-        add_whole_word_ts(tokenizer, all_segments,
-                          prepend_punctuations=prepend_punctuations,
-                          append_punctuations=append_punctuations)
-        if verbose:
-            print('\nSTABILIZED\n')
-            for seg_ in all_segments:
-                print(f'[{format_timestamp(seg_["start"])} --> {format_timestamp(seg_["end"])}] "{seg_["text"]}"')
-                if seg_['word_timestamps']:
-                    ts_str = (f' ->[{format_timestamp(ts_["timestamp"])}] "{ts_["word"].strip()}"' for ts_ in
-                              seg_['word_timestamps'])
-                    print('\n'.join(ts_str), end='\n\n')
-
-    return dict(text=tokenizer.decode(all_tokens[len(initial_prompt):]), segments=all_segments, language=language)
-
-
-def _suppress_ts(ts_logits: Tensor, suppress_ts_mask: Tensor = None):
-    if suppress_ts_mask is not None:
-        ts_logits[:, suppress_ts_mask] = -np.inf
-
-
-def _ts_topk(ts_logits: Tensor, k: int, prev_ts: Tensor = None) -> Tensor:
-    temp_ts = torch.stack(torch.topk(ts_logits, k, dim=-1), 0).unsqueeze(-2)
-    return temp_ts if prev_ts is None else torch.cat([prev_ts, temp_ts], dim=-2)
-
-
-# modified version of whisper.GreedyDecoder
-class GreedyDecoderWordLevel(GreedyDecoder):
-    def __init__(self, *args, **kwargs):
-        self.ts_num: int = kwargs.pop('ts_num', 10)
-        self.suppress_ts_mask: Tensor = kwargs.pop('suppress_ts_mask', None)
-        self.timestamp_begin = kwargs.pop('timestamp_begin', 50364)
-        super(GreedyDecoderWordLevel, self).__init__(*args, **kwargs)
-        self.ts = None
-
-    def _suppress_ts(self, logits: Tensor):
-        _suppress_ts(logits[:, self.timestamp_begin:],
-                     suppress_ts_mask=self.suppress_ts_mask)
-
-    def update_with_ts(self, tokens: Tensor, logits: Tensor, sum_logprobs: Tensor, ts: Tensor) -> Tuple[Tensor, bool]:
-        self.ts = ts
-
-        self._suppress_ts(logits)
-
-        if self.temperature == 0:
-            next_tokens = logits.argmax(dim=-1)
-        else:
-            next_tokens = Categorical(logits=logits / self.temperature).sample()
-
-        logprobs = F.log_softmax(logits.float(), dim=-1)
-        current_logprobs = logprobs[torch.arange(logprobs.shape[0]), next_tokens]
-        sum_logprobs += current_logprobs * (tokens[:, -1] != self.eot)
-
-        next_tokens[tokens[:, -1] == self.eot] = self.eot
-        tokens = torch.cat([tokens, next_tokens[:, None]], dim=-1)
-
-        completed = (tokens[:, -1] == self.eot).all()
-        return tokens, completed
-
-    def finalize(self, tokens: Tensor, sum_logprobs: Tensor):
-        # make sure each sequence has at least one EOT token at the end
-        tokens = F.pad(tokens, (0, 1), value=self.eot)
-        return tokens, sum_logprobs.tolist(), self.ts.transpose(1, 0)[None]
-
-
-# modified version of whisper.BeamSearchDecoder
-class BeamSearchDecoderWordLevel(BeamSearchDecoder):
-
-    def __init__(self, *args, **kwargs):
-        self.ts_num: int = kwargs.pop('ts_num', 10)
-        self.suppress_ts_mask: Tensor = kwargs.pop('suppress_ts_mask', None)
-        self.timestamp_begin = kwargs.pop('timestamp_begin', 50364)
-        super(BeamSearchDecoderWordLevel, self).__init__(*args, **kwargs)
-        self.ts = None
-        self.finished_ts_ls = None
-
-    def reset(self):
-        self.finished_sequences = None
-        self.finished_ts_ls = None
-
-    def _suppress_ts(self, logits: Tensor):
-        _suppress_ts(logits[:, self.timestamp_begin:],
-                     suppress_ts_mask=self.suppress_ts_mask)
-
-    def update_with_ts(self, tokens: Tensor, logits: Tensor, sum_logprobs: Tensor, ts: Tensor) -> Tuple[Tensor, bool]:
-        if tokens.shape[0] % self.beam_size != 0:
-            raise ValueError(f"{tokens.shape}[0] % {self.beam_size} != 0")
-
-        self.ts = ts
-
-        n_audio = tokens.shape[0] // self.beam_size
-        if self.finished_sequences is None:  # for the first update
-            self.finished_sequences = [{} for _ in range(n_audio)]
-            self.finished_ts_ls = [{} for _ in range(n_audio)]
-
-        logprobs = F.log_softmax(logits.float(), dim=-1)
-        next_tokens, source_indices, finished_sequences, finished_ts_ls = [], [], [], []
-
-        self._suppress_ts(logprobs)
-
-        for i in range(n_audio):
-            scores, sources, finished, finished_ts = {}, {}, {}, {}
-
-            # STEP 1: calculate the cumulative log probabilities for possible candidates
-            for j in range(self.beam_size):
-                idx = i * self.beam_size + j
-                prefix = tokens[idx].tolist()
-                for logprob, token in zip(*logprobs[idx].topk(self.beam_size + 1)):
-                    new_logprob = (sum_logprobs[idx] + logprob).item()
-                    sequence = tuple(prefix + [token.item()])
-                    scores[sequence] = new_logprob
-                    sources[sequence] = idx
-
-            # STEP 2: rank the candidates and keep the top beam_size sequences for each audio
-            saved = 0
-            for sequence in sorted(scores, key=scores.get, reverse=True):
-                if sequence[-1] == self.eot:
-                    finished[sequence] = scores[sequence]
-                    finished_ts[sequence] = self.ts[:, sources[sequence]]
-                else:
-                    sum_logprobs[len(next_tokens)] = scores[sequence]
-                    next_tokens.append(sequence)
-                    source_indices.append(sources[sequence])
-
-                    saved += 1
-                    if saved == self.beam_size:
-                        break
-
-            finished_sequences.append(finished)
-            finished_ts_ls.append(finished_ts)
-
-        tokens = torch.tensor(next_tokens, device=tokens.device)
-        self.inference.rearrange_kv_cache(source_indices)
-        self.ts = self.ts[:, source_indices]
-
-        # add newly finished sequences to self.finished_sequences
-        assert len(self.finished_sequences) == len(finished_sequences)
-        for previously_finished, newly_finished, \
-            prev_ts_ls, new_ts_ls in \
-                zip(self.finished_sequences, finished_sequences,
-                    self.finished_ts_ls, finished_ts_ls):
-            for seq in sorted(newly_finished, key=newly_finished.get, reverse=True):
-                if len(previously_finished) >= self.max_candidates:
-                    break  # the candidate list is full
-                previously_finished[seq] = newly_finished[seq]
-                prev_ts_ls[seq] = new_ts_ls[seq]
-
-        # mark as completed if all audio has enough number of samples
-        completed = all(
-            len(sequences) >= self.max_candidates for sequences in self.finished_sequences
-        )
-        return tokens, completed
-
-    def finalize(self, preceding_tokens: Tensor, sum_logprobs: Tensor):
-        # collect all finished sequences, including patience, and add unfinished ones if not enough
-        self.ts = self.ts.reshape(self.ts.shape[0], *preceding_tokens.shape[:2], *self.ts.shape[2:])
-        sum_logprobs = sum_logprobs.cpu()
-        for i, (sequences, ts_) in \
-                enumerate(zip(self.finished_sequences, self.finished_ts_ls)):
-            if len(sequences) < self.beam_size:  # when not enough sequences are finished
-                for j in list(np.argsort(sum_logprobs[i]))[::-1]:
-                    sequence = preceding_tokens[i, j].tolist() + [self.eot]
-                    seq_tuple = tuple(sequence)
-                    sequences[seq_tuple] = sum_logprobs[i][j].item()
-                    ts_[seq_tuple] = self.ts[:, i, j]
-                    if len(sequences) >= self.beam_size:
-                        break
-
-        tokens: List[List[Tensor]] = [
-            [torch.tensor(seq) for seq in sequences.keys()] for sequences in self.finished_sequences
-        ]
-        sum_logprobs: List[List[float]] = [
-            list(sequences.values()) for sequences in self.finished_sequences
-        ]
-        final_ts: List[List[Tensor]] = [
-            list(sequences.values()) for sequences in self.finished_ts_ls
-        ]
-        return tokens, sum_logprobs, final_ts
-
-
-class DecodingTaskWordLevel(DecodingTask):
-
-    def __init__(self, *args, **kwargs):
-        self.ts_num: int = kwargs.pop('ts_num', 10)
-        self.alpha: float = kwargs.pop('alpha', None)  # experimental
-        self.suppress_ts_mask: Tensor = kwargs.pop('suppress_ts_mask', None)
-        self.suppress_word_ts: bool = kwargs.pop('suppress_word_ts', True)
-        super(DecodingTaskWordLevel, self).__init__(*args, **kwargs)
-        if hasattr(self.decoder, 'beam_size'):
-            self.decoder = BeamSearchDecoderWordLevel(self.decoder.beam_size,
-                                                      self.decoder.eot,
-                                                      self.inference,
-                                                      self.decoder.patience,
-                                                      ts_num=self.ts_num,
-                                                      suppress_ts_mask=self.suppress_ts_mask,
-                                                      timestamp_begin=self.tokenizer.timestamp_begin)
-        else:
-            self.decoder = GreedyDecoderWordLevel(self.decoder.temperature,
-                                                  self.decoder.eot,
-                                                  ts_num=self.ts_num,
-                                                  suppress_ts_mask=self.suppress_ts_mask,
-                                                  timestamp_begin=self.tokenizer.timestamp_begin)
-
-    # modified version of whisper.DecodingTask._main_loop
-    def _main_loop(self, audio_features: Tensor, tokens: Tensor):
-        assert audio_features.shape[0] == tokens.shape[0]
-        n_batch = tokens.shape[0]
-        sum_logprobs: Tensor = torch.zeros(n_batch, device=audio_features.device)
-        no_speech_probs = [np.nan] * n_batch
-
-        # ts = None
-
-        try:
-            for i in range(self.sample_len):
-                if self.alpha:
-                    logits = self.inference.logits(tokens,
-                                                   audio_features * (torch.rand_like(audio_features) * self.alpha + 1))
-                else:
-                    logits = self.inference.logits(tokens, audio_features)
-
-                if i == 0 and get_new_attrs(self.tokenizer, 'no_captions') is not None:  # save no_speech_probs
-                    probs_at_sot = logits[:, self.sot_index].float().softmax(dim=-1)
-                    no_speech_probs = probs_at_sot[:, get_new_attrs(self.tokenizer, 'no_captions')].tolist()
-
-                # now we need to consider the logits at the last token only
-                logits = logits[:, -1]
-
-                ts_logits = torch.clone(logits[:, self.tokenizer.timestamp_begin:])
-                if self.suppress_word_ts:
-                    _suppress_ts(ts_logits, self.suppress_ts_mask)
-                ts = _ts_topk(ts_logits, k=self.ts_num, prev_ts=self.decoder.ts)
-
-                # apply the logit filters, e.g. for suppressing or applying penalty to
-                for logit_filter in self.logit_filters:
-                    logit_filter.apply(logits, tokens)
-
-                # expand the tokens tensor with the selected next tokens
-                tokens, completed = self.decoder.update_with_ts(tokens, logits, sum_logprobs, ts)
-
-                if completed or tokens.shape[-1] > self.n_ctx:
-                    break
-        finally:
-            self.inference.cleanup_caching()
-
-        return tokens, sum_logprobs, no_speech_probs
-
-    # modified version of whisper.DecodingTask.run
-    @torch.no_grad()
-    def run(self, mel: Tensor) \
-            -> Union[List[DecodingResult], Tuple[List[DecodingResult], List[List[int]]]]:
-        self.decoder.reset()
-        tokenizer: Tokenizer = self.tokenizer
-        n_audio: int = mel.shape[0]
-
-        audio_features: Tensor = self._get_audio_features(mel)  # encoder forward pass
-        tokens: Tensor = torch.tensor([self.initial_tokens]).expand(n_audio, -1)
-
-        # detect language if requested, overwriting the language token
-        languages, language_probs = self._detect_language(audio_features, tokens)
-        if self.options.task == "lang_id":
-            return [
-                DecodingResult(audio_features=features, language=language, language_probs=probs)
-                for features, language, probs in zip(audio_features, languages, language_probs)
-            ]
-
-        # repeat the audio & text tensors by the group size, for beam search or best-of-n sampling
-        audio_features = audio_features.repeat_interleave(self.n_group, dim=0)
-        tokens = tokens.repeat_interleave(self.n_group, dim=0).to(audio_features.device)
-
-        # call the main sampling loop
-        tokens, sum_logprobs, no_speech_probs = self._main_loop(audio_features, tokens)
-
-        # reshape the tensors to have (n_audio, n_group) as the first two dimensions
-        audio_features = audio_features[:: self.n_group]
-        no_speech_probs = no_speech_probs[:: self.n_group]
-        assert audio_features.shape[0] == len(no_speech_probs) == n_audio
-
-        tokens = tokens.reshape(n_audio, self.n_group, -1)
-        sum_logprobs = sum_logprobs.reshape(n_audio, self.n_group)
-
-        # get the final candidates for each group, and slice between the first sampled token and EOT
-        tokens, sum_logprobs, ts = self.decoder.finalize(tokens, sum_logprobs)
-        tokens: List[List[Tensor]] = [
-            [t[self.sample_begin: (t == tokenizer.eot).nonzero()[0, 0]] for t in s] for s in tokens
-        ]
-        ts: List[List[Tensor]] = [[t[:, :tokens[i][j].shape[-1]] for j, t in enumerate(s)] for i, s in enumerate(ts)]
-
-        # select the top-ranked sample in each group
-        selected = self.sequence_ranker.rank(tokens, sum_logprobs)
-        tokens: List[List[int]] = [t[i].tolist() for i, t in zip(selected, tokens)]
-        ts: List[List[int]] = [t[i].tolist() for i, t in zip(selected, ts)]
-        texts: List[str] = [tokenizer.decode(t).strip() for t in tokens]
-
-        sum_logprobs: List[float] = [lp[i] for i, lp in zip(selected, sum_logprobs)]
-        avg_logprobs: List[float] = [lp / (len(t) + 1) for t, lp in zip(tokens, sum_logprobs)]
-
-        fields = (texts, languages, tokens, audio_features, avg_logprobs, no_speech_probs)
-        if len(set(map(len, fields))) != 1:
-            raise RuntimeError(f"inconsistent result lengths: {list(map(len, fields))}")
-
-        return [
-                   DecodingResult(
-                       audio_features=features,
-                       language=language,
-                       tokens=tokens,
-                       text=text,
-                       avg_logprob=avg_logprob,
-                       **(dict(no_caption_prob=no_speech_prob) if hasattr(DecodingResult, 'no_caption_prob') else dict(
-                           no_speech_prob=no_speech_prob)),
-                       temperature=self.options.temperature,
-                       compression_ratio=compression_ratio(text),
-                   )
-                   for text, language, tokens, features, avg_logprob, no_speech_prob in zip(*fields)
-               ], ts
-
-
-# modified version of whisper.decoding.decode
-@torch.no_grad()
-def decode_word_level(model: "Whisper", mel: Tensor, options: DecodingOptions = DecodingOptions(),
-                      ts_num: int = None, alpha: float = None, suppress_ts_mask: Tensor = None,
-                      suppress_word_ts=False) -> \
-        Union[DecodingResult, List[DecodingResult], tuple]:
-    """
-    Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).
-
-    Parameters
-    ----------
-    model: Whisper
-        the Whisper model instance
-
-    mel: torch.Tensor, shape = (80, 3000) or (*, 80, 3000)
-        A tensor containing the Mel spectrogram(s)
-
-    options: DecodingOptions
-        A dataclass that contains all necessary options for decoding 30-second segments
-
-    ts_num: int
-        Number of additional top timestamp predictions to save for each word for postprocessing stabilization (default: 5).
-
-    alpha: float
-        Amount of noise to add to audio to produce slightly difference results.
-        audio_features *= torch.rand_like(audio_features) * alpha + 1
-
-    suppress_ts_mask: (list, Tensor)
-        Mask suppress to timestamp token(s) for decoding
-
-    suppress_word_ts: bool
-        Use suppress_ts_mask to suppress timestamp tokens of words
-
-    Returns
-    -------
-    result: Union[DecodingResult, List[DecodingResult]]
-        The result(s) of decoding contained in `DecodingResult` dataclass instance(s)
-    """
-    single = mel.ndim == 2
-    if single:
-        mel = mel.unsqueeze(0)
-
-    result, ts = DecodingTaskWordLevel(model, options,
-                                       ts_num=ts_num,
-                                       alpha=alpha,
-                                       suppress_ts_mask=suppress_ts_mask,
-                                       suppress_word_ts=suppress_word_ts).run(mel)
-
-    if single:
-        result = result[0]
-        ts_tokens = ts[0][1]
-        ts_logits = ts[0][0]
-    else:
-        ts_tokens = [ts_[1] for ts_ in ts]
-        ts_logits = [ts_[0] for ts_ in ts]
-
-    return result, ts_tokens, ts_logits
-
-
-def modify_model(model: whisper.model.Whisper):
-    model.decode = MethodType(decode_word_level, model)
-    model.transcribe = MethodType(transcribe_word_level, model)

spaces/Awiny/Image2Paragraph/models/grit_src/third_party/CenterNet2/docs/tutorials/training.md

@@ -1,67 +0,0 @@
-# Training
-
-From the previous tutorials, you may now have a custom model and a data loader.
-To run training, users typically have a preference in one of the following two styles:
-
-### Custom Training Loop
-
-With a model and a data loader ready, everything else needed to write a training loop can
-be found in PyTorch, and you are free to write the training loop yourself.
-This style allows researchers to manage the entire training logic more clearly and have full control.
-One such example is provided in [tools/plain_train_net.py](../../tools/plain_train_net.py).
-
-Any customization on the training logic is then easily controlled by the user.
-
-### Trainer Abstraction
-
-We also provide a standardized "trainer" abstraction with a
-hook system that helps simplify the standard training behavior.
-It includes the following two instantiations:
-
-* [SimpleTrainer](../modules/engine.html#detectron2.engine.SimpleTrainer)
-  provides a minimal training loop for single-cost single-optimizer single-data-source training, with nothing else.
-  Other tasks (checkpointing, logging, etc) can be implemented using
-  [the hook system](../modules/engine.html#detectron2.engine.HookBase).
-* [DefaultTrainer](../modules/engine.html#detectron2.engine.defaults.DefaultTrainer) is a `SimpleTrainer` initialized from a
-  yacs config, used by
-  [tools/train_net.py](../../tools/train_net.py) and many scripts.
-  It includes more standard default behaviors that one might want to opt in,
-  including default configurations for optimizer, learning rate schedule,
-  logging, evaluation, checkpointing etc.
-
-To customize a `DefaultTrainer`:
-
-1. For simple customizations (e.g. change optimizer, evaluator, LR scheduler, data loader, etc.), overwrite [its methods](../modules/engine.html#detectron2.engine.defaults.DefaultTrainer) in a subclass, just like [tools/train_net.py](../../tools/train_net.py).
-2. For extra tasks during training, check the
-   [hook system](../modules/engine.html#detectron2.engine.HookBase) to see if it's supported.
-
-   As an example, to print hello during training:
-   ```python
-   class HelloHook(HookBase):
-     def after_step(self):
-       if self.trainer.iter % 100 == 0:
-         print(f"Hello at iteration {self.trainer.iter}!")
-   ```
-3. Using a trainer+hook system means there will always be some non-standard behaviors that cannot be supported, especially in research.
-   For this reason, we intentionally keep the trainer & hook system minimal, rather than powerful.
-   If anything cannot be achieved by such a system, it's easier to start from [tools/plain_train_net.py](../../tools/plain_train_net.py) to implement custom training logic manually.
-
-### Logging of Metrics
-
-During training, detectron2 models and trainer put metrics to a centralized [EventStorage](../modules/utils.html#detectron2.utils.events.EventStorage).
-You can use the following code to access it and log metrics to it:
-```
-from detectron2.utils.events import get_event_storage
-
-# inside the model:
-if self.training:
-  value = # compute the value from inputs
-  storage = get_event_storage()
-  storage.put_scalar("some_accuracy", value)
-```
-
-Refer to its documentation for more details.
-
-Metrics are then written to various destinations with [EventWriter](../modules/utils.html#module-detectron2.utils.events).
-DefaultTrainer enables a few `EventWriter` with default configurations.
-See above for how to customize them.

spaces/BAAI/vid2vid-zero/README.md

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

spaces/Bart92/RVC_HF/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py

@@ -1,86 +0,0 @@
-from lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-import pyworld
-import numpy as np
-
-
-class HarvestF0Predictor(F0Predictor):
-    def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
-        self.hop_length = hop_length
-        self.f0_min = f0_min
-        self.f0_max = f0_max
-        self.sampling_rate = sampling_rate
-
-    def interpolate_f0(self, f0):
-        """
-        对F0进行插值处理
-        """
-
-        data = np.reshape(f0, (f0.size, 1))
-
-        vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
-        vuv_vector[data > 0.0] = 1.0
-        vuv_vector[data <= 0.0] = 0.0
-
-        ip_data = data
-
-        frame_number = data.size
-        last_value = 0.0
-        for i in range(frame_number):
-            if data[i] <= 0.0:
-                j = i + 1
-                for j in range(i + 1, frame_number):
-                    if data[j] > 0.0:
-                        break
-                if j < frame_number - 1:
-                    if last_value > 0.0:
-                        step = (data[j] - data[i - 1]) / float(j - i)
-                        for k in range(i, j):
-                            ip_data[k] = data[i - 1] + step * (k - i + 1)
-                    else:
-                        for k in range(i, j):
-                            ip_data[k] = data[j]
-                else:
-                    for k in range(i, frame_number):
-                        ip_data[k] = last_value
-            else:
-                ip_data[i] = data[i]  # 这里可能存在一个没有必要的拷贝
-                last_value = data[i]
-
-        return ip_data[:, 0], vuv_vector[:, 0]
-
-    def resize_f0(self, x, target_len):
-        source = np.array(x)
-        source[source < 0.001] = np.nan
-        target = np.interp(
-            np.arange(0, len(source) * target_len, len(source)) / target_len,
-            np.arange(0, len(source)),
-            source,
-        )
-        res = np.nan_to_num(target)
-        return res
-
-    def compute_f0(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.harvest(
-            wav.astype(np.double),
-            fs=self.hop_length,
-            f0_ceil=self.f0_max,
-            f0_floor=self.f0_min,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.fs)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
-
-    def compute_f0_uv(self, wav, p_len=None):
-        if p_len is None:
-            p_len = wav.shape[0] // self.hop_length
-        f0, t = pyworld.harvest(
-            wav.astype(np.double),
-            fs=self.sampling_rate,
-            f0_floor=self.f0_min,
-            f0_ceil=self.f0_max,
-            frame_period=1000 * self.hop_length / self.sampling_rate,
-        )
-        f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
-        return self.interpolate_f0(self.resize_f0(f0, p_len))

spaces/Benson/text-generation/Examples/Descargar Aplikasi True Skate.md

@@ -1,51 +0,0 @@
-
-<h1>Descargar Aplikasi True Skate: El Último Skateboarding Sim</h1>
-<p>Si te gusta el skateboarding, te encantará True Skate. True Skate es un juego móvil que simula la experiencia del skateboarding en el mundo real. Puedes realizar trucos, explorar parques de skate, personalizar tu skater y tabla, editar y compartir tus repeticiones, y más. En este artículo, te diremos qué es True Skate, cómo descargarlo y por qué deberías jugarlo. </p>
-<h2>¿Qué es True Skate? </h2>
-<p>True Skate es un juego desarrollado por True Axis, una compañía australiana que se especializa en juegos basados en la física. True Skate fue lanzado en 2012 y desde entonces se ha convertido en uno de los juegos de skateboarding más populares y aclamados en dispositivos móviles. Es el juego oficial de Street League Skateboarding, la primera serie de skateboarding competitivo del mundo. </p>
-<h2>descargar aplikasi true skate</h2><br /><p><b><b>Download File</b> &#9734;&#9734;&#9734; <a href="https://bltlly.com/2v6MUO">https://bltlly.com/2v6MUO</a></b></p><br /><br />
-<h3>Características de True Skate</h3>
-<p>True Skate tiene muchas características que lo hacen destacar de otros juegos de skateboarding. Aquí están algunas de ellas:</p>
-<h4>Controles basados en la física</h4>
-<p>True Skate usa los dedos como los pies en el tablero. Puedes mover, arrastrar, tocar y deslizar el dedo para hacer que el tablero reaccione exactamente como lo esperarías. También puede utilizar un gamepad para un control más preciso. El juego tiene un sistema de física realista que tiene en cuenta la posición, la dirección y la fuerza de su entrada. Esto significa que cada truco es posible con verdadero control del tablero. </p>
-<h4>Parques de skate realistas y spots</h4>
-<p>True Skate viene con un solo skatepark, el Underpass, que tiene repisas, escaleras, rieles, cuencos, medias tuberías y cuartos de tubería. También puedes desbloquear 10 parques de fantasía con pernos, la moneda del juego. Además, puede comprar más de 20 spots del mundo real como compras en la aplicación. Estos incluyen lugares famosos como los cursos de The Berrics, SPoT, Love Park, MACBA y Street League. </p>
-<h4>Skater personalizable y configuración</h4>
-
-<h4>Editor de reproducción y uso compartido</h4>
-<p>True Skate se trata de clavar la línea perfecta. Puedes grabar tus carreras y editarlas con diferentes ángulos y efectos de cámara. También puede insertar fotogramas clave para mezclar entre levas. Puede elegir entre levas preestablecidas o crear su propia leva personalizada con opciones como FOV, distorsión, distancia, altura, tono, pan, guiñada y órbita. También puede usar una cámara de trípode con modos automático, fijo o de seguimiento. Una vez que estés satisfecho con tu repetición, puedes compartirla con otros jugadores o en las redes sociales. </p>
-<h4>Modo de bricolaje y comunidad</h4>
-<p>True Skate también tiene un modo de bricolaje que te permite crear tu propio skatepark con objetos que puedes generar y multiplicar. También puedes desbloquear nuevos objetos jugando o comprándolos en la tienda. Puedes jugar en tu propio parque o compartirlo con otros jugadores. También puedes competir en tablas de clasificación globales o desafiar a tus amigos en juegos de S.K.A.T.E o modo SANDBOX. </p>
-<p></p>
-<h3>¿Cómo descargar aplikasi true skate? </h3>
-<p>True Skate está disponible para dispositivos Android e iOS. Aquí está cómo descargarlo:</p>
-<h4>Para dispositivos Android</h4>
-<ol>
-<li>Ir a la aplicación Google Play Store en su dispositivo. </ <li>Buscar "True Skate" en la barra de búsqueda. </li>
-<li>Seleccione la aplicación de la lista de resultados y toque en "Instalar". </li>
-<li>Espere a que la aplicación se descargue e instale en su dispositivo. </li>
-<li>Abre la aplicación y disfruta jugando True Skate.</li>
-</ol>
-<h4>Para dispositivos iOS</h4>
-<ol>
-<li>Ir a la aplicación App Store en su dispositivo. </li>
-<li>Buscar "True Skate" en la barra de búsqueda. </li>
-<li>Seleccione la aplicación de la lista de resultados y toque en "Obtener". </li>
-<li>Introduzca su ID de Apple y contraseña si se le solicita. </li>
-<li>Espere a que la aplicación se descargue e instale en su dispositivo. </li>
-<li>Abre la aplicación y disfruta jugando True Skate.</li>
-</ol>
-<h2>¿Por qué descargar aplikasi true skate? </h2>
-
-<h3>Beneficios de jugar True Skate</h3>
-<p>Jugar True Skate puede ayudarte de muchas maneras, como:</p>
-<h4>Mejora tus habilidades de skateboarding</h4>
-<p>True Skate puede ayudarte a aprender nuevos trucos, mejorar tu técnica y dominar tu equilibrio. Puedes practicar en diferentes entornos, con diferentes obstáculos y a diferentes velocidades. También puedes ver las repeticiones de otros jugadores o profesionales y aprender de sus movimientos. También puedes usar True Skate como herramienta para visualizar tus trucos antes de probarlos en la vida real. </p>
-<h4>Expresa tu creatividad y estilo</h4>
-<p>True Skate te permite personalizar tu skater y tabla con varias opciones. También puedes crear tu propio skatepark con el modo DIY y compartirlo con otros. También puedes editar y compartir tus repeticiones con diferentes cams y efectos. Puedes mostrar tus habilidades, creatividad y estilo al mundo. </p>
-<h4>Diviértete y ponte a prueba</h4>
-<p>True Skate es un juego divertido y adictivo que te mantendrá entretenido durante horas. Puedes explorar diferentes parques de skate y lugares, completar misiones y logros, competir en tablas de clasificación y desafíos, y jugar con tus amigos. También puedes establecer tus propios objetivos y desafiarte a mejorar tu rendimiento. </p>
-<h2>Conclusión</h2>
-<p>True Skate es un juego que todo amante del skateboarding debería probar. Es una simulación realista, inmersiva y agradable del skateboarding en el mundo real. Puedes descargar aplikasi true skate para dispositivos Android o iOS y empezar a jugar de inmediato. No te arrepentirás. </p> 64aa2da5cf<br />
-<br />
-<br />

spaces/Betacuckgpt/ehartford-Wizard-Vicuna-30B-Uncensored123/README.md

@@ -1,12 +0,0 @@
----
-title: Ehartford Wizard Vicuna 30B Uncensored123
-emoji: 🏆
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.47.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/modeling/poolers.py

@@ -1,235 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-import math
-import sys
-import torch
-from torch import nn
-from torchvision.ops import RoIPool
-
-from detectron2.layers import ROIAlign, ROIAlignRotated, cat
-
-__all__ = ["ROIPooler"]
-
-
-def assign_boxes_to_levels(box_lists, min_level, max_level, canonical_box_size, canonical_level):
-    """
-    Map each box in `box_lists` to a feature map level index and return the assignment
-    vector.
-
-    Args:
-        box_lists (list[Boxes] | list[RotatedBoxes]): A list of N Boxes or N RotatedBoxes,
-            where N is the number of images in the batch.
-        min_level (int): Smallest feature map level index. The input is considered index 0,
-            the output of stage 1 is index 1, and so.
-        max_level (int): Largest feature map level index.
-        canonical_box_size (int): A canonical box size in pixels (sqrt(box area)).
-        canonical_level (int): The feature map level index on which a canonically-sized box
-            should be placed.
-
-    Returns:
-        A tensor of length M, where M is the total number of boxes aggregated over all
-            N batch images. The memory layout corresponds to the concatenation of boxes
-            from all images. Each element is the feature map index, as an offset from
-            `self.min_level`, for the corresponding box (so value i means the box is at
-            `self.min_level + i`).
-    """
-    eps = sys.float_info.epsilon
-    box_sizes = torch.sqrt(cat([boxes.area() for boxes in box_lists]))
-    # Eqn.(1) in FPN paper
-    level_assignments = torch.floor(
-        canonical_level + torch.log2(box_sizes / canonical_box_size + eps)
-    )
-    # clamp level to (min, max), in case the box size is too large or too small
-    # for the available feature maps
-    level_assignments = torch.clamp(level_assignments, min=min_level, max=max_level)
-    return level_assignments.to(torch.int64) - min_level
-
-
-def convert_boxes_to_pooler_format(box_lists):
-    """
-    Convert all boxes in `box_lists` to the low-level format used by ROI pooling ops
-    (see description under Returns).
-
-    Args:
-        box_lists (list[Boxes] | list[RotatedBoxes]):
-            A list of N Boxes or N RotatedBoxes, where N is the number of images in the batch.
-
-    Returns:
-        When input is list[Boxes]:
-            A tensor of shape (M, 5), where M is the total number of boxes aggregated over all
-            N batch images.
-            The 5 columns are (batch index, x0, y0, x1, y1), where batch index
-            is the index in [0, N) identifying which batch image the box with corners at
-            (x0, y0, x1, y1) comes from.
-        When input is list[RotatedBoxes]:
-            A tensor of shape (M, 6), where M is the total number of boxes aggregated over all
-            N batch images.
-            The 6 columns are (batch index, x_ctr, y_ctr, width, height, angle_degrees),
-            where batch index is the index in [0, N) identifying which batch image the
-            rotated box (x_ctr, y_ctr, width, height, angle_degrees) comes from.
-    """
-
-    def fmt_box_list(box_tensor, batch_index):
-        repeated_index = torch.full(
-            (len(box_tensor), 1), batch_index, dtype=box_tensor.dtype, device=box_tensor.device
-        )
-        return cat((repeated_index, box_tensor), dim=1)
-
-    pooler_fmt_boxes = cat(
-        [fmt_box_list(box_list.tensor, i) for i, box_list in enumerate(box_lists)], dim=0
-    )
-
-    return pooler_fmt_boxes
-
-
-class ROIPooler(nn.Module):
-    """
-    Region of interest feature map pooler that supports pooling from one or more
-    feature maps.
-    """
-
-    def __init__(
-        self,
-        output_size,
-        scales,
-        sampling_ratio,
-        pooler_type,
-        canonical_box_size=224,
-        canonical_level=4,
-    ):
-        """
-        Args:
-            output_size (int, tuple[int] or list[int]): output size of the pooled region,
-                e.g., 14 x 14. If tuple or list is given, the length must be 2.
-            scales (list[float]): The scale for each low-level pooling op relative to
-                the input image. For a feature map with stride s relative to the input
-                image, scale is defined as a 1 / s. The stride must be power of 2.
-                When there are multiple scales, they must form a pyramid, i.e. they must be
-                a monotically decreasing geometric sequence with a factor of 1/2.
-            sampling_ratio (int): The `sampling_ratio` parameter for the ROIAlign op.
-            pooler_type (string): Name of the type of pooling operation that should be applied.
-                For instance, "ROIPool" or "ROIAlignV2".
-            canonical_box_size (int): A canonical box size in pixels (sqrt(box area)). The default
-                is heuristically defined as 224 pixels in the FPN paper (based on ImageNet
-                pre-training).
-            canonical_level (int): The feature map level index from which a canonically-sized box
-                should be placed. The default is defined as level 4 (stride=16) in the FPN paper,
-                i.e., a box of size 224x224 will be placed on the feature with stride=16.
-                The box placement for all boxes will be determined from their sizes w.r.t
-                canonical_box_size. For example, a box whose area is 4x that of a canonical box
-                should be used to pool features from feature level ``canonical_level+1``.
-
-                Note that the actual input feature maps given to this module may not have
-                sufficiently many levels for the input boxes. If the boxes are too large or too
-                small for the input feature maps, the closest level will be used.
-        """
-        super().__init__()
-
-        if isinstance(output_size, int):
-            output_size = (output_size, output_size)
-        assert len(output_size) == 2
-        assert isinstance(output_size[0], int) and isinstance(output_size[1], int)
-        self.output_size = output_size
-
-        if pooler_type == "ROIAlign":
-            self.level_poolers = nn.ModuleList(
-                ROIAlign(
-                    output_size, spatial_scale=scale, sampling_ratio=sampling_ratio, aligned=False
-                )
-                for scale in scales
-            )
-        elif pooler_type == "ROIAlignV2":
-            self.level_poolers = nn.ModuleList(
-                ROIAlign(
-                    output_size, spatial_scale=scale, sampling_ratio=sampling_ratio, aligned=True
-                )
-                for scale in scales
-            )
-        elif pooler_type == "ROIPool":
-            self.level_poolers = nn.ModuleList(
-                RoIPool(output_size, spatial_scale=scale) for scale in scales
-            )
-        elif pooler_type == "ROIAlignRotated":
-            self.level_poolers = nn.ModuleList(
-                ROIAlignRotated(output_size, spatial_scale=scale, sampling_ratio=sampling_ratio)
-                for scale in scales
-            )
-        else:
-            raise ValueError("Unknown pooler type: {}".format(pooler_type))
-
-        # Map scale (defined as 1 / stride) to its feature map level under the
-        # assumption that stride is a power of 2.
-        min_level = -math.log2(scales[0])
-        max_level = -math.log2(scales[-1])
-        assert math.isclose(min_level, int(min_level)) and math.isclose(
-            max_level, int(max_level)
-        ), "Featuremap stride is not power of 2!"
-        self.min_level = int(min_level)
-        self.max_level = int(max_level)
-        assert (
-            len(scales) == self.max_level - self.min_level + 1
-        ), "[ROIPooler] Sizes of input featuremaps do not form a pyramid!"
-        assert 0 < self.min_level and self.min_level <= self.max_level
-        if len(scales) > 1:
-            # When there is only one feature map, canonical_level is redundant and we should not
-            # require it to be a sensible value. Therefore we skip this assertion
-            assert self.min_level <= canonical_level and canonical_level <= self.max_level
-        self.canonical_level = canonical_level
-        assert canonical_box_size > 0
-        self.canonical_box_size = canonical_box_size
-
-    def forward(self, x, box_lists):
-        """
-        Args:
-            x (list[Tensor]): A list of feature maps of NCHW shape, with scales matching those
-                used to construct this module.
-            box_lists (list[Boxes] | list[RotatedBoxes]):
-                A list of N Boxes or N RotatedBoxes, where N is the number of images in the batch.
-                The box coordinates are defined on the original image and
-                will be scaled by the `scales` argument of :class:`ROIPooler`.
-
-        Returns:
-            Tensor:
-                A tensor of shape (M, C, output_size, output_size) where M is the total number of
-                boxes aggregated over all N batch images and C is the number of channels in `x`.
-        """
-        num_level_assignments = len(self.level_poolers)
-
-        assert isinstance(x, list) and isinstance(
-            box_lists, list
-        ), "Arguments to pooler must be lists"
-        assert (
-            len(x) == num_level_assignments
-        ), "unequal value, num_level_assignments={}, but x is list of {} Tensors".format(
-            num_level_assignments, len(x)
-        )
-
-        assert len(box_lists) == x[0].size(
-            0
-        ), "unequal value, x[0] batch dim 0 is {}, but box_list has length {}".format(
-            x[0].size(0), len(box_lists)
-        )
-
-        pooler_fmt_boxes = convert_boxes_to_pooler_format(box_lists)
-
-        if num_level_assignments == 1:
-            return self.level_poolers[0](x[0], pooler_fmt_boxes)
-
-        level_assignments = assign_boxes_to_levels(
-            box_lists, self.min_level, self.max_level, self.canonical_box_size, self.canonical_level
-        )
-
-        num_boxes = len(pooler_fmt_boxes)
-        num_channels = x[0].shape[1]
-        output_size = self.output_size[0]
-
-        dtype, device = x[0].dtype, x[0].device
-        output = torch.zeros(
-            (num_boxes, num_channels, output_size, output_size), dtype=dtype, device=device
-        )
-
-        for level, (x_level, pooler) in enumerate(zip(x, self.level_poolers)):
-            inds = torch.nonzero(level_assignments == level).squeeze(1)
-            pooler_fmt_boxes_level = pooler_fmt_boxes[inds]
-            output[inds] = pooler(x_level, pooler_fmt_boxes_level)
-
-        return output

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

@@ -1,146 +0,0 @@
-import torch
-
-from mmdet.core import bbox2result
-from ..builder import DETECTORS, build_head
-from .single_stage import SingleStageDetector
-
-
-@DETECTORS.register_module()
-class YOLACT(SingleStageDetector):
-    """Implementation of `YOLACT <https://arxiv.org/abs/1904.02689>`_"""
-
-    def __init__(self,
-                 backbone,
-                 neck,
-                 bbox_head,
-                 segm_head,
-                 mask_head,
-                 train_cfg=None,
-                 test_cfg=None,
-                 pretrained=None):
-        super(YOLACT, self).__init__(backbone, neck, bbox_head, train_cfg,
-                                     test_cfg, pretrained)
-        self.segm_head = build_head(segm_head)
-        self.mask_head = build_head(mask_head)
-        self.init_segm_mask_weights()
-
-    def init_segm_mask_weights(self):
-        """Initialize weights of the YOLACT segm head and YOLACT mask head."""
-        self.segm_head.init_weights()
-        self.mask_head.init_weights()
-
-    def forward_dummy(self, img):
-        """Used for computing network flops.
-
-        See `mmdetection/tools/analysis_tools/get_flops.py`
-        """
-        raise NotImplementedError
-
-    def forward_train(self,
-                      img,
-                      img_metas,
-                      gt_bboxes,
-                      gt_labels,
-                      gt_bboxes_ignore=None,
-                      gt_masks=None):
-        """
-        Args:
-            img (Tensor): of shape (N, C, H, W) encoding input images.
-                Typically these should be mean centered and std scaled.
-            img_metas (list[dict]): list of image info dict where each dict
-                has: 'img_shape', 'scale_factor', 'flip', and may also contain
-                'filename', 'ori_shape', 'pad_shape', and 'img_norm_cfg'.
-                For details on the values of these keys see
-                `mmdet/datasets/pipelines/formatting.py:Collect`.
-            gt_bboxes (list[Tensor]): Ground truth bboxes for each image with
-                shape (num_gts, 4) in [tl_x, tl_y, br_x, br_y] format.
-            gt_labels (list[Tensor]): class indices corresponding to each box
-            gt_bboxes_ignore (None | list[Tensor]): specify which bounding
-                boxes can be ignored when computing the loss.
-            gt_masks (None | Tensor) : true segmentation masks for each box
-                used if the architecture supports a segmentation task.
-
-        Returns:
-            dict[str, Tensor]: a dictionary of loss components
-        """
-        # convert Bitmap mask or Polygon Mask to Tensor here
-        gt_masks = [
-            gt_mask.to_tensor(dtype=torch.uint8, device=img.device)
-            for gt_mask in gt_masks
-        ]
-
-        x = self.extract_feat(img)
-
-        cls_score, bbox_pred, coeff_pred = self.bbox_head(x)
-        bbox_head_loss_inputs = (cls_score, bbox_pred) + (gt_bboxes, gt_labels,
-                                                          img_metas)
-        losses, sampling_results = self.bbox_head.loss(
-            *bbox_head_loss_inputs, gt_bboxes_ignore=gt_bboxes_ignore)
-
-        segm_head_outs = self.segm_head(x[0])
-        loss_segm = self.segm_head.loss(segm_head_outs, gt_masks, gt_labels)
-        losses.update(loss_segm)
-
-        mask_pred = self.mask_head(x[0], coeff_pred, gt_bboxes, img_metas,
-                                   sampling_results)
-        loss_mask = self.mask_head.loss(mask_pred, gt_masks, gt_bboxes,
-                                        img_metas, sampling_results)
-        losses.update(loss_mask)
-
-        # check NaN and Inf
-        for loss_name in losses.keys():
-            assert torch.isfinite(torch.stack(losses[loss_name]))\
-                .all().item(), '{} becomes infinite or NaN!'\
-                .format(loss_name)
-
-        return losses
-
-    def simple_test(self, img, img_metas, rescale=False):
-        """Test function without test time augmentation."""
-        x = self.extract_feat(img)
-
-        cls_score, bbox_pred, coeff_pred = self.bbox_head(x)
-
-        bbox_inputs = (cls_score, bbox_pred,
-                       coeff_pred) + (img_metas, self.test_cfg, rescale)
-        det_bboxes, det_labels, det_coeffs = self.bbox_head.get_bboxes(
-            *bbox_inputs)
-        bbox_results = [
-            bbox2result(det_bbox, det_label, self.bbox_head.num_classes)
-            for det_bbox, det_label in zip(det_bboxes, det_labels)
-        ]
-
-        num_imgs = len(img_metas)
-        scale_factors = tuple(meta['scale_factor'] for meta in img_metas)
-        if all(det_bbox.shape[0] == 0 for det_bbox in det_bboxes):
-            segm_results = [[[] for _ in range(self.mask_head.num_classes)]
-                            for _ in range(num_imgs)]
-        else:
-            # if det_bboxes is rescaled to the original image size, we need to
-            # rescale it back to the testing scale to obtain RoIs.
-            if rescale and not isinstance(scale_factors[0], float):
-                scale_factors = [
-                    torch.from_numpy(scale_factor).to(det_bboxes[0].device)
-                    for scale_factor in scale_factors
-                ]
-            _bboxes = [
-                det_bboxes[i][:, :4] *
-                scale_factors[i] if rescale else det_bboxes[i][:, :4]
-                for i in range(len(det_bboxes))
-            ]
-            mask_preds = self.mask_head(x[0], det_coeffs, _bboxes, img_metas)
-            # apply mask post-processing to each image individually
-            segm_results = []
-            for i in range(num_imgs):
-                if det_bboxes[i].shape[0] == 0:
-                    segm_results.append(
-                        [[] for _ in range(self.mask_head.num_classes)])
-                else:
-                    segm_result = self.mask_head.get_seg_masks(
-                        mask_preds[i], det_labels[i], img_metas[i], rescale)
-                    segm_results.append(segm_result)
-        return list(zip(bbox_results, segm_results))
-
-    def aug_test(self, imgs, img_metas, rescale=False):
-        """Test with augmentations."""
-        raise NotImplementedError

spaces/ChandraMohanNayal/AutoGPT/CONTRIBUTING.md

@@ -1,105 +0,0 @@
-# Contributing to ProjectName
-
-First of all, thank you for considering contributing to our project! We appreciate your time and effort, and we value any contribution, whether it's reporting a bug, suggesting a new feature, or submitting a pull request.
-
-This document provides guidelines and best practices to help you contribute effectively.
-
-## Table of Contents
-
-- [Code of Conduct](#code-of-conduct)
-- [Getting Started](#getting-started)
-- [How to Contribute](#how-to-contribute)
-  - [Reporting Bugs](#reporting-bugs)
-  - [Suggesting Enhancements](#suggesting-enhancements)
-  - [Submitting Pull Requests](#submitting-pull-requests)
-- [Style Guidelines](#style-guidelines)
-  - [Code Formatting](#code-formatting)
-  - [Pre-Commit Hooks](#pre-commit-hooks)
-
-## Code of Conduct
-
-By participating in this project, you agree to abide by our [Code of Conduct](CODE_OF_CONDUCT.md). Please read it to understand the expectations we have for everyone who contributes to this project.
-
-## 📢 A Quick Word
-Right now we will not be accepting any Contributions that add non-essential commands to Auto-GPT.
-
-However, you absolutely can still add these commands to Auto-GPT in the form of plugins. Please check out this [template](https://github.com/Significant-Gravitas/Auto-GPT-Plugin-Template).
-> ⚠️ Plugin support is expected to ship within the week. You can follow PR #757 for more updates!
-
-## Getting Started
-
-To start contributing, follow these steps:
-
-1. Fork the repository and clone your fork.
-2. Create a new branch for your changes (use a descriptive name, such as `fix-bug-123` or `add-new-feature`).
-3. Make your changes in the new branch.
-4. Test your changes thoroughly.
-5. Commit and push your changes to your fork.
-6. Create a pull request following the guidelines in the [Submitting Pull Requests](#submitting-pull-requests) section.
-
-## How to Contribute
-
-### Reporting Bugs
-
-If you find a bug in the project, please create an issue on GitHub with the following information:
-
-- A clear, descriptive title for the issue.
-- A description of the problem, including steps to reproduce the issue.
-- Any relevant logs, screenshots, or other supporting information.
-
-### Suggesting Enhancements
-
-If you have an idea for a new feature or improvement, please create an issue on GitHub with the following information:
-
-- A clear, descriptive title for the issue.
-- A detailed description of the proposed enhancement, including any benefits and potential drawbacks.
-- Any relevant examples, mockups, or supporting information.
-
-### Submitting Pull Requests
-
-When submitting a pull request, please ensure that your changes meet the following criteria:
-
-- Your pull request should be atomic and focus on a single change.
-- Your pull request should include tests for your change.
-- You should have thoroughly tested your changes with multiple different prompts.
-- You should have considered potential risks and mitigations for your changes.
-- You should have documented your changes clearly and comprehensively.
-- You should not include any unrelated or "extra" small tweaks or changes.
-
-## Style Guidelines
-
-### Code Formatting
-
-We use the `black` code formatter to maintain a consistent coding style across the project. Please ensure that your code is formatted using `black` before submitting a pull request. You can install `black` using `pip`:
-
-```bash
-pip install black
-```
-
-To format your code, run the following command in the project's root directory:
-
-```bash
-black .
-```
-### Pre-Commit Hooks
-We use pre-commit hooks to ensure that code formatting and other checks are performed automatically before each commit. To set up pre-commit hooks for this project, follow these steps:
-
-Install the pre-commit package using pip:
-```bash
-pip install pre-commit
-```
-
-Run the following command in the project's root directory to install the pre-commit hooks:
-```bash
-pre-commit install
-```
-
-Now, the pre-commit hooks will run automatically before each commit, checking your code formatting and other requirements.
-
-If you encounter any issues or have questions, feel free to reach out to the maintainers or open a new issue on GitHub. We're here to help and appreciate your efforts to contribute to the project.
-
-Happy coding, and once again, thank you for your contributions!
-
-Maintainers will look at PR that have no merge conflicts when deciding what to add to the project. Make sure your PR shows up here:
-
-https://github.com/Torantulino/Auto-GPT/pulls?q=is%3Apr+is%3Aopen+-is%3Aconflict+

spaces/Cletrason/Cletrason-toad-in-the-mario-movie/optimization.py

@@ -1,756 +0,0 @@
-# coding=utf-8
-# Copyright 2018 The Google AI Language Team Authors and The HuggingFace Inc. team.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""PyTorch optimization for BERT model."""
-
-import math
-import warnings
-from functools import partial
-from typing import Callable, Iterable, Optional, Tuple, Union
-
-import torch
-from torch import nn
-from torch.optim import Optimizer
-from torch.optim.lr_scheduler import LambdaLR
-
-from .trainer_utils import SchedulerType
-from .utils import logging
-from .utils.versions import require_version
-
-
-logger = logging.get_logger(__name__)
-
-
-def get_constant_schedule(optimizer: Optimizer, last_epoch: int = -1):
-    """
-    Create a schedule with a constant learning rate, using the learning rate set in optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-
-    return LambdaLR(optimizer, lambda _: 1, last_epoch=last_epoch)
-
-
-def _get_constant_schedule_with_warmup_lr_lambda(current_step: int, *, num_warmup_steps: int):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1.0, num_warmup_steps))
-    return 1.0
-
-
-def get_constant_schedule_with_warmup(optimizer: Optimizer, num_warmup_steps: int, last_epoch: int = -1):
-    """
-    Create a schedule with a constant learning rate preceded by a warmup period during which the learning rate
-    increases linearly between 0 and the initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-
-    lr_lambda = partial(_get_constant_schedule_with_warmup_lr_lambda, num_warmup_steps=num_warmup_steps)
-    return LambdaLR(optimizer, lr_lambda, last_epoch=last_epoch)
-
-
-def _get_linear_schedule_with_warmup_lr_lambda(current_step: int, *, num_warmup_steps: int, num_training_steps: int):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1, num_warmup_steps))
-    return max(0.0, float(num_training_steps - current_step) / float(max(1, num_training_steps - num_warmup_steps)))
-
-
-def get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_training_steps, last_epoch=-1):
-    """
-    Create a schedule with a learning rate that decreases linearly from the initial lr set in the optimizer to 0, after
-    a warmup period during which it increases linearly from 0 to the initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        num_training_steps (`int`):
-            The total number of training steps.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-
-    lr_lambda = partial(
-        _get_linear_schedule_with_warmup_lr_lambda,
-        num_warmup_steps=num_warmup_steps,
-        num_training_steps=num_training_steps,
-    )
-    return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-
-def _get_cosine_schedule_with_warmup_lr_lambda(
-    current_step: int, *, num_warmup_steps: int, num_training_steps: int, num_cycles: float
-):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1, num_warmup_steps))
-    progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
-    return max(0.0, 0.5 * (1.0 + math.cos(math.pi * float(num_cycles) * 2.0 * progress)))
-
-
-def get_cosine_schedule_with_warmup(
-    optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: float = 0.5, last_epoch: int = -1
-):
-    """
-    Create a schedule with a learning rate that decreases following the values of the cosine function between the
-    initial lr set in the optimizer to 0, after a warmup period during which it increases linearly between 0 and the
-    initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        num_training_steps (`int`):
-            The total number of training steps.
-        num_cycles (`float`, *optional*, defaults to 0.5):
-            The number of waves in the cosine schedule (the defaults is to just decrease from the max value to 0
-            following a half-cosine).
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-
-    lr_lambda = partial(
-        _get_cosine_schedule_with_warmup_lr_lambda,
-        num_warmup_steps=num_warmup_steps,
-        num_training_steps=num_training_steps,
-        num_cycles=num_cycles,
-    )
-    return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-
-def _get_cosine_with_hard_restarts_schedule_with_warmup_lr_lambda(
-    current_step: int, *, num_warmup_steps: int, num_training_steps: int, num_cycles: int
-):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1, num_warmup_steps))
-    progress = float(current_step - num_warmup_steps) / float(max(1, num_training_steps - num_warmup_steps))
-    if progress >= 1.0:
-        return 0.0
-    return max(0.0, 0.5 * (1.0 + math.cos(math.pi * ((float(num_cycles) * progress) % 1.0))))
-
-
-def get_cosine_with_hard_restarts_schedule_with_warmup(
-    optimizer: Optimizer, num_warmup_steps: int, num_training_steps: int, num_cycles: int = 1, last_epoch: int = -1
-):
-    """
-    Create a schedule with a learning rate that decreases following the values of the cosine function between the
-    initial lr set in the optimizer to 0, with several hard restarts, after a warmup period during which it increases
-    linearly between 0 and the initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        num_training_steps (`int`):
-            The total number of training steps.
-        num_cycles (`int`, *optional*, defaults to 1):
-            The number of hard restarts to use.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-
-    lr_lambda = partial(
-        _get_cosine_with_hard_restarts_schedule_with_warmup_lr_lambda,
-        num_warmup_steps=num_warmup_steps,
-        num_training_steps=num_training_steps,
-        num_cycles=num_cycles,
-    )
-    return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-
-def _get_polynomial_decay_schedule_with_warmup_lr_lambda(
-    current_step: int,
-    *,
-    num_warmup_steps: int,
-    num_training_steps: int,
-    lr_end: float,
-    power: float,
-    lr_init: int,
-):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1, num_warmup_steps))
-    elif current_step > num_training_steps:
-        return lr_end / lr_init  # as LambdaLR multiplies by lr_init
-    else:
-        lr_range = lr_init - lr_end
-        decay_steps = num_training_steps - num_warmup_steps
-        pct_remaining = 1 - (current_step - num_warmup_steps) / decay_steps
-        decay = lr_range * pct_remaining**power + lr_end
-        return decay / lr_init  # as LambdaLR multiplies by lr_init
-
-
-def get_polynomial_decay_schedule_with_warmup(
-    optimizer, num_warmup_steps, num_training_steps, lr_end=1e-7, power=1.0, last_epoch=-1
-):
-    """
-    Create a schedule with a learning rate that decreases as a polynomial decay from the initial lr set in the
-    optimizer to end lr defined by *lr_end*, after a warmup period during which it increases linearly from 0 to the
-    initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        num_training_steps (`int`):
-            The total number of training steps.
-        lr_end (`float`, *optional*, defaults to 1e-7):
-            The end LR.
-        power (`float`, *optional*, defaults to 1.0):
-            Power factor.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Note: *power* defaults to 1.0 as in the fairseq implementation, which in turn is based on the original BERT
-    implementation at
-    https://github.com/google-research/bert/blob/f39e881b169b9d53bea03d2d341b31707a6c052b/optimization.py#L37
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-
-    """
-
-    lr_init = optimizer.defaults["lr"]
-    if not (lr_init > lr_end):
-        raise ValueError(f"lr_end ({lr_end}) must be be smaller than initial lr ({lr_init})")
-
-    lr_lambda = partial(
-        _get_polynomial_decay_schedule_with_warmup_lr_lambda,
-        num_warmup_steps=num_warmup_steps,
-        num_training_steps=num_training_steps,
-        lr_end=lr_end,
-        power=power,
-        lr_init=lr_init,
-    )
-    return LambdaLR(optimizer, lr_lambda, last_epoch)
-
-
-def _get_inverse_sqrt_schedule_lr_lambda(current_step: int, *, num_warmup_steps: int, timescale: int = None):
-    if current_step < num_warmup_steps:
-        return float(current_step) / float(max(1, num_warmup_steps))
-    shift = timescale - num_warmup_steps
-    decay = 1.0 / math.sqrt((current_step + shift) / timescale)
-    return decay
-
-
-def get_inverse_sqrt_schedule(
-    optimizer: Optimizer, num_warmup_steps: int, timescale: int = None, last_epoch: int = -1
-):
-    """
-    Create a schedule with an inverse square-root learning rate, from the initial lr set in the optimizer, after a
-    warmup period which increases lr linearly from 0 to the initial lr set in the optimizer.
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        num_warmup_steps (`int`):
-            The number of steps for the warmup phase.
-        timescale (`int`, *optional*, defaults to `num_warmup_steps`):
-            Time scale.
-        last_epoch (`int`, *optional*, defaults to -1):
-            The index of the last epoch when resuming training.
-
-    Return:
-        `torch.optim.lr_scheduler.LambdaLR` with the appropriate schedule.
-    """
-    # Note: this implementation is adapted from
-    # https://github.com/google-research/big_vision/blob/f071ce68852d56099437004fd70057597a95f6ef/big_vision/utils.py#L930
-
-    if timescale is None:
-        timescale = num_warmup_steps
-
-    lr_lambda = partial(_get_inverse_sqrt_schedule_lr_lambda, num_warmup_steps=num_warmup_steps, timescale=timescale)
-    return LambdaLR(optimizer, lr_lambda, last_epoch=last_epoch)
-
-
-TYPE_TO_SCHEDULER_FUNCTION = {
-    SchedulerType.LINEAR: get_linear_schedule_with_warmup,
-    SchedulerType.COSINE: get_cosine_schedule_with_warmup,
-    SchedulerType.COSINE_WITH_RESTARTS: get_cosine_with_hard_restarts_schedule_with_warmup,
-    SchedulerType.POLYNOMIAL: get_polynomial_decay_schedule_with_warmup,
-    SchedulerType.CONSTANT: get_constant_schedule,
-    SchedulerType.CONSTANT_WITH_WARMUP: get_constant_schedule_with_warmup,
-    SchedulerType.INVERSE_SQRT: get_inverse_sqrt_schedule,
-}
-
-
-def get_scheduler(
-    name: Union[str, SchedulerType],
-    optimizer: Optimizer,
-    num_warmup_steps: Optional[int] = None,
-    num_training_steps: Optional[int] = None,
-):
-    """
-    Unified API to get any scheduler from its name.
-
-    Args:
-        name (`str` or `SchedulerType`):
-            The name of the scheduler to use.
-        optimizer (`torch.optim.Optimizer`):
-            The optimizer that will be used during training.
-        num_warmup_steps (`int`, *optional*):
-            The number of warmup steps to do. This is not required by all schedulers (hence the argument being
-            optional), the function will raise an error if it's unset and the scheduler type requires it.
-        num_training_steps (`int``, *optional*):
-            The number of training steps to do. This is not required by all schedulers (hence the argument being
-            optional), the function will raise an error if it's unset and the scheduler type requires it.
-    """
-    name = SchedulerType(name)
-    schedule_func = TYPE_TO_SCHEDULER_FUNCTION[name]
-    if name == SchedulerType.CONSTANT:
-        return schedule_func(optimizer)
-
-    # All other schedulers require `num_warmup_steps`
-    if num_warmup_steps is None:
-        raise ValueError(f"{name} requires `num_warmup_steps`, please provide that argument.")
-
-    if name == SchedulerType.CONSTANT_WITH_WARMUP:
-        return schedule_func(optimizer, num_warmup_steps=num_warmup_steps)
-
-    if name == SchedulerType.INVERSE_SQRT:
-        return schedule_func(optimizer, num_warmup_steps=num_warmup_steps)
-
-    # All other schedulers require `num_training_steps`
-    if num_training_steps is None:
-        raise ValueError(f"{name} requires `num_training_steps`, please provide that argument.")
-
-    return schedule_func(optimizer, num_warmup_steps=num_warmup_steps, num_training_steps=num_training_steps)
-
-
-class AdamW(Optimizer):
-    """
-    Implements Adam algorithm with weight decay fix as introduced in [Decoupled Weight Decay
-    Regularization](https://arxiv.org/abs/1711.05101).
-
-    Parameters:
-        params (`Iterable[nn.parameter.Parameter]`):
-            Iterable of parameters to optimize or dictionaries defining parameter groups.
-        lr (`float`, *optional*, defaults to 1e-3):
-            The learning rate to use.
-        betas (`Tuple[float,float]`, *optional*, defaults to (0.9, 0.999)):
-            Adam's betas parameters (b1, b2).
-        eps (`float`, *optional*, defaults to 1e-6):
-            Adam's epsilon for numerical stability.
-        weight_decay (`float`, *optional*, defaults to 0):
-            Decoupled weight decay to apply.
-        correct_bias (`bool`, *optional*, defaults to `True`):
-            Whether or not to correct bias in Adam (for instance, in Bert TF repository they use `False`).
-        no_deprecation_warning (`bool`, *optional*, defaults to `False`):
-            A flag used to disable the deprecation warning (set to `True` to disable the warning).
-    """
-
-    def __init__(
-        self,
-        params: Iterable[nn.parameter.Parameter],
-        lr: float = 1e-3,
-        betas: Tuple[float, float] = (0.9, 0.999),
-        eps: float = 1e-6,
-        weight_decay: float = 0.0,
-        correct_bias: bool = True,
-        no_deprecation_warning: bool = False,
-    ):
-        if not no_deprecation_warning:
-            warnings.warn(
-                "This implementation of AdamW is deprecated and will be removed in a future version. Use the PyTorch"
-                " implementation torch.optim.AdamW instead, or set `no_deprecation_warning=True` to disable this"
-                " warning",
-                FutureWarning,
-            )
-        require_version("torch>=1.5.0")  # add_ with alpha
-        if lr < 0.0:
-            raise ValueError(f"Invalid learning rate: {lr} - should be >= 0.0")
-        if not 0.0 <= betas[0] < 1.0:
-            raise ValueError(f"Invalid beta parameter: {betas[0]} - should be in [0.0, 1.0)")
-        if not 0.0 <= betas[1] < 1.0:
-            raise ValueError(f"Invalid beta parameter: {betas[1]} - should be in [0.0, 1.0)")
-        if not 0.0 <= eps:
-            raise ValueError(f"Invalid epsilon value: {eps} - should be >= 0.0")
-        defaults = {"lr": lr, "betas": betas, "eps": eps, "weight_decay": weight_decay, "correct_bias": correct_bias}
-        super().__init__(params, defaults)
-
-    def step(self, closure: Callable = None):
-        """
-        Performs a single optimization step.
-
-        Arguments:
-            closure (`Callable`, *optional*): A closure that reevaluates the model and returns the loss.
-        """
-        loss = None
-        if closure is not None:
-            loss = closure()
-
-        for group in self.param_groups:
-            for p in group["params"]:
-                if p.grad is None:
-                    continue
-                grad = p.grad.data
-                if grad.is_sparse:
-                    raise RuntimeError("Adam does not support sparse gradients, please consider SparseAdam instead")
-
-                state = self.state[p]
-
-                # State initialization
-                if len(state) == 0:
-                    state["step"] = 0
-                    # Exponential moving average of gradient values
-                    state["exp_avg"] = torch.zeros_like(p.data)
-                    # Exponential moving average of squared gradient values
-                    state["exp_avg_sq"] = torch.zeros_like(p.data)
-
-                exp_avg, exp_avg_sq = state["exp_avg"], state["exp_avg_sq"]
-                beta1, beta2 = group["betas"]
-
-                state["step"] += 1
-
-                # Decay the first and second moment running average coefficient
-                # In-place operations to update the averages at the same time
-                exp_avg.mul_(beta1).add_(grad, alpha=(1.0 - beta1))
-                exp_avg_sq.mul_(beta2).addcmul_(grad, grad, value=1.0 - beta2)
-                denom = exp_avg_sq.sqrt().add_(group["eps"])
-
-                step_size = group["lr"]
-                if group["correct_bias"]:  # No bias correction for Bert
-                    bias_correction1 = 1.0 - beta1 ** state["step"]
-                    bias_correction2 = 1.0 - beta2 ** state["step"]
-                    step_size = step_size * math.sqrt(bias_correction2) / bias_correction1
-
-                p.data.addcdiv_(exp_avg, denom, value=-step_size)
-
-                # Just adding the square of the weights to the loss function is *not*
-                # the correct way of using L2 regularization/weight decay with Adam,
-                # since that will interact with the m and v parameters in strange ways.
-                #
-                # Instead we want to decay the weights in a manner that doesn't interact
-                # with the m/v parameters. This is equivalent to adding the square
-                # of the weights to the loss with plain (non-momentum) SGD.
-                # Add weight decay at the end (fixed version)
-                if group["weight_decay"] > 0.0:
-                    p.data.add_(p.data, alpha=(-group["lr"] * group["weight_decay"]))
-
-        return loss
-
-
-class Adafactor(Optimizer):
-    """
-    AdaFactor pytorch implementation can be used as a drop in replacement for Adam original fairseq code:
-    https://github.com/pytorch/fairseq/blob/master/fairseq/optim/adafactor.py
-
-    Paper: *Adafactor: Adaptive Learning Rates with Sublinear Memory Cost* https://arxiv.org/abs/1804.04235 Note that
-    this optimizer internally adjusts the learning rate depending on the `scale_parameter`, `relative_step` and
-    `warmup_init` options. To use a manual (external) learning rate schedule you should set `scale_parameter=False` and
-    `relative_step=False`.
-
-    Arguments:
-        params (`Iterable[nn.parameter.Parameter]`):
-            Iterable of parameters to optimize or dictionaries defining parameter groups.
-        lr (`float`, *optional*):
-            The external learning rate.
-        eps (`Tuple[float, float]`, *optional*, defaults to (1e-30, 1e-3)):
-            Regularization constants for square gradient and parameter scale respectively
-        clip_threshold (`float`, *optional*, defaults 1.0):
-            Threshold of root mean square of final gradient update
-        decay_rate (`float`, *optional*, defaults to -0.8):
-            Coefficient used to compute running averages of square
-        beta1 (`float`, *optional*):
-            Coefficient used for computing running averages of gradient
-        weight_decay (`float`, *optional*, defaults to 0):
-            Weight decay (L2 penalty)
-        scale_parameter (`bool`, *optional*, defaults to `True`):
-            If True, learning rate is scaled by root mean square
-        relative_step (`bool`, *optional*, defaults to `True`):
-            If True, time-dependent learning rate is computed instead of external learning rate
-        warmup_init (`bool`, *optional*, defaults to `False`):
-            Time-dependent learning rate computation depends on whether warm-up initialization is being used
-
-    This implementation handles low-precision (FP16, bfloat) values, but we have not thoroughly tested.
-
-    Recommended T5 finetuning settings (https://discuss.huggingface.co/t/t5-finetuning-tips/684/3):
-
-        - Training without LR warmup or clip_threshold is not recommended.
-
-           - use scheduled LR warm-up to fixed LR
-           - use clip_threshold=1.0 (https://arxiv.org/abs/1804.04235)
-        - Disable relative updates
-        - Use scale_parameter=False
-        - Additional optimizer operations like gradient clipping should not be used alongside Adafactor
-
-    Example:
-
-    ```python
-    Adafactor(model.parameters(), scale_parameter=False, relative_step=False, warmup_init=False, lr=1e-3)
-    ```
-
-    Others reported the following combination to work well:
-
-    ```python
-    Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
-    ```
-
-    When using `lr=None` with [`Trainer`] you will most likely need to use [`~optimization.AdafactorSchedule`]
-    scheduler as following:
-
-    ```python
-    from transformers.optimization import Adafactor, AdafactorSchedule
-
-    optimizer = Adafactor(model.parameters(), scale_parameter=True, relative_step=True, warmup_init=True, lr=None)
-    lr_scheduler = AdafactorSchedule(optimizer)
-    trainer = Trainer(..., optimizers=(optimizer, lr_scheduler))
-    ```
-
-    Usage:
-
-    ```python
-    # replace AdamW with Adafactor
-    optimizer = Adafactor(
-        model.parameters(),
-        lr=1e-3,
-        eps=(1e-30, 1e-3),
-        clip_threshold=1.0,
-        decay_rate=-0.8,
-        beta1=None,
-        weight_decay=0.0,
-        relative_step=False,
-        scale_parameter=False,
-        warmup_init=False,
-    )
-    ```"""
-
-    def __init__(
-        self,
-        params,
-        lr=None,
-        eps=(1e-30, 1e-3),
-        clip_threshold=1.0,
-        decay_rate=-0.8,
-        beta1=None,
-        weight_decay=0.0,
-        scale_parameter=True,
-        relative_step=True,
-        warmup_init=False,
-    ):
-        require_version("torch>=1.5.0")  # add_ with alpha
-        if lr is not None and relative_step:
-            raise ValueError("Cannot combine manual `lr` and `relative_step=True` options")
-        if warmup_init and not relative_step:
-            raise ValueError("`warmup_init=True` requires `relative_step=True`")
-
-        defaults = {
-            "lr": lr,
-            "eps": eps,
-            "clip_threshold": clip_threshold,
-            "decay_rate": decay_rate,
-            "beta1": beta1,
-            "weight_decay": weight_decay,
-            "scale_parameter": scale_parameter,
-            "relative_step": relative_step,
-            "warmup_init": warmup_init,
-        }
-        super().__init__(params, defaults)
-
-    @staticmethod
-    def _get_lr(param_group, param_state):
-        rel_step_sz = param_group["lr"]
-        if param_group["relative_step"]:
-            min_step = 1e-6 * param_state["step"] if param_group["warmup_init"] else 1e-2
-            rel_step_sz = min(min_step, 1.0 / math.sqrt(param_state["step"]))
-        param_scale = 1.0
-        if param_group["scale_parameter"]:
-            param_scale = max(param_group["eps"][1], param_state["RMS"])
-        return param_scale * rel_step_sz
-
-    @staticmethod
-    def _get_options(param_group, param_shape):
-        factored = len(param_shape) >= 2
-        use_first_moment = param_group["beta1"] is not None
-        return factored, use_first_moment
-
-    @staticmethod
-    def _rms(tensor):
-        return tensor.norm(2) / (tensor.numel() ** 0.5)
-
-    @staticmethod
-    def _approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col):
-        # copy from fairseq's adafactor implementation:
-        # https://github.com/huggingface/transformers/blob/8395f14de6068012787d83989c3627c3df6a252b/src/transformers/optimization.py#L505
-        r_factor = (exp_avg_sq_row / exp_avg_sq_row.mean(dim=-1, keepdim=True)).rsqrt_().unsqueeze(-1)
-        c_factor = exp_avg_sq_col.unsqueeze(-2).rsqrt()
-        return torch.mul(r_factor, c_factor)
-
-    def step(self, closure=None):
-        """
-        Performs a single optimization step
-
-        Arguments:
-            closure (callable, optional): A closure that reevaluates the model
-                and returns the loss.
-        """
-        loss = None
-        if closure is not None:
-            loss = closure()
-
-        for group in self.param_groups:
-            for p in group["params"]:
-                if p.grad is None:
-                    continue
-                grad = p.grad.data
-                if grad.dtype in {torch.float16, torch.bfloat16}:
-                    grad = grad.float()
-                if grad.is_sparse:
-                    raise RuntimeError("Adafactor does not support sparse gradients.")
-
-                state = self.state[p]
-                grad_shape = grad.shape
-
-                factored, use_first_moment = self._get_options(group, grad_shape)
-                # State Initialization
-                if len(state) == 0:
-                    state["step"] = 0
-
-                    if use_first_moment:
-                        # Exponential moving average of gradient values
-                        state["exp_avg"] = torch.zeros_like(grad)
-                    if factored:
-                        state["exp_avg_sq_row"] = torch.zeros(grad_shape[:-1]).to(grad)
-                        state["exp_avg_sq_col"] = torch.zeros(grad_shape[:-2] + grad_shape[-1:]).to(grad)
-                    else:
-                        state["exp_avg_sq"] = torch.zeros_like(grad)
-
-                    state["RMS"] = 0
-                else:
-                    if use_first_moment:
-                        state["exp_avg"] = state["exp_avg"].to(grad)
-                    if factored:
-                        state["exp_avg_sq_row"] = state["exp_avg_sq_row"].to(grad)
-                        state["exp_avg_sq_col"] = state["exp_avg_sq_col"].to(grad)
-                    else:
-                        state["exp_avg_sq"] = state["exp_avg_sq"].to(grad)
-
-                p_data_fp32 = p.data
-                if p.data.dtype in {torch.float16, torch.bfloat16}:
-                    p_data_fp32 = p_data_fp32.float()
-
-                state["step"] += 1
-                state["RMS"] = self._rms(p_data_fp32)
-                lr = self._get_lr(group, state)
-
-                beta2t = 1.0 - math.pow(state["step"], group["decay_rate"])
-                update = (grad**2) + group["eps"][0]
-                if factored:
-                    exp_avg_sq_row = state["exp_avg_sq_row"]
-                    exp_avg_sq_col = state["exp_avg_sq_col"]
-
-                    exp_avg_sq_row.mul_(beta2t).add_(update.mean(dim=-1), alpha=(1.0 - beta2t))
-                    exp_avg_sq_col.mul_(beta2t).add_(update.mean(dim=-2), alpha=(1.0 - beta2t))
-
-                    # Approximation of exponential moving average of square of gradient
-                    update = self._approx_sq_grad(exp_avg_sq_row, exp_avg_sq_col)
-                    update.mul_(grad)
-                else:
-                    exp_avg_sq = state["exp_avg_sq"]
-
-                    exp_avg_sq.mul_(beta2t).add_(update, alpha=(1.0 - beta2t))
-                    update = exp_avg_sq.rsqrt().mul_(grad)
-
-                update.div_((self._rms(update) / group["clip_threshold"]).clamp_(min=1.0))
-                update.mul_(lr)
-
-                if use_first_moment:
-                    exp_avg = state["exp_avg"]
-                    exp_avg.mul_(group["beta1"]).add_(update, alpha=(1 - group["beta1"]))
-                    update = exp_avg
-
-                if group["weight_decay"] != 0:
-                    p_data_fp32.add_(p_data_fp32, alpha=(-group["weight_decay"] * lr))
-
-                p_data_fp32.add_(-update)
-
-                if p.data.dtype in {torch.float16, torch.bfloat16}:
-                    p.data.copy_(p_data_fp32)
-
-        return loss
-
-
-class AdafactorSchedule(LambdaLR):
-    """
-    Since [`~optimization.Adafactor`] performs its own scheduling, if the training loop relies on a scheduler (e.g.,
-    for logging), this class creates a proxy object that retrieves the current lr values from the optimizer.
-
-    It returns `initial_lr` during startup and the actual `lr` during stepping.
-    """
-
-    def __init__(self, optimizer, initial_lr=0.0):
-        def lr_lambda(_):
-            return initial_lr
-
-        for group in optimizer.param_groups:
-            group["initial_lr"] = initial_lr
-        super().__init__(optimizer, lr_lambda)
-        for group in optimizer.param_groups:
-            del group["initial_lr"]
-
-    def get_lr(self):
-        opt = self.optimizer
-        lrs = [
-            opt._get_lr(group, opt.state[group["params"][0]])
-            for group in opt.param_groups
-            if group["params"][0].grad is not None
-        ]
-        if len(lrs) == 0:
-            lrs = self.base_lrs  # if called before stepping
-        return lrs
-
-
-def get_adafactor_schedule(optimizer, initial_lr=0.0):
-    """
-    Get a proxy schedule for [`~optimization.Adafactor`]
-
-    Args:
-        optimizer ([`~torch.optim.Optimizer`]):
-            The optimizer for which to schedule the learning rate.
-        initial_lr (`float`, *optional*, defaults to 0.0):
-            Initial lr
-
-    Return:
-        [`~optimization.Adafactor`] proxy schedule object.
-
-
-    """
-    return AdafactorSchedule(optimizer, initial_lr)

spaces/ClueAI/CLUE_AIGC/README.md

@@ -1,13 +0,0 @@
----
-title: Demo
-emoji: 👁
-colorFrom: pink
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.9.1
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

spaces/CofAI/chat.b4/README.md

@@ -1,16 +0,0 @@
----
-title: Chat.CofAI BETA-4
-emoji: 💬♻️🗨️
-colorFrom: blue
-colorTo: yellow
-sdk: docker
-sdk_version: 1.24.0
-app_file: run.py
-pinned: true
-app_port: 1338
-duplicated_from: TNR-5/freegpt-webui
----
-
-💬 This is Free UI ChatGPT-4!
-
-🍀 Try free!

spaces/CoreyMorris/MMLU-by-task-Leaderboard/result_data_processor.py

@@ -1,226 +0,0 @@
-import pandas as pd
-import os
-import fnmatch
-import json
-import re
-import numpy as np
-import logging
-
-logging.basicConfig(filename='error_log.log', level=logging.ERROR)
-
-class ResultDataProcessor:
-    
-
-    def __init__(self, directory='results', pattern='results*.json'):
-        
-        self.directory = directory
-        self.pattern = pattern
-        self.data = self.process_data()
-        self.ranked_data = self.rank_data()
-
-    def _find_files(self, directory='results', pattern='results*.json'):
-        matching_files = {}
-        for root, dirs, files in os.walk(directory):
-            for basename in files:
-                if fnmatch.fnmatch(basename, pattern):
-                    filename = os.path.join(root, basename)
-                    matching_files[root] = filename
-        # TODO decide on removing this since I am catching the error when processing the file
-        matching_files = {key: value for key, value in matching_files.items() if 'gpt-j-6b' not in key}
-        matching_files = list(matching_files.values())
-        return matching_files
-
-    def _read_and_transform_data(self, filename):
-        with open(filename) as f:
-            data = json.load(f)
-        df = pd.DataFrame(data['results']).T
-        return df
-    
-    def _cleanup_dataframe(self, df, model_name):
-        df = df.rename(columns={'acc': model_name})
-        df.index = (df.index.str.replace('hendrycksTest-', 'MMLU_', regex=True)
-                          .str.replace('harness\|', '', regex=True)
-                          .str.replace('\|5', '', regex=True))
-        return df[[model_name]]
-    
-    def _extract_mc1(self, df, model_name):
-        df = df.rename(columns={'mc1': model_name})
-        # rename row harness|truthfulqa:mc|0 to truthfulqa:mc1
-        df.index = (df.index.str.replace('mc\|0', 'mc1', regex=True))
-        # just return the harness|truthfulqa:mc1 row
-        df = df.loc[['harness|truthfulqa:mc1']]
-        return df[[model_name]]
-    
-    def _extract_mc2(self, df, model_name):
-        # rename row harness|truthfulqa:mc|0 to truthfulqa:mc2
-        df = df.rename(columns={'mc2': model_name})
-        df.index = (df.index.str.replace('mc\|0', 'mc2', regex=True))
-        df = df.loc[['harness|truthfulqa:mc2']]
-        return df[[model_name]]
-    
-    # remove extreme outliers from column harness|truthfulqa:mc1
-    def _remove_mc1_outliers(self, df):
-        mc1 = df['harness|truthfulqa:mc1']
-        # Identify the outliers
-        # outliers_condition = mc1 > mc1.quantile(.95)
-        outliers_condition = mc1 == 1.0
-        # Replace the outliers with NaN
-        df.loc[outliers_condition, 'harness|truthfulqa:mc1'] = np.nan
-        return df
-
-
-    
-    @staticmethod
-    def _extract_parameters(model_name):
-        """
-        Function to extract parameters from model name.
-        It handles names with 'b/B' for billions and 'm/M' for millions. 
-        """
-        # pattern to match a number followed by 'b' (representing billions) or 'm' (representing millions)
-        pattern = re.compile(r'(\d+\.?\d*)([bBmM])')
-        
-        match = pattern.search(model_name)
-        
-        if match:
-            num, magnitude = match.groups()
-            num = float(num)
-            
-            # convert millions to billions
-            if magnitude.lower() == 'm':
-                num /= 1000
-            
-            return num
-        
-        # return NaN if no match
-        return np.nan
-
-    
-    def process_data(self):
-        full_model_name_count = 0
-        full_model_names = []
-        dataframes = []
-        organization_names = []
-        for filename in self._find_files(self.directory, self.pattern):
-            # try:
-            raw_data = self._read_and_transform_data(filename)
-            split_path = filename.split('/')
-            model_name = split_path[2]
-            organization_name = split_path[1]
-            full_model_name = f'{organization_name}/{model_name}'
-            full_model_name_count += 1
-            # print count every 100 models
-            if full_model_name_count % 100 == 0:
-                print(full_model_name_count)
-
-            cleaned_data = self._cleanup_dataframe(raw_data, model_name)
-            # mc1 = self._extract_mc1(raw_data, full_model_name)
-            # mc2 = self._extract_mc2(raw_data, full_model_name)
-            # cleaned_data = pd.concat([cleaned_data, mc1])
-            # cleaned_data = pd.concat([cleaned_data, mc2])
-            organization_names.append(organization_name)
-            full_model_names.append(full_model_name)
-            dataframes.append(cleaned_data)
-            # except Exception as e:
-            #     # logging.error(f'Error processing {filename}')
-            #     # logging.error(f'The error is: {e}')
-            #     print(f'Error processing {filename}')
-            #     print(f'The error is: {e}')
-            #     continue
-
-
-        data = pd.concat(dataframes, axis=1).transpose()
-
-        # Add organization column
-        # data['organization'] = organization_names
-        print("full_model_names")
-        print(len(full_model_names))
-        print("organization_names")
-        print(len(organization_name))
-        data['full_model_name'] = full_model_names
-
-        # Add Model Name and rearrange columns
-        data['Model Name'] = data.index
-        cols = data.columns.tolist()
-        cols = cols[-1:] + cols[:-1]
-        data = data[cols]
-
-        # Remove the 'Model Name' column
-        data = data.drop(columns=['Model Name'])
-        
-        # Add average column
-        data['MMLU_average'] = data.filter(regex='MMLU').mean(axis=1)
-
-        # Reorder columns to move 'MMLU_average' to the third position
-        cols = data.columns.tolist()
-        cols = cols[:2] + cols[-1:] + cols[2:-1]
-        data = data[cols]
-
-
-
-
-
-
-        # Add parameter count column using extract_parameters function
-        data['Parameters'] = data.index.to_series().apply(self._extract_parameters)
-
-        # move the parameters column to the front of the dataframe
-        cols = data.columns.tolist()
-        cols = cols[-1:] + cols[:-1]
-        print(cols)
-        data = data[cols]
-
-
-        new_columns = ['full_model_name'] + [col for col in data.columns if col != 'full_model_name']
-        data = data.reindex(columns=new_columns)
-
-        # # Reorder columns to move 'organization' to the second position
-        # cols = data.columns.tolist()
-        # cols = cols[-1:] + cols[:-1]
-        # data = data[cols]
-
-        # remove extreme outliers from column harness|truthfulqa:mc1
-        # data = self._remove_mc1_outliers(data)
-
-        data = self.manual_removal_of_models(data)
-
-
-        # drop rows if MMLU_abstract_algebra is NaN
-        data = data.dropna(subset=['MMLU_abstract_algebra'])
-
-        # add a URL column that takes https://huggingface.co/ + full_model_name
-        data['URL'] = 'https://huggingface.co/' + data['full_model_name']
-
-        new_columns = ['URL'] + [col for col in data.columns if col != 'URL']
-        data = data.reindex(columns=new_columns)
-
-        # drop columns drop|3 gsm8k and winogrande
-        data = data.drop(columns=['drop|3', 'gsm8k', 'winogrande'])
-        # # Drop specific columns
-        data = data.drop(columns=['all', 'truthfulqa:mc|0'])
-
-        # save to csv with the current date as part of the filename
-        data.to_csv(f'processed_data_{pd.Timestamp.now().strftime("%Y-%m-%d")}.csv')
-        
-        return data
-    
-    def manual_removal_of_models(self, df):
-    # remove models verified to be trained on evaluation data
-        # load the list of models
-        with open('contaminated_models.txt') as f:
-            contaminated_models = f.read().splitlines()
-        # remove the models from the dataframe
-        df = df[~df.index.isin(contaminated_models)]
-        return df
-
-    
-    def rank_data(self):
-        # add rank for each column to the dataframe
-        # copy the data dataframe to avoid modifying the original dataframe
-        rank_data = self.data.copy()
-        for col in list(rank_data.columns):
-            rank_data[col + "_rank"] = rank_data[col].rank(ascending=False, method='min')
-
-        return rank_data
-
-    def get_data(self, selected_models):
-        return self.data[self.data.index.isin(selected_models)]

spaces/CorvaeOboro/gen_ability_icon/torch_utils/__init__.py

@@ -1,9 +0,0 @@
-# Copyright (c) 2021, NVIDIA CORPORATION.  All rights reserved.
-#
-# NVIDIA CORPORATION and its licensors retain all intellectual property
-# and proprietary rights in and to this software, related documentation
-# and any modifications thereto.  Any use, reproduction, disclosure or
-# distribution of this software and related documentation without an express
-# license agreement from NVIDIA CORPORATION is strictly prohibited.
-
-# empty

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fontTools/pens/transformPen.py

@@ -1,111 +0,0 @@
-from fontTools.pens.filterPen import FilterPen, FilterPointPen
-
-
-__all__ = ["TransformPen", "TransformPointPen"]
-
-
-class TransformPen(FilterPen):
-
-    """Pen that transforms all coordinates using a Affine transformation,
-    and passes them to another pen.
-    """
-
-    def __init__(self, outPen, transformation):
-        """The 'outPen' argument is another pen object. It will receive the
-        transformed coordinates. The 'transformation' argument can either
-        be a six-tuple, or a fontTools.misc.transform.Transform object.
-        """
-        super(TransformPen, self).__init__(outPen)
-        if not hasattr(transformation, "transformPoint"):
-            from fontTools.misc.transform import Transform
-
-            transformation = Transform(*transformation)
-        self._transformation = transformation
-        self._transformPoint = transformation.transformPoint
-        self._stack = []
-
-    def moveTo(self, pt):
-        self._outPen.moveTo(self._transformPoint(pt))
-
-    def lineTo(self, pt):
-        self._outPen.lineTo(self._transformPoint(pt))
-
-    def curveTo(self, *points):
-        self._outPen.curveTo(*self._transformPoints(points))
-
-    def qCurveTo(self, *points):
-        if points[-1] is None:
-            points = self._transformPoints(points[:-1]) + [None]
-        else:
-            points = self._transformPoints(points)
-        self._outPen.qCurveTo(*points)
-
-    def _transformPoints(self, points):
-        transformPoint = self._transformPoint
-        return [transformPoint(pt) for pt in points]
-
-    def closePath(self):
-        self._outPen.closePath()
-
-    def endPath(self):
-        self._outPen.endPath()
-
-    def addComponent(self, glyphName, transformation):
-        transformation = self._transformation.transform(transformation)
-        self._outPen.addComponent(glyphName, transformation)
-
-
-class TransformPointPen(FilterPointPen):
-    """PointPen that transforms all coordinates using a Affine transformation,
-    and passes them to another PointPen.
-
-    >>> from fontTools.pens.recordingPen import RecordingPointPen
-    >>> rec = RecordingPointPen()
-    >>> pen = TransformPointPen(rec, (2, 0, 0, 2, -10, 5))
-    >>> v = iter(rec.value)
-    >>> pen.beginPath(identifier="contour-0")
-    >>> next(v)
-    ('beginPath', (), {'identifier': 'contour-0'})
-    >>> pen.addPoint((100, 100), "line")
-    >>> next(v)
-    ('addPoint', ((190, 205), 'line', False, None), {})
-    >>> pen.endPath()
-    >>> next(v)
-    ('endPath', (), {})
-    >>> pen.addComponent("a", (1, 0, 0, 1, -10, 5), identifier="component-0")
-    >>> next(v)
-    ('addComponent', ('a', <Transform [2 0 0 2 -30 15]>), {'identifier': 'component-0'})
-    """
-
-    def __init__(self, outPointPen, transformation):
-        """The 'outPointPen' argument is another point pen object.
-        It will receive the transformed coordinates.
-        The 'transformation' argument can either be a six-tuple, or a
-        fontTools.misc.transform.Transform object.
-        """
-        super().__init__(outPointPen)
-        if not hasattr(transformation, "transformPoint"):
-            from fontTools.misc.transform import Transform
-
-            transformation = Transform(*transformation)
-        self._transformation = transformation
-        self._transformPoint = transformation.transformPoint
-
-    def addPoint(self, pt, segmentType=None, smooth=False, name=None, **kwargs):
-        self._outPen.addPoint(
-            self._transformPoint(pt), segmentType, smooth, name, **kwargs
-        )
-
-    def addComponent(self, baseGlyphName, transformation, **kwargs):
-        transformation = self._transformation.transform(transformation)
-        self._outPen.addComponent(baseGlyphName, transformation, **kwargs)
-
-
-if __name__ == "__main__":
-    from fontTools.pens.basePen import _TestPen
-
-    pen = TransformPen(_TestPen(None), (2, 0, 0.5, 2, -10, 0))
-    pen.moveTo((0, 0))
-    pen.lineTo((0, 100))
-    pen.curveTo((50, 75), (60, 50), (50, 25), (0, 0))
-    pen.closePath()

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio/templates/cdn/assets/index-4ffdbeab.css

@@ -1 +0,0 @@
-.model3D.svelte-14ct53h{display:flex;position:relative;width:var(--size-full);height:var(--size-full)}canvas.svelte-14ct53h{width:var(--size-full);height:var(--size-full);object-fit:contain}.download.svelte-14ct53h{position:absolute;top:6px;right:6px}.input-model.svelte-wn75i6{display:flex;position:relative;justify-content:center;align-items:center;width:var(--size-full);height:var(--size-64)}canvas.svelte-wn75i6{width:var(--size-full);height:var(--size-full);object-fit:contain}

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

@@ -1,5 +0,0 @@
-import{S as he,e as ge,s as me,O as K,N as T,K as b,U as B,p as O,Q as I,n as te,A as S,a1 as be,F as ce,h as Z,P as ee,R as pe,m as rl,aq as il,j as ne,k as j,M as q,o as G,t as ae,z as M,u as X,v as U,y as x,x as Q,B as Fe,J as $,a7 as P,G as W,H as _e,I as de,am as fl,E as ul,ae as ol,q as cl,r as _l}from"./index-1d65707a.js";import{a as He,B as dl}from"./Button-f155035a.js";import{U as hl}from"./Upload-9bb55fba.js";import"./ModifyUpload.svelte_svelte_type_style_lang-d2acacf0.js";import{d as gl}from"./dsv-576afacd.js";var Ne=Object.prototype.hasOwnProperty;function se(a,e){var l,t;if(a===e)return!0;if(a&&e&&(l=a.constructor)===e.constructor){if(l===Date)return a.getTime()===e.getTime();if(l===RegExp)return a.toString()===e.toString();if(l===Array){if((t=a.length)===e.length)for(;t--&&se(a[t],e[t]););return t===-1}if(!l||typeof a=="object"){t=0;for(l in a)if(Ne.call(a,l)&&++t&&!Ne.call(e,l)||!(l in e)||!se(a[l],e[l]))return!1;return Object.keys(e).length===t}}return a!==a&&e!==e}function Ee(a){let e,l,t;return{c(){e=T("input"),b(e,"tabindex","-1"),e.value=a[0],b(e,"class","svelte-q8uklq"),B(e,"header",a[3])},m(n,r){O(n,e,r),a[7](e),l||(t=[I(e,"keydown",a[6]),I(e,"blur",a[8])],l=!0)},p(n,r){r&1&&e.value!==n[0]&&(e.value=n[0]),r&8&&B(e,"header",n[3])},d(n){n&&S(e),a[7](null),l=!1,be(t)}}}function ml(a){let e;return{c(){e=ee(a[0])},m(l,t){O(l,e,t)},p(l,t){t&1&&pe(e,l[0])},d(l){l&&S(e)}}}function bl(a){let e,l;return{c(){e=new il(!1),l=rl(),e.a=l},m(t,n){e.m(a[0],t,n),O(t,l,n)},p(t,n){n&1&&e.p(t[0])},d(t){t&&(S(l),e.d())}}}function pl(a){let e,l,t,n,r=a[2]&&Ee(a);function c(f,o){return f[4]==="markdown"||f[4]==="html"?bl:ml}let i=c(a),_=i(a);return{c(){r&&r.c(),e=K(),l=T("span"),_.c(),b(l,"tabindex","-1"),b(l,"role","button"),b(l,"class","svelte-q8uklq"),B(l,"edit",a[2])},m(f,o){r&&r.m(f,o),O(f,e,o),O(f,l,o),_.m(l,null),t||(n=I(l,"dblclick",a[5]),t=!0)},p(f,[o]){f[2]?r?r.p(f,o):(r=Ee(f),r.c(),r.m(e.parentNode,e)):r&&(r.d(1),r=null),i===(i=c(f))&&_?_.p(f,o):(_.d(1),_=i(f),_&&(_.c(),_.m(l,null))),o&4&&B(l,"edit",f[2])},i:te,o:te,d(f){f&&(S(e),S(l)),r&&r.d(f),_.d(),t=!1,n()}}}function wl(a,e,l){let{edit:t}=e,{value:n=""}=e,{el:r}=e,{header:c=!1}=e,{datatype:i="str"}=e;function _(p){ce.call(this,a,p)}function f(p){ce.call(this,a,p)}function o(p){Z[p?"unshift":"push"](()=>{r=p,l(1,r)})}const m=({currentTarget:p})=>{l(0,n=p.value),p.setAttribute("tabindex","-1")};return a.$$set=p=>{"edit"in p&&l(2,t=p.edit),"value"in p&&l(0,n=p.value),"el"in p&&l(1,r=p.el),"header"in p&&l(3,c=p.header),"datatype"in p&&l(4,i=p.datatype)},[n,r,t,c,i,_,f,o,m]}class Je extends he{constructor(e){super(),ge(this,e,wl,pl,me,{edit:2,value:0,el:1,header:3,datatype:4})}}function Le(a,e,l){const t=a.slice();return t[53]=e[l],t[55]=l,t}function qe(a,e,l){const t=a.slice();return t[56]=e[l].value,t[57]=e[l].id,t[58]=e,t[59]=l,t}function Be(a,e,l){const t=a.slice();return t[56]=e[l].value,t[57]=e[l].id,t[60]=e,t[55]=l,t}function Me(a){let e,l;return{c(){e=T("p"),l=ee(a[1]),b(e,"class","svelte-1tclfmr")},m(t,n){O(t,e,n),q(e,l)},p(t,n){n[0]&2&&pe(l,t[1])},d(t){t&&S(e)}}}function Oe(a){let e,l;return{c(){e=T("caption"),l=ee(a[1]),b(e,"class","sr-only")},m(t,n){O(t,e,n),q(e,l)},p(t,n){n[0]&2&&pe(l,t[1])},d(t){t&&S(e)}}}function Se(a,e){let l,t,n,r,c,i,_,f,o,m,p,h=e[57],A,d,C;function y(w){e[30](w,e[57])}function g(){return e[31](e[57])}let N={value:e[56],edit:e[13]===e[57],header:!0};e[10][e[57]].input!==void 0&&(N.el=e[10][e[57]].input),n=new Je({props:N}),Z.push(()=>ne(n,"el",y)),n.$on("keydown",e[21]),n.$on("dblclick",g);function L(){return e[32](e[55])}const v=()=>e[33](l,h),R=()=>e[33](null,h);return{key:a,first:null,c(){l=T("th"),t=T("div"),j(n.$$.fragment),c=K(),i=T("div"),_=$("svg"),f=$("path"),m=K(),b(f,"d","M4.49999 0L8.3971 6.75H0.602875L4.49999 0Z"),b(_,"width","1em"),b(_,"height","1em"),b(_,"viewBox","0 0 9 7"),b(_,"fill","none"),b(_,"xmlns","http://www.w3.org/2000/svg"),b(_,"class","svelte-1tclfmr"),b(i,"class",o="sort-button "+e[11]+" svelte-1tclfmr"),B(i,"sorted",e[12]===e[55]),B(i,"des",e[12]===e[55]&&e[11]==="des"),b(t,"class","cell-wrap svelte-1tclfmr"),b(l,"aria-sort",p=e[15](e[56],e[12],e[11])),b(l,"class","svelte-1tclfmr"),B(l,"editing",e[13]===e[57]),this.first=l},m(w,z){O(w,l,z),q(l,t),G(n,t,null),q(t,c),q(t,i),q(i,_),q(_,f),q(l,m),v(),A=!0,d||(C=I(i,"click",L),d=!0)},p(w,z){e=w;const J={};z[0]&256&&(J.value=e[56]),z[0]&8448&&(J.edit=e[13]===e[57]),!r&&z[0]&1280&&(r=!0,J.el=e[10][e[57]].input,ae(()=>r=!1)),n.$set(J),(!A||z[0]&2048&&o!==(o="sort-button "+e[11]+" svelte-1tclfmr"))&&b(i,"class",o),(!A||z[0]&6400)&&B(i,"sorted",e[12]===e[55]),(!A||z[0]&6400)&&B(i,"des",e[12]===e[55]&&e[11]==="des"),(!A||z[0]&6400&&p!==(p=e[15](e[56],e[12],e[11])))&&b(l,"aria-sort",p),h!==e[57]&&(R(),h=e[57],v()),(!A||z[0]&8448)&&B(l,"editing",e[13]===e[57])},i(w){A||(M(n.$$.fragment,w),A=!0)},o(w){U(n.$$.fragment,w),A=!1},d(w){w&&S(l),Q(n),R(),d=!1,C()}}}function Te(a,e){let l,t,n,r,c,i=e[57],_,f,o;function m(L){e[34](L,e[56],e[58],e[59])}function p(L){e[35](L,e[57])}let h={edit:e[7]===e[57],datatype:Array.isArray(e[0])?e[0][e[59]]:e[0]};e[56]!==void 0&&(h.value=e[56]),e[10][e[57]].input!==void 0&&(h.el=e[10][e[57]].input),n=new Je({props:h}),Z.push(()=>ne(n,"value",m)),Z.push(()=>ne(n,"el",p));const A=()=>e[36](l,i),d=()=>e[36](null,i);function C(){return e[37](e[57])}function y(){return e[38](e[57])}function g(){return e[39](e[57])}function N(...L){return e[40](e[55],e[59],e[57],...L)}return{key:a,first:null,c(){l=T("td"),t=T("div"),j(n.$$.fragment),b(t,"class","cell-wrap svelte-1tclfmr"),B(t,"border-transparent",e[6]!==e[57]),b(l,"tabindex","0"),b(l,"class","svelte-1tclfmr"),this.first=l},m(L,v){O(L,l,v),q(l,t),G(n,t,null),A(),_=!0,f||(o=[I(l,"touchstart",C,{passive:!0}),I(l,"click",y),I(l,"dblclick",g),I(l,"keydown",N)],f=!0)},p(L,v){e=L;const R={};v[0]&640&&(R.edit=e[7]===e[57]),v[0]&513&&(R.datatype=Array.isArray(e[0])?e[0][e[59]]:e[0]),!r&&v[0]&512&&(r=!0,R.value=e[56],ae(()=>r=!1)),!c&&v[0]&1536&&(c=!0,R.el=e[10][e[57]].input,ae(()=>c=!1)),n.$set(R),(!_||v[0]&576)&&B(t,"border-transparent",e[6]!==e[57]),i!==e[57]&&(d(),i=e[57],A())},i(L){_||(M(n.$$.fragment,L),_=!0)},o(L){U(n.$$.fragment,L),_=!1},d(L){L&&S(l),Q(n),d(),f=!1,be(o)}}}function Ce(a,e){let l,t=[],n=new Map,r,c,i=W(e[53]);const _=f=>f[57];for(let f=0;f<i.length;f+=1){let o=qe(e,i,f),m=_(o);n.set(m,t[f]=Te(m,o))}return{key:a,first:null,c(){l=T("tr");for(let f=0;f<t.length;f+=1)t[f].c();r=K(),b(l,"class","svelte-1tclfmr"),this.first=l},m(f,o){O(f,l,o);for(let m=0;m<t.length;m+=1)t[m]&&t[m].m(l,null);q(l,r),c=!0},p(f,o){e=f,o[0]&460481&&(i=W(e[53]),X(),t=_e(t,o,_,1,e,i,n,l,de,Te,r,qe),x())},i(f){if(!c){for(let o=0;o<i.length;o+=1)M(t[o]);c=!0}},o(f){for(let o=0;o<t.length;o+=1)U(t[o]);c=!1},d(f){f&&S(l);for(let o=0;o<t.length;o+=1)t[o].d()}}}function kl(a){let e,l,t,n,r=[],c=new Map,i,_,f=[],o=new Map,m,p=a[1]&&a[1].length!==0&&Oe(a),h=W(a[8]);const A=y=>y[57];for(let y=0;y<h.length;y+=1){let g=Be(a,h,y),N=A(g);c.set(N,r[y]=Se(N,g))}let d=W(a[9]);const C=y=>y[53];for(let y=0;y<d.length;y+=1){let g=Le(a,d,y),N=C(g);o.set(N,f[y]=Ce(N,g))}return{c(){e=T("table"),p&&p.c(),l=K(),t=T("thead"),n=T("tr");for(let y=0;y<r.length;y+=1)r[y].c();i=K(),_=T("tbody");for(let y=0;y<f.length;y+=1)f[y].c();b(n,"class","svelte-1tclfmr"),b(t,"class","svelte-1tclfmr"),b(_,"class","svelte-1tclfmr"),b(e,"class","svelte-1tclfmr"),B(e,"dragging",a[14])},m(y,g){O(y,e,g),p&&p.m(e,null),q(e,l),q(e,t),q(t,n);for(let N=0;N<r.length;N+=1)r[N]&&r[N].m(n,null);q(e,i),q(e,_);for(let N=0;N<f.length;N+=1)f[N]&&f[N].m(_,null);m=!0},p(y,g){y[1]&&y[1].length!==0?p?p.p(y,g):(p=Oe(y),p.c(),p.m(e,l)):p&&(p.d(1),p=null),g[0]&3718400&&(h=W(y[8]),X(),r=_e(r,g,A,1,y,h,c,n,de,Se,null,Be),x()),g[0]&460481&&(d=W(y[9]),X(),f=_e(f,g,C,1,y,d,o,_,de,Ce,null,Le),x()),(!m||g[0]&16384)&&B(e,"dragging",y[14])},i(y){if(!m){for(let g=0;g<h.length;g+=1)M(r[g]);for(let g=0;g<d.length;g+=1)M(f[g]);m=!0}},o(y){for(let g=0;g<r.length;g+=1)U(r[g]);for(let g=0;g<f.length;g+=1)U(f[g]);m=!1},d(y){y&&S(e),p&&p.d();for(let g=0;g<r.length;g+=1)r[g].d();for(let g=0;g<f.length;g+=1)f[g].d()}}}function Re(a){let e,l,t,n=a[3][1]==="dynamic"&&Ue(a),r=a[2][1]==="dynamic"&&ze(a);return{c(){e=T("div"),n&&n.c(),l=K(),r&&r.c(),b(e,"class","controls-wrap svelte-1tclfmr")},m(c,i){O(c,e,i),n&&n.m(e,null),q(e,l),r&&r.m(e,null),t=!0},p(c,i){c[3][1]==="dynamic"?n?(n.p(c,i),i[0]&8&&M(n,1)):(n=Ue(c),n.c(),M(n,1),n.m(e,l)):n&&(X(),U(n,1,1,()=>{n=null}),x()),c[2][1]==="dynamic"?r?(r.p(c,i),i[0]&4&&M(r,1)):(r=ze(c),r.c(),M(r,1),r.m(e,null)):r&&(X(),U(r,1,1,()=>{r=null}),x())},i(c){t||(M(n),M(r),t=!0)},o(c){U(n),U(r),t=!1},d(c){c&&S(e),n&&n.d(),r&&r.d()}}}function Ue(a){let e,l,t;return l=new He({props:{variant:"secondary",size:"sm",$$slots:{default:[yl]},$$scope:{ctx:a}}}),l.$on("click",a[43]),{c(){e=T("span"),j(l.$$.fragment),b(e,"class","button-wrap svelte-1tclfmr")},m(n,r){O(n,e,r),G(l,e,null),t=!0},p(n,r){const c={};r[1]&1073741824&&(c.$$scope={dirty:r,ctx:n}),l.$set(c)},i(n){t||(M(l.$$.fragment,n),t=!0)},o(n){U(l.$$.fragment,n),t=!1},d(n){n&&S(e),Q(l)}}}function yl(a){let e,l,t;return{c(){e=$("svg"),l=$("path"),t=ee(`
-						New row`),b(l,"fill","currentColor"),b(l,"d","M24.59 16.59L17 24.17V4h-2v20.17l-7.59-7.58L6 18l10 10l10-10l-1.41-1.41z"),b(e,"xmlns","http://www.w3.org/2000/svg"),b(e,"xmlns:xlink","http://www.w3.org/1999/xlink"),b(e,"aria-hidden","true"),b(e,"role","img"),b(e,"width","1em"),b(e,"height","1em"),b(e,"preserveAspectRatio","xMidYMid meet"),b(e,"viewBox","0 0 32 32"),b(e,"class","svelte-1tclfmr")},m(n,r){O(n,e,r),q(e,l),O(n,t,r)},p:te,d(n){n&&(S(e),S(t))}}}function ze(a){let e,l,t;return l=new He({props:{variant:"secondary",size:"sm",$$slots:{default:[vl]},$$scope:{ctx:a}}}),l.$on("click",a[23]),{c(){e=T("span"),j(l.$$.fragment),b(e,"class","button-wrap svelte-1tclfmr")},m(n,r){O(n,e,r),G(l,e,null),t=!0},p(n,r){const c={};r[1]&1073741824&&(c.$$scope={dirty:r,ctx:n}),l.$set(c)},i(n){t||(M(l.$$.fragment,n),t=!0)},o(n){U(l.$$.fragment,n),t=!1},d(n){n&&S(e),Q(l)}}}function vl(a){let e,l,t;return{c(){e=$("svg"),l=$("path"),t=ee(`
-						New column`),b(l,"fill","currentColor"),b(l,"d","m18 6l-1.43 1.393L24.15 15H4v2h20.15l-7.58 7.573L18 26l10-10L18 6z"),b(e,"xmlns","http://www.w3.org/2000/svg"),b(e,"xmlns:xlink","http://www.w3.org/1999/xlink"),b(e,"aria-hidden","true"),b(e,"role","img"),b(e,"width","1em"),b(e,"height","1em"),b(e,"preserveAspectRatio","xMidYMid meet"),b(e,"viewBox","0 0 32 32"),b(e,"class","svelte-1tclfmr")},m(n,r){O(n,e,r),q(e,l),O(n,t,r)},p:te,d(n){n&&(S(e),S(t))}}}function Al(a){let e,l,t,n,r,c,i,_,f,o=a[1]&&a[1].length!==0&&Me(a);function m(A){a[41](A)}let p={flex:!1,center:!1,boundedheight:!1,disable_click:!0,$$slots:{default:[kl]},$$scope:{ctx:a}};a[14]!==void 0&&(p.dragging=a[14]),n=new hl({props:p}),Z.push(()=>ne(n,"dragging",m)),n.$on("load",a[42]);let h=a[4]&&Re(a);return{c(){e=T("div"),o&&o.c(),l=K(),t=T("div"),j(n.$$.fragment),c=K(),h&&h.c(),b(t,"class","table-wrap scroll-hide svelte-1tclfmr"),B(t,"dragging",a[14]),B(t,"no-wrap",!a[5]),b(e,"class","svelte-1tclfmr"),B(e,"label",a[1]&&a[1].length!==0)},m(A,d){O(A,e,d),o&&o.m(e,null),q(e,l),q(e,t),G(n,t,null),q(e,c),h&&h.m(e,null),i=!0,_||(f=[I(window,"click",a[24]),I(window,"touchstart",a[24])],_=!0)},p(A,d){A[1]&&A[1].length!==0?o?o.p(A,d):(o=Me(A),o.c(),o.m(e,l)):o&&(o.d(1),o=null);const C={};d[0]&32707|d[1]&1073741824&&(C.$$scope={dirty:d,ctx:A}),!r&&d[0]&16384&&(r=!0,C.dragging=A[14],ae(()=>r=!1)),n.$set(C),(!i||d[0]&16384)&&B(t,"dragging",A[14]),(!i||d[0]&32)&&B(t,"no-wrap",!A[5]),A[4]?h?(h.p(A,d),d[0]&16&&M(h,1)):(h=Re(A),h.c(),M(h,1),h.m(e,null)):h&&(X(),U(h,1,1,()=>{h=null}),x()),(!i||d[0]&2)&&B(e,"label",A[1]&&A[1].length!==0)},i(A){i||(M(n.$$.fragment,A),M(h),i=!0)},o(A){U(n.$$.fragment,A),U(h),i=!1},d(A){A&&S(e),o&&o.d(),Q(n),h&&h.d(),_=!1,be(f)}}}function Dl(a,e){return e.filter(l);function l(t){var n=-1;return a.split(`
-`).every(r);function r(c){if(!c)return!0;var i=c.split(t).length;return n<0&&(n=i),n===i&&i>1}}}function Nl(a){const e=atob(a.split(",")[1]),l=a.split(",")[0].split(":")[1].split(";")[0],t=new ArrayBuffer(e.length),n=new Uint8Array(t);for(let r=0;r<e.length;r++)n[r]=e.charCodeAt(r);return new Blob([t],{type:l})}function El(a,e,l){let{datatype:t}=e,{label:n=null}=e,{headers:r=[]}=e,{values:c=[[]]}=e,{col_count:i}=e,{row_count:_}=e,{editable:f=!0}=e,{wrap:o=!1}=e,m=!1;const p=Fe();let h=!1;const A=(s,u)=>v[s][u].value;let d={};function C(s){let u=s||[];if(i[1]==="fixed"&&u.length<i[0]){const k=Array(i[0]-u.length).fill("").map((D,E)=>`${E+u.length}`);u=u.concat(k)}return!u||u.length===0?Array(i[0]).fill(0).map((k,D)=>{const E=`h-${D}`;return l(10,d[E]={cell:null,input:null},d),{id:E,value:JSON.stringify(D+1)}}):u.map((k,D)=>{const E=`h-${D}`;return l(10,d[E]={cell:null,input:null},d),{id:E,value:k??""}})}function y(s){const u=s.length>0?s.length:_[0];return Array(_[1]==="fixed"||u<_[0]?_[0]:u).fill(0).map((k,D)=>Array(i[1]==="fixed"?i[0]:s[0].length).fill(0).map((E,H)=>{const Y=`${D}-${H}`;return l(10,d[Y]={input:null,cell:null},d),{value:s?.[D]?.[H]??"",id:Y}}))}let g=C(r),N;async function L(){typeof h=="string"?(await P(),d[h]?.input?.focus()):typeof m=="string"&&(await P(),d[m]?.input?.focus())}let v=[[]],R;function w(s,u,k){if(!u)return"none";if(r[u]===s){if(k==="asc")return"ascending";if(k==="des")return"descending"}}function z(s){return v.reduce((u,k,D)=>{const E=k.reduce((H,Y,ue)=>s===Y.id?ue:H,-1);return E===-1?u:[D,E]},[-1,-1])}async function J(s,u){if(!f||h===s)return;if(u){const[D,E]=z(s);l(9,v[D][E].value="",v)}l(7,h=s),await P();const{input:k}=d[s];k?.focus()}async function we(s,u,k,D){let E;switch(s.key){case"ArrowRight":if(h)break;s.preventDefault(),E=v[u][k+1],l(6,m=E?E.id:m);break;case"ArrowLeft":if(h)break;s.preventDefault(),E=v[u][k-1],l(6,m=E?E.id:m);break;case"ArrowDown":if(h)break;s.preventDefault(),E=v[u+1],l(6,m=E?E[k].id:m);break;case"ArrowUp":if(h)break;s.preventDefault(),E=v[u-1],l(6,m=E?E[k].id:m);break;case"Escape":if(!f)break;s.preventDefault(),l(6,m=h),l(7,h=!1);break;case"Enter":if(!f)break;if(s.preventDefault(),s.shiftKey){ie(u),await P();const[sl]=z(D);l(6,m=v[sl+1][k].id)}else h===D?l(7,h=!1):J(D);break;case"Backspace":if(!f)break;h||(s.preventDefault(),l(9,v[u][k].value="",v));break;case"Delete":if(!f)break;h||(s.preventDefault(),l(9,v[u][k].value="",v));break;case"Tab":let H=s.shiftKey?-1:1,Y=v[u][k+H],ue=v?.[u+H]?.[H>0?0:g.length-1],oe=Y||ue;oe&&(s.preventDefault(),l(6,m=oe?oe.id:m)),l(7,h=!1);break;default:(!h||h&&h!==D)&&s.key.length===1&&J(D,!0);break}}async function ke(s){h!==s&&m!==s&&(l(7,h=!1),l(6,m=s))}async function ye(s,u){if(u==="edit"&&typeof s=="string"&&(await P(),d[s].input?.focus()),u==="edit"&&typeof s=="boolean"&&typeof m=="string"){let k=d[m]?.cell;await P(),k?.focus()}if(u==="select"&&typeof s=="string"){const{cell:k}=d[s];await P(),k?.focus()}}let V,le;function Ie(s,u){u==="asc"?l(9,v=v.sort((k,D)=>k[s].value<D[s].value?-1:1)):u==="des"&&l(9,v=v.sort((k,D)=>k[s].value>D[s].value?-1:1))}function ve(s){typeof le!="number"||le!==s?(l(11,V="asc"),l(12,le=s)):V==="asc"?l(11,V="des"):V==="des"&&l(11,V="asc"),Ie(s,V)}let F;function Ae(){if(typeof m=="string"){const s=d[m].input?.value;if(g.find(u=>u.id===m)){let u=g.find(k=>k.id===m);s&&(u.value=s)}else s&&g.push({id:m,value:s})}}async function re(s,u){!f||i[1]!=="dynamic"||h===s||(l(13,F=s),await P(),d[s].input?.focus(),u&&d[s].input?.select())}function Ke(s){if(f)switch(s.key){case"Escape":case"Enter":case"Tab":s.preventDefault(),l(6,m=F),l(13,F=!1),Ae();break}}function ie(s){_[1]==="dynamic"&&(v.splice(s?s+1:v.length,0,Array(v[0].length).fill(0).map((u,k)=>{const D=`${v.length}-${k}`;return l(10,d[D]={cell:null,input:null},d),{id:D,value:""}})),l(9,v),l(27,c),l(29,R),l(26,r))}async function Pe(){if(i[1]!=="dynamic")return;for(let u=0;u<v.length;u++){const k=`${u}-${v[u].length}`;l(10,d[k]={cell:null,input:null},d),v[u].push({id:k,value:""})}const s=`h-${g.length}`;l(10,d[s]={cell:null,input:null},d),g.push({id:s,value:`Header ${g.length+1}`}),l(9,v),l(27,c),l(29,R),l(26,r),l(8,g),l(26,r),l(28,N),l(27,c),await P(),re(s,!0)}function Ye(s){typeof h=="string"&&d[h]&&d[h].cell!==s.target&&!d[h].cell?.contains(s?.target)&&l(7,h=!1),typeof F=="string"&&d[F]&&d[F].cell!==s.target&&!d[F].cell?.contains(s.target)&&(l(6,m=F),l(13,F=!1),Ae(),l(13,F=!1))}function De(s){const u=new FileReader;function k(D){if(!D?.target?.result||typeof D.target.result!="string")return;const[E]=Dl(D.target.result,[",","	"]),[H,...Y]=gl(E).parseRows(D.target.result);l(8,g=C(i[1]==="fixed"?H.slice(0,i[0]):H)),l(27,c=Y),u.removeEventListener("loadend",k)}u.addEventListener("loadend",k),u.readAsText(s)}let fe=!1;function je(s,u){a.$$.not_equal(d[u].input,s)&&(d[u].input=s,l(10,d))}const Ge=s=>re(s),Qe=s=>ve(s);function Ve(s,u){Z[s?"unshift":"push"](()=>{d[u].cell=s,l(10,d)})}function Ze(s,u,k,D){k[D].value=s,l(9,v),l(27,c),l(29,R),l(26,r)}function We(s,u){a.$$.not_equal(d[u].input,s)&&(d[u].input=s,l(10,d))}function Xe(s,u){Z[s?"unshift":"push"](()=>{d[u].cell=s,l(10,d)})}const xe=s=>J(s),$e=s=>ke(s),el=s=>J(s),ll=(s,u,k,D)=>we(D,s,u,k);function tl(s){fe=s,l(14,fe)}const nl=s=>De(Nl(s.detail.data)),al=()=>ie();return a.$$set=s=>{"datatype"in s&&l(0,t=s.datatype),"label"in s&&l(1,n=s.label),"headers"in s&&l(26,r=s.headers),"values"in s&&l(27,c=s.values),"col_count"in s&&l(2,i=s.col_count),"row_count"in s&&l(3,_=s.row_count),"editable"in s&&l(4,f=s.editable),"wrap"in s&&l(5,o=s.wrap)},a.$$.update=()=>{if(a.$$.dirty[0]&201326592&&(c&&!Array.isArray(c)?(l(26,r=c.headers),l(27,c=c.data.length===0?[Array(r.length).fill("")]:c.data),l(6,m=!1)):c===null&&(l(27,c=[Array(r.length).fill("")]),l(6,m=!1))),a.$$.dirty[0]&64&&m!==!1){const s=m.split("-"),u=parseInt(s[0]),k=parseInt(s[1]);!isNaN(u)&&!isNaN(k)&&p("select",{index:[u,k],value:A(u,k)})}a.$$.dirty[0]&335544320&&(se(r,N)||(l(8,g=C(r)),l(28,N=r),L())),a.$$.dirty[0]&671088640&&(se(c,R)||(l(9,v=y(c)),l(29,R=c),L())),a.$$.dirty[0]&768&&g&&p("change",{data:v.map(s=>s.map(({value:u})=>u)),headers:g.map(s=>s.value)}),a.$$.dirty[0]&128&&ye(h,"edit"),a.$$.dirty[0]&64&&ye(m,"select")},[t,n,i,_,f,o,m,h,g,v,d,V,le,F,fe,w,J,we,ke,ve,re,Ke,ie,Pe,Ye,De,r,c,N,R,je,Ge,Qe,Ve,Ze,We,Xe,xe,$e,el,ll,tl,nl,al]}class Ll extends he{constructor(e){super(),ge(this,e,El,Al,me,{datatype:0,label:1,headers:26,values:27,col_count:2,row_count:3,editable:4,wrap:5},null,[-1,-1])}}function ql(a){let e,l,t,n;const r=[a[13]];let c={};for(let i=0;i<r.length;i+=1)c=ul(c,r[i]);return e=new ol({props:c}),t=new Ll({props:{label:a[8],row_count:a[7],col_count:a[6],values:a[0],headers:a[1],editable:a[5]==="dynamic",wrap:a[9],datatype:a[10]}}),t.$on("change",a[16]),t.$on("select",a[17]),{c(){j(e.$$.fragment),l=K(),j(t.$$.fragment)},m(i,_){G(e,i,_),O(i,l,_),G(t,i,_),n=!0},p(i,_){const f=_&8192?cl(r,[_l(i[13])]):{};e.$set(f);const o={};_&256&&(o.label=i[8]),_&128&&(o.row_count=i[7]),_&64&&(o.col_count=i[6]),_&1&&(o.values=i[0]),_&2&&(o.headers=i[1]),_&32&&(o.editable=i[5]==="dynamic"),_&512&&(o.wrap=i[9]),_&1024&&(o.datatype=i[10]),t.$set(o)},i(i){n||(M(e.$$.fragment,i),M(t.$$.fragment,i),n=!0)},o(i){U(e.$$.fragment,i),U(t.$$.fragment,i),n=!1},d(i){i&&S(l),Q(e,i),Q(t,i)}}}function Bl(a){let e,l;return e=new dl({props:{visible:a[4],padding:!1,elem_id:a[2],elem_classes:a[3],container:!1,scale:a[11],min_width:a[12],allow_overflow:!1,$$slots:{default:[ql]},$$scope:{ctx:a}}}),{c(){j(e.$$.fragment)},m(t,n){G(e,t,n),l=!0},p(t,[n]){const r={};n&16&&(r.visible=t[4]),n&4&&(r.elem_id=t[2]),n&8&&(r.elem_classes=t[3]),n&2048&&(r.scale=t[11]),n&4096&&(r.min_width=t[12]),n&1058787&&(r.$$scope={dirty:n,ctx:t}),e.$set(r)},i(t){l||(M(e.$$.fragment,t),l=!0)},o(t){U(e.$$.fragment,t),l=!1},d(t){Q(e,t)}}}function Ml(a,e,l){let{headers:t=[]}=e,{elem_id:n=""}=e,{elem_classes:r=[]}=e,{visible:c=!0}=e,{value:i={data:[["","",""]],headers:["1","2","3"]}}=e,_=JSON.stringify(i),{value_is_output:f=!1}=e,{mode:o}=e,{col_count:m}=e,{row_count:p}=e,{label:h=null}=e,{wrap:A}=e,{datatype:d}=e,{scale:C=null}=e,{min_width:y=void 0}=e;const g=Fe();let{loading_status:N}=e;function L(){g("change",i),f||g("input")}fl(()=>{l(14,f=!1)});const v=({detail:w})=>{l(0,i=w)};function R(w){ce.call(this,a,w)}return a.$$set=w=>{"headers"in w&&l(1,t=w.headers),"elem_id"in w&&l(2,n=w.elem_id),"elem_classes"in w&&l(3,r=w.elem_classes),"visible"in w&&l(4,c=w.visible),"value"in w&&l(0,i=w.value),"value_is_output"in w&&l(14,f=w.value_is_output),"mode"in w&&l(5,o=w.mode),"col_count"in w&&l(6,m=w.col_count),"row_count"in w&&l(7,p=w.row_count),"label"in w&&l(8,h=w.label),"wrap"in w&&l(9,A=w.wrap),"datatype"in w&&l(10,d=w.datatype),"scale"in w&&l(11,C=w.scale),"min_width"in w&&l(12,y=w.min_width),"loading_status"in w&&l(13,N=w.loading_status)},a.$$.update=()=>{a.$$.dirty&32769&&JSON.stringify(i)!==_&&(l(15,_=JSON.stringify(i)),L())},[i,t,n,r,c,o,m,p,h,A,d,C,y,N,f,_,v,R]}class Ol extends he{constructor(e){super(),ge(this,e,Ml,Bl,me,{headers:1,elem_id:2,elem_classes:3,visible:4,value:0,value_is_output:14,mode:5,col_count:6,row_count:7,label:8,wrap:9,datatype:10,scale:11,min_width:12,loading_status:13})}}const zl=Ol,Fl=["static","dynamic"],Hl=a=>({type:{payload:"{ data: Array<Array<string | number>>; headers: Array<string> }"},description:{payload:"an object with an array of data and an array of headers"},example_data:a.value});export{zl as Component,Hl as document,Fl as modes};
-//# sourceMappingURL=index-bacb8946.js.map

spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/gradio_client/__init__.py

@@ -1,7 +0,0 @@
-from gradio_client.client import Client
-from gradio_client.utils import __version__
-
-__all__ = [
-    "Client",
-    "__version__",
-]

spaces/Docfile/open_llm_leaderboard/src/display_models/model_metadata_flags.py

@@ -1,18 +0,0 @@
-# Models which have been flagged by users as being problematic for a reason or another
-# (Model name to forum discussion link)
-FLAGGED_MODELS = {
-    "Voicelab/trurl-2-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/202",
-    "deepnight-research/llama-2-70B-inst": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/207",
-    "Aspik101/trurl-2-13b-pl-instruct_unload": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/213",
-    "Fredithefish/ReasonixPajama-3B-HF": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/236",
-    "TigerResearch/tigerbot-7b-sft-v1": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/237",
-    "gaodrew/gaodrew-gorgonzola-13b": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/215",
-    "AIDC-ai-business/Marcoroni-70B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-    "AIDC-ai-business/Marcoroni-13B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-    "AIDC-ai-business/Marcoroni-7B": "https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard/discussions/287",
-}
-
-# Models which have been requested by orgs to not be submitted on the leaderboard
-DO_NOT_SUBMIT_MODELS = [
-    "Voicelab/trurl-2-13b",  # trained on MMLU
-]

spaces/DragGan/DragGan-Inversion/PTI/utils/log_utils.py

@@ -1,79 +0,0 @@
-import numpy as np
-from PIL import Image
-import wandb
-from PTI.configs import global_config
-import torch
-import matplotlib.pyplot as plt
-
-
-def log_image_from_w(w, G, name):
-    img = get_image_from_w(w, G)
-    pillow_image = Image.fromarray(img)
-    wandb.log(
-        {f"{name}": [
-            wandb.Image(pillow_image, caption=f"current inversion {name}")]},
-        step=global_config.training_step)
-
-
-def log_images_from_w(ws, G, names):
-    for name, w in zip(names, ws):
-        w = w.to(global_config.device)
-        log_image_from_w(w, G, name)
-
-
-def plot_image_from_w(w, G):
-    img = get_image_from_w(w, G)
-    pillow_image = Image.fromarray(img)
-    plt.imshow(pillow_image)
-    plt.show()
-
-
-def plot_image(img):
-    img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8).detach().cpu().numpy()
-    pillow_image = Image.fromarray(img[0])
-    plt.imshow(pillow_image)
-    plt.show()
-
-
-def save_image(name, method_type, results_dir, image, run_id):
-    image.save(f'{results_dir}/{method_type}_{name}_{run_id}.jpg')
-
-
-def save_w(w, G, name, method_type, results_dir):
-    im = get_image_from_w(w, G)
-    im = Image.fromarray(im, mode='RGB')
-    save_image(name, method_type, results_dir, im)
-
-
-def save_concat_image(base_dir, image_latents, new_inv_image_latent, new_G,
-                      old_G,
-                      file_name,
-                      extra_image=None):
-    images_to_save = []
-    if extra_image is not None:
-        images_to_save.append(extra_image)
-    for latent in image_latents:
-        images_to_save.append(get_image_from_w(latent, old_G))
-    images_to_save.append(get_image_from_w(new_inv_image_latent, new_G))
-    result_image = create_alongside_images(images_to_save)
-    result_image.save(f'{base_dir}/{file_name}.jpg')
-
-
-def save_single_image(base_dir, image_latent, G, file_name):
-    image_to_save = get_image_from_w(image_latent, G)
-    image_to_save = Image.fromarray(image_to_save, mode='RGB')
-    image_to_save.save(f'{base_dir}/{file_name}.jpg')
-
-
-def create_alongside_images(images):
-    res = np.concatenate([np.array(image) for image in images], axis=1)
-    return Image.fromarray(res, mode='RGB')
-
-
-def get_image_from_w(w, G):
-    if len(w.size()) <= 2:
-        w = w.unsqueeze(0)
-    with torch.no_grad():
-        img = G.synthesis(w, noise_mode='const')
-        img = (img.permute(0, 2, 3, 1) * 127.5 + 128).clamp(0, 255).to(torch.uint8).detach().cpu().numpy()
-    return img[0]

spaces/EPFL-VILAB/MultiMAE/utils/checkpoint.py

@@ -1,152 +0,0 @@
-# --------------------------------------------------------
-# Based on the timm and MAE-priv code base
-# https://github.com/rwightman/pytorch-image-models/tree/master/timm
-# https://github.com/BUPT-PRIV/MAE-priv
-# --------------------------------------------------------
-import io
-import os
-from pathlib import Path
-
-import torch
-
-from .dist import save_on_master
-from .model import get_state_dict
-
-
-def _load_checkpoint_for_ema(model_ema, checkpoint):
-    """
-    Workaround for ModelEma._load_checkpoint to accept an already-loaded object
-    """
-    mem_file = io.BytesIO()
-    torch.save(checkpoint, mem_file)
-    mem_file.seek(0)
-    model_ema._load_checkpoint(mem_file)
-
-
-def load_state_dict(model, state_dict, prefix='', ignore_missing="relative_position_index"):
-    missing_keys = []
-    unexpected_keys = []
-    error_msgs = []
-    # copy state_dict so _load_from_state_dict can modify it
-    metadata = getattr(state_dict, '_metadata', None)
-    state_dict = state_dict.copy()
-    if metadata is not None:
-        state_dict._metadata = metadata
-
-    def load(module, prefix=''):
-        local_metadata = {} if metadata is None else metadata.get(
-            prefix[:-1], {})
-        module._load_from_state_dict(
-            state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs)
-        for name, child in module._modules.items():
-            if child is not None:
-                load(child, prefix + name + '.')
-
-    load(model, prefix=prefix)
-
-    warn_missing_keys = []
-    ignore_missing_keys = []
-    for key in missing_keys:
-        keep_flag = True
-        for ignore_key in ignore_missing.split('|'):
-            if ignore_key in key:
-                keep_flag = False
-                break
-        if keep_flag:
-            warn_missing_keys.append(key)
-        else:
-            ignore_missing_keys.append(key)
-
-    missing_keys = warn_missing_keys
-
-    if len(missing_keys) > 0:
-        print("Weights of {} not initialized from pretrained model: {}".format(
-            model.__class__.__name__, missing_keys))
-    if len(unexpected_keys) > 0:
-        print("Weights from pretrained model not used in {}: {}".format(
-            model.__class__.__name__, unexpected_keys))
-    if len(ignore_missing_keys) > 0:
-        print("Ignored weights of {} not initialized from pretrained model: {}".format(
-            model.__class__.__name__, ignore_missing_keys))
-    if len(error_msgs) > 0:
-        print('\n'.join(error_msgs))
-
-
-def save_model(args, epoch, model, model_without_ddp, optimizer, loss_scaler, loss_balancer=None, model_ema=None):
-    output_dir = Path(args.output_dir)
-    epoch_name = str(epoch)
-    if loss_scaler is not None:
-        checkpoint_paths = [output_dir / ('checkpoint-%s.pth' % epoch_name)]
-        for checkpoint_path in checkpoint_paths:
-            to_save = {
-                'model': model_without_ddp.state_dict(),
-                'optimizer': optimizer.state_dict(),
-                'epoch': epoch,
-                'scaler': loss_scaler.state_dict(),
-                'args': args
-            }
-
-            if loss_balancer is not None:
-                to_save['loss_balancer'] = loss_balancer.state_dict()
-
-            if model_ema is not None:
-                to_save['model_ema'] = get_state_dict(model_ema)
-
-            save_on_master(to_save, checkpoint_path)
-    else:
-        client_state = {'epoch': epoch}
-        if model_ema is not None:
-            client_state['model_ema'] = get_state_dict(model_ema)
-        model.save_checkpoint(save_dir=args.output_dir, tag="checkpoint-%s" % epoch_name, client_state=client_state)
-
-
-def auto_load_model(args, model, model_without_ddp, optimizer, loss_scaler, model_ema=None):
-    output_dir = Path(args.output_dir)
-    if loss_scaler is not None:
-        # torch.amp
-        if args.auto_resume and len(args.resume) == 0:
-            import glob
-            all_checkpoints = glob.glob(os.path.join(output_dir, 'checkpoint-*.pth'))
-            latest_ckpt = -1
-            for ckpt in all_checkpoints:
-                t = ckpt.split('-')[-1].split('.')[0]
-                if t.isdigit():
-                    latest_ckpt = max(int(t), latest_ckpt)
-            if latest_ckpt >= 0:
-                args.resume = os.path.join(output_dir, 'checkpoint-%d.pth' % latest_ckpt)
-            print("Auto resume checkpoint: %s" % args.resume)
-
-        if args.resume:
-            if args.resume.startswith('https'):
-                checkpoint = torch.hub.load_state_dict_from_url(
-                    args.resume, map_location='cpu')
-            else:
-                checkpoint = torch.load(args.resume, map_location='cpu')
-            model_without_ddp.load_state_dict(checkpoint['model'])
-            print("Resume checkpoint %s" % args.resume)
-            if 'optimizer' in checkpoint and 'epoch' in checkpoint:
-                optimizer.load_state_dict(checkpoint['optimizer'])
-                args.start_epoch = checkpoint['epoch'] + 1
-                if hasattr(args, 'model_ema') and args.model_ema:
-                    _load_checkpoint_for_ema(model_ema, checkpoint['model_ema'])
-                if 'scaler' in checkpoint:
-                    loss_scaler.load_state_dict(checkpoint['scaler'])
-                print("With optim & sched!")
-    else:
-        # deepspeed, only support '--auto_resume'.
-        if args.auto_resume:
-            import glob
-            all_checkpoints = glob.glob(os.path.join(output_dir, 'checkpoint-*'))
-            latest_ckpt = -1
-            for ckpt in all_checkpoints:
-                t = ckpt.split('-')[-1].split('.')[0]
-                if t.isdigit():
-                    latest_ckpt = max(int(t), latest_ckpt)
-            if latest_ckpt >= 0:
-                args.resume = os.path.join(output_dir, 'checkpoint-%d' % latest_ckpt)
-                print("Auto resume checkpoint: %d" % latest_ckpt)
-                _, client_states = model.load_checkpoint(args.output_dir, tag='checkpoint-%d' % latest_ckpt)
-                args.start_epoch = client_states['epoch'] + 1
-                if model_ema is not None:
-                    if args.model_ema:
-                        _load_checkpoint_for_ema(model_ema, client_states['model_ema'])

spaces/Flux9665/IMS-Toucan/app.py

@@ -1,160 +0,0 @@
-import os
-
-import gradio as gr
-import numpy as np
-import torch
-
-from InferenceInterfaces.Meta_FastSpeech2 import Meta_FastSpeech2
-
-def float2pcm(sig, dtype='int16'):
-    """
-    https://gist.github.com/HudsonHuang/fbdf8e9af7993fe2a91620d3fb86a182
-    """
-    sig = np.asarray(sig)
-    if sig.dtype.kind != 'f':
-        raise TypeError("'sig' must be a float array")
-    dtype = np.dtype(dtype)
-    if dtype.kind not in 'iu':
-        raise TypeError("'dtype' must be an integer type")
-    i = np.iinfo(dtype)
-    abs_max = 2 ** (i.bits - 1)
-    offset = i.min + abs_max
-    return (sig * abs_max + offset).clip(i.min, i.max).astype(dtype)
-
-
-class TTS_Interface:
-
-    def __init__(self):
-        self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        self.model = Meta_FastSpeech2(device=self.device)
-        self.current_speaker = "English Speaker's Voice"
-        self.current_language = "English"
-        self.current_accent = "English"
-        self.language_id_lookup = {
-            "English"   : "en",
-            "German"    : "de",
-            "Greek"     : "el",
-            "Spanish"   : "es",
-            "Finnish"   : "fi",
-            "Russian"   : "ru",
-            "Hungarian" : "hu",
-            "Dutch"     : "nl",
-            "French"    : "fr",
-            'Polish'    : "pl",
-            'Portuguese': "pt",
-            'Italian'   : "it",
-            }
-        self.speaker_path_lookup = {
-            "English Speaker's Voice"   : "reference_audios/english.wav",
-            "German Speaker's Voice"    : "reference_audios/german.wav",
-            "Greek Speaker's Voice"     : "reference_audios/greek.wav",
-            "Spanish Speaker's Voice"   : "reference_audios/spanish.wav",
-            "Finnish Speaker's Voice"   : "reference_audios/finnish.wav",
-            "Russian Speaker's Voice"   : "reference_audios/russian.wav",
-            "Hungarian Speaker's Voice" : "reference_audios/hungarian.wav",
-            "Dutch Speaker's Voice"     : "reference_audios/dutch.wav",
-            "French Speaker's Voice"    : "reference_audios/french.wav",
-            "Polish Speaker's Voice"    : "reference_audios/polish.flac",
-            "Portuguese Speaker's Voice": "reference_audios/portuguese.flac",
-            "Italian Speaker's Voice"   : "reference_audios/italian.flac",
-            }
-        self.model.set_utterance_embedding(self.speaker_path_lookup[self.current_speaker])
-
-
-    def read(self, prompt, language, accent, speaker):
-        language = language.split()[0]
-        accent = accent.split()[0]
-        if self.current_language != language:
-            self.model.set_phonemizer_language(self.language_id_lookup[language])
-            self.current_language = language
-        if self.current_accent != accent:
-            self.model.set_accent_language(self.language_id_lookup[accent])
-            self.current_accent = accent
-        if self.current_speaker != speaker:
-            self.model.set_utterance_embedding(self.speaker_path_lookup[speaker])
-            self.current_speaker = speaker
-            
-        phones = self.model.text2phone.get_phone_string(prompt)
-        if len(phones) > 1800:
-            if language == "English":
-                prompt = "Your input was too long. Please try either a shorter text or split it into several parts."
-            elif language == "German":
-                prompt = "Deine Eingabe war zu lang. Bitte versuche es entweder mit einem kürzeren Text oder teile ihn in mehrere Teile auf."
-            elif language == "Greek":
-                prompt = "Η εισήγησή σας ήταν πολύ μεγάλη. Παρακαλώ δοκιμάστε είτε ένα μικρότερο κείμενο είτε χωρίστε το σε διάφορα μέρη."
-            elif language == "Spanish":
-                prompt = "Su entrada es demasiado larga. Por favor, intente un texto más corto o divídalo en varias partes."
-            elif language == "Finnish":
-                prompt = "Vastauksesi oli liian pitkä. Kokeile joko lyhyempää tekstiä tai jaa se useampaan osaan."
-            elif language == "Russian":
-                prompt = "Ваш текст слишком длинный. Пожалуйста, попробуйте либо сократить текст, либо разделить его на несколько частей."
-            elif language == "Hungarian":
-                prompt = "Túl hosszú volt a bevitele. Kérjük, próbáljon meg rövidebb szöveget írni, vagy ossza több részre."
-            elif language == "Dutch":
-                prompt = "Uw input was te lang. Probeer een kortere tekst of splits het in verschillende delen."
-            elif language == "French":
-                prompt = "Votre saisie était trop longue. Veuillez essayer un texte plus court ou le diviser en plusieurs parties."
-            elif language == 'Polish':
-                prompt = "Twój wpis był zbyt długi. Spróbuj skrócić tekst lub podzielić go na kilka części."
-            elif language == 'Portuguese':
-                prompt = "O seu contributo foi demasiado longo. Por favor, tente um texto mais curto ou divida-o em várias partes."
-            elif language == 'Italian':
-                prompt = "Il tuo input era troppo lungo. Per favore, prova un testo più corto o dividilo in più parti."
-            phones = self.model.text2phone.get_phone_string(prompt)
-
-        wav = self.model(phones)
-        return 48000, float2pcm(wav.cpu().numpy())
-
-
-meta_model = TTS_Interface()
-article = "<p style='text-align: left'>This is still a work in progress, models will be exchanged for better ones as soon as they are done. All of those languages are spoken by a single model. Speakers can be transferred across languages. More languages will be added soon. If you just want to listen to some pregenerated audios <a href='https://multilingualtoucan.github.io/' target='_blank'>click here.</a></p><p style='text-align: center'><a href='https://github.com/DigitalPhonetics/IMS-Toucan' target='_blank'>Click here to learn more about the IMS Toucan Speech Synthesis Toolkit</a></p>"
-
-iface = gr.Interface(fn=meta_model.read,
-                     inputs=[gr.inputs.Textbox(lines=2,
-                                               placeholder="write what you want the synthesis to read here... \n(to prevent out of memory errors, too long inputs get replaced with a placeholder)",
-                                               label="Text input"),
-                             gr.inputs.Dropdown(['English Text',
-                                                 'German Text',
-                                                 'Greek Text',
-                                                 'Spanish Text',
-                                                 'Finnish Text',
-                                                 'Russian Text',
-                                                 'Hungarian Text',
-                                                 'Dutch Text',
-                                                 'French Text',
-                                                 'Polish Text',
-                                                 'Portuguese Text',
-                                                 'Italian Text'], type="value", default='English Text', label="Select the Language of the Text"),
-                             gr.inputs.Dropdown(['English Accent',
-                                                 'German Accent',
-                                                 'Greek Accent',
-                                                 'Spanish Accent',
-                                                 'Finnish Accent',
-                                                 'Russian Accent',
-                                                 'Hungarian Accent',
-                                                 'Dutch Accent',
-                                                 'French Accent',
-                                                 'Polish Accent',
-                                                 'Portuguese Accent',
-                                                 'Italian Accent'], type="value", default='English Accent', label="Select the Accent of the Speaker"),
-                             gr.inputs.Dropdown(["English Speaker's Voice",
-                                                 "German Speaker's Voice",
-                                                 "Greek Speaker's Voice",
-                                                 "Spanish Speaker's Voice",
-                                                 "Finnish Speaker's Voice",
-                                                 "Russian Speaker's Voice",
-                                                 "Hungarian Speaker's Voice",
-                                                 "Dutch Speaker's Voice",
-                                                 "French Speaker's Voice",
-                                                 "Polish Speaker's Voice",
-                                                 "Portuguese Speaker's Voice",
-                                                 "Italian Speaker's Voice"], type="value", default="English Speaker's Voice", label="Select the Voice of the Speaker")],
-                     outputs=gr.outputs.Audio(type="numpy", label=None),
-                     layout="vertical",
-                     title="IMS Toucan - Multilingual Multispeaker",
-                     thumbnail="Utility/toucan.png",
-                     theme="default",
-                     allow_flagging="never",
-                     allow_screenshot=False,
-                     article=article)
-iface.launch(enable_queue=True)

spaces/FrankZxShen/so-vits-svc-models-pcr/diffusion/unit2mel.py

@@ -1,100 +0,0 @@
-import os
-import yaml
-import torch
-import torch.nn as nn
-import numpy as np
-from .diffusion import GaussianDiffusion
-from .wavenet import WaveNet
-from .vocoder import Vocoder
-
-class DotDict(dict):
-    def __getattr__(*args):         
-        val = dict.get(*args)         
-        return DotDict(val) if type(val) is dict else val   
-
-    __setattr__ = dict.__setitem__    
-    __delattr__ = dict.__delitem__
-
-    
-def load_model_vocoder(
-        model_path,
-        device='cpu',
-        config_path = None
-        ):
-    if config_path is None: config_file = os.path.join(os.path.split(model_path)[0], 'config.yaml')
-    else: config_file = config_path
-    
-    with open(config_file, "r") as config:
-        args = yaml.safe_load(config)
-    args = DotDict(args)
-    
-    # load vocoder
-    vocoder = Vocoder(args.vocoder.type, args.vocoder.ckpt, device=device)
-    
-    # load model
-    model = Unit2Mel(
-                args.data.encoder_out_channels, 
-                args.model.n_spk,
-                args.model.use_pitch_aug,
-                vocoder.dimension,
-                args.model.n_layers,
-                args.model.n_chans,
-                args.model.n_hidden)
-    
-    print(' [Loading] ' + model_path)
-    ckpt = torch.load(model_path, map_location=torch.device(device))
-    model.to(device)
-    model.load_state_dict(ckpt['model'])
-    model.eval()
-    return model, vocoder, args
-
-
-class Unit2Mel(nn.Module):
-    def __init__(
-            self,
-            input_channel,
-            n_spk,
-            use_pitch_aug=False,
-            out_dims=128,
-            n_layers=20, 
-            n_chans=384, 
-            n_hidden=256):
-        super().__init__()
-        self.unit_embed = nn.Linear(input_channel, n_hidden)
-        self.f0_embed = nn.Linear(1, n_hidden)
-        self.volume_embed = nn.Linear(1, n_hidden)
-        if use_pitch_aug:
-            self.aug_shift_embed = nn.Linear(1, n_hidden, bias=False)
-        else:
-            self.aug_shift_embed = None
-        self.n_spk = n_spk
-        if n_spk is not None and n_spk > 1:
-            self.spk_embed = nn.Embedding(n_spk, n_hidden)
-            
-        # diffusion
-        self.decoder = GaussianDiffusion(WaveNet(out_dims, n_layers, n_chans, n_hidden), out_dims=out_dims)
-
-    def forward(self, units, f0, volume, spk_id = None, spk_mix_dict = None, aug_shift = None,
-                gt_spec=None, infer=True, infer_speedup=10, method='dpm-solver', k_step=300, use_tqdm=True):
-        
-        '''
-        input: 
-            B x n_frames x n_unit
-        return: 
-            dict of B x n_frames x feat
-        '''
-
-        x = self.unit_embed(units) + self.f0_embed((1+ f0 / 700).log()) + self.volume_embed(volume)
-        if self.n_spk is not None and self.n_spk > 1:
-            if spk_mix_dict is not None:
-                for k, v in spk_mix_dict.items():
-                    spk_id_torch = torch.LongTensor(np.array([[k]])).to(units.device)
-                    x = x + v * self.spk_embed(spk_id_torch)
-            else:
-                x = x + self.spk_embed(spk_id)
-        if self.aug_shift_embed is not None and aug_shift is not None:
-            x = x + self.aug_shift_embed(aug_shift / 5) 
-        x = self.decoder(x, gt_spec=gt_spec, infer=infer, infer_speedup=infer_speedup, method=method, k_step=k_step, use_tqdm=use_tqdm)
-    
-        return x
-