{highlighted_code}'
-
- code_block_pattern = r"```(\w+)?\n([\s\S]+?)\n```"
- md_str = re.sub(code_block_pattern, replacer, md_str, flags=re.MULTILINE)
-
- html_str = markdown(md_str)
- return html_str
-
-
-def normalize_markdown(md_text: str) -> str: # deprecated
- lines = md_text.split("\n")
- normalized_lines = []
- inside_list = False
-
- for i, line in enumerate(lines):
- if re.match(r"^(\d+\.|-|\*|\+)\s", line.strip()):
- if not inside_list and i > 0 and lines[i - 1].strip() != "":
- normalized_lines.append("")
- inside_list = True
- normalized_lines.append(line)
- elif inside_list and line.strip() == "":
- if i < len(lines) - 1 and not re.match(
- r"^(\d+\.|-|\*|\+)\s", lines[i + 1].strip()
- ):
- normalized_lines.append(line)
- continue
- else:
- inside_list = False
- normalized_lines.append(line)
-
- return "\n".join(normalized_lines)
-
-
-def convert_mdtext(md_text): # deprecated
- code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
- inline_code_pattern = re.compile(r"`(.*?)`", re.DOTALL)
- code_blocks = code_block_pattern.findall(md_text)
- non_code_parts = code_block_pattern.split(md_text)[::2]
-
- result = []
- raw = f''
- for non_code, code in zip(non_code_parts, code_blocks + [""]):
- if non_code.strip():
- non_code = normalize_markdown(non_code)
- result.append(markdown(non_code, extensions=["tables"]))
- if code.strip():
- # _, code = detect_language(code) # 暂时去除代码高亮功能，因为在大段代码的情况下会出现问题
- # code = code.replace("\n\n", "\n") # 暂时去除代码中的空行，因为在大段代码的情况下会出现问题
- code = f"\n```{code}\n\n```"
- code = markdown_to_html_with_syntax_highlight(code)
- result.append(code)
- result = "".join(result)
- output = f''
- output += raw
- output += ALREADY_CONVERTED_MARK
- return output
-
-
-def clip_rawtext(chat_message, need_escape=True):
- # first, clip hr line
- hr_pattern = r'\n\n(.*?)' - hr_match = re.search(hr_pattern, chat_message, re.DOTALL) - message_clipped = chat_message[:hr_match.start()] if hr_match else chat_message - # second, avoid agent-prefix being escaped - agent_prefix_pattern = r'
(.*?)<\/p>' - agent_matches = re.findall(agent_prefix_pattern, message_clipped) - final_message = "" - if agent_matches: - agent_parts = re.split(agent_prefix_pattern, message_clipped) - for i, part in enumerate(agent_parts): - if i % 2 == 0: - final_message += escape_markdown(part) if need_escape else part - else: - final_message += f'
{part}
' - else: - final_message = escape_markdown(message_clipped) if need_escape else message_clipped - return final_message - - -def convert_bot_before_marked(chat_message): - """ - 注意不能给输出加缩进, 否则会被marked解析成代码块 - """ - if '' in chat_message:
- return chat_message
- else:
- raw = f''
- # really_raw = f'{START_OF_OUTPUT_MARK}{END_OF_OUTPUT_MARK}'
-
- code_block_pattern = re.compile(r"```(.*?)(?:```|$)", re.DOTALL)
- code_blocks = code_block_pattern.findall(chat_message)
- non_code_parts = code_block_pattern.split(chat_message)[::2]
- result = []
- for non_code, code in zip(non_code_parts, code_blocks + [""]):
- if non_code.strip():
- result.append(non_code)
- if code.strip():
- code = f"\n```{code}\n```"
- result.append(code)
- result = "".join(result)
- md = f''
- return raw + md
-
-def convert_user_before_marked(chat_message):
- if '
' in chat_message:
- return chat_message
- else:
- return f''
-
-def escape_markdown(text):
- """
- Escape Markdown special characters to HTML-safe equivalents.
- """
- escape_chars = {
- # ' ': ' ',
- '_': '_',
- '*': '*',
- '[': '[',
- ']': ']',
- '(': '(',
- ')': ')',
- '{': '{',
- '}': '}',
- '#': '#',
- '+': '+',
- '-': '-',
- '.': '.',
- '!': '!',
- '`': '`',
- '>': '>',
- '<': '<',
- '|': '|',
- '$': '$',
- ':': ':',
- '\n': '
', - } - text = text.replace(' ', ' ') - return ''.join(escape_chars.get(c, c) for c in text) - - -def convert_asis(userinput): # deprecated - return ( - f'"
- )
- return nodes
-
-
-def sheet_to_string(sheet, sheet_name = None):
- result = []
- for index, row in sheet.iterrows():
- row_string = ""
- for column in sheet.columns:
- row_string += f"{column}: {row[column]}, "
- row_string = row_string.rstrip(", ")
- row_string += "."
- result.append(row_string)
- return result
-
-def excel_to_string(file_path):
- # 读取Excel文件中的所有工作表
- excel_file = pd.read_excel(file_path, engine='openpyxl', sheet_name=None)
-
- # 初始化结果字符串
- result = []
-
- # 遍历每一个工作表
- for sheet_name, sheet_data in excel_file.items():
-
- # 处理当前工作表并添加到结果字符串
- result += sheet_to_string(sheet_data, sheet_name=sheet_name)
-
-
- return result
-
-def get_last_day_of_month(any_day):
- # The day 28 exists in every month. 4 days later, it's always next month
- next_month = any_day.replace(day=28) + datetime.timedelta(days=4)
- # subtracting the number of the current day brings us back one month
- return next_month - datetime.timedelta(days=next_month.day)
-
-def get_model_source(model_name, alternative_source):
- if model_name == "gpt2-medium":
- return "https://huggingface.co/gpt2-medium"
-
-def refresh_ui_elements_on_load(current_model, selected_model_name, user_name):
- current_model.set_user_identifier(user_name)
- return toggle_like_btn_visibility(selected_model_name), *current_model.auto_load()
-
-def toggle_like_btn_visibility(selected_model_name):
- if selected_model_name == "xmchat":
- return gr.update(visible=True)
- else:
- return gr.update(visible=False)
-
-def new_auto_history_filename(dirname):
- latest_file = get_latest_filepath(dirname)
- if latest_file:
- with open(os.path.join(dirname, latest_file), 'r', encoding="utf-8") as f:
- if len(f.read()) == 0:
- return latest_file
- now = datetime.datetime.now().strftime('%Y-%m-%d_%H-%M-%S')
- return f'{now}.json'
-
-def get_latest_filepath(dirname):
- pattern = re.compile(r'\d{4}-\d{2}-\d{2}_\d{2}-\d{2}-\d{2}')
- latest_time = None
- latest_file = None
- for filename in os.listdir(dirname):
- if os.path.isfile(os.path.join(dirname, filename)):
- match = pattern.search(filename)
- if match and match.group(0) == filename[:19]:
- time_str = filename[:19]
- filetime = datetime.datetime.strptime(time_str, '%Y-%m-%d_%H-%M-%S')
- if not latest_time or filetime > latest_time:
- latest_time = filetime
- latest_file = filename
- return latest_file
-
-def get_history_filepath(username):
- dirname = os.path.join(HISTORY_DIR, username)
- os.makedirs(dirname, exist_ok=True)
- latest_file = get_latest_filepath(dirname)
- if not latest_file:
- latest_file = new_auto_history_filename(dirname)
-
- latest_file = os.path.join(dirname, latest_file)
- return latest_file
-
-def beautify_err_msg(err_msg):
- if "insufficient_quota" in err_msg:
- return i18n("剩余配额不足，[进一步了解](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/%E5%B8%B8%E8%A7%81%E9%97%AE%E9%A2%98#you-exceeded-your-current-quota-please-check-your-plan-and-billing-details)")
- if "The model: gpt-4 does not exist" in err_msg:
- return i18n("你没有权限访问 GPT4，[进一步了解](https://github.com/GaiZhenbiao/ChuanhuChatGPT/issues/843)")
- if "Resource not found" in err_msg:
- return i18n("请查看 config_example.json，配置 Azure OpenAI")
- return err_msg
-
-def auth_from_conf(username, password):
- try:
- with open("config.json", encoding="utf-8") as f:
- conf = json.load(f)
- usernames, passwords = [i[0] for i in conf["users"]], [i[1] for i in conf["users"]]
- if username in usernames:
- if passwords[usernames.index(username)] == password:
- return True
- return False
- except:
- return False
-
-def get_file_hash(file_src=None, file_paths=None):
- if file_src:
- file_paths = [x.name for x in file_src]
- file_paths.sort(key=lambda x: os.path.basename(x))
-
- md5_hash = hashlib.md5()
- for file_path in file_paths:
- with open(file_path, "rb") as f:
- while chunk := f.read(8192):
- md5_hash.update(chunk)
-
- return md5_hash.hexdigest()
diff --git a/spaces/JohnTan38/calculator/app.py b/spaces/JohnTan38/calculator/app.py
deleted file mode 100644
index 285668c2ffa62b984c42c5b6214dd1546f93b068..0000000000000000000000000000000000000000
--- a/spaces/JohnTan38/calculator/app.py
+++ /dev/null
@@ -1,28 +0,0 @@
-import gradio as gr
-
-def calculator(num1, operation, num2):
- if operation == "thêm vào":
- return num1 + num2
- elif operation == "trừ đi":
- return num1 - num2
- elif operation == "nhân":
- return num1 * num2
- elif operation == "chia":
- return num1 / num2
-
-demo = gr.Interface(
- fn=calculator,
- inputs=[
- gr.Number(value=2),
- gr.Radio(["thêm vào", "trừ đi","nhân","chia"]),
- "number"
- ],
- outputs="number",
- examples=[
-
- ],
- title="Mạnh Cường cậu bé thông minh",
- description="Máy tính. thêm vào. trừ. nhân"
-)
-
-demo.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/Joom/Front-end-code-generation-from-images/classes/Utils.py b/spaces/Joom/Front-end-code-generation-from-images/classes/Utils.py
deleted file mode 100644
index a7aff300380f793c941953e0d63ddf6d71281592..0000000000000000000000000000000000000000
--- a/spaces/Joom/Front-end-code-generation-from-images/classes/Utils.py
+++ /dev/null
@@ -1,39 +0,0 @@
-__author__ = 'Taneem Jan, taneemishere.github.io'
-
-import numpy as np
-
-
-class Utils:
- @staticmethod
- def sparsify(label_vector, output_size):
- sparse_vector = []
-
- for label in label_vector:
- sparse_label = np.zeros(output_size)
- sparse_label[label] = 1
-
- sparse_vector.append(sparse_label)
-
- return np.array(sparse_vector)
-
- @staticmethod
- def get_preprocessed_img(img_path, image_size):
- import cv2
- # from keras.preprocessing.image import array_to_img, img_to_array
- # img = array_to_img(img_path)
- # img = img_to_array(img)
- # img = cv2.imread(img_path)
- # don't need to read the image as we're now directly passing the
- # image as numpy array to this method
- img = cv2.resize(img_path, (image_size, image_size))
- img = img.astype('float32')
- img /= 255
- return img
-
- @staticmethod
- def show(image):
- import cv2
- cv2.namedWindow("view", cv2.WINDOW_AUTOSIZE)
- cv2.imshow("view", image)
- cv2.waitKey(0)
- cv2.destroyWindow("view")
diff --git a/spaces/KenjieDec/RemBG/rembg/sessions/base.py b/spaces/KenjieDec/RemBG/rembg/sessions/base.py
deleted file mode 100644
index f6bbe5a0e0575eef049aa42592fb9e3c736bfc2d..0000000000000000000000000000000000000000
--- a/spaces/KenjieDec/RemBG/rembg/sessions/base.py
+++ /dev/null
@@ -1,85 +0,0 @@
-import os
-from typing import Dict, List, Tuple
-
-import numpy as np
-import onnxruntime as ort
-from PIL import Image
-from PIL.Image import Image as PILImage
-
-
-class BaseSession:
- def __init__(
- self,
- model_name: str,
- sess_opts: ort.SessionOptions,
- providers=None,
- *args,
- **kwargs
- ):
- self.model_name = model_name
-
- self.providers = []
-
- _providers = ort.get_available_providers()
- if providers:
- for provider in providers:
- if provider in _providers:
- self.providers.append(provider)
- else:
- self.providers.extend(_providers)
-
- self.inner_session = ort.InferenceSession(
- str(self.__class__.download_models()),
- providers=self.providers,
- sess_options=sess_opts,
- )
-
- def normalize(
- self,
- img: PILImage,
- mean: Tuple[float, float, float],
- std: Tuple[float, float, float],
- size: Tuple[int, int],
- *args,
- **kwargs
- ) -> Dict[str, np.ndarray]:
- im = img.convert("RGB").resize(size, Image.LANCZOS)
-
- im_ary = np.array(im)
- im_ary = im_ary / np.max(im_ary)
-
- tmpImg = np.zeros((im_ary.shape[0], im_ary.shape[1], 3))
- tmpImg[:, :, 0] = (im_ary[:, :, 0] - mean[0]) / std[0]
- tmpImg[:, :, 1] = (im_ary[:, :, 1] - mean[1]) / std[1]
- tmpImg[:, :, 2] = (im_ary[:, :, 2] - mean[2]) / std[2]
-
- tmpImg = tmpImg.transpose((2, 0, 1))
-
- return {
- self.inner_session.get_inputs()[0]
- .name: np.expand_dims(tmpImg, 0)
- .astype(np.float32)
- }
-
- def predict(self, img: PILImage, *args, **kwargs) -> List[PILImage]:
- raise NotImplementedError
-
- @classmethod
- def checksum_disabled(cls, *args, **kwargs):
- return os.getenv("MODEL_CHECKSUM_DISABLED", None) is not None
-
- @classmethod
- def u2net_home(cls, *args, **kwargs):
- return os.path.expanduser(
- os.getenv(
- "U2NET_HOME", os.path.join(os.getenv("XDG_DATA_HOME", "~"), ".u2net")
- )
- )
-
- @classmethod
- def download_models(cls, *args, **kwargs):
- raise NotImplementedError
-
- @classmethod
- def name(cls, *args, **kwargs):
- raise NotImplementedError
diff --git a/spaces/Kimata/Sanskrit-TTS/indic_nlp_library/indicnlp/syllable/__init__.py b/spaces/Kimata/Sanskrit-TTS/indic_nlp_library/indicnlp/syllable/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/KyanChen/RSPrompter/mmpl/utils/__init__.py b/spaces/KyanChen/RSPrompter/mmpl/utils/__init__.py
deleted file mode 100644
index 53e90f15c7d80a807ede74e6192fc039da92d83a..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmpl/utils/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .collect_env import collect_env
-from .misc import is_metainfo_lower, switch_to_deploy
-from .setup_env import register_all_modules
-from .typing_utils import *
-
-__all__ = [
- 'register_all_modules', 'collect_env', 'switch_to_deploy',
- 'is_metainfo_lower', 'ConfigType', 'OptMultiConfig', 'MultiConfig',
-]
diff --git a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/tools/diffq/utils.py b/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/tools/diffq/utils.py
deleted file mode 100644
index be6ab5253c38564140bc202077292bb99f9f397b..0000000000000000000000000000000000000000
--- a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/tools/diffq/utils.py
+++ /dev/null
@@ -1,37 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-import inspect
-from typing import Optional, List
-
-
-def simple_repr(obj, attrs: Optional[List[str]] = None, overrides={}):
- """
- Return a simple representation string for `obj`.
- If `attrs` is not None, it should be a list of attributes to include.
- """
- params = inspect.signature(obj.__class__).parameters
- attrs_repr = []
- if attrs is None:
- attrs = params.keys()
- for attr in attrs:
- display = False
- if attr in overrides:
- value = overrides[attr]
- elif hasattr(obj, attr):
- value = getattr(obj, attr)
- else:
- continue
- if attr in params:
- param = params[attr]
- if param.default is inspect._empty or value != param.default:
- display = True
- else:
- display = True
-
- if display:
- attrs_repr.append(f"{attr}={value}")
- return f"{obj.__class__.__name__}({','.join(attrs_repr)})"
diff --git a/spaces/MCkernick/Image_Restoration_Colorization/Face_Enhancement/models/networks/Synchronized-BatchNorm-PyTorch/sync_batchnorm/__init__.py b/spaces/MCkernick/Image_Restoration_Colorization/Face_Enhancement/models/networks/Synchronized-BatchNorm-PyTorch/sync_batchnorm/__init__.py
deleted file mode 100644
index 6d9b36c74b1808b56ded68cf080a689db7e0ee4e..0000000000000000000000000000000000000000
--- a/spaces/MCkernick/Image_Restoration_Colorization/Face_Enhancement/models/networks/Synchronized-BatchNorm-PyTorch/sync_batchnorm/__init__.py
+++ /dev/null
@@ -1,14 +0,0 @@
-# -*- coding: utf-8 -*-
-# File : __init__.py
-# Author : Jiayuan Mao
-# Email : maojiayuan@gmail.com
-# Date : 27/01/2018
-#
-# This file is part of Synchronized-BatchNorm-PyTorch.
-# https://github.com/vacancy/Synchronized-BatchNorm-PyTorch
-# Distributed under MIT License.
-
-from .batchnorm import set_sbn_eps_mode
-from .batchnorm import SynchronizedBatchNorm1d, SynchronizedBatchNorm2d, SynchronizedBatchNorm3d
-from .batchnorm import patch_sync_batchnorm, convert_model
-from .replicate import DataParallelWithCallback, patch_replication_callback
diff --git a/spaces/MVV/3dTopDenoising/models/SAP/dpsr.py b/spaces/MVV/3dTopDenoising/models/SAP/dpsr.py
deleted file mode 100644
index 25f0ddb3bfb1ac3565b47b330761c498ddb72317..0000000000000000000000000000000000000000
--- a/spaces/MVV/3dTopDenoising/models/SAP/dpsr.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import torch
-import torch.nn as nn
-from .utils import spec_gaussian_filter, fftfreqs, img, grid_interp, point_rasterize
-import numpy as np
-import torch.fft
-
-class DPSR(nn.Module):
- def __init__(self, res, sig=10, scale=True, shift=True):
- """
- :param res: tuple of output field resolution. eg., (128,128)
- :param sig: degree of gaussian smoothing
- """
- super(DPSR, self).__init__()
- self.res = res
- self.sig = sig
- self.dim = len(res)
- self.denom = np.prod(res)
- G = spec_gaussian_filter(res=res, sig=sig).float()
- # self.G.requires_grad = False # True, if we also make sig a learnable parameter
- self.omega = fftfreqs(res, dtype=torch.float32)
- self.scale = scale
- self.shift = shift
- self.register_buffer("G", G)
-
- def forward(self, V, N):
- """
- :param V: (batch, nv, 2 or 3) tensor for point cloud coordinates
- :param N: (batch, nv, 2 or 3) tensor for point normals
- :return phi: (batch, res, res, ...) tensor of output indicator function field
- """
- assert(V.shape == N.shape) # [b, nv, ndims]
- ras_p = point_rasterize(V, N, self.res) # [b, n_dim, dim0, dim1, dim2]
-
- ras_s = torch.fft.rfftn(ras_p, dim=(2,3,4))
- ras_s = ras_s.permute(*tuple([0]+list(range(2, self.dim+1))+[self.dim+1, 1]))
- N_ = ras_s[..., None] * self.G # [b, dim0, dim1, dim2/2+1, n_dim, 1]
-
- omega = fftfreqs(self.res, dtype=torch.float32).unsqueeze(-1) # [dim0, dim1, dim2/2+1, n_dim, 1]
- omega *= 2 * np.pi # normalize frequencies
- omega = omega.to(V.device)
-
- DivN = torch.sum(-img(torch.view_as_real(N_[..., 0])) * omega, dim=-2)
-
- Lap = -torch.sum(omega**2, -2) # [dim0, dim1, dim2/2+1, 1]
- Phi = DivN / (Lap+1e-6) # [b, dim0, dim1, dim2/2+1, 2]
- Phi = Phi.permute(*tuple([list(range(1,self.dim+2)) + [0]])) # [dim0, dim1, dim2/2+1, 2, b]
- Phi[tuple([0] * self.dim)] = 0
- Phi = Phi.permute(*tuple([[self.dim+1] + list(range(self.dim+1))])) # [b, dim0, dim1, dim2/2+1, 2]
-
- phi = torch.fft.irfftn(torch.view_as_complex(Phi), s=self.res, dim=(1,2,3))
-
- if self.shift or self.scale:
- # ensure values at points are zero
- fv = grid_interp(phi.unsqueeze(-1), V, batched=True).squeeze(-1) # [b, nv]
- if self.shift: # offset points to have mean of 0
- offset = torch.mean(fv, dim=-1) # [b,]
- phi -= offset.view(*tuple([-1] + [1] * self.dim))
-
- phi = phi.permute(*tuple([list(range(1,self.dim+1)) + [0]]))
- fv0 = phi[tuple([0] * self.dim)] # [b,]
- phi = phi.permute(*tuple([[self.dim] + list(range(self.dim))]))
-
- if self.scale:
- phi = -phi / torch.abs(fv0.view(*tuple([-1]+[1] * self.dim))) *0.5
- return phi
\ No newline at end of file
diff --git a/spaces/Maharani/stock_prediction/setup.sh b/spaces/Maharani/stock_prediction/setup.sh
deleted file mode 100644
index c8650a8b74a58d9a5f53b185fd711c5668e1cd52..0000000000000000000000000000000000000000
--- a/spaces/Maharani/stock_prediction/setup.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-mkdir -p ~/.streamlit/
-
-echo "\
-[general]\n\
-email = \"your-email@domain.com\"\n\
-" > ~/.streamlit/credentials.toml
-
-echo "\
-[server]\n\
-headless = true\n\
-enableCORS=false\n\
-port = $PORT\n\
-" > ~/.streamlit/config.toml
\ No newline at end of file
diff --git a/spaces/Mahiruoshi/BangDream-Bert-VITS2/data_utils.py b/spaces/Mahiruoshi/BangDream-Bert-VITS2/data_utils.py
deleted file mode 100644
index d8e6b9e30b90839644e8a2c33c5166288b720d02..0000000000000000000000000000000000000000
--- a/spaces/Mahiruoshi/BangDream-Bert-VITS2/data_utils.py
+++ /dev/null
@@ -1,406 +0,0 @@
-import os
-import random
-import torch
-import torch.utils.data
-from tqdm import tqdm
-from loguru import logger
-import commons
-from mel_processing import spectrogram_torch, mel_spectrogram_torch
-from utils import load_wav_to_torch, load_filepaths_and_text
-from text import cleaned_text_to_sequence, get_bert
-
-"""Multi speaker version"""
-
-
-class TextAudioSpeakerLoader(torch.utils.data.Dataset):
- """
- 1) loads audio, speaker_id, text pairs
- 2) normalizes text and converts them to sequences of integers
- 3) computes spectrograms from audio files.
- """
-
- def __init__(self, audiopaths_sid_text, hparams):
- self.audiopaths_sid_text = load_filepaths_and_text(audiopaths_sid_text)
- self.max_wav_value = hparams.max_wav_value
- self.sampling_rate = hparams.sampling_rate
- self.filter_length = hparams.filter_length
- self.hop_length = hparams.hop_length
- self.win_length = hparams.win_length
- self.sampling_rate = hparams.sampling_rate
- self.spk_map = hparams.spk2id
- self.hparams = hparams
-
- self.use_mel_spec_posterior = getattr(
- hparams, "use_mel_posterior_encoder", False
- )
- if self.use_mel_spec_posterior:
- self.n_mel_channels = getattr(hparams, "n_mel_channels", 80)
-
- self.cleaned_text = getattr(hparams, "cleaned_text", False)
-
- self.add_blank = hparams.add_blank
- self.min_text_len = getattr(hparams, "min_text_len", 1)
- self.max_text_len = getattr(hparams, "max_text_len", 300)
-
- random.seed(1234)
- random.shuffle(self.audiopaths_sid_text)
- self._filter()
-
- def _filter(self):
- """
- Filter text & store spec lengths
- """
- # Store spectrogram lengths for Bucketing
- # wav_length ~= file_size / (wav_channels * Bytes per dim) = file_size / (1 * 2)
- # spec_length = wav_length // hop_length
-
- audiopaths_sid_text_new = []
- lengths = []
- skipped = 0
- logger.info("Init dataset...")
- for _id, spk, language, text, phones, tone, word2ph in tqdm(
- self.audiopaths_sid_text
- ):
- audiopath = f"{_id}"
- if self.min_text_len <= len(phones) and len(phones) <= self.max_text_len:
- phones = phones.split(" ")
- tone = [int(i) for i in tone.split(" ")]
- word2ph = [int(i) for i in word2ph.split(" ")]
- audiopaths_sid_text_new.append(
- [audiopath, spk, language, text, phones, tone, word2ph]
- )
- lengths.append(os.path.getsize(audiopath) // (2 * self.hop_length))
- else:
- skipped += 1
- logger.info(
- "skipped: "
- + str(skipped)
- + ", total: "
- + str(len(self.audiopaths_sid_text))
- )
- self.audiopaths_sid_text = audiopaths_sid_text_new
- self.lengths = lengths
-
- def get_audio_text_speaker_pair(self, audiopath_sid_text):
- # separate filename, speaker_id and text
- audiopath, sid, language, text, phones, tone, word2ph = audiopath_sid_text
-
- bert, ja_bert, phones, tone, language = self.get_text(
- text, word2ph, phones, tone, language, audiopath
- )
-
- spec, wav = self.get_audio(audiopath)
- sid = torch.LongTensor([int(self.spk_map[sid])])
- return (phones, spec, wav, sid, tone, language, bert, ja_bert)
-
- def get_audio(self, filename):
- audio, sampling_rate = load_wav_to_torch(filename)
- if sampling_rate != self.sampling_rate:
- raise ValueError(
- "{} {} SR doesn't match target {} SR".format(
- filename, sampling_rate, self.sampling_rate
- )
- )
- audio_norm = audio / self.max_wav_value
- audio_norm = audio_norm.unsqueeze(0)
- spec_filename = filename.replace(".wav", ".spec.pt")
- if self.use_mel_spec_posterior:
- spec_filename = spec_filename.replace(".spec.pt", ".mel.pt")
- try:
- spec = torch.load(spec_filename)
- except:
- if self.use_mel_spec_posterior:
- spec = mel_spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.n_mel_channels,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- self.hparams.mel_fmin,
- self.hparams.mel_fmax,
- center=False,
- )
- else:
- spec = spectrogram_torch(
- audio_norm,
- self.filter_length,
- self.sampling_rate,
- self.hop_length,
- self.win_length,
- center=False,
- )
- spec = torch.squeeze(spec, 0)
- torch.save(spec, spec_filename)
- return spec, audio_norm
-
- def get_text(self, text, word2ph, phone, tone, language_str, wav_path):
- phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
- if self.add_blank:
- phone = commons.intersperse(phone, 0)
- tone = commons.intersperse(tone, 0)
- language = commons.intersperse(language, 0)
- for i in range(len(word2ph)):
- word2ph[i] = word2ph[i] * 2
- word2ph[0] += 1
- bert_path = wav_path.replace(".wav", ".bert.pt")
- try:
- bert = torch.load(bert_path)
- assert bert.shape[-1] == len(phone)
- except:
- bert = get_bert(text, word2ph, language_str)
- torch.save(bert, bert_path)
- assert bert.shape[-1] == len(phone), phone
-
- if language_str == "ZH":
- bert = bert
- ja_bert = torch.zeros(768, len(phone))
- elif language_str == "JP":
- ja_bert = bert
- bert = torch.zeros(1024, len(phone))
- else:
- bert = torch.zeros(1024, len(phone))
- ja_bert = torch.zeros(768, len(phone))
- assert bert.shape[-1] == len(phone), (
- bert.shape,
- len(phone),
- sum(word2ph),
- p1,
- p2,
- t1,
- t2,
- pold,
- pold2,
- word2ph,
- text,
- w2pho,
- )
- phone = torch.LongTensor(phone)
- tone = torch.LongTensor(tone)
- language = torch.LongTensor(language)
- return bert, ja_bert, phone, tone, language
-
- def get_sid(self, sid):
- sid = torch.LongTensor([int(sid)])
- return sid
-
- def __getitem__(self, index):
- return self.get_audio_text_speaker_pair(self.audiopaths_sid_text[index])
-
- def __len__(self):
- return len(self.audiopaths_sid_text)
-
-
-class TextAudioSpeakerCollate:
- """Zero-pads model inputs and targets"""
-
- def __init__(self, return_ids=False):
- self.return_ids = return_ids
-
- def __call__(self, batch):
- """Collate's training batch from normalized text, audio and speaker identities
- PARAMS
- ------
- batch: [text_normalized, spec_normalized, wav_normalized, sid]
- """
- # Right zero-pad all one-hot text sequences to max input length
- _, ids_sorted_decreasing = torch.sort(
- torch.LongTensor([x[1].size(1) for x in batch]), dim=0, descending=True
- )
-
- max_text_len = max([len(x[0]) for x in batch])
- max_spec_len = max([x[1].size(1) for x in batch])
- max_wav_len = max([x[2].size(1) for x in batch])
-
- text_lengths = torch.LongTensor(len(batch))
- spec_lengths = torch.LongTensor(len(batch))
- wav_lengths = torch.LongTensor(len(batch))
- sid = torch.LongTensor(len(batch))
-
- text_padded = torch.LongTensor(len(batch), max_text_len)
- tone_padded = torch.LongTensor(len(batch), max_text_len)
- language_padded = torch.LongTensor(len(batch), max_text_len)
- bert_padded = torch.FloatTensor(len(batch), 1024, max_text_len)
- ja_bert_padded = torch.FloatTensor(len(batch), 768, max_text_len)
-
- spec_padded = torch.FloatTensor(len(batch), batch[0][1].size(0), max_spec_len)
- wav_padded = torch.FloatTensor(len(batch), 1, max_wav_len)
- text_padded.zero_()
- tone_padded.zero_()
- language_padded.zero_()
- spec_padded.zero_()
- wav_padded.zero_()
- bert_padded.zero_()
- ja_bert_padded.zero_()
- for i in range(len(ids_sorted_decreasing)):
- row = batch[ids_sorted_decreasing[i]]
-
- text = row[0]
- text_padded[i, : text.size(0)] = text
- text_lengths[i] = text.size(0)
-
- spec = row[1]
- spec_padded[i, :, : spec.size(1)] = spec
- spec_lengths[i] = spec.size(1)
-
- wav = row[2]
- wav_padded[i, :, : wav.size(1)] = wav
- wav_lengths[i] = wav.size(1)
-
- sid[i] = row[3]
-
- tone = row[4]
- tone_padded[i, : tone.size(0)] = tone
-
- language = row[5]
- language_padded[i, : language.size(0)] = language
-
- bert = row[6]
- bert_padded[i, :, : bert.size(1)] = bert
-
- ja_bert = row[7]
- ja_bert_padded[i, :, : ja_bert.size(1)] = ja_bert
-
- return (
- text_padded,
- text_lengths,
- spec_padded,
- spec_lengths,
- wav_padded,
- wav_lengths,
- sid,
- tone_padded,
- language_padded,
- bert_padded,
- ja_bert_padded,
- )
-
-
-class DistributedBucketSampler(torch.utils.data.distributed.DistributedSampler):
- """
- Maintain similar input lengths in a batch.
- Length groups are specified by boundaries.
- Ex) boundaries = [b1, b2, b3] -> any batch is included either {x | b1 < length(x) <=b2} or {x | b2 < length(x) <= b3}.
-
- It removes samples which are not included in the boundaries.
- Ex) boundaries = [b1, b2, b3] -> any x s.t. length(x) <= b1 or length(x) > b3 are discarded.
- """
-
- def __init__(
- self,
- dataset,
- batch_size,
- boundaries,
- num_replicas=None,
- rank=None,
- shuffle=True,
- ):
- super().__init__(dataset, num_replicas=num_replicas, rank=rank, shuffle=shuffle)
- self.lengths = dataset.lengths
- self.batch_size = batch_size
- self.boundaries = boundaries
-
- self.buckets, self.num_samples_per_bucket = self._create_buckets()
- self.total_size = sum(self.num_samples_per_bucket)
- self.num_samples = self.total_size // self.num_replicas
-
- def _create_buckets(self):
- buckets = [[] for _ in range(len(self.boundaries) - 1)]
- for i in range(len(self.lengths)):
- length = self.lengths[i]
- idx_bucket = self._bisect(length)
- if idx_bucket != -1:
- buckets[idx_bucket].append(i)
-
- try:
- for i in range(len(buckets) - 1, 0, -1):
- if len(buckets[i]) == 0:
- buckets.pop(i)
- self.boundaries.pop(i + 1)
- assert all(len(bucket) > 0 for bucket in buckets)
- # When one bucket is not traversed
- except Exception as e:
- print("Bucket warning ", e)
- for i in range(len(buckets) - 1, -1, -1):
- if len(buckets[i]) == 0:
- buckets.pop(i)
- self.boundaries.pop(i + 1)
-
- num_samples_per_bucket = []
- for i in range(len(buckets)):
- len_bucket = len(buckets[i])
- total_batch_size = self.num_replicas * self.batch_size
- rem = (
- total_batch_size - (len_bucket % total_batch_size)
- ) % total_batch_size
- num_samples_per_bucket.append(len_bucket + rem)
- return buckets, num_samples_per_bucket
-
- def __iter__(self):
- # deterministically shuffle based on epoch
- g = torch.Generator()
- g.manual_seed(self.epoch)
-
- indices = []
- if self.shuffle:
- for bucket in self.buckets:
- indices.append(torch.randperm(len(bucket), generator=g).tolist())
- else:
- for bucket in self.buckets:
- indices.append(list(range(len(bucket))))
-
- batches = []
- for i in range(len(self.buckets)):
- bucket = self.buckets[i]
- len_bucket = len(bucket)
- if len_bucket == 0:
- continue
- ids_bucket = indices[i]
- num_samples_bucket = self.num_samples_per_bucket[i]
-
- # add extra samples to make it evenly divisible
- rem = num_samples_bucket - len_bucket
- ids_bucket = (
- ids_bucket
- + ids_bucket * (rem // len_bucket)
- + ids_bucket[: (rem % len_bucket)]
- )
-
- # subsample
- ids_bucket = ids_bucket[self.rank :: self.num_replicas]
-
- # batching
- for j in range(len(ids_bucket) // self.batch_size):
- batch = [
- bucket[idx]
- for idx in ids_bucket[
- j * self.batch_size : (j + 1) * self.batch_size
- ]
- ]
- batches.append(batch)
-
- if self.shuffle:
- batch_ids = torch.randperm(len(batches), generator=g).tolist()
- batches = [batches[i] for i in batch_ids]
- self.batches = batches
-
- assert len(self.batches) * self.batch_size == self.num_samples
- return iter(self.batches)
-
- def _bisect(self, x, lo=0, hi=None):
- if hi is None:
- hi = len(self.boundaries) - 1
-
- if hi > lo:
- mid = (hi + lo) // 2
- if self.boundaries[mid] < x and x <= self.boundaries[mid + 1]:
- return mid
- elif x <= self.boundaries[mid]:
- return self._bisect(x, lo, mid)
- else:
- return self._bisect(x, mid + 1, hi)
- else:
- return -1
-
- def __len__(self):
- return self.num_samples // self.batch_size
diff --git a/spaces/MathysL/AutoGPT4/run.bat b/spaces/MathysL/AutoGPT4/run.bat
deleted file mode 100644
index afbab57a0603a126b04845ec754d1ecf3fdea18d..0000000000000000000000000000000000000000
--- a/spaces/MathysL/AutoGPT4/run.bat
+++ /dev/null
@@ -1,8 +0,0 @@
-@echo off
-python scripts/check_requirements.py requirements.txt
-if errorlevel 1 (
- echo Installing missing packages...
- pip install -r requirements.txt
-)
-python -m autogpt %*
-pause
diff --git a/spaces/Mikey211/GUI2/README.md b/spaces/Mikey211/GUI2/README.md
deleted file mode 100644
index 53205f002eb23977d75bd6037138942c97032f8e..0000000000000000000000000000000000000000
--- a/spaces/Mikey211/GUI2/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: GUI2
-emoji: 📊
-colorFrom: blue
-colorTo: green
-sdk: gradio
-sdk_version: 3.16.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/utils.py b/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/utils.py
deleted file mode 100644
index 9c93c996d3cc73c30d71c1fc47056e4230f35c0f..0000000000000000000000000000000000000000
--- a/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/utils.py
+++ /dev/null
@@ -1,68 +0,0 @@
-import glob
-import os
-import matplotlib
-import torch
-from torch.nn.utils import weight_norm
-# matplotlib.use("Agg")
-import matplotlib.pylab as plt
-
-
-def plot_spectrogram(spectrogram):
- fig, ax = plt.subplots(figsize=(10, 2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower",
- interpolation='none')
- plt.colorbar(im, ax=ax)
-
- fig.canvas.draw()
- plt.close()
-
- return fig
-
-
-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 apply_weight_norm(m):
- classname = m.__class__.__name__
- if classname.find("Conv") != -1:
- weight_norm(m)
-
-
-def get_padding(kernel_size, dilation=1):
- return int((kernel_size*dilation - dilation)/2)
-
-
-def load_checkpoint(filepath, device):
- assert os.path.isfile(filepath)
- print("Loading '{}'".format(filepath))
- checkpoint_dict = torch.load(filepath, map_location=device)
- print("Complete.")
- return checkpoint_dict
-
-
-def save_checkpoint(filepath, obj):
- print("Saving checkpoint to {}".format(filepath))
- torch.save(obj, filepath)
- print("Complete.")
-
-
-def del_old_checkpoints(cp_dir, prefix, n_models=2):
- pattern = os.path.join(cp_dir, prefix + '????????')
- cp_list = glob.glob(pattern) # get checkpoint paths
- cp_list = sorted(cp_list)# sort by iter
- if len(cp_list) > n_models: # if more than n_models models are found
- for cp in cp_list[:-n_models]:# delete the oldest models other than lastest n_models
- open(cp, 'w').close()# empty file contents
- os.unlink(cp)# delete file (move to trash when using Colab)
-
-
-def scan_checkpoint(cp_dir, prefix):
- pattern = os.path.join(cp_dir, prefix + '????????')
- cp_list = glob.glob(pattern)
- if len(cp_list) == 0:
- return None
- return sorted(cp_list)[-1]
-
diff --git a/spaces/Mountchicken/MAERec-Gradio/mmocr/utils/polygon_utils.py b/spaces/Mountchicken/MAERec-Gradio/mmocr/utils/polygon_utils.py
deleted file mode 100644
index 805404a6f49cdc26129cdad4197bab28a4da5556..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/mmocr/utils/polygon_utils.py
+++ /dev/null
@@ -1,457 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import math
-import operator
-from functools import reduce
-from typing import List, Optional, Sequence, Tuple, Union
-
-import numpy as np
-import pyclipper
-import shapely
-from mmengine.utils import is_list_of
-from shapely.geometry import MultiPolygon, Polygon
-
-from mmocr.utils import bbox2poly, valid_boundary
-from mmocr.utils.check_argument import is_2dlist
-from mmocr.utils.typing_utils import ArrayLike
-
-
-def rescale_polygon(polygon: ArrayLike,
- scale_factor: Tuple[int, int],
- mode: str = 'mul') -> np.ndarray:
- """Rescale a polygon according to scale_factor.
-
- The behavior is different depending on the mode. When mode is 'mul', the
- coordinates will be multiplied by scale_factor, which is usually used in
- preprocessing transforms such as :func:`Resize`.
- The coordinates will be divided by scale_factor if mode is 'div'. It can be
- used in postprocessors to recover the polygon in the original
- image size.
-
- Args:
- polygon (ArrayLike): A polygon. In any form can be converted
- to an 1-D numpy array. E.g. list[float], np.ndarray,
- or torch.Tensor. Polygon is written in
- [x1, y1, x2, y2, ...].
- scale_factor (tuple(int, int)): (w_scale, h_scale).
- model (str): Rescale mode. Can be 'mul' or 'div'. Defaults to 'mul'.
-
- Returns:
- np.ndarray: Rescaled polygon.
- """
- assert len(polygon) % 2 == 0
- assert mode in ['mul', 'div']
- polygon = np.array(polygon, dtype=np.float32)
- poly_shape = polygon.shape
- reshape_polygon = polygon.reshape(-1, 2)
- scale_factor = np.array(scale_factor, dtype=float)
- if mode == 'div':
- scale_factor = 1 / scale_factor
- polygon = (reshape_polygon * scale_factor[None]).reshape(poly_shape)
- return polygon
-
-
-def rescale_polygons(polygons: Union[ArrayLike, Sequence[ArrayLike]],
- scale_factor: Tuple[int, int],
- mode: str = 'mul'
- ) -> Union[ArrayLike, Sequence[np.ndarray]]:
- """Rescale polygons according to scale_factor.
-
- The behavior is different depending on the mode. When mode is 'mul', the
- coordinates will be multiplied by scale_factor, which is usually used in
- preprocessing transforms such as :func:`Resize`.
- The coordinates will be divided by scale_factor if mode is 'div'. It can be
- used in postprocessors to recover the polygon in the original
- image size.
-
- Args:
- polygons (list[ArrayLike] or ArrayLike): A list of polygons, each
- written in [x1, y1, x2, y2, ...] and in any form can be converted
- to an 1-D numpy array. E.g. list[list[float]],
- list[np.ndarray], or list[torch.Tensor].
- scale_factor (tuple(int, int)): (w_scale, h_scale).
- model (str): Rescale mode. Can be 'mul' or 'div'. Defaults to 'mul'.
-
- Returns:
- list[np.ndarray] or np.ndarray: Rescaled polygons. The type of the
- return value depends on the type of the input polygons.
- """
- results = []
- for polygon in polygons:
- results.append(rescale_polygon(polygon, scale_factor, mode))
- if isinstance(polygons, np.ndarray):
- results = np.array(results)
- return results
-
-
-def poly2bbox(polygon: ArrayLike) -> np.array:
- """Converting a polygon to a bounding box.
-
- Args:
- polygon (ArrayLike): A polygon. In any form can be converted
- to an 1-D numpy array. E.g. list[float], np.ndarray,
- or torch.Tensor. Polygon is written in
- [x1, y1, x2, y2, ...].
-
- Returns:
- np.array: The converted bounding box [x1, y1, x2, y2]
- """
- assert len(polygon) % 2 == 0
- polygon = np.array(polygon, dtype=np.float32)
- x = polygon[::2]
- y = polygon[1::2]
- return np.array([min(x), min(y), max(x), max(y)])
-
-
-def poly2shapely(polygon: ArrayLike) -> Polygon:
- """Convert a polygon to shapely.geometry.Polygon.
-
- Args:
- polygon (ArrayLike): A set of points of 2k shape.
-
- Returns:
- polygon (Polygon): A polygon object.
- """
- polygon = np.array(polygon, dtype=np.float32)
- assert polygon.size % 2 == 0 and polygon.size >= 6
-
- polygon = polygon.reshape([-1, 2])
- return Polygon(polygon)
-
-
-def polys2shapely(polygons: Sequence[ArrayLike]) -> Sequence[Polygon]:
- """Convert a nested list of boundaries to a list of Polygons.
-
- Args:
- polygons (list): The point coordinates of the instance boundary.
-
- Returns:
- list: Converted shapely.Polygon.
- """
- return [poly2shapely(polygon) for polygon in polygons]
-
-
-def shapely2poly(polygon: Polygon) -> np.array:
- """Convert a nested list of boundaries to a list of Polygons.
-
- Args:
- polygon (Polygon): A polygon represented by shapely.Polygon.
-
- Returns:
- np.array: Converted numpy array
- """
- return np.array(polygon.exterior.coords).reshape(-1, )
-
-
-def crop_polygon(polygon: ArrayLike,
- crop_box: np.ndarray) -> Union[np.ndarray, None]:
- """Crop polygon to be within a box region.
-
- Args:
- polygon (ndarray): polygon in shape (N, ).
- crop_box (ndarray): target box region in shape (4, ).
-
- Returns:
- np.array or None: Cropped polygon. If the polygon is not within the
- crop box, return None.
- """
- poly = poly_make_valid(poly2shapely(polygon))
- crop_poly = poly_make_valid(poly2shapely(bbox2poly(crop_box)))
- area, poly_cropped = poly_intersection(poly, crop_poly, return_poly=True)
- if area == 0 or area is None or not isinstance(
- poly_cropped, shapely.geometry.polygon.Polygon):
- return None
- else:
- poly_cropped = poly_make_valid(poly_cropped)
- poly_cropped = np.array(poly_cropped.boundary.xy, dtype=np.float32)
- poly_cropped = poly_cropped.T
- # reverse poly_cropped to have clockwise order
- poly_cropped = poly_cropped[::-1, :].reshape(-1)
- return poly_cropped
-
-
-def poly_make_valid(poly: Polygon) -> Polygon:
- """Convert a potentially invalid polygon to a valid one by eliminating
- self-crossing or self-touching parts. Note that if the input is a line, the
- returned polygon could be an empty one.
-
- Args:
- poly (Polygon): A polygon needed to be converted.
-
- Returns:
- Polygon: A valid polygon, which might be empty.
- """
- assert isinstance(poly, Polygon)
- fixed_poly = poly if poly.is_valid else poly.buffer(0)
- # Sometimes the fixed_poly is still a MultiPolygon,
- # so we need to find the convex hull of the MultiPolygon, which should
- # always be a Polygon (but could be empty).
- if not isinstance(fixed_poly, Polygon):
- fixed_poly = fixed_poly.convex_hull
- return fixed_poly
-
-
-def poly_intersection(poly_a: Polygon,
- poly_b: Polygon,
- invalid_ret: Optional[Union[float, int]] = None,
- return_poly: bool = False
- ) -> Tuple[float, Optional[Polygon]]:
- """Calculate the intersection area between two polygons.
-
- Args:
- poly_a (Polygon): Polygon a.
- poly_b (Polygon): Polygon b.
- invalid_ret (float or int, optional): The return value when the
- invalid polygon exists. If it is not specified, the function
- allows the computation to proceed with invalid polygons by
- cleaning the their self-touching or self-crossing parts.
- Defaults to None.
- return_poly (bool): Whether to return the polygon of the intersection
- Defaults to False.
-
- Returns:
- float or tuple(float, Polygon): Returns the intersection area or
- a tuple ``(area, Optional[poly_obj])``, where the `area` is the
- intersection area between two polygons and `poly_obj` is The Polygon
- object of the intersection area, which will be `None` if the input is
- invalid. `poly_obj` will be returned only if `return_poly` is `True`.
- """
- assert isinstance(poly_a, Polygon)
- assert isinstance(poly_b, Polygon)
- assert invalid_ret is None or isinstance(invalid_ret, (float, int))
-
- if invalid_ret is None:
- poly_a = poly_make_valid(poly_a)
- poly_b = poly_make_valid(poly_b)
-
- poly_obj = None
- area = invalid_ret
- if poly_a.is_valid and poly_b.is_valid:
- if poly_a.intersects(poly_b):
- poly_obj = poly_a.intersection(poly_b)
- area = poly_obj.area
- else:
- poly_obj = Polygon()
- area = 0.0
- return (area, poly_obj) if return_poly else area
-
-
-def poly_union(
- poly_a: Polygon,
- poly_b: Polygon,
- invalid_ret: Optional[Union[float, int]] = None,
- return_poly: bool = False
-) -> Tuple[float, Optional[Union[Polygon, MultiPolygon]]]:
- """Calculate the union area between two polygons.
-
- Args:
- poly_a (Polygon): Polygon a.
- poly_b (Polygon): Polygon b.
- invalid_ret (float or int, optional): The return value when the
- invalid polygon exists. If it is not specified, the function
- allows the computation to proceed with invalid polygons by
- cleaning the their self-touching or self-crossing parts.
- Defaults to False.
- return_poly (bool): Whether to return the polygon of the union.
- Defaults to False.
-
- Returns:
- tuple: Returns a tuple ``(area, Optional[poly_obj])``, where
- the `area` is the union between two polygons and `poly_obj` is the
- Polygon or MultiPolygon object of the union of the inputs. The type
- of object depends on whether they intersect or not. Set as `None`
- if the input is invalid. `poly_obj` will be returned only if
- `return_poly` is `True`.
- """
- assert isinstance(poly_a, Polygon)
- assert isinstance(poly_b, Polygon)
- assert invalid_ret is None or isinstance(invalid_ret, (float, int))
-
- if invalid_ret is None:
- poly_a = poly_make_valid(poly_a)
- poly_b = poly_make_valid(poly_b)
-
- poly_obj = None
- area = invalid_ret
- if poly_a.is_valid and poly_b.is_valid:
- poly_obj = poly_a.union(poly_b)
- area = poly_obj.area
- return (area, poly_obj) if return_poly else area
-
-
-def poly_iou(poly_a: Polygon,
- poly_b: Polygon,
- zero_division: float = 0.) -> float:
- """Calculate the IOU between two polygons.
-
- Args:
- poly_a (Polygon): Polygon a.
- poly_b (Polygon): Polygon b.
- zero_division (float): The return value when invalid polygon exists.
-
- Returns:
- float: The IoU between two polygons.
- """
- assert isinstance(poly_a, Polygon)
- assert isinstance(poly_b, Polygon)
- area_inters = poly_intersection(poly_a, poly_b)
- area_union = poly_union(poly_a, poly_b)
- return area_inters / area_union if area_union != 0 else zero_division
-
-
-def is_poly_inside_rect(poly: ArrayLike, rect: np.ndarray) -> bool:
- """Check if the polygon is inside the target region.
- Args:
- poly (ArrayLike): Polygon in shape (N, ).
- rect (ndarray): Target region [x1, y1, x2, y2].
-
- Returns:
- bool: Whether the polygon is inside the cropping region.
- """
-
- poly = poly2shapely(poly)
- rect = poly2shapely(bbox2poly(rect))
- return rect.contains(poly)
-
-
-def offset_polygon(poly: ArrayLike, distance: float) -> ArrayLike:
- """Offset (expand/shrink) the polygon by the target distance. It's a
- wrapper around pyclipper based on Vatti clipping algorithm.
-
- Warning:
- Polygon coordinates will be casted to int type in PyClipper. Mind the
- potential precision loss caused by the casting.
-
- Args:
- poly (ArrayLike): A polygon. In any form can be converted
- to an 1-D numpy array. E.g. list[float], np.ndarray,
- or torch.Tensor. Polygon is written in
- [x1, y1, x2, y2, ...].
- distance (float): The offset distance. Positive value means expanding,
- negative value means shrinking.
-
- Returns:
- np.array: 1-D Offsetted polygon ndarray in float32 type. If the
- result polygon is invalid or has been split into several parts,
- return an empty array.
- """
- poly = np.array(poly).reshape(-1, 2)
- pco = pyclipper.PyclipperOffset()
- pco.AddPath(poly, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON)
- # Returned result will be in type of int32, convert it back to float32
- # following MMOCR's convention
- result = np.array(pco.Execute(distance), dtype=object)
- if len(result) > 0 and isinstance(result[0], list):
- # The processed polygon has been split into several parts
- result = np.array([])
- result = result.astype(np.float32)
- # Always use the first polygon since only one polygon is expected
- # But when the resulting polygon is invalid, return the empty array
- # as it is
- return result if len(result) == 0 else result[0].flatten()
-
-
-def boundary_iou(src: List,
- target: List,
- zero_division: Union[int, float] = 0) -> float:
- """Calculate the IOU between two boundaries.
-
- Args:
- src (list): Source boundary.
- target (list): Target boundary.
- zero_division (int or float): The return value when invalid
- boundary exists.
-
- Returns:
- float: The iou between two boundaries.
- """
- assert valid_boundary(src, False)
- assert valid_boundary(target, False)
- src_poly = poly2shapely(src)
- target_poly = poly2shapely(target)
-
- return poly_iou(src_poly, target_poly, zero_division=zero_division)
-
-
-def sort_points(points):
- # TODO Add typehints & test & docstring
- """Sort arbitrary points in clockwise order in Cartesian coordinate, you
- may need to reverse the output sequence if you are using OpenCV's image
- coordinate.
-
- Reference:
- https://github.com/novioleo/Savior/blob/master/Utils/GeometryUtils.py.
-
- Warning: This function can only sort convex polygons.
-
- Args:
- points (list[ndarray] or ndarray or list[list]): A list of unsorted
- boundary points.
-
- Returns:
- list[ndarray]: A list of points sorted in clockwise order.
- """
- assert is_list_of(points, np.ndarray) or isinstance(points, np.ndarray) \
- or is_2dlist(points)
- center_point = tuple(
- map(operator.truediv,
- reduce(lambda x, y: map(operator.add, x, y), points),
- [len(points)] * 2))
- return sorted(
- points,
- key=lambda coord: (180 + math.degrees(
- math.atan2(*tuple(map(operator.sub, coord, center_point))))) % 360)
-
-
-def sort_vertex(points_x, points_y):
- # TODO Add typehints & test
- """Sort box vertices in clockwise order from left-top first.
-
- Args:
- points_x (list[float]): x of four vertices.
- points_y (list[float]): y of four vertices.
-
- Returns:
- tuple[list[float], list[float]]: Sorted x and y of four vertices.
-
- - sorted_points_x (list[float]): x of sorted four vertices.
- - sorted_points_y (list[float]): y of sorted four vertices.
- """
- assert is_list_of(points_x, (float, int))
- assert is_list_of(points_y, (float, int))
- assert len(points_x) == 4
- assert len(points_y) == 4
- vertices = np.stack((points_x, points_y), axis=-1).astype(np.float32)
- vertices = _sort_vertex(vertices)
- sorted_points_x = list(vertices[:, 0])
- sorted_points_y = list(vertices[:, 1])
- return sorted_points_x, sorted_points_y
-
-
-def _sort_vertex(vertices):
- # TODO Add typehints & docstring & test
- assert vertices.ndim == 2
- assert vertices.shape[-1] == 2
- N = vertices.shape[0]
- if N == 0:
- return vertices
-
- center = np.mean(vertices, axis=0)
- directions = vertices - center
- angles = np.arctan2(directions[:, 1], directions[:, 0])
- sort_idx = np.argsort(angles)
- vertices = vertices[sort_idx]
-
- left_top = np.min(vertices, axis=0)
- dists = np.linalg.norm(left_top - vertices, axis=-1, ord=2)
- lefttop_idx = np.argmin(dists)
- indexes = (np.arange(N, dtype=np.int_) + lefttop_idx) % N
- return vertices[indexes]
-
-
-def sort_vertex8(points):
- # TODO Add typehints & docstring & test
- """Sort vertex with 8 points [x1 y1 x2 y2 x3 y3 x4 y4]"""
- assert len(points) == 8
- vertices = _sort_vertex(np.array(points, dtype=np.float32).reshape(-1, 2))
- sorted_box = list(vertices.flatten())
- return sorted_box
diff --git a/spaces/MultiAgentSystems/MapAI-ClinicsAndMedCenters/README.md b/spaces/MultiAgentSystems/MapAI-ClinicsAndMedCenters/README.md
deleted file mode 100644
index a6730dc76af0ebd9158a5f3acfe91b9956ea9e4b..0000000000000000000000000000000000000000
--- a/spaces/MultiAgentSystems/MapAI-ClinicsAndMedCenters/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: MapAI ClinicsAndMedCenters
-emoji: 💻
-colorFrom: green
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.28.1
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/NATSpeech/DiffSpeech/data_gen/tts/runs/train_mfa_align.py b/spaces/NATSpeech/DiffSpeech/data_gen/tts/runs/train_mfa_align.py
deleted file mode 100644
index daaeebe57690a8032be3d15c05d71701211604a7..0000000000000000000000000000000000000000
--- a/spaces/NATSpeech/DiffSpeech/data_gen/tts/runs/train_mfa_align.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import utils.commons.single_thread_env # NOQA
-import glob
-import subprocess
-from textgrid import TextGrid
-import os
-from utils.commons.hparams import hparams, set_hparams
-
-
-def train_mfa_align(mfa_outputs="mfa_outputs",
- mfa_inputs="mfa_inputs",
- model_name=None, pretrain_model_name=None,
- mfa_cmd='train'):
- CORPUS = hparams['processed_data_dir'].split("/")[-1]
- NUM_JOB = int(os.getenv('N_PROC', os.cpu_count()))
- env_vars = [f'CORPUS={CORPUS}', f'NUM_JOB={NUM_JOB}']
- if mfa_outputs is not None:
- env_vars.append(f'MFA_OUTPUTS={mfa_outputs}')
- if mfa_inputs is not None:
- env_vars.append(f'MFA_INPUTS={mfa_inputs}')
- if model_name is not None:
- env_vars.append(f'MODEL_NAME={model_name}')
- if pretrain_model_name is not None:
- env_vars.append(f'PRETRAIN_MODEL_NAME={pretrain_model_name}')
- if mfa_cmd is not None:
- env_vars.append(f'MFA_CMD={mfa_cmd}')
- env_str = ' '.join(env_vars)
- print(f"| Run MFA for {CORPUS}. Env vars: {env_str}")
- subprocess.check_call(f'{env_str} bash mfa_usr/run_mfa_train_align.sh', shell=True)
- mfa_offset = hparams['preprocess_args']['mfa_offset']
- if mfa_offset > 0:
- for tg_fn in glob.glob(f'{hparams["processed_data_dir"]}/{mfa_outputs}/*.TextGrid'):
- tg = TextGrid.fromFile(tg_fn)
- max_time = tg.maxTime
- for tier in tg.tiers:
- for interval in tier.intervals:
- interval.maxTime = min(interval.maxTime + mfa_offset, max_time)
- interval.minTime = min(interval.minTime + mfa_offset, max_time)
- tier.intervals[0].minTime = 0
- tier.maxTime = min(tier.maxTime + mfa_offset, max_time)
- tg.write(tg_fn)
- TextGrid.fromFile(tg_fn)
-
-
-if __name__ == '__main__':
- set_hparams(print_hparams=False)
- train_mfa_align()
diff --git a/spaces/NCTCMumbai/NCTC/models/research/attention_ocr/python/metrics_test.py b/spaces/NCTCMumbai/NCTC/models/research/attention_ocr/python/metrics_test.py
deleted file mode 100644
index 5560ec2c898fe7674715ec54daa08ba9e7471adf..0000000000000000000000000000000000000000
--- a/spaces/NCTCMumbai/NCTC/models/research/attention_ocr/python/metrics_test.py
+++ /dev/null
@@ -1,97 +0,0 @@
-# Copyright 2017 The TensorFlow Authors All Rights Reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-# ==============================================================================
-
-"""Tests for the metrics module."""
-import contextlib
-import numpy as np
-import tensorflow as tf
-
-import metrics
-
-
-class AccuracyTest(tf.test.TestCase):
- def setUp(self):
- tf.test.TestCase.setUp(self)
- self.rng = np.random.RandomState([11, 23, 50])
- self.num_char_classes = 3
- self.batch_size = 4
- self.seq_length = 5
- self.rej_char = 42
-
- @contextlib.contextmanager
- def initialized_session(self):
- """Wrapper for test session context manager with required initialization.
-
- Yields:
- A session object that should be used as a context manager.
- """
- with self.cached_session() as sess:
- sess.run(tf.global_variables_initializer())
- sess.run(tf.local_variables_initializer())
- yield sess
-
- def _fake_labels(self):
- return self.rng.randint(
- low=0,
- high=self.num_char_classes,
- size=(self.batch_size, self.seq_length),
- dtype='int32')
-
- def _incorrect_copy(self, values, bad_indexes):
- incorrect = np.copy(values)
- incorrect[bad_indexes] = values[bad_indexes] + 1
- return incorrect
-
- def test_sequence_accuracy_identical_samples(self):
- labels_tf = tf.convert_to_tensor(self._fake_labels())
-
- accuracy_tf = metrics.sequence_accuracy(labels_tf, labels_tf,
- self.rej_char)
- with self.initialized_session() as sess:
- accuracy_np = sess.run(accuracy_tf)
-
- self.assertAlmostEqual(accuracy_np, 1.0)
-
- def test_sequence_accuracy_one_char_difference(self):
- ground_truth_np = self._fake_labels()
- ground_truth_tf = tf.convert_to_tensor(ground_truth_np)
- prediction_tf = tf.convert_to_tensor(
- self._incorrect_copy(ground_truth_np, bad_indexes=((0, 0))))
-
- accuracy_tf = metrics.sequence_accuracy(prediction_tf, ground_truth_tf,
- self.rej_char)
- with self.initialized_session() as sess:
- accuracy_np = sess.run(accuracy_tf)
-
- # 1 of 4 sequences is incorrect.
- self.assertAlmostEqual(accuracy_np, 1.0 - 1.0 / self.batch_size)
-
- def test_char_accuracy_one_char_difference_with_padding(self):
- ground_truth_np = self._fake_labels()
- ground_truth_tf = tf.convert_to_tensor(ground_truth_np)
- prediction_tf = tf.convert_to_tensor(
- self._incorrect_copy(ground_truth_np, bad_indexes=((0, 0))))
-
- accuracy_tf = metrics.char_accuracy(prediction_tf, ground_truth_tf,
- self.rej_char)
- with self.initialized_session() as sess:
- accuracy_np = sess.run(accuracy_tf)
-
- chars_count = self.seq_length * self.batch_size
- self.assertAlmostEqual(accuracy_np, 1.0 - 1.0 / chars_count)
-
-
-if __name__ == '__main__':
- tf.test.main()
diff --git a/spaces/NotFungibleIO/Conversational-CSV/app.py b/spaces/NotFungibleIO/Conversational-CSV/app.py
deleted file mode 100644
index 3c41163d8d5ac9a5b2758644bce9b2a929313429..0000000000000000000000000000000000000000
--- a/spaces/NotFungibleIO/Conversational-CSV/app.py
+++ /dev/null
@@ -1,52 +0,0 @@
-import os
-os.system('pip install gradio==2.3.5b0')
-os.system('pip install torch-scatter -f https://pytorch-geometric.com/whl/torch-1.9.0+${CUDA}.html')
-
-
-import gradio as gr
-
-from transformers import pipeline
-
-import pandas as pd
-
-
-table = pd.DataFrame()
-tqa = pipeline(task="table-question-answering", model="google/tapas-base-finetuned-wtq")
-
-
-def chat(message):
- history = gr.get_state() or []
-
-
- global table
-
- if message.startswith('http'):
- table = pd.read_csv(message)
- table = table.astype(str)
- response = 'thank you for the dataset... now you can ask questions about it'
-
- elif table.empty:
- response = 'Hi! Please send a url of a dataset in csv format. Then ask as many questions as you want about it. If you want to talk about another dataset, just send a new link.'
-
- else:
- response = tqa(table=table, query=message)["answer"]
-
-
-
- history.append((message, response))
- gr.set_state(history)
- html = ""
-
- wrd_to_phn = {}
-
- with open(args.lexicon, "r") as lf:
- for line in lf:
- items = line.rstrip().split()
- assert len(items) > 1, line
- assert items[0] not in wrd_to_phn, items
- wrd_to_phn[items[0]] = items[1:]
-
- for line in sys.stdin:
- words = line.strip().split()
-
- if not all(w in wrd_to_phn for w in words):
- continue
-
- phones = []
- if surround:
- phones.append(sil)
-
- sample_sil_probs = None
- if sil_prob > 0 and len(words) > 1:
- sample_sil_probs = np.random.random(len(words) - 1)
-
- for i, w in enumerate(words):
- phones.extend(wrd_to_phn[w])
- if (
- sample_sil_probs is not None
- and i < len(sample_sil_probs)
- and sample_sil_probs[i] < sil_prob
- ):
- phones.append(sil)
-
- if surround:
- phones.append(sil)
- print(" ".join(phones))
-
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/hubert/hubert.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/hubert/hubert.py
deleted file mode 100644
index 232a5e402a146023e5c93f3c2574ecec98faf9d5..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/fairseq/models/hubert/hubert.py
+++ /dev/null
@@ -1,563 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import logging
-from typing import Dict, List, Optional, Tuple
-
-import numpy as np
-
-import torch
-import torch.nn as nn
-from dataclasses import dataclass, field
-from fairseq import utils
-from fairseq.data.data_utils import compute_mask_indices
-from fairseq.data.dictionary import Dictionary
-from fairseq.dataclass import ChoiceEnum, FairseqDataclass
-from fairseq.models import BaseFairseqModel, register_model
-from fairseq.models.wav2vec.wav2vec2 import (
- ConvFeatureExtractionModel,
- TransformerEncoder,
-)
-from fairseq.modules import GradMultiply, LayerNorm
-from fairseq.tasks.hubert_pretraining import (
- HubertPretrainingConfig,
- HubertPretrainingTask,
-)
-from omegaconf import II
-
-logger = logging.getLogger(__name__)
-
-EXTRACTOR_MODE_CHOICES = ChoiceEnum(["default", "layer_norm"])
-MASKING_DISTRIBUTION_CHOICES = ChoiceEnum(
- ["static", "uniform", "normal", "poisson"]
-)
-
-
-@dataclass
-class HubertConfig(FairseqDataclass):
- label_rate: int = II("task.label_rate")
-
- extractor_mode: EXTRACTOR_MODE_CHOICES = field(
- default="default",
- metadata={
- "help": "mode for feature extractor. default has a single group "
- "norm with d groups in the first conv block, whereas layer_norm "
- "has layer norms in every block (meant to use with normalize=True)"
- },
- )
- encoder_layers: int = field(
- default=12, metadata={"help": "num encoder layers in the transformer"}
- )
- encoder_embed_dim: int = field(
- default=768, metadata={"help": "encoder embedding dimension"}
- )
- encoder_ffn_embed_dim: int = field(
- default=3072, metadata={"help": "encoder embedding dimension for FFN"}
- )
- encoder_attention_heads: int = field(
- default=12, metadata={"help": "num encoder attention heads"}
- )
- activation_fn: ChoiceEnum(utils.get_available_activation_fns()) = field(
- default="gelu", metadata={"help": "activation function to use"}
- )
-
- # dropouts
- dropout: float = field(
- default=0.1,
- metadata={"help": "dropout probability for the transformer"},
- )
- attention_dropout: float = field(
- default=0.1,
- metadata={"help": "dropout probability for attention weights"},
- )
- activation_dropout: float = field(
- default=0.0,
- metadata={"help": "dropout probability after activation in FFN"},
- )
- encoder_layerdrop: float = field(
- default=0.0,
- metadata={"help": "probability of dropping a tarnsformer layer"},
- )
- dropout_input: float = field(
- default=0.0,
- metadata={"help": "dropout to apply to the input (after feat extr)"},
- )
- dropout_features: float = field(
- default=0.0,
- metadata={
- "help": "dropout to apply to the features (after feat extr)"
- },
- )
-
- final_dim: int = field(
- default=0,
- metadata={
- "help": "project final representations and targets to this many "
- "dimensions. set to encoder_embed_dim is <= 0"
- },
- )
- untie_final_proj: bool = field(
- default=False,
- metadata={"help": "use separate projection for each target"},
- )
- layer_norm_first: bool = field(
- default=False,
- metadata={"help": "apply layernorm first in the transformer"},
- )
- conv_feature_layers: str = field(
- default="[(512,10,5)] + [(512,3,2)] * 4 + [(512,2,2)] * 2",
- metadata={
- "help": "string describing convolutional feature extraction "
- "layers in form of a python list that contains "
- "[(dim, kernel_size, stride), ...]"
- },
- )
- conv_bias: bool = field(
- default=False, metadata={"help": "include bias in conv encoder"}
- )
- logit_temp: float = field(
- default=0.1, metadata={"help": "temperature to divide logits by"}
- )
- target_glu: bool = field(
- default=False, metadata={"help": "adds projection + glu to targets"}
- )
- feature_grad_mult: float = field(
- default=1.0,
- metadata={"help": "multiply feature extractor var grads by this"},
- )
-
- # masking
- mask_length: int = field(default=10, metadata={"help": "mask length"})
- mask_prob: float = field(
- default=0.65,
- metadata={"help": "probability of replacing a token with mask"},
- )
- mask_selection: MASKING_DISTRIBUTION_CHOICES = field(
- default="static", metadata={"help": "how to choose mask length"}
- )
- mask_other: float = field(
- default=0,
- metadata={
- "help": "secondary mask argument "
- "(used for more complex distributions), "
- "see help in compute_mask_indicesh"
- },
- )
- no_mask_overlap: bool = field(
- default=False, metadata={"help": "whether to allow masks to overlap"}
- )
- mask_min_space: int = field(
- default=1,
- metadata={
- "help": "min space between spans (if no overlap is enabled)"
- },
- )
-
- # channel masking
- mask_channel_length: int = field(
- default=10,
- metadata={"help": "length of the mask for features (channels)"},
- )
- mask_channel_prob: float = field(
- default=0.0,
- metadata={"help": "probability of replacing a feature with 0"},
- )
- mask_channel_selection: MASKING_DISTRIBUTION_CHOICES = field(
- default="static",
- metadata={"help": "how to choose mask length for channel masking"},
- )
- mask_channel_other: float = field(
- default=0,
- metadata={
- "help": "secondary mask argument "
- "(used for more complex distributions), "
- "see help in compute_mask_indicesh"
- },
- )
- no_mask_channel_overlap: bool = field(
- default=False,
- metadata={"help": "whether to allow channel masks to overlap"},
- )
- mask_channel_min_space: int = field(
- default=1,
- metadata={
- "help": "min space between spans (if no overlap is enabled)"
- },
- )
-
- # positional embeddings
- conv_pos: int = field(
- default=128,
- metadata={
- "help": "number of filters for convolutional positional embeddings"
- },
- )
- conv_pos_groups: int = field(
- default=16,
- metadata={
- "help": "number of groups for convolutional positional embedding"
- },
- )
-
- latent_temp: Tuple[float, float, float] = field(
- default=(2, 0.5, 0.999995),
- metadata={"help": "legacy (to be removed)"},
- )
-
- # loss computation
- skip_masked: bool = field(
- default=False,
- metadata={"help": "skip computing losses over masked frames"},
- )
- skip_nomask: bool = field(
- default=False,
- metadata={"help": "skip computing losses over unmasked frames"},
- )
-
-
-@register_model("hubert", dataclass=HubertConfig)
-class HubertModel(BaseFairseqModel):
- def __init__(
- self,
- cfg: HubertConfig,
- task_cfg: HubertPretrainingConfig,
- dictionaries: List[Dictionary],
- ) -> None:
- super().__init__()
- logger.info(f"HubertModel Config: {cfg}")
-
- feature_enc_layers = eval(cfg.conv_feature_layers) # noqa
- self.embed = feature_enc_layers[-1][0]
-
- self.feature_extractor = ConvFeatureExtractionModel(
- conv_layers=feature_enc_layers,
- dropout=0.0,
- mode=cfg.extractor_mode,
- conv_bias=cfg.conv_bias,
- )
- feature_ds_rate = np.prod([s for _, _, s in feature_enc_layers])
- self.feat2tar_ratio = (
- cfg.label_rate * feature_ds_rate / task_cfg.sample_rate
- )
-
- self.post_extract_proj = (
- nn.Linear(self.embed, cfg.encoder_embed_dim)
- if self.embed != cfg.encoder_embed_dim
- else None
- )
-
- self.mask_prob = cfg.mask_prob
- self.mask_selection = cfg.mask_selection
- self.mask_other = cfg.mask_other
- self.mask_length = cfg.mask_length
- self.no_mask_overlap = cfg.no_mask_overlap
- self.mask_min_space = cfg.mask_min_space
-
- self.mask_channel_prob = cfg.mask_channel_prob
- self.mask_channel_selection = cfg.mask_channel_selection
- self.mask_channel_other = cfg.mask_channel_other
- self.mask_channel_length = cfg.mask_channel_length
- self.no_mask_channel_overlap = cfg.no_mask_channel_overlap
- self.mask_channel_min_space = cfg.mask_channel_min_space
-
- self.dropout_input = nn.Dropout(cfg.dropout_input)
- self.dropout_features = nn.Dropout(cfg.dropout_features)
-
- self.feature_grad_mult = cfg.feature_grad_mult
- self.logit_temp = cfg.logit_temp
- self.skip_masked = cfg.skip_masked
- self.skip_nomask = cfg.skip_nomask
-
- final_dim = (
- cfg.final_dim if cfg.final_dim > 0 else cfg.encoder_embed_dim
- )
-
- self.mask_emb = nn.Parameter(
- torch.FloatTensor(cfg.encoder_embed_dim).uniform_()
- )
-
- self.encoder = TransformerEncoder(cfg)
- self.layer_norm = LayerNorm(self.embed)
-
- self.target_glu = None
- if cfg.target_glu:
- self.target_glu = nn.Sequential(
- nn.Linear(final_dim, final_dim * 2), nn.GLU()
- )
-
- self.untie_final_proj = cfg.untie_final_proj
- if self.untie_final_proj:
- self.final_proj = nn.Linear(
- cfg.encoder_embed_dim, final_dim * len(dictionaries)
- )
- else:
- self.final_proj = nn.Linear(cfg.encoder_embed_dim, final_dim)
-
- # modules below are not needed during fine-tuning
- if any([d is None for d in dictionaries]):
- logger.info(
- "cannot find dictionary. assume will be used for fine-tuning"
- )
- else:
- self.num_classes = [len(d) for d in dictionaries]
- self.label_embs_concat = nn.Parameter(
- torch.FloatTensor(sum(self.num_classes), final_dim)
- )
- nn.init.uniform_(self.label_embs_concat)
-
- def upgrade_state_dict_named(self, state_dict, name):
- """Upgrade a (possibly old) state dict for new versions of fairseq."""
-
- super().upgrade_state_dict_named(state_dict, name)
- return state_dict
-
- @classmethod
- def build_model(cls, cfg: HubertConfig, task: HubertPretrainingTask):
- """Build a new model instance."""
-
- model = HubertModel(cfg, task.cfg, task.dictionaries)
- return model
-
- def apply_mask(self, x, padding_mask, target_list):
- B, T, C = x.shape
- if self.mask_prob > 0:
- mask_indices = compute_mask_indices(
- (B, T),
- padding_mask,
- self.mask_prob,
- self.mask_length,
- self.mask_selection,
- self.mask_other,
- min_masks=2,
- no_overlap=self.no_mask_overlap,
- min_space=self.mask_min_space,
- )
- mask_indices = torch.from_numpy(mask_indices).to(x.device)
- x[mask_indices] = self.mask_emb
- else:
- mask_indices = None
-
- if self.mask_channel_prob > 0:
- mask_channel_indices = compute_mask_indices(
- (B, C),
- None,
- self.mask_channel_prob,
- self.mask_channel_length,
- self.mask_channel_selection,
- self.mask_channel_other,
- no_overlap=self.no_mask_channel_overlap,
- min_space=self.mask_channel_min_space,
- )
- mask_channel_indices = (
- torch.from_numpy(mask_channel_indices)
- .to(x.device)
- .unsqueeze(1)
- .expand(-1, T, -1)
- )
- x[mask_channel_indices] = 0
-
- return x, mask_indices
-
- def compute_nce(self, x, pos, negs):
- neg_is_pos = (pos == negs).all(-1)
- pos = pos.unsqueeze(0)
- targets = torch.cat([pos, negs], dim=0)
-
- logits = torch.cosine_similarity(
- x.float(), targets.float(), dim=-1
- ).type_as(x)
- logits /= self.logit_temp
- if neg_is_pos.any():
- logits[1:][neg_is_pos] = float("-inf")
- logits = logits.transpose(0, 1) # (num_x, num_cls+1)
- return logits
-
- def forward_features(self, source: torch.Tensor) -> torch.Tensor:
- if self.feature_grad_mult > 0:
- features = self.feature_extractor(source)
- if self.feature_grad_mult != 1.0:
- features = GradMultiply.apply(features, self.feature_grad_mult)
- else:
- with torch.no_grad():
- features = self.feature_extractor(source)
- return features
-
- def forward_targets(
- self, features: torch.Tensor, target_list: List[torch.Tensor],
- ) -> Tuple[torch.Tensor, torch.Tensor]:
- # Trim features to ensure labels exist and then get aligned labels
- feat_tsz = features.size(2)
- targ_tsz = min([t.size(1) for t in target_list])
- if self.feat2tar_ratio * feat_tsz > targ_tsz:
- feat_tsz = int(targ_tsz / self.feat2tar_ratio)
- features = features[..., :feat_tsz]
- target_inds = torch.arange(feat_tsz).float() * self.feat2tar_ratio
- target_list = [t[:, target_inds.long()] for t in target_list]
- return features, target_list
-
- def forward_padding_mask(
- self, features: torch.Tensor, padding_mask: torch.Tensor,
- ) -> torch.Tensor:
- extra = padding_mask.size(1) % features.size(1)
- if extra > 0:
- padding_mask = padding_mask[:, :-extra]
- padding_mask = padding_mask.view(
- padding_mask.size(0), features.size(1), -1
- )
- padding_mask = padding_mask.all(-1)
- return padding_mask
-
- def forward(
- self,
- source: torch.Tensor,
- target_list: Optional[List[torch.Tensor]] = None,
- padding_mask: Optional[torch.Tensor] = None,
- mask: bool = True,
- features_only: bool = False,
- output_layer: Optional[int] = None,
- ) -> Dict[str, torch.Tensor]:
- """output layer is 1-based"""
- features = self.forward_features(source)
- if target_list is not None:
- features, target_list = self.forward_targets(features, target_list)
-
- features_pen = features.float().pow(2).mean()
-
- features = features.transpose(1, 2)
- features = self.layer_norm(features)
- unmasked_features = features.clone()
-
- if padding_mask is not None:
- padding_mask = self.forward_padding_mask(features, padding_mask)
-
- if self.post_extract_proj is not None:
- features = self.post_extract_proj(features)
-
- features = self.dropout_input(features)
- unmasked_features = self.dropout_features(unmasked_features)
-
- if mask:
- x, mask_indices = self.apply_mask(
- features, padding_mask, target_list
- )
- else:
- x = features
- mask_indices = None
-
- # feature: (B, T, D), float
- # target: (B, T), long
- # x: (B, T, D), float
- # padding_mask: (B, T), bool
- # mask_indices: (B, T), bool
- x, _ = self.encoder(
- x,
- padding_mask=padding_mask,
- layer=None if output_layer is None else output_layer - 1
- )
-
- if features_only:
- return {"x": x, "padding_mask": padding_mask, "features": features}
-
- def compute_pred(proj_x, target, label_embs):
- # compute logits for the i-th label set
- y = torch.index_select(label_embs, 0, target.long())
- negs = label_embs.unsqueeze(1).expand(-1, proj_x.size(0), -1)
- if self.target_glu:
- y = self.target_glu(y)
- negs = self.target_glu(negs)
- # proj_x: (S, D)
- # y: (S, D)
- # negs: (Neg, S, D)
- return self.compute_nce(proj_x, y, negs)
-
- label_embs_list = self.label_embs_concat.split(self.num_classes, 0)
-
- if not self.skip_masked:
- masked_indices = torch.logical_and(~padding_mask, mask_indices)
- proj_x_m = self.final_proj(x[masked_indices])
- if self.untie_final_proj:
- proj_x_m_list = proj_x_m.chunk(len(target_list), dim=-1)
- else:
- proj_x_m_list = [proj_x_m for _ in range(len(target_list))]
- logit_m_list = [
- compute_pred(proj_x_m, t[masked_indices], label_embs_list[i])
- for i, (proj_x_m, t) in enumerate(
- zip(proj_x_m_list, target_list)
- )
- ]
- else:
- logit_m_list = [None for _ in target_list]
-
- if not self.skip_nomask:
- nomask_indices = torch.logical_and(~padding_mask, ~mask_indices)
- proj_x_u = self.final_proj(x[nomask_indices])
- if self.untie_final_proj:
- proj_x_u_list = proj_x_u.chunk(len(target_list), dim=-1)
- else:
- proj_x_u_list = [proj_x_u for _ in range(len(target_list))]
-
- logit_u_list = [
- compute_pred(proj_x_u, t[nomask_indices], label_embs_list[i])
- for i, (proj_x_u, t) in enumerate(
- zip(proj_x_u_list, target_list)
- )
- ]
- else:
- logit_u_list = [None for _ in target_list]
-
- result = {
- "logit_m_list": logit_m_list,
- "logit_u_list": logit_u_list,
- "padding_mask": padding_mask,
- "features_pen": features_pen,
- }
- return result
-
- def extract_features(
- self,
- source: torch.Tensor,
- padding_mask: Optional[torch.Tensor] = None,
- mask: bool = False,
- ret_conv: bool = False,
- output_layer: Optional[int] = None,
- ) -> Tuple[torch.Tensor, torch.Tensor]:
- res = self.forward(
- source,
- padding_mask=padding_mask,
- mask=mask,
- features_only=True,
- output_layer=output_layer,
- )
- feature = res["features"] if ret_conv else res["x"]
- return feature, res["padding_mask"]
-
- def get_logits(self, net_output, is_masked=True):
- if is_masked:
- logits_list = net_output["logit_m_list"]
- else:
- logits_list = net_output["logit_u_list"]
- logits_list = [x.float() for x in logits_list if x is not None]
- return logits_list
-
- def get_targets(self, net_output, is_masked=True):
- logits_list = self.get_logits(net_output, is_masked)
- targets_list = [
- x.new_zeros(x.size(0), dtype=torch.long) for x in logits_list
- ]
- return targets_list
-
- def get_extra_losses(self, net_output):
- extra_losses = []
- names = []
-
- if "features_pen" in net_output:
- extra_losses.append(net_output["features_pen"])
- names.append("features_pen")
-
- return extra_losses, names
-
- def remove_pretraining_modules(self):
- self.target_glu = None
- self.final_proj = None
diff --git a/spaces/OFA-Sys/OFA-vqa/run_scripts/refcoco/evaluate_refcoco.sh b/spaces/OFA-Sys/OFA-vqa/run_scripts/refcoco/evaluate_refcoco.sh
deleted file mode 100644
index c775ed124458b30a7dda74749244e095d763e93a..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/run_scripts/refcoco/evaluate_refcoco.sh
+++ /dev/null
@@ -1,197 +0,0 @@
-#!/usr/bin/env bash
-
-
-########################## Evaluate Refcoco ##########################
-user_dir=../../ofa_module
-bpe_dir=../../utils/BPE
-selected_cols=0,4,2,3
-
-data=../../dataset/refcoco_data/refcoco_val.tsv
-path=../../checkpoints/refcoco_large_best.pt
-result_path=../../results/refcoco
-split='refcoco_val'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-data=../../dataset/refcoco_data/refcoco_testA.tsv
-path=../../checkpoints/refcoco_large_best.pt
-result_path=../../results/refcoco
-split='refcoco_testA'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-data=../../dataset/refcoco_data/refcoco_testB.tsv
-path=../../checkpoints/refcoco_large_best.pt
-result_path=../../results/refcoco
-split='refcoco_testB'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-
-
-######################### Evaluate Refcocoplus ##########################
-data=../../dataset/refcocoplus_data/refcocoplus_val.tsv
-path=../../checkpoints/refcocoplus_large_best.pt
-result_path=../../results/refcocoplus
-split='refcocoplus_val'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-data=../../dataset/refcocoplus_data/refcocoplus_testA.tsv
-path=../../checkpoints/refcocoplus_large_best.pt
-result_path=../../results/refcocoplus
-split='refcocoplus_testA'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-data=../../dataset/refcocoplus_data/refcocoplus_testB.tsv
-path=../../checkpoints/refcocoplus_large_best.pt
-result_path=../../results/refcocoplus
-split='refcocoplus_testB'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-
-
-########################## Evaluate Refcocog ##########################
-data=../../dataset/refcocog_data/refcocog_val.tsv
-path=../../checkpoints/refcocog_large_best.pt
-result_path=../../results/refcocog
-split='refcocog_val'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
-
-data=../../dataset/refcocog_data/refcocog_test.tsv
-path=../../checkpoints/refcocog_large_best.pt
-result_path=../../results/refcocog
-split='refcocog_test'
-CUDA_VISIBLE_DEVICES=0,1,2,3 python3 ../../evaluate.py \
- ${data} \
- --path=${path} \
- --user-dir=${user_dir} \
- --task=refcoco \
- --batch-size=16 \
- --log-format=simple --log-interval=10 \
- --seed=7 \
- --gen-subset=${split} \
- --results-path=${result_path} \
- --beam=5 \
- --min-len=4 \
- --max-len-a=0 \
- --max-len-b=4 \
- --no-repeat-ngram-size=3 \
- --fp16 \
- --num-workers=0 \
- --model-overrides="{\"data\":\"${data}\",\"bpe_dir\":\"${bpe_dir}\",\"selected_cols\":\"${selected_cols}\"}"
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/README.md b/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/README.md
deleted file mode 100644
index 778ed3da0bae89820831bcd8a72ff7b9cad8d4dd..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/grit_src/third_party/CenterNet2/detectron2/layers/csrc/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-
-To add a new Op:
-
-1. Create a new directory
-2. Implement new ops there
-3. Delcare its Python interface in `vision.cpp`.
diff --git a/spaces/OpenGVLab/InternGPT/iGPT/models/inpainting_src/ldm_inpainting/ldm/modules/diffusionmodules/model.py b/spaces/OpenGVLab/InternGPT/iGPT/models/inpainting_src/ldm_inpainting/ldm/modules/diffusionmodules/model.py
deleted file mode 100644
index 533e589a2024f1d7c52093d8c472c3b1b6617e26..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/iGPT/models/inpainting_src/ldm_inpainting/ldm/modules/diffusionmodules/model.py
+++ /dev/null
@@ -1,835 +0,0 @@
-# pytorch_diffusion + derived encoder decoder
-import math
-import torch
-import torch.nn as nn
-import numpy as np
-from einops import rearrange
-
-from ldm.util import instantiate_from_config
-from ldm.modules.attention import LinearAttention
-
-
-def get_timestep_embedding(timesteps, embedding_dim):
- """
- This matches the implementation in Denoising Diffusion Probabilistic Models:
- From Fairseq.
- Build sinusoidal embeddings.
- This matches the implementation in tensor2tensor, but differs slightly
- from the description in Section 3.5 of "Attention Is All You Need".
- """
- assert len(timesteps.shape) == 1
-
- half_dim = embedding_dim // 2
- emb = math.log(10000) / (half_dim - 1)
- emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
- emb = emb.to(device=timesteps.device)
- emb = timesteps.float()[:, None] * emb[None, :]
- emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
- if embedding_dim % 2 == 1: # zero pad
- emb = torch.nn.functional.pad(emb, (0,1,0,0))
- return emb
-
-
-def nonlinearity(x):
- # swish
- return x*torch.sigmoid(x)
-
-
-def Normalize(in_channels, num_groups=32):
- return torch.nn.GroupNorm(num_groups=num_groups, num_channels=in_channels, eps=1e-6, affine=True)
-
-
-class Upsample(nn.Module):
- def __init__(self, in_channels, with_conv):
- super().__init__()
- self.with_conv = with_conv
- if self.with_conv:
- self.conv = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x):
- x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
- if self.with_conv:
- x = self.conv(x)
- return x
-
-
-class Downsample(nn.Module):
- def __init__(self, in_channels, with_conv):
- super().__init__()
- self.with_conv = with_conv
- if self.with_conv:
- # no asymmetric padding in torch conv, must do it ourselves
- self.conv = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=3,
- stride=2,
- padding=0)
-
- def forward(self, x):
- if self.with_conv:
- pad = (0,1,0,1)
- x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
- x = self.conv(x)
- else:
- x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
- return x
-
-
-class ResnetBlock(nn.Module):
- def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
- dropout, temb_channels=512):
- super().__init__()
- self.in_channels = in_channels
- out_channels = in_channels if out_channels is None else out_channels
- self.out_channels = out_channels
- self.use_conv_shortcut = conv_shortcut
-
- self.norm1 = Normalize(in_channels)
- self.conv1 = torch.nn.Conv2d(in_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
- if temb_channels > 0:
- self.temb_proj = torch.nn.Linear(temb_channels,
- out_channels)
- self.norm2 = Normalize(out_channels)
- self.dropout = torch.nn.Dropout(dropout)
- self.conv2 = torch.nn.Conv2d(out_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
- if self.in_channels != self.out_channels:
- if self.use_conv_shortcut:
- self.conv_shortcut = torch.nn.Conv2d(in_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
- else:
- self.nin_shortcut = torch.nn.Conv2d(in_channels,
- out_channels,
- kernel_size=1,
- stride=1,
- padding=0)
-
- def forward(self, x, temb):
- h = x
- h = self.norm1(h)
- h = nonlinearity(h)
- h = self.conv1(h)
-
- if temb is not None:
- h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None]
-
- h = self.norm2(h)
- h = nonlinearity(h)
- h = self.dropout(h)
- h = self.conv2(h)
-
- if self.in_channels != self.out_channels:
- if self.use_conv_shortcut:
- x = self.conv_shortcut(x)
- else:
- x = self.nin_shortcut(x)
-
- return x+h
-
-
-class LinAttnBlock(LinearAttention):
- """to match AttnBlock usage"""
- def __init__(self, in_channels):
- super().__init__(dim=in_channels, heads=1, dim_head=in_channels)
-
-
-class AttnBlock(nn.Module):
- def __init__(self, in_channels):
- super().__init__()
- self.in_channels = in_channels
-
- self.norm = Normalize(in_channels)
- self.q = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.k = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.v = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
- self.proj_out = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=1,
- stride=1,
- padding=0)
-
-
- def forward(self, x):
- h_ = x
- h_ = self.norm(h_)
- q = self.q(h_)
- k = self.k(h_)
- v = self.v(h_)
-
- # compute attention
- b,c,h,w = q.shape
- q = q.reshape(b,c,h*w)
- q = q.permute(0,2,1) # b,hw,c
- k = k.reshape(b,c,h*w) # b,c,hw
- w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
- w_ = w_ * (int(c)**(-0.5))
- w_ = torch.nn.functional.softmax(w_, dim=2)
-
- # attend to values
- v = v.reshape(b,c,h*w)
- w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q)
- h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
- h_ = h_.reshape(b,c,h,w)
-
- h_ = self.proj_out(h_)
-
- return x+h_
-
-
-def make_attn(in_channels, attn_type="vanilla"):
- assert attn_type in ["vanilla", "linear", "none"], f'attn_type {attn_type} unknown'
- print(f"making attention of type '{attn_type}' with {in_channels} in_channels")
- if attn_type == "vanilla":
- return AttnBlock(in_channels)
- elif attn_type == "none":
- return nn.Identity(in_channels)
- else:
- return LinAttnBlock(in_channels)
-
-
-class Model(nn.Module):
- def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
- attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
- resolution, use_timestep=True, use_linear_attn=False, attn_type="vanilla"):
- super().__init__()
- if use_linear_attn: attn_type = "linear"
- self.ch = ch
- self.temb_ch = self.ch*4
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
-
- self.use_timestep = use_timestep
- if self.use_timestep:
- # timestep embedding
- self.temb = nn.Module()
- self.temb.dense = nn.ModuleList([
- torch.nn.Linear(self.ch,
- self.temb_ch),
- torch.nn.Linear(self.temb_ch,
- self.temb_ch),
- ])
-
- # downsampling
- self.conv_in = torch.nn.Conv2d(in_channels,
- self.ch,
- kernel_size=3,
- stride=1,
- padding=1)
-
- curr_res = resolution
- in_ch_mult = (1,)+tuple(ch_mult)
- self.down = nn.ModuleList()
- for i_level in range(self.num_resolutions):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_in = ch*in_ch_mult[i_level]
- block_out = ch*ch_mult[i_level]
- for i_block in range(self.num_res_blocks):
- block.append(ResnetBlock(in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(make_attn(block_in, attn_type=attn_type))
- down = nn.Module()
- down.block = block
- down.attn = attn
- if i_level != self.num_resolutions-1:
- down.downsample = Downsample(block_in, resamp_with_conv)
- curr_res = curr_res // 2
- self.down.append(down)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
- self.mid.block_2 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # upsampling
- self.up = nn.ModuleList()
- for i_level in reversed(range(self.num_resolutions)):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_out = ch*ch_mult[i_level]
- skip_in = ch*ch_mult[i_level]
- for i_block in range(self.num_res_blocks+1):
- if i_block == self.num_res_blocks:
- skip_in = ch*in_ch_mult[i_level]
- block.append(ResnetBlock(in_channels=block_in+skip_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(make_attn(block_in, attn_type=attn_type))
- up = nn.Module()
- up.block = block
- up.attn = attn
- if i_level != 0:
- up.upsample = Upsample(block_in, resamp_with_conv)
- curr_res = curr_res * 2
- self.up.insert(0, up) # prepend to get consistent order
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(block_in,
- out_ch,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x, t=None, context=None):
- #assert x.shape[2] == x.shape[3] == self.resolution
- if context is not None:
- # assume aligned context, cat along channel axis
- x = torch.cat((x, context), dim=1)
- if self.use_timestep:
- # timestep embedding
- assert t is not None
- temb = get_timestep_embedding(t, self.ch)
- temb = self.temb.dense[0](temb)
- temb = nonlinearity(temb)
- temb = self.temb.dense[1](temb)
- else:
- temb = None
-
- # downsampling
- hs = [self.conv_in(x)]
- for i_level in range(self.num_resolutions):
- for i_block in range(self.num_res_blocks):
- h = self.down[i_level].block[i_block](hs[-1], temb)
- if len(self.down[i_level].attn) > 0:
- h = self.down[i_level].attn[i_block](h)
- hs.append(h)
- if i_level != self.num_resolutions-1:
- hs.append(self.down[i_level].downsample(hs[-1]))
-
- # middle
- h = hs[-1]
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks+1):
- h = self.up[i_level].block[i_block](
- torch.cat([h, hs.pop()], dim=1), temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
-
- # end
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
- def get_last_layer(self):
- return self.conv_out.weight
-
-
-class Encoder(nn.Module):
- def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
- attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
- resolution, z_channels, double_z=True, use_linear_attn=False, attn_type="vanilla",
- **ignore_kwargs):
- super().__init__()
- if use_linear_attn: attn_type = "linear"
- self.ch = ch
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
-
- # downsampling
- self.conv_in = torch.nn.Conv2d(in_channels,
- self.ch,
- kernel_size=3,
- stride=1,
- padding=1)
-
- curr_res = resolution
- in_ch_mult = (1,)+tuple(ch_mult)
- self.in_ch_mult = in_ch_mult
- self.down = nn.ModuleList()
- for i_level in range(self.num_resolutions):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_in = ch*in_ch_mult[i_level]
- block_out = ch*ch_mult[i_level]
- for i_block in range(self.num_res_blocks):
- block.append(ResnetBlock(in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(make_attn(block_in, attn_type=attn_type))
- down = nn.Module()
- down.block = block
- down.attn = attn
- if i_level != self.num_resolutions-1:
- down.downsample = Downsample(block_in, resamp_with_conv)
- curr_res = curr_res // 2
- self.down.append(down)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
- self.mid.block_2 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(block_in,
- 2*z_channels if double_z else z_channels,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x):
- # timestep embedding
- temb = None
-
- # downsampling
- hs = [self.conv_in(x)]
- for i_level in range(self.num_resolutions):
- for i_block in range(self.num_res_blocks):
- h = self.down[i_level].block[i_block](hs[-1], temb)
- if len(self.down[i_level].attn) > 0:
- h = self.down[i_level].attn[i_block](h)
- hs.append(h)
- if i_level != self.num_resolutions-1:
- hs.append(self.down[i_level].downsample(hs[-1]))
-
- # middle
- h = hs[-1]
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # end
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
-
-class Decoder(nn.Module):
- def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
- attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
- resolution, z_channels, give_pre_end=False, tanh_out=False, use_linear_attn=False,
- attn_type="vanilla", **ignorekwargs):
- super().__init__()
- if use_linear_attn: attn_type = "linear"
- self.ch = ch
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
- self.give_pre_end = give_pre_end
- self.tanh_out = tanh_out
-
- # compute in_ch_mult, block_in and curr_res at lowest res
- in_ch_mult = (1,)+tuple(ch_mult)
- block_in = ch*ch_mult[self.num_resolutions-1]
- curr_res = resolution // 2**(self.num_resolutions-1)
- self.z_shape = (1,z_channels,curr_res,curr_res)
- print("Working with z of shape {} = {} dimensions.".format(
- self.z_shape, np.prod(self.z_shape)))
-
- # z to block_in
- self.conv_in = torch.nn.Conv2d(z_channels,
- block_in,
- kernel_size=3,
- stride=1,
- padding=1)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = make_attn(block_in, attn_type=attn_type)
- self.mid.block_2 = ResnetBlock(in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # upsampling
- self.up = nn.ModuleList()
- for i_level in reversed(range(self.num_resolutions)):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_out = ch*ch_mult[i_level]
- for i_block in range(self.num_res_blocks+1):
- block.append(ResnetBlock(in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(make_attn(block_in, attn_type=attn_type))
- up = nn.Module()
- up.block = block
- up.attn = attn
- if i_level != 0:
- up.upsample = Upsample(block_in, resamp_with_conv)
- curr_res = curr_res * 2
- self.up.insert(0, up) # prepend to get consistent order
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(block_in,
- out_ch,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, z):
- #assert z.shape[1:] == self.z_shape[1:]
- self.last_z_shape = z.shape
-
- # timestep embedding
- temb = None
-
- # z to block_in
- h = self.conv_in(z)
-
- # middle
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks+1):
- h = self.up[i_level].block[i_block](h, temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
-
- # end
- if self.give_pre_end:
- return h
-
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- if self.tanh_out:
- h = torch.tanh(h)
- return h
-
-
-class SimpleDecoder(nn.Module):
- def __init__(self, in_channels, out_channels, *args, **kwargs):
- super().__init__()
- self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1),
- ResnetBlock(in_channels=in_channels,
- out_channels=2 * in_channels,
- temb_channels=0, dropout=0.0),
- ResnetBlock(in_channels=2 * in_channels,
- out_channels=4 * in_channels,
- temb_channels=0, dropout=0.0),
- ResnetBlock(in_channels=4 * in_channels,
- out_channels=2 * in_channels,
- temb_channels=0, dropout=0.0),
- nn.Conv2d(2*in_channels, in_channels, 1),
- Upsample(in_channels, with_conv=True)])
- # end
- self.norm_out = Normalize(in_channels)
- self.conv_out = torch.nn.Conv2d(in_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x):
- for i, layer in enumerate(self.model):
- if i in [1,2,3]:
- x = layer(x, None)
- else:
- x = layer(x)
-
- h = self.norm_out(x)
- h = nonlinearity(h)
- x = self.conv_out(h)
- return x
-
-
-class UpsampleDecoder(nn.Module):
- def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution,
- ch_mult=(2,2), dropout=0.0):
- super().__init__()
- # upsampling
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- block_in = in_channels
- curr_res = resolution // 2 ** (self.num_resolutions - 1)
- self.res_blocks = nn.ModuleList()
- self.upsample_blocks = nn.ModuleList()
- for i_level in range(self.num_resolutions):
- res_block = []
- block_out = ch * ch_mult[i_level]
- for i_block in range(self.num_res_blocks + 1):
- res_block.append(ResnetBlock(in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- self.res_blocks.append(nn.ModuleList(res_block))
- if i_level != self.num_resolutions - 1:
- self.upsample_blocks.append(Upsample(block_in, True))
- curr_res = curr_res * 2
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(block_in,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x):
- # upsampling
- h = x
- for k, i_level in enumerate(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks + 1):
- h = self.res_blocks[i_level][i_block](h, None)
- if i_level != self.num_resolutions - 1:
- h = self.upsample_blocks[k](h)
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
-
-class LatentRescaler(nn.Module):
- def __init__(self, factor, in_channels, mid_channels, out_channels, depth=2):
- super().__init__()
- # residual block, interpolate, residual block
- self.factor = factor
- self.conv_in = nn.Conv2d(in_channels,
- mid_channels,
- kernel_size=3,
- stride=1,
- padding=1)
- self.res_block1 = nn.ModuleList([ResnetBlock(in_channels=mid_channels,
- out_channels=mid_channels,
- temb_channels=0,
- dropout=0.0) for _ in range(depth)])
- self.attn = AttnBlock(mid_channels)
- self.res_block2 = nn.ModuleList([ResnetBlock(in_channels=mid_channels,
- out_channels=mid_channels,
- temb_channels=0,
- dropout=0.0) for _ in range(depth)])
-
- self.conv_out = nn.Conv2d(mid_channels,
- out_channels,
- kernel_size=1,
- )
-
- def forward(self, x):
- x = self.conv_in(x)
- for block in self.res_block1:
- x = block(x, None)
- x = torch.nn.functional.interpolate(x, size=(int(round(x.shape[2]*self.factor)), int(round(x.shape[3]*self.factor))))
- x = self.attn(x)
- for block in self.res_block2:
- x = block(x, None)
- x = self.conv_out(x)
- return x
-
-
-class MergedRescaleEncoder(nn.Module):
- def __init__(self, in_channels, ch, resolution, out_ch, num_res_blocks,
- attn_resolutions, dropout=0.0, resamp_with_conv=True,
- ch_mult=(1,2,4,8), rescale_factor=1.0, rescale_module_depth=1):
- super().__init__()
- intermediate_chn = ch * ch_mult[-1]
- self.encoder = Encoder(in_channels=in_channels, num_res_blocks=num_res_blocks, ch=ch, ch_mult=ch_mult,
- z_channels=intermediate_chn, double_z=False, resolution=resolution,
- attn_resolutions=attn_resolutions, dropout=dropout, resamp_with_conv=resamp_with_conv,
- out_ch=None)
- self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=intermediate_chn,
- mid_channels=intermediate_chn, out_channels=out_ch, depth=rescale_module_depth)
-
- def forward(self, x):
- x = self.encoder(x)
- x = self.rescaler(x)
- return x
-
-
-class MergedRescaleDecoder(nn.Module):
- def __init__(self, z_channels, out_ch, resolution, num_res_blocks, attn_resolutions, ch, ch_mult=(1,2,4,8),
- dropout=0.0, resamp_with_conv=True, rescale_factor=1.0, rescale_module_depth=1):
- super().__init__()
- tmp_chn = z_channels*ch_mult[-1]
- self.decoder = Decoder(out_ch=out_ch, z_channels=tmp_chn, attn_resolutions=attn_resolutions, dropout=dropout,
- resamp_with_conv=resamp_with_conv, in_channels=None, num_res_blocks=num_res_blocks,
- ch_mult=ch_mult, resolution=resolution, ch=ch)
- self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=z_channels, mid_channels=tmp_chn,
- out_channels=tmp_chn, depth=rescale_module_depth)
-
- def forward(self, x):
- x = self.rescaler(x)
- x = self.decoder(x)
- return x
-
-
-class Upsampler(nn.Module):
- def __init__(self, in_size, out_size, in_channels, out_channels, ch_mult=2):
- super().__init__()
- assert out_size >= in_size
- num_blocks = int(np.log2(out_size//in_size))+1
- factor_up = 1.+ (out_size % in_size)
- print(f"Building {self.__class__.__name__} with in_size: {in_size} --> out_size {out_size} and factor {factor_up}")
- self.rescaler = LatentRescaler(factor=factor_up, in_channels=in_channels, mid_channels=2*in_channels,
- out_channels=in_channels)
- self.decoder = Decoder(out_ch=out_channels, resolution=out_size, z_channels=in_channels, num_res_blocks=2,
- attn_resolutions=[], in_channels=None, ch=in_channels,
- ch_mult=[ch_mult for _ in range(num_blocks)])
-
- def forward(self, x):
- x = self.rescaler(x)
- x = self.decoder(x)
- return x
-
-
-class Resize(nn.Module):
- def __init__(self, in_channels=None, learned=False, mode="bilinear"):
- super().__init__()
- self.with_conv = learned
- self.mode = mode
- if self.with_conv:
- print(f"Note: {self.__class__.__name} uses learned downsampling and will ignore the fixed {mode} mode")
- raise NotImplementedError()
- assert in_channels is not None
- # no asymmetric padding in torch conv, must do it ourselves
- self.conv = torch.nn.Conv2d(in_channels,
- in_channels,
- kernel_size=4,
- stride=2,
- padding=1)
-
- def forward(self, x, scale_factor=1.0):
- if scale_factor==1.0:
- return x
- else:
- x = torch.nn.functional.interpolate(x, mode=self.mode, align_corners=False, scale_factor=scale_factor)
- return x
-
-class FirstStagePostProcessor(nn.Module):
-
- def __init__(self, ch_mult:list, in_channels,
- pretrained_model:nn.Module=None,
- reshape=False,
- n_channels=None,
- dropout=0.,
- pretrained_config=None):
- super().__init__()
- if pretrained_config is None:
- assert pretrained_model is not None, 'Either "pretrained_model" or "pretrained_config" must not be None'
- self.pretrained_model = pretrained_model
- else:
- assert pretrained_config is not None, 'Either "pretrained_model" or "pretrained_config" must not be None'
- self.instantiate_pretrained(pretrained_config)
-
- self.do_reshape = reshape
-
- if n_channels is None:
- n_channels = self.pretrained_model.encoder.ch
-
- self.proj_norm = Normalize(in_channels,num_groups=in_channels//2)
- self.proj = nn.Conv2d(in_channels,n_channels,kernel_size=3,
- stride=1,padding=1)
-
- blocks = []
- downs = []
- ch_in = n_channels
- for m in ch_mult:
- blocks.append(ResnetBlock(in_channels=ch_in,out_channels=m*n_channels,dropout=dropout))
- ch_in = m * n_channels
- downs.append(Downsample(ch_in, with_conv=False))
-
- self.model = nn.ModuleList(blocks)
- self.downsampler = nn.ModuleList(downs)
-
-
- def instantiate_pretrained(self, config):
- model = instantiate_from_config(config)
- self.pretrained_model = model.eval()
- # self.pretrained_model.train = False
- for param in self.pretrained_model.parameters():
- param.requires_grad = False
-
-
- @torch.no_grad()
- def encode_with_pretrained(self,x):
- c = self.pretrained_model.encode(x)
- if isinstance(c, DiagonalGaussianDistribution):
- c = c.mode()
- return c
-
- def forward(self,x):
- z_fs = self.encode_with_pretrained(x)
- z = self.proj_norm(z_fs)
- z = self.proj(z)
- z = nonlinearity(z)
-
- for submodel, downmodel in zip(self.model,self.downsampler):
- z = submodel(z,temb=None)
- z = downmodel(z)
-
- if self.do_reshape:
- z = rearrange(z,'b c h w -> b (h w) c')
- return z
-
diff --git a/spaces/OpenGVLab/InternGPT/third-party/lama/bin/saicinpainting/utils.py b/spaces/OpenGVLab/InternGPT/third-party/lama/bin/saicinpainting/utils.py
deleted file mode 100644
index c2d67ed8bc793dd5113224fa322adb88f3ed9b22..0000000000000000000000000000000000000000
--- a/spaces/OpenGVLab/InternGPT/third-party/lama/bin/saicinpainting/utils.py
+++ /dev/null
@@ -1,177 +0,0 @@
-import bisect
-import functools
-import logging
-import numbers
-import os
-import signal
-import sys
-import traceback
-import warnings
-
-import torch
-from pytorch_lightning import seed_everything
-
-LOGGER = logging.getLogger(__name__)
-
-import platform
-if platform.system() != 'Linux':
- signal.SIGUSR1 = 1
-
-def check_and_warn_input_range(tensor, min_value, max_value, name):
- actual_min = tensor.min()
- actual_max = tensor.max()
- if actual_min < min_value or actual_max > max_value:
- warnings.warn(f"{name} must be in {min_value}..{max_value} range, but it ranges {actual_min}..{actual_max}")
-
-
-def sum_dict_with_prefix(target, cur_dict, prefix, default=0):
- for k, v in cur_dict.items():
- target_key = prefix + k
- target[target_key] = target.get(target_key, default) + v
-
-
-def average_dicts(dict_list):
- result = {}
- norm = 1e-3
- for dct in dict_list:
- sum_dict_with_prefix(result, dct, '')
- norm += 1
- for k in list(result):
- result[k] /= norm
- return result
-
-
-def add_prefix_to_keys(dct, prefix):
- return {prefix + k: v for k, v in dct.items()}
-
-
-def set_requires_grad(module, value):
- for param in module.parameters():
- param.requires_grad = value
-
-
-def flatten_dict(dct):
- result = {}
- for k, v in dct.items():
- if isinstance(k, tuple):
- k = '_'.join(k)
- if isinstance(v, dict):
- for sub_k, sub_v in flatten_dict(v).items():
- result[f'{k}_{sub_k}'] = sub_v
- else:
- result[k] = v
- return result
-
-
-class LinearRamp:
- def __init__(self, start_value=0, end_value=1, start_iter=-1, end_iter=0):
- self.start_value = start_value
- self.end_value = end_value
- self.start_iter = start_iter
- self.end_iter = end_iter
-
- def __call__(self, i):
- if i < self.start_iter:
- return self.start_value
- if i >= self.end_iter:
- return self.end_value
- part = (i - self.start_iter) / (self.end_iter - self.start_iter)
- return self.start_value * (1 - part) + self.end_value * part
-
-
-class LadderRamp:
- def __init__(self, start_iters, values):
- self.start_iters = start_iters
- self.values = values
- assert len(values) == len(start_iters) + 1, (len(values), len(start_iters))
-
- def __call__(self, i):
- segment_i = bisect.bisect_right(self.start_iters, i)
- return self.values[segment_i]
-
-
-def get_ramp(kind='ladder', **kwargs):
- if kind == 'linear':
- return LinearRamp(**kwargs)
- if kind == 'ladder':
- return LadderRamp(**kwargs)
- raise ValueError(f'Unexpected ramp kind: {kind}')
-
-
-def print_traceback_handler(sig, frame):
- LOGGER.warning(f'Received signal {sig}')
- bt = ''.join(traceback.format_stack())
- LOGGER.warning(f'Requested stack trace:\n{bt}')
-
-
-def register_debug_signal_handlers(sig=signal.SIGUSR1, handler=print_traceback_handler):
- LOGGER.warning(f'Setting signal {sig} handler {handler}')
- signal.signal(sig, handler)
-
-
-def handle_deterministic_config(config):
- seed = dict(config).get('seed', None)
- if seed is None:
- return False
-
- seed_everything(seed)
- return True
-
-
-def get_shape(t):
- if torch.is_tensor(t):
- return tuple(t.shape)
- elif isinstance(t, dict):
- return {n: get_shape(q) for n, q in t.items()}
- elif isinstance(t, (list, tuple)):
- return [get_shape(q) for q in t]
- elif isinstance(t, numbers.Number):
- return type(t)
- else:
- raise ValueError('unexpected type {}'.format(type(t)))
-
-
-def get_has_ddp_rank():
- master_port = os.environ.get('MASTER_PORT', None)
- node_rank = os.environ.get('NODE_RANK', None)
- local_rank = os.environ.get('LOCAL_RANK', None)
- world_size = os.environ.get('WORLD_SIZE', None)
- has_rank = master_port is not None or node_rank is not None or local_rank is not None or world_size is not None
- return has_rank
-
-
-def handle_ddp_subprocess():
- def main_decorator(main_func):
- @functools.wraps(main_func)
- def new_main(*args, **kwargs):
- # Trainer sets MASTER_PORT, NODE_RANK, LOCAL_RANK, WORLD_SIZE
- parent_cwd = os.environ.get('TRAINING_PARENT_WORK_DIR', None)
- has_parent = parent_cwd is not None
- has_rank = get_has_ddp_rank()
- assert has_parent == has_rank, f'Inconsistent state: has_parent={has_parent}, has_rank={has_rank}'
-
- if has_parent:
- # we are in the worker
- sys.argv.extend([
- f'hydra.run.dir={parent_cwd}',
- # 'hydra/hydra_logging=disabled',
- # 'hydra/job_logging=disabled'
- ])
- # do nothing if this is a top-level process
- # TRAINING_PARENT_WORK_DIR is set in handle_ddp_parent_process after hydra initialization
-
- main_func(*args, **kwargs)
- return new_main
- return main_decorator
-
-
-def handle_ddp_parent_process():
- parent_cwd = os.environ.get('TRAINING_PARENT_WORK_DIR', None)
- has_parent = parent_cwd is not None
- has_rank = get_has_ddp_rank()
- assert has_parent == has_rank, f'Inconsistent state: has_parent={has_parent}, has_rank={has_rank}'
-
- if parent_cwd is None:
- os.environ['TRAINING_PARENT_WORK_DIR'] = os.getcwd()
-
- return has_parent
diff --git a/spaces/PKaushik/humandetect/yolov6/models/end2end.py b/spaces/PKaushik/humandetect/yolov6/models/end2end.py
deleted file mode 100644
index 228912e34301b74d5ea17367314d2ea183e0afd3..0000000000000000000000000000000000000000
--- a/spaces/PKaushik/humandetect/yolov6/models/end2end.py
+++ /dev/null
@@ -1,152 +0,0 @@
-import torch
-import torch.nn as nn
-import random
-
-
-class ORT_NMS(torch.autograd.Function):
- '''ONNX-Runtime NMS operation'''
- @staticmethod
- def forward(ctx,
- boxes,
- scores,
- max_output_boxes_per_class=torch.tensor([100]),
- iou_threshold=torch.tensor([0.45]),
- score_threshold=torch.tensor([0.25])):
- device = boxes.device
- batch = scores.shape[0]
- num_det = random.randint(0, 100)
- batches = torch.randint(0, batch, (num_det,)).sort()[0].to(device)
- idxs = torch.arange(100, 100 + num_det).to(device)
- zeros = torch.zeros((num_det,), dtype=torch.int64).to(device)
- selected_indices = torch.cat([batches[None], zeros[None], idxs[None]], 0).T.contiguous()
- selected_indices = selected_indices.to(torch.int64)
- return selected_indices
-
- @staticmethod
- def symbolic(g, boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold):
- return g.op("NonMaxSuppression", boxes, scores, max_output_boxes_per_class, iou_threshold, score_threshold)
-
-
-class TRT_NMS(torch.autograd.Function):
- '''TensorRT NMS operation'''
- @staticmethod
- def forward(
- ctx,
- boxes,
- scores,
- background_class=-1,
- box_coding=1,
- iou_threshold=0.45,
- max_output_boxes=100,
- plugin_version="1",
- score_activation=0,
- score_threshold=0.25,
- ):
- batch_size, num_boxes, num_classes = scores.shape
- num_det = torch.randint(0, max_output_boxes, (batch_size, 1), dtype=torch.int32)
- det_boxes = torch.randn(batch_size, max_output_boxes, 4)
- det_scores = torch.randn(batch_size, max_output_boxes)
- det_classes = torch.randint(0, num_classes, (batch_size, max_output_boxes), dtype=torch.int32)
- return num_det, det_boxes, det_scores, det_classes
-
- @staticmethod
- def symbolic(g,
- boxes,
- scores,
- background_class=-1,
- box_coding=1,
- iou_threshold=0.45,
- max_output_boxes=100,
- plugin_version="1",
- score_activation=0,
- score_threshold=0.25):
- out = g.op("TRT::EfficientNMS_TRT",
- boxes,
- scores,
- background_class_i=background_class,
- box_coding_i=box_coding,
- iou_threshold_f=iou_threshold,
- max_output_boxes_i=max_output_boxes,
- plugin_version_s=plugin_version,
- score_activation_i=score_activation,
- score_threshold_f=score_threshold,
- outputs=4)
- nums, boxes, scores, classes = out
- return nums, boxes, scores, classes
-
-
-class ONNX_ORT(nn.Module):
- '''onnx module with ONNX-Runtime NMS operation.'''
- def __init__(self, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=640, device=None):
- super().__init__()
- self.device = device if device else torch.device("cpu")
- self.max_obj = torch.tensor([max_obj]).to(device)
- self.iou_threshold = torch.tensor([iou_thres]).to(device)
- self.score_threshold = torch.tensor([score_thres]).to(device)
- self.max_wh = max_wh
- self.convert_matrix = torch.tensor([[1, 0, 1, 0], [0, 1, 0, 1], [-0.5, 0, 0.5, 0], [0, -0.5, 0, 0.5]],
- dtype=torch.float32,
- device=self.device)
-
- def forward(self, x):
- box = x[:, :, :4]
- conf = x[:, :, 4:5]
- score = x[:, :, 5:]
- score *= conf
- box @= self.convert_matrix
- objScore, objCls = score.max(2, keepdim=True)
- dis = objCls.float() * self.max_wh
- nmsbox = box + dis
- objScore1 = objScore.transpose(1, 2).contiguous()
- selected_indices = ORT_NMS.apply(nmsbox, objScore1, self.max_obj, self.iou_threshold, self.score_threshold)
- X, Y = selected_indices[:, 0], selected_indices[:, 2]
- resBoxes = box[X, Y, :]
- resClasses = objCls[X, Y, :].float()
- resScores = objScore[X, Y, :]
- X = X.unsqueeze(1).float()
- return torch.cat([X, resBoxes, resClasses, resScores], 1)
-
-class ONNX_TRT(nn.Module):
- '''onnx module with TensorRT NMS operation.'''
- def __init__(self, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=None ,device=None):
- super().__init__()
- assert max_wh is None
- self.device = device if device else torch.device('cpu')
- self.background_class = -1,
- self.box_coding = 1,
- self.iou_threshold = iou_thres
- self.max_obj = max_obj
- self.plugin_version = '1'
- self.score_activation = 0
- self.score_threshold = score_thres
-
- def forward(self, x):
- box = x[:, :, :4]
- conf = x[:, :, 4:5]
- score = x[:, :, 5:]
- score *= conf
- num_det, det_boxes, det_scores, det_classes = TRT_NMS.apply(box, score, self.background_class, self.box_coding,
- self.iou_threshold, self.max_obj,
- self.plugin_version, self.score_activation,
- self.score_threshold)
- return num_det, det_boxes, det_scores, det_classes
-
-
-class End2End(nn.Module):
- '''export onnx or tensorrt model with NMS operation.'''
- def __init__(self, model, max_obj=100, iou_thres=0.45, score_thres=0.25, max_wh=None, device=None, with_preprocess=False):
- super().__init__()
- device = device if device else torch.device('cpu')
- self.with_preprocess = with_preprocess
- self.model = model.to(device)
- self.patch_model = ONNX_TRT if max_wh is None else ONNX_ORT
- self.end2end = self.patch_model(max_obj, iou_thres, score_thres, max_wh, device)
- self.end2end.eval()
-
- def forward(self, x):
- if self.with_preprocess:
- x = x[:,[2,1,0],...]
- x = x * (1/255)
- x = self.model(x)
- x = self.end2end(x)
- return x
diff --git a/spaces/PSLD/PSLD/stable-diffusion/main.py b/spaces/PSLD/PSLD/stable-diffusion/main.py
deleted file mode 100644
index e8e18c18fbb01f2e16d9376ea1bfb51f3b5df601..0000000000000000000000000000000000000000
--- a/spaces/PSLD/PSLD/stable-diffusion/main.py
+++ /dev/null
@@ -1,741 +0,0 @@
-import argparse, os, sys, datetime, glob, importlib, csv
-import numpy as np
-import time
-import torch
-import torchvision
-import pytorch_lightning as pl
-
-from packaging import version
-from omegaconf import OmegaConf
-from torch.utils.data import random_split, DataLoader, Dataset, Subset
-from functools import partial
-from PIL import Image
-
-from pytorch_lightning import seed_everything
-from pytorch_lightning.trainer import Trainer
-from pytorch_lightning.callbacks import ModelCheckpoint, Callback, LearningRateMonitor
-from pytorch_lightning.utilities.distributed import rank_zero_only
-from pytorch_lightning.utilities import rank_zero_info
-
-from ldm.data.base import Txt2ImgIterableBaseDataset
-from ldm.util import instantiate_from_config
-
-
-def get_parser(**parser_kwargs):
- def str2bool(v):
- if isinstance(v, bool):
- return v
- if v.lower() in ("yes", "true", "t", "y", "1"):
- return True
- elif v.lower() in ("no", "false", "f", "n", "0"):
- return False
- else:
- raise argparse.ArgumentTypeError("Boolean value expected.")
-
- parser = argparse.ArgumentParser(**parser_kwargs)
- parser.add_argument(
- "-n",
- "--name",
- type=str,
- const=True,
- default="",
- nargs="?",
- help="postfix for logdir",
- )
- parser.add_argument(
- "-r",
- "--resume",
- type=str,
- const=True,
- default="",
- nargs="?",
- help="resume from logdir or checkpoint in logdir",
- )
- parser.add_argument(
- "-b",
- "--base",
- nargs="*",
- metavar="base_config.yaml",
- help="paths to base configs. Loaded from left-to-right. "
- "Parameters can be overwritten or added with command-line options of the form `--key value`.",
- default=list(),
- )
- parser.add_argument(
- "-t",
- "--train",
- type=str2bool,
- const=True,
- default=False,
- nargs="?",
- help="train",
- )
- parser.add_argument(
- "--no-test",
- type=str2bool,
- const=True,
- default=False,
- nargs="?",
- help="disable test",
- )
- parser.add_argument(
- "-p",
- "--project",
- help="name of new or path to existing project"
- )
- parser.add_argument(
- "-d",
- "--debug",
- type=str2bool,
- nargs="?",
- const=True,
- default=False,
- help="enable post-mortem debugging",
- )
- parser.add_argument(
- "-s",
- "--seed",
- type=int,
- default=23,
- help="seed for seed_everything",
- )
- parser.add_argument(
- "-f",
- "--postfix",
- type=str,
- default="",
- help="post-postfix for default name",
- )
- parser.add_argument(
- "-l",
- "--logdir",
- type=str,
- default="logs",
- help="directory for logging dat shit",
- )
- parser.add_argument(
- "--scale_lr",
- type=str2bool,
- nargs="?",
- const=True,
- default=True,
- help="scale base-lr by ngpu * batch_size * n_accumulate",
- )
- return parser
-
-
-def nondefault_trainer_args(opt):
- parser = argparse.ArgumentParser()
- parser = Trainer.add_argparse_args(parser)
- args = parser.parse_args([])
- return sorted(k for k in vars(args) if getattr(opt, k) != getattr(args, k))
-
-
-class WrappedDataset(Dataset):
- """Wraps an arbitrary object with __len__ and __getitem__ into a pytorch dataset"""
-
- def __init__(self, dataset):
- self.data = dataset
-
- def __len__(self):
- return len(self.data)
-
- def __getitem__(self, idx):
- return self.data[idx]
-
-
-def worker_init_fn(_):
- worker_info = torch.utils.data.get_worker_info()
-
- dataset = worker_info.dataset
- worker_id = worker_info.id
-
- if isinstance(dataset, Txt2ImgIterableBaseDataset):
- split_size = dataset.num_records // worker_info.num_workers
- # reset num_records to the true number to retain reliable length information
- dataset.sample_ids = dataset.valid_ids[worker_id * split_size:(worker_id + 1) * split_size]
- current_id = np.random.choice(len(np.random.get_state()[1]), 1)
- return np.random.seed(np.random.get_state()[1][current_id] + worker_id)
- else:
- return np.random.seed(np.random.get_state()[1][0] + worker_id)
-
-
-class DataModuleFromConfig(pl.LightningDataModule):
- def __init__(self, batch_size, train=None, validation=None, test=None, predict=None,
- wrap=False, num_workers=None, shuffle_test_loader=False, use_worker_init_fn=False,
- shuffle_val_dataloader=False):
- super().__init__()
- self.batch_size = batch_size
- self.dataset_configs = dict()
- self.num_workers = num_workers if num_workers is not None else batch_size * 2
- self.use_worker_init_fn = use_worker_init_fn
- if train is not None:
- self.dataset_configs["train"] = train
- self.train_dataloader = self._train_dataloader
- if validation is not None:
- self.dataset_configs["validation"] = validation
- self.val_dataloader = partial(self._val_dataloader, shuffle=shuffle_val_dataloader)
- if test is not None:
- self.dataset_configs["test"] = test
- self.test_dataloader = partial(self._test_dataloader, shuffle=shuffle_test_loader)
- if predict is not None:
- self.dataset_configs["predict"] = predict
- self.predict_dataloader = self._predict_dataloader
- self.wrap = wrap
-
- def prepare_data(self):
- for data_cfg in self.dataset_configs.values():
- instantiate_from_config(data_cfg)
-
- def setup(self, stage=None):
- self.datasets = dict(
- (k, instantiate_from_config(self.dataset_configs[k]))
- for k in self.dataset_configs)
- if self.wrap:
- for k in self.datasets:
- self.datasets[k] = WrappedDataset(self.datasets[k])
-
- def _train_dataloader(self):
- is_iterable_dataset = isinstance(self.datasets['train'], Txt2ImgIterableBaseDataset)
- if is_iterable_dataset or self.use_worker_init_fn:
- init_fn = worker_init_fn
- else:
- init_fn = None
- return DataLoader(self.datasets["train"], batch_size=self.batch_size,
- num_workers=self.num_workers, shuffle=False if is_iterable_dataset else True,
- worker_init_fn=init_fn)
-
- def _val_dataloader(self, shuffle=False):
- if isinstance(self.datasets['validation'], Txt2ImgIterableBaseDataset) or self.use_worker_init_fn:
- init_fn = worker_init_fn
- else:
- init_fn = None
- return DataLoader(self.datasets["validation"],
- batch_size=self.batch_size,
- num_workers=self.num_workers,
- worker_init_fn=init_fn,
- shuffle=shuffle)
-
- def _test_dataloader(self, shuffle=False):
- is_iterable_dataset = isinstance(self.datasets['train'], Txt2ImgIterableBaseDataset)
- if is_iterable_dataset or self.use_worker_init_fn:
- init_fn = worker_init_fn
- else:
- init_fn = None
-
- # do not shuffle dataloader for iterable dataset
- shuffle = shuffle and (not is_iterable_dataset)
-
- return DataLoader(self.datasets["test"], batch_size=self.batch_size,
- num_workers=self.num_workers, worker_init_fn=init_fn, shuffle=shuffle)
-
- def _predict_dataloader(self, shuffle=False):
- if isinstance(self.datasets['predict'], Txt2ImgIterableBaseDataset) or self.use_worker_init_fn:
- init_fn = worker_init_fn
- else:
- init_fn = None
- return DataLoader(self.datasets["predict"], batch_size=self.batch_size,
- num_workers=self.num_workers, worker_init_fn=init_fn)
-
-
-class SetupCallback(Callback):
- def __init__(self, resume, now, logdir, ckptdir, cfgdir, config, lightning_config):
- super().__init__()
- self.resume = resume
- self.now = now
- self.logdir = logdir
- self.ckptdir = ckptdir
- self.cfgdir = cfgdir
- self.config = config
- self.lightning_config = lightning_config
-
- def on_keyboard_interrupt(self, trainer, pl_module):
- if trainer.global_rank == 0:
- print("Summoning checkpoint.")
- ckpt_path = os.path.join(self.ckptdir, "last.ckpt")
- trainer.save_checkpoint(ckpt_path)
-
- def on_pretrain_routine_start(self, trainer, pl_module):
- if trainer.global_rank == 0:
- # Create logdirs and save configs
- os.makedirs(self.logdir, exist_ok=True)
- os.makedirs(self.ckptdir, exist_ok=True)
- os.makedirs(self.cfgdir, exist_ok=True)
-
- if "callbacks" in self.lightning_config:
- if 'metrics_over_trainsteps_checkpoint' in self.lightning_config['callbacks']:
- os.makedirs(os.path.join(self.ckptdir, 'trainstep_checkpoints'), exist_ok=True)
- print("Project config")
- print(OmegaConf.to_yaml(self.config))
- OmegaConf.save(self.config,
- os.path.join(self.cfgdir, "{}-project.yaml".format(self.now)))
-
- print("Lightning config")
- print(OmegaConf.to_yaml(self.lightning_config))
- OmegaConf.save(OmegaConf.create({"lightning": self.lightning_config}),
- os.path.join(self.cfgdir, "{}-lightning.yaml".format(self.now)))
-
- else:
- # ModelCheckpoint callback created log directory --- remove it
- if not self.resume and os.path.exists(self.logdir):
- dst, name = os.path.split(self.logdir)
- dst = os.path.join(dst, "child_runs", name)
- os.makedirs(os.path.split(dst)[0], exist_ok=True)
- try:
- os.rename(self.logdir, dst)
- except FileNotFoundError:
- pass
-
-
-class ImageLogger(Callback):
- def __init__(self, batch_frequency, max_images, clamp=True, increase_log_steps=True,
- rescale=True, disabled=False, log_on_batch_idx=False, log_first_step=False,
- log_images_kwargs=None):
- super().__init__()
- self.rescale = rescale
- self.batch_freq = batch_frequency
- self.max_images = max_images
- self.logger_log_images = {
- pl.loggers.TestTubeLogger: self._testtube,
- }
- self.log_steps = [2 ** n for n in range(int(np.log2(self.batch_freq)) + 1)]
- if not increase_log_steps:
- self.log_steps = [self.batch_freq]
- self.clamp = clamp
- self.disabled = disabled
- self.log_on_batch_idx = log_on_batch_idx
- self.log_images_kwargs = log_images_kwargs if log_images_kwargs else {}
- self.log_first_step = log_first_step
-
- @rank_zero_only
- def _testtube(self, pl_module, images, batch_idx, split):
- for k in images:
- grid = torchvision.utils.make_grid(images[k])
- grid = (grid + 1.0) / 2.0 # -1,1 -> 0,1; c,h,w
-
- tag = f"{split}/{k}"
- pl_module.logger.experiment.add_image(
- tag, grid,
- global_step=pl_module.global_step)
-
- @rank_zero_only
- def log_local(self, save_dir, split, images,
- global_step, current_epoch, batch_idx):
- root = os.path.join(save_dir, "images", split)
- for k in images:
- grid = torchvision.utils.make_grid(images[k], nrow=4)
- if self.rescale:
- grid = (grid + 1.0) / 2.0 # -1,1 -> 0,1; c,h,w
- grid = grid.transpose(0, 1).transpose(1, 2).squeeze(-1)
- grid = grid.numpy()
- grid = (grid * 255).astype(np.uint8)
- filename = "{}_gs-{:06}_e-{:06}_b-{:06}.png".format(
- k,
- global_step,
- current_epoch,
- batch_idx)
- path = os.path.join(root, filename)
- os.makedirs(os.path.split(path)[0], exist_ok=True)
- Image.fromarray(grid).save(path)
-
- def log_img(self, pl_module, batch, batch_idx, split="train"):
- check_idx = batch_idx if self.log_on_batch_idx else pl_module.global_step
- if (self.check_frequency(check_idx) and # batch_idx % self.batch_freq == 0
- hasattr(pl_module, "log_images") and
- callable(pl_module.log_images) and
- self.max_images > 0):
- logger = type(pl_module.logger)
-
- is_train = pl_module.training
- if is_train:
- pl_module.eval()
-
- with torch.no_grad():
- images = pl_module.log_images(batch, split=split, **self.log_images_kwargs)
-
- for k in images:
- N = min(images[k].shape[0], self.max_images)
- images[k] = images[k][:N]
- if isinstance(images[k], torch.Tensor):
- images[k] = images[k].detach().cpu()
- if self.clamp:
- images[k] = torch.clamp(images[k], -1., 1.)
-
- self.log_local(pl_module.logger.save_dir, split, images,
- pl_module.global_step, pl_module.current_epoch, batch_idx)
-
- logger_log_images = self.logger_log_images.get(logger, lambda *args, **kwargs: None)
- logger_log_images(pl_module, images, pl_module.global_step, split)
-
- if is_train:
- pl_module.train()
-
- def check_frequency(self, check_idx):
- if ((check_idx % self.batch_freq) == 0 or (check_idx in self.log_steps)) and (
- check_idx > 0 or self.log_first_step):
- try:
- self.log_steps.pop(0)
- except IndexError as e:
- print(e)
- pass
- return True
- return False
-
- def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
- if not self.disabled and (pl_module.global_step > 0 or self.log_first_step):
- self.log_img(pl_module, batch, batch_idx, split="train")
-
- def on_validation_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
- if not self.disabled and pl_module.global_step > 0:
- self.log_img(pl_module, batch, batch_idx, split="val")
- if hasattr(pl_module, 'calibrate_grad_norm'):
- if (pl_module.calibrate_grad_norm and batch_idx % 25 == 0) and batch_idx > 0:
- self.log_gradients(trainer, pl_module, batch_idx=batch_idx)
-
-
-class CUDACallback(Callback):
- # see https://github.com/SeanNaren/minGPT/blob/master/mingpt/callback.py
- def on_train_epoch_start(self, trainer, pl_module):
- # Reset the memory use counter
- torch.cuda.reset_peak_memory_stats(trainer.root_gpu)
- torch.cuda.synchronize(trainer.root_gpu)
- self.start_time = time.time()
-
- def on_train_epoch_end(self, trainer, pl_module, outputs):
- torch.cuda.synchronize(trainer.root_gpu)
- max_memory = torch.cuda.max_memory_allocated(trainer.root_gpu) / 2 ** 20
- epoch_time = time.time() - self.start_time
-
- try:
- max_memory = trainer.training_type_plugin.reduce(max_memory)
- epoch_time = trainer.training_type_plugin.reduce(epoch_time)
-
- rank_zero_info(f"Average Epoch time: {epoch_time:.2f} seconds")
- rank_zero_info(f"Average Peak memory {max_memory:.2f}MiB")
- except AttributeError:
- pass
-
-
-if __name__ == "__main__":
- # custom parser to specify config files, train, test and debug mode,
- # postfix, resume.
- # `--key value` arguments are interpreted as arguments to the trainer.
- # `nested.key=value` arguments are interpreted as config parameters.
- # configs are merged from left-to-right followed by command line parameters.
-
- # model:
- # base_learning_rate: float
- # target: path to lightning module
- # params:
- # key: value
- # data:
- # target: main.DataModuleFromConfig
- # params:
- # batch_size: int
- # wrap: bool
- # train:
- # target: path to train dataset
- # params:
- # key: value
- # validation:
- # target: path to validation dataset
- # params:
- # key: value
- # test:
- # target: path to test dataset
- # params:
- # key: value
- # lightning: (optional, has sane defaults and can be specified on cmdline)
- # trainer:
- # additional arguments to trainer
- # logger:
- # logger to instantiate
- # modelcheckpoint:
- # modelcheckpoint to instantiate
- # callbacks:
- # callback1:
- # target: importpath
- # params:
- # key: value
-
- now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
-
- # add cwd for convenience and to make classes in this file available when
- # running as `python main.py`
- # (in particular `main.DataModuleFromConfig`)
- sys.path.append(os.getcwd())
-
- parser = get_parser()
- parser = Trainer.add_argparse_args(parser)
-
- opt, unknown = parser.parse_known_args()
- if opt.name and opt.resume:
- raise ValueError(
- "-n/--name and -r/--resume cannot be specified both."
- "If you want to resume training in a new log folder, "
- "use -n/--name in combination with --resume_from_checkpoint"
- )
- if opt.resume:
- if not os.path.exists(opt.resume):
- raise ValueError("Cannot find {}".format(opt.resume))
- if os.path.isfile(opt.resume):
- paths = opt.resume.split("/")
- # idx = len(paths)-paths[::-1].index("logs")+1
- # logdir = "/".join(paths[:idx])
- logdir = "/".join(paths[:-2])
- ckpt = opt.resume
- else:
- assert os.path.isdir(opt.resume), opt.resume
- logdir = opt.resume.rstrip("/")
- ckpt = os.path.join(logdir, "checkpoints", "last.ckpt")
-
- opt.resume_from_checkpoint = ckpt
- base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*.yaml")))
- opt.base = base_configs + opt.base
- _tmp = logdir.split("/")
- nowname = _tmp[-1]
- else:
- if opt.name:
- name = "_" + opt.name
- elif opt.base:
- cfg_fname = os.path.split(opt.base[0])[-1]
- cfg_name = os.path.splitext(cfg_fname)[0]
- name = "_" + cfg_name
- else:
- name = ""
- nowname = now + name + opt.postfix
- logdir = os.path.join(opt.logdir, nowname)
-
- ckptdir = os.path.join(logdir, "checkpoints")
- cfgdir = os.path.join(logdir, "configs")
- seed_everything(opt.seed)
-
- try:
- # init and save configs
- configs = [OmegaConf.load(cfg) for cfg in opt.base]
- cli = OmegaConf.from_dotlist(unknown)
- config = OmegaConf.merge(*configs, cli)
- lightning_config = config.pop("lightning", OmegaConf.create())
- # merge trainer cli with config
- trainer_config = lightning_config.get("trainer", OmegaConf.create())
- # default to ddp
- trainer_config["accelerator"] = "ddp"
- for k in nondefault_trainer_args(opt):
- trainer_config[k] = getattr(opt, k)
- if not "gpus" in trainer_config:
- del trainer_config["accelerator"]
- cpu = True
- else:
- gpuinfo = trainer_config["gpus"]
- print(f"Running on GPUs {gpuinfo}")
- cpu = False
- trainer_opt = argparse.Namespace(**trainer_config)
- lightning_config.trainer = trainer_config
-
- # model
- model = instantiate_from_config(config.model)
-
- # trainer and callbacks
- trainer_kwargs = dict()
-
- # default logger configs
- default_logger_cfgs = {
- "wandb": {
- "target": "pytorch_lightning.loggers.WandbLogger",
- "params": {
- "name": nowname,
- "save_dir": logdir,
- "offline": opt.debug,
- "id": nowname,
- }
- },
- "testtube": {
- "target": "pytorch_lightning.loggers.TestTubeLogger",
- "params": {
- "name": "testtube",
- "save_dir": logdir,
- }
- },
- }
- default_logger_cfg = default_logger_cfgs["testtube"]
- if "logger" in lightning_config:
- logger_cfg = lightning_config.logger
- else:
- logger_cfg = OmegaConf.create()
- logger_cfg = OmegaConf.merge(default_logger_cfg, logger_cfg)
- trainer_kwargs["logger"] = instantiate_from_config(logger_cfg)
-
- # modelcheckpoint - use TrainResult/EvalResult(checkpoint_on=metric) to
- # specify which metric is used to determine best models
- default_modelckpt_cfg = {
- "target": "pytorch_lightning.callbacks.ModelCheckpoint",
- "params": {
- "dirpath": ckptdir,
- "filename": "{epoch:06}",
- "verbose": True,
- "save_last": True,
- }
- }
- if hasattr(model, "monitor"):
- print(f"Monitoring {model.monitor} as checkpoint metric.")
- default_modelckpt_cfg["params"]["monitor"] = model.monitor
- default_modelckpt_cfg["params"]["save_top_k"] = 3
-
- if "modelcheckpoint" in lightning_config:
- modelckpt_cfg = lightning_config.modelcheckpoint
- else:
- modelckpt_cfg = OmegaConf.create()
- modelckpt_cfg = OmegaConf.merge(default_modelckpt_cfg, modelckpt_cfg)
- print(f"Merged modelckpt-cfg: \n{modelckpt_cfg}")
- if version.parse(pl.__version__) < version.parse('1.4.0'):
- trainer_kwargs["checkpoint_callback"] = instantiate_from_config(modelckpt_cfg)
-
- # add callback which sets up log directory
- default_callbacks_cfg = {
- "setup_callback": {
- "target": "main.SetupCallback",
- "params": {
- "resume": opt.resume,
- "now": now,
- "logdir": logdir,
- "ckptdir": ckptdir,
- "cfgdir": cfgdir,
- "config": config,
- "lightning_config": lightning_config,
- }
- },
- "image_logger": {
- "target": "main.ImageLogger",
- "params": {
- "batch_frequency": 750,
- "max_images": 4,
- "clamp": True
- }
- },
- "learning_rate_logger": {
- "target": "main.LearningRateMonitor",
- "params": {
- "logging_interval": "step",
- # "log_momentum": True
- }
- },
- "cuda_callback": {
- "target": "main.CUDACallback"
- },
- }
- if version.parse(pl.__version__) >= version.parse('1.4.0'):
- default_callbacks_cfg.update({'checkpoint_callback': modelckpt_cfg})
-
- if "callbacks" in lightning_config:
- callbacks_cfg = lightning_config.callbacks
- else:
- callbacks_cfg = OmegaConf.create()
-
- if 'metrics_over_trainsteps_checkpoint' in callbacks_cfg:
- print(
- 'Caution: Saving checkpoints every n train steps without deleting. This might require some free space.')
- default_metrics_over_trainsteps_ckpt_dict = {
- 'metrics_over_trainsteps_checkpoint':
- {"target": 'pytorch_lightning.callbacks.ModelCheckpoint',
- 'params': {
- "dirpath": os.path.join(ckptdir, 'trainstep_checkpoints'),
- "filename": "{epoch:06}-{step:09}",
- "verbose": True,
- 'save_top_k': -1,
- 'every_n_train_steps': 10000,
- 'save_weights_only': True
- }
- }
- }
- default_callbacks_cfg.update(default_metrics_over_trainsteps_ckpt_dict)
-
- callbacks_cfg = OmegaConf.merge(default_callbacks_cfg, callbacks_cfg)
- if 'ignore_keys_callback' in callbacks_cfg and hasattr(trainer_opt, 'resume_from_checkpoint'):
- callbacks_cfg.ignore_keys_callback.params['ckpt_path'] = trainer_opt.resume_from_checkpoint
- elif 'ignore_keys_callback' in callbacks_cfg:
- del callbacks_cfg['ignore_keys_callback']
-
- trainer_kwargs["callbacks"] = [instantiate_from_config(callbacks_cfg[k]) for k in callbacks_cfg]
-
- trainer = Trainer.from_argparse_args(trainer_opt, **trainer_kwargs)
- trainer.logdir = logdir ###
-
- # data
- data = instantiate_from_config(config.data)
- # NOTE according to https://pytorch-lightning.readthedocs.io/en/latest/datamodules.html
- # calling these ourselves should not be necessary but it is.
- # lightning still takes care of proper multiprocessing though
- data.prepare_data()
- data.setup()
- print("#### Data #####")
- for k in data.datasets:
- print(f"{k}, {data.datasets[k].__class__.__name__}, {len(data.datasets[k])}")
-
- # configure learning rate
- bs, base_lr = config.data.params.batch_size, config.model.base_learning_rate
- if not cpu:
- ngpu = len(lightning_config.trainer.gpus.strip(",").split(','))
- else:
- ngpu = 1
- if 'accumulate_grad_batches' in lightning_config.trainer:
- accumulate_grad_batches = lightning_config.trainer.accumulate_grad_batches
- else:
- accumulate_grad_batches = 1
- print(f"accumulate_grad_batches = {accumulate_grad_batches}")
- lightning_config.trainer.accumulate_grad_batches = accumulate_grad_batches
- if opt.scale_lr:
- model.learning_rate = accumulate_grad_batches * ngpu * bs * base_lr
- print(
- "Setting learning rate to {:.2e} = {} (accumulate_grad_batches) * {} (num_gpus) * {} (batchsize) * {:.2e} (base_lr)".format(
- model.learning_rate, accumulate_grad_batches, ngpu, bs, base_lr))
- else:
- model.learning_rate = base_lr
- print("++++ NOT USING LR SCALING ++++")
- print(f"Setting learning rate to {model.learning_rate:.2e}")
-
-
- # allow checkpointing via USR1
- def melk(*args, **kwargs):
- # run all checkpoint hooks
- if trainer.global_rank == 0:
- print("Summoning checkpoint.")
- ckpt_path = os.path.join(ckptdir, "last.ckpt")
- trainer.save_checkpoint(ckpt_path)
-
-
- def divein(*args, **kwargs):
- if trainer.global_rank == 0:
- import pudb;
- pudb.set_trace()
-
-
- import signal
-
- signal.signal(signal.SIGUSR1, melk)
- signal.signal(signal.SIGUSR2, divein)
-
- # run
- if opt.train:
- try:
- trainer.fit(model, data)
- except Exception:
- melk()
- raise
- if not opt.no_test and not trainer.interrupted:
- trainer.test(model, data)
- except Exception:
- if opt.debug and trainer.global_rank == 0:
- try:
- import pudb as debugger
- except ImportError:
- import pdb as debugger
- debugger.post_mortem()
- raise
- finally:
- # move newly created debug project to debug_runs
- if opt.debug and not opt.resume and trainer.global_rank == 0:
- dst, name = os.path.split(logdir)
- dst = os.path.join(dst, "debug_runs", name)
- os.makedirs(os.path.split(dst)[0], exist_ok=True)
- os.rename(logdir, dst)
- if trainer.global_rank == 0:
- print(trainer.profiler.summary())
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-26.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-26.go
deleted file mode 100644
index a0741d289f64b444609e098d9cf24f5b8063ddc6..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/guile/2.2/ccache/srfi/srfi-26.go and /dev/null differ
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/output-ps.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/output-ps.go
deleted file mode 100644
index c95823f729378e2e0ddbe3132380a4bd593d517a..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/output-ps.go and /dev/null differ
diff --git a/spaces/Pclanglais/MonadGPT/README.md b/spaces/Pclanglais/MonadGPT/README.md
deleted file mode 100644
index 2994c6cac771cde355cbf364b4bc1e3a29e7628c..0000000000000000000000000000000000000000
--- a/spaces/Pclanglais/MonadGPT/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: MonadGPT
-emoji: 🚀
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-pinned: false
-app_port: 3000
-suggested_hardware: a10g-small
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/models/losses/utils.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/models/losses/utils.py
deleted file mode 100644
index 85aec9f3045240c3de96a928324ae8f5c3aebe8b..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmseg/models/losses/utils.py
+++ /dev/null
@@ -1,121 +0,0 @@
-import functools
-
-import annotator.uniformer.mmcv as mmcv
-import numpy as np
-import torch.nn.functional as F
-
-
-def get_class_weight(class_weight):
- """Get class weight for loss function.
-
- Args:
- class_weight (list[float] | str | None): If class_weight is a str,
- take it as a file name and read from it.
- """
- if isinstance(class_weight, str):
- # take it as a file path
- if class_weight.endswith('.npy'):
- class_weight = np.load(class_weight)
- else:
- # pkl, json or yaml
- class_weight = mmcv.load(class_weight)
-
- return class_weight
-
-
-def reduce_loss(loss, reduction):
- """Reduce loss as specified.
-
- Args:
- loss (Tensor): Elementwise loss tensor.
- reduction (str): Options are "none", "mean" and "sum".
-
- Return:
- Tensor: Reduced loss tensor.
- """
- reduction_enum = F._Reduction.get_enum(reduction)
- # none: 0, elementwise_mean:1, sum: 2
- if reduction_enum == 0:
- return loss
- elif reduction_enum == 1:
- return loss.mean()
- elif reduction_enum == 2:
- return loss.sum()
-
-
-def weight_reduce_loss(loss, weight=None, reduction='mean', avg_factor=None):
- """Apply element-wise weight and reduce loss.
-
- Args:
- loss (Tensor): Element-wise loss.
- weight (Tensor): Element-wise weights.
- reduction (str): Same as built-in losses of PyTorch.
- avg_factor (float): Avarage factor when computing the mean of losses.
-
- Returns:
- Tensor: Processed loss values.
- """
- # if weight is specified, apply element-wise weight
- if weight is not None:
- assert weight.dim() == loss.dim()
- if weight.dim() > 1:
- assert weight.size(1) == 1 or weight.size(1) == loss.size(1)
- loss = loss * weight
-
- # if avg_factor is not specified, just reduce the loss
- if avg_factor is None:
- loss = reduce_loss(loss, reduction)
- else:
- # if reduction is mean, then average the loss by avg_factor
- if reduction == 'mean':
- loss = loss.sum() / avg_factor
- # if reduction is 'none', then do nothing, otherwise raise an error
- elif reduction != 'none':
- raise ValueError('avg_factor can not be used with reduction="sum"')
- return loss
-
-
-def weighted_loss(loss_func):
- """Create a weighted version of a given loss function.
-
- To use this decorator, the loss function must have the signature like
- `loss_func(pred, target, **kwargs)`. The function only needs to compute
- element-wise loss without any reduction. This decorator will add weight
- and reduction arguments to the function. The decorated function will have
- the signature like `loss_func(pred, target, weight=None, reduction='mean',
- avg_factor=None, **kwargs)`.
-
- :Example:
-
- >>> import torch
- >>> @weighted_loss
- >>> def l1_loss(pred, target):
- >>> return (pred - target).abs()
-
- >>> pred = torch.Tensor([0, 2, 3])
- >>> target = torch.Tensor([1, 1, 1])
- >>> weight = torch.Tensor([1, 0, 1])
-
- >>> l1_loss(pred, target)
- tensor(1.3333)
- >>> l1_loss(pred, target, weight)
- tensor(1.)
- >>> l1_loss(pred, target, reduction='none')
- tensor([1., 1., 2.])
- >>> l1_loss(pred, target, weight, avg_factor=2)
- tensor(1.5000)
- """
-
- @functools.wraps(loss_func)
- def wrapper(pred,
- target,
- weight=None,
- reduction='mean',
- avg_factor=None,
- **kwargs):
- # get element-wise loss
- loss = loss_func(pred, target, **kwargs)
- loss = weight_reduce_loss(loss, weight, reduction, avg_factor)
- return loss
-
- return wrapper
diff --git a/spaces/Podtekatel/Arcane_Style_Transfer/README.md b/spaces/Podtekatel/Arcane_Style_Transfer/README.md
deleted file mode 100644
index 9c2f6149d4099419d9357f26533c8436eb729e7f..0000000000000000000000000000000000000000
--- a/spaces/Podtekatel/Arcane_Style_Transfer/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Arcane Style Transfer
-emoji: 👩🏻🔧💎😈
-colorFrom: blue
-colorTo: pink
-sdk: gradio
-sdk_version: 3.8.2
-app_file: app.py
-pinned: true
-license: bsd-3-clause
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Pranjal2041/SemSup-XC/cleaned_code/src/utils.py b/spaces/Pranjal2041/SemSup-XC/cleaned_code/src/utils.py
deleted file mode 100644
index 54d714379938aff99cb64a006f5bf1a84339607b..0000000000000000000000000000000000000000
--- a/spaces/Pranjal2041/SemSup-XC/cleaned_code/src/utils.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import yaml
-from typing import Dict
-import re
-
-
-loader = yaml.SafeLoader
-loader.add_implicit_resolver(
- u'tag:yaml.org,2002:float',
- re.compile(u'''^(?:
- [-+]?(?:[0-9][0-9_]*)\\.[0-9_]*(?:[eE][-+]?[0-9]+)?
- |[-+]?(?:[0-9][0-9_]*)(?:[eE][-+]?[0-9]+)
- |\\.[0-9_]+(?:[eE][-+][0-9]+)?
- |[-+]?[0-9][0-9_]*(?::[0-5]?[0-9])+\\.[0-9_]*
- |[-+]?\\.(?:inf|Inf|INF)
- |\\.(?:nan|NaN|NAN))$''', re.X),
- list(u'-+0123456789.'))
-
-
-def read_yaml_config(file : str, output_dir : str = "", extra_args = {}) -> Dict:
- data = yaml.load(open(file), Loader=loader)
- data = {**{k: v for d in data if isinstance(data[d], dict) for k, v in data[d].items()}, **{k:v for k,v in data.items() if not isinstance(v, dict)}}
- data['output_dir'] = output_dir if output_dir else data['EXP_NAME']
- for e,v in extra_args.items():
- data[e] = v
- print(f'Yaml Config is:\n{"-" * 80}\n{data}\n{"-" * 80}')
- return data
diff --git a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/metrics/clap_consistency.py b/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/metrics/clap_consistency.py
deleted file mode 100644
index d2a6c61ae177533ca2fb17e25bc77d2acbbe3791..0000000000000000000000000000000000000000
--- a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/metrics/clap_consistency.py
+++ /dev/null
@@ -1,84 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from pathlib import Path
-import typing as tp
-
-import torch
-import torchmetrics
-from transformers import RobertaTokenizer # type: ignore
-
-from ..data.audio_utils import convert_audio
-from ..environment import AudioCraftEnvironment
-from ..utils.utils import load_clap_state_dict
-
-try:
- import laion_clap # type: ignore
-except ImportError:
- laion_clap = None
-
-
-class TextConsistencyMetric(torchmetrics.Metric):
- """Text consistency metric measuring consistency between audio and text pairs."""
-
- def update(self, audio: torch.Tensor, text: tp.List[str], sizes: torch.Tensor, sample_rates: torch.Tensor) -> None:
- raise NotImplementedError("implement how to update the metric from the audio and text pairs.")
-
- def compute(self):
- raise NotImplementedError("implement how to compute the final metric score.")
-
-
-class CLAPTextConsistencyMetric(TextConsistencyMetric):
- """Text consistency metric relying on Contrastive Language-Audio Pretraining (CLAP).
-
- This metric is similar to the MuLan Cycle Consistency from MusicLM (https://arxiv.org/pdf/2301.11325.pdf)
- or the CLAP score used in Make-An-Audio (https://arxiv.org/pdf/2301.12661v1.pdf).
-
- As a joint audio-text embedding model, a pretrained CLAP model can be used to quantify the
- similarity between audio-text pairs. We compute the CLAP embeddings from the text descriptions as
- well as the generated audio based on them, and define the MCC metric as the average cosine similarity
- between these embeddings.
-
- Model implementation & pre-trained checkpoints: https://github.com/LAION-AI/CLAP
- """
- def __init__(self, model_path: tp.Union[str, Path], model_arch: str = 'HTSAT-tiny', enable_fusion: bool = False):
- super().__init__()
- if laion_clap is None:
- raise ImportError("Please install CLAP to compute text consistency: 'pip install laion_clap'")
- self.add_state("cosine_sum", default=torch.tensor(0.), dist_reduce_fx="sum")
- self.add_state("weight", default=torch.tensor(0.), dist_reduce_fx="sum")
- self._initialize_model(model_path, model_arch, enable_fusion)
-
- def _initialize_model(self, model_path: tp.Union[str, Path], model_arch: str, enable_fusion: bool):
- model_path = AudioCraftEnvironment.resolve_reference_path(model_path)
- self.tokenize = RobertaTokenizer.from_pretrained('roberta-base')
- self.model = laion_clap.CLAP_Module(enable_fusion=enable_fusion, amodel=model_arch)
- self.model_sample_rate = 48_000
- load_clap_state_dict(self.model, model_path)
- self.model.eval()
-
- def _tokenizer(self, texts: tp.Union[str, tp.List[str]]) -> dict:
- # we use the default params from CLAP module here as well
- return self.tokenize(texts, padding="max_length", truncation=True, max_length=77, return_tensors="pt")
-
- def update(self, audio: torch.Tensor, text: tp.List[str], sizes: torch.Tensor, sample_rates: torch.Tensor) -> None:
- """Compute cosine similarity between audio and text pairs and accumulate scores over the dataset."""
- assert audio.size(0) == len(text), "Number of audio and text samples should match"
- assert torch.all(sample_rates == sample_rates[0].item()), "All items in batch should have the same sample rate"
- sample_rate = int(sample_rates[0].item())
- # convert audio batch to 48kHz monophonic audio with no channel dimension: [B, C, T] -> [B, T]
- audio = convert_audio(audio, from_rate=sample_rate, to_rate=self.model_sample_rate, to_channels=1).mean(dim=1)
- audio_embeddings = self.model.get_audio_embedding_from_data(audio, use_tensor=True)
- text_embeddings = self.model.get_text_embedding(text, tokenizer=self._tokenizer, use_tensor=True)
- # cosine similarity between the text and the audio embedding
- cosine_sim = torch.nn.functional.cosine_similarity(audio_embeddings, text_embeddings, dim=1, eps=1e-8)
- self.cosine_sum += cosine_sim.sum(dim=0)
- self.weight += torch.tensor(cosine_sim.size(0))
-
- def compute(self):
- """Computes the average cosine similarty across all audio/text pairs."""
- assert self.weight.item() > 0, "Unable to compute with total number of comparisons <= 0" # type: ignore
- return (self.cosine_sum / self.weight).item() # type: ignore
diff --git a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/optim/polynomial_decay_lr_scheduler.py b/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/optim/polynomial_decay_lr_scheduler.py
deleted file mode 100644
index c5ea30b094538269dbb0055ab3163f84d1cf6e90..0000000000000000000000000000000000000000
--- a/spaces/Prof-Reza/Audiocraft_Music-Audio_Generation/audiocraft/optim/polynomial_decay_lr_scheduler.py
+++ /dev/null
@@ -1,47 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-from torch.optim import Optimizer
-from torch.optim.lr_scheduler import _LRScheduler
-
-
-class PolynomialDecayLRScheduler(_LRScheduler):
- """Polynomial decay LR scheduler.
-
- Args:
- optimizer (Optimizer): Torch optimizer.
- warmup_steps (int): Number of warmup steps.
- total_steps (int): Total number of steps.
- end_lr (float): Final learning rate to achieve over total number of steps.
- zero_lr_warmup_steps (int): Number of steps with a learning rate of value 0.
- power (float): Decay exponent.
- """
- def __init__(self, optimizer: Optimizer, warmup_steps: int, total_steps: int,
- end_lr: float = 0., zero_lr_warmup_steps: int = 0, power: float = 1.):
- self.warmup_steps = warmup_steps
- self.total_steps = total_steps
- self.end_lr = end_lr
- self.zero_lr_warmup_steps = zero_lr_warmup_steps
- self.power = power
- super().__init__(optimizer)
-
- def _get_sched_lr(self, lr: float, step: int):
- if self.zero_lr_warmup_steps > 0 and step <= self.zero_lr_warmup_steps:
- lr = 0
- elif self.warmup_steps > 0 and step <= self.warmup_steps + self.zero_lr_warmup_steps:
- lr_ratio = (step - self.zero_lr_warmup_steps) / float(self.warmup_steps)
- lr = lr_ratio * lr
- elif step >= self.total_steps:
- lr = self.end_lr
- else:
- total_warmup_steps = self.warmup_steps + self.zero_lr_warmup_steps
- lr_range = lr - self.end_lr
- pct_remaining = 1 - (step - total_warmup_steps) / (self.total_steps - total_warmup_steps)
- lr = lr_range * pct_remaining ** self.power + self.end_lr
- return lr
-
- def get_lr(self):
- return [self._get_sched_lr(base_lr, self.last_epoch) for base_lr in self.base_lrs]
diff --git a/spaces/Rakot2223/faster-whisper-webui/app.py b/spaces/Rakot2223/faster-whisper-webui/app.py
deleted file mode 100644
index b87cf044822410d851f0567497ca4adfbd324144..0000000000000000000000000000000000000000
--- a/spaces/Rakot2223/faster-whisper-webui/app.py
+++ /dev/null
@@ -1,544 +0,0 @@
-from datetime import datetime
-import math
-from typing import Iterator, Union
-import argparse
-
-from io import StringIO
-import os
-import pathlib
-import tempfile
-import zipfile
-import numpy as np
-
-import torch
-
-from src.config import ApplicationConfig, VadInitialPromptMode
-from src.hooks.progressListener import ProgressListener
-from src.hooks.subTaskProgressListener import SubTaskProgressListener
-from src.hooks.whisperProgressHook import create_progress_listener_handle
-from src.languages import get_language_names
-from src.modelCache import ModelCache
-from src.source import get_audio_source_collection
-from src.vadParallel import ParallelContext, ParallelTranscription
-
-# External programs
-import ffmpeg
-
-# UI
-import gradio as gr
-
-from src.download import ExceededMaximumDuration, download_url
-from src.utils import slugify, write_srt, write_vtt
-from src.vad import AbstractTranscription, NonSpeechStrategy, PeriodicTranscriptionConfig, TranscriptionConfig, VadPeriodicTranscription, VadSileroTranscription
-from src.whisper.abstractWhisperContainer import AbstractWhisperContainer
-from src.whisper.whisperFactory import create_whisper_container
-
-# Configure more application defaults in config.json5
-
-# Gradio seems to truncate files without keeping the extension, so we need to truncate the file prefix ourself
-MAX_FILE_PREFIX_LENGTH = 17
-
-# Limit auto_parallel to a certain number of CPUs (specify vad_cpu_cores to get a higher number)
-MAX_AUTO_CPU_CORES = 8
-
-WHISPER_MODELS = ["tiny", "base", "small", "medium", "large", "large-v1", "large-v2"]
-
-class VadOptions:
- def __init__(self, vad: str = None, vadMergeWindow: float = 5, vadMaxMergeSize: float = 150, vadPadding: float = 1, vadPromptWindow: float = 1,
- vadInitialPromptMode: Union[VadInitialPromptMode, str] = VadInitialPromptMode.PREPREND_FIRST_SEGMENT):
- self.vad = vad
- self.vadMergeWindow = vadMergeWindow
- self.vadMaxMergeSize = vadMaxMergeSize
- self.vadPadding = vadPadding
- self.vadPromptWindow = vadPromptWindow
- self.vadInitialPromptMode = vadInitialPromptMode if isinstance(vadInitialPromptMode, VadInitialPromptMode) \
- else VadInitialPromptMode.from_string(vadInitialPromptMode)
-
-class WhisperTranscriber:
- def __init__(self, input_audio_max_duration: float = None, vad_process_timeout: float = None,
- vad_cpu_cores: int = 1, delete_uploaded_files: bool = False, output_dir: str = None,
- app_config: ApplicationConfig = None):
- self.model_cache = ModelCache()
- self.parallel_device_list = None
- self.gpu_parallel_context = None
- self.cpu_parallel_context = None
- self.vad_process_timeout = vad_process_timeout
- self.vad_cpu_cores = vad_cpu_cores
-
- self.vad_model = None
- self.inputAudioMaxDuration = input_audio_max_duration
- self.deleteUploadedFiles = delete_uploaded_files
- self.output_dir = output_dir
-
- self.app_config = app_config
-
- def set_parallel_devices(self, vad_parallel_devices: str):
- self.parallel_device_list = [ device.strip() for device in vad_parallel_devices.split(",") ] if vad_parallel_devices else None
-
- def set_auto_parallel(self, auto_parallel: bool):
- if auto_parallel:
- if torch.cuda.is_available():
- self.parallel_device_list = [ str(gpu_id) for gpu_id in range(torch.cuda.device_count())]
-
- self.vad_cpu_cores = min(os.cpu_count(), MAX_AUTO_CPU_CORES)
- print("[Auto parallel] Using GPU devices " + str(self.parallel_device_list) + " and " + str(self.vad_cpu_cores) + " CPU cores for VAD/transcription.")
-
- # Entry function for the simple tab
- def transcribe_webui_simple(self, modelName, languageName, urlData, multipleFiles, microphoneData, task, vad, vadMergeWindow, vadMaxMergeSize, vadPadding, vadPromptWindow,
- progress=gr.Progress()):
-
- vadOptions = VadOptions(vad, vadMergeWindow, vadMaxMergeSize, vadPadding, vadPromptWindow, self.app_config.vad_initial_prompt_mode)
-
- return self.transcribe_webui(modelName, languageName, urlData, multipleFiles, microphoneData, task, vadOptions, progress=progress)
-
- # Entry function for the full tab
- def transcribe_webui_full(self, modelName, languageName, urlData, multipleFiles, microphoneData, task,
- vad, vadMergeWindow, vadMaxMergeSize, vadPadding, vadPromptWindow, vadInitialPromptMode,
- initial_prompt: str, temperature: float, best_of: int, beam_size: int, patience: float, length_penalty: float, suppress_tokens: str,
- condition_on_previous_text: bool, fp16: bool, temperature_increment_on_fallback: float,
- compression_ratio_threshold: float, logprob_threshold: float, no_speech_threshold: float,
- progress=gr.Progress()):
-
- # Handle temperature_increment_on_fallback
- if temperature_increment_on_fallback is not None:
- temperature = tuple(np.arange(temperature, 1.0 + 1e-6, temperature_increment_on_fallback))
- else:
- temperature = [temperature]
-
- vadOptions = VadOptions(vad, vadMergeWindow, vadMaxMergeSize, vadPadding, vadPromptWindow, vadInitialPromptMode)
-
- return self.transcribe_webui(modelName, languageName, urlData, multipleFiles, microphoneData, task, vadOptions,
- initial_prompt=initial_prompt, temperature=temperature, best_of=best_of, beam_size=beam_size, patience=patience, length_penalty=length_penalty, suppress_tokens=suppress_tokens,
- condition_on_previous_text=condition_on_previous_text, fp16=fp16,
- compression_ratio_threshold=compression_ratio_threshold, logprob_threshold=logprob_threshold, no_speech_threshold=no_speech_threshold,
- progress=progress)
-
- def transcribe_webui(self, modelName, languageName, urlData, multipleFiles, microphoneData, task,
- vadOptions: VadOptions, progress: gr.Progress = None, **decodeOptions: dict):
- try:
- sources = self.__get_source(urlData, multipleFiles, microphoneData)
-
- try:
- selectedLanguage = languageName.lower() if len(languageName) > 0 else None
- selectedModel = modelName if modelName is not None else "base"
-
- model = create_whisper_container(whisper_implementation=self.app_config.whisper_implementation,
- model_name=selectedModel, compute_type=self.app_config.compute_type,
- cache=self.model_cache, models=self.app_config.models)
-
- # Result
- download = []
- zip_file_lookup = {}
- text = ""
- vtt = ""
-
- # Write result
- downloadDirectory = tempfile.mkdtemp()
- source_index = 0
-
- outputDirectory = self.output_dir if self.output_dir is not None else downloadDirectory
-
- # Progress
- total_duration = sum([source.get_audio_duration() for source in sources])
- current_progress = 0
-
- # A listener that will report progress to Gradio
- root_progress_listener = self._create_progress_listener(progress)
-
- # Execute whisper
- for source in sources:
- source_prefix = ""
- source_audio_duration = source.get_audio_duration()
-
- if (len(sources) > 1):
- # Prefix (minimum 2 digits)
- source_index += 1
- source_prefix = str(source_index).zfill(2) + "_"
- print("Transcribing ", source.source_path)
-
- scaled_progress_listener = SubTaskProgressListener(root_progress_listener,
- base_task_total=total_duration,
- sub_task_start=current_progress,
- sub_task_total=source_audio_duration)
-
- # Transcribe
- result = self.transcribe_file(model, source.source_path, selectedLanguage, task, vadOptions, scaled_progress_listener, **decodeOptions)
- filePrefix = slugify(source_prefix + source.get_short_name(), allow_unicode=True)
-
- # Update progress
- current_progress += source_audio_duration
-
- source_download, source_text, source_vtt = self.write_result(result, filePrefix, outputDirectory)
-
- if len(sources) > 1:
- # Add new line separators
- if (len(source_text) > 0):
- source_text += os.linesep + os.linesep
- if (len(source_vtt) > 0):
- source_vtt += os.linesep + os.linesep
-
- # Append file name to source text too
- source_text = source.get_full_name() + ":" + os.linesep + source_text
- source_vtt = source.get_full_name() + ":" + os.linesep + source_vtt
-
- # Add to result
- download.extend(source_download)
- text += source_text
- vtt += source_vtt
-
- if (len(sources) > 1):
- # Zip files support at least 260 characters, but we'll play it safe and use 200
- zipFilePrefix = slugify(source_prefix + source.get_short_name(max_length=200), allow_unicode=True)
-
- # File names in ZIP file can be longer
- for source_download_file in source_download:
- # Get file postfix (after last -)
- filePostfix = os.path.basename(source_download_file).split("-")[-1]
- zip_file_name = zipFilePrefix + "-" + filePostfix
- zip_file_lookup[source_download_file] = zip_file_name
-
- # Create zip file from all sources
- if len(sources) > 1:
- downloadAllPath = os.path.join(downloadDirectory, "All_Output-" + datetime.now().strftime("%Y%m%d-%H%M%S") + ".zip")
-
- with zipfile.ZipFile(downloadAllPath, 'w', zipfile.ZIP_DEFLATED) as zip:
- for download_file in download:
- # Get file name from lookup
- zip_file_name = zip_file_lookup.get(download_file, os.path.basename(download_file))
- zip.write(download_file, arcname=zip_file_name)
-
- download.insert(0, downloadAllPath)
-
- return download, text, vtt
-
- finally:
- # Cleanup source
- if self.deleteUploadedFiles:
- for source in sources:
- print("Deleting source file " + source.source_path)
-
- try:
- os.remove(source.source_path)
- except Exception as e:
- # Ignore error - it's just a cleanup
- print("Error deleting source file " + source.source_path + ": " + str(e))
-
- except ExceededMaximumDuration as e:
- return [], ("[ERROR]: Maximum remote video length is " + str(e.maxDuration) + "s, file was " + str(e.videoDuration) + "s"), "[ERROR]"
-
- def transcribe_file(self, model: AbstractWhisperContainer, audio_path: str, language: str, task: str = None,
- vadOptions: VadOptions = VadOptions(),
- progressListener: ProgressListener = None, **decodeOptions: dict):
-
- initial_prompt = decodeOptions.pop('initial_prompt', None)
-
- if progressListener is None:
- # Default progress listener
- progressListener = ProgressListener()
-
- if ('task' in decodeOptions):
- task = decodeOptions.pop('task')
-
- # Callable for processing an audio file
- whisperCallable = model.create_callback(language, task, initial_prompt, initial_prompt_mode=vadOptions.vadInitialPromptMode, **decodeOptions)
-
- # The results
- if (vadOptions.vad == 'silero-vad'):
- # Silero VAD where non-speech gaps are transcribed
- process_gaps = self._create_silero_config(NonSpeechStrategy.CREATE_SEGMENT, vadOptions)
- result = self.process_vad(audio_path, whisperCallable, self.vad_model, process_gaps, progressListener=progressListener)
- elif (vadOptions.vad == 'silero-vad-skip-gaps'):
- # Silero VAD where non-speech gaps are simply ignored
- skip_gaps = self._create_silero_config(NonSpeechStrategy.SKIP, vadOptions)
- result = self.process_vad(audio_path, whisperCallable, self.vad_model, skip_gaps, progressListener=progressListener)
- elif (vadOptions.vad == 'silero-vad-expand-into-gaps'):
- # Use Silero VAD where speech-segments are expanded into non-speech gaps
- expand_gaps = self._create_silero_config(NonSpeechStrategy.EXPAND_SEGMENT, vadOptions)
- result = self.process_vad(audio_path, whisperCallable, self.vad_model, expand_gaps, progressListener=progressListener)
- elif (vadOptions.vad == 'periodic-vad'):
- # Very simple VAD - mark every 5 minutes as speech. This makes it less likely that Whisper enters an infinite loop, but
- # it may create a break in the middle of a sentence, causing some artifacts.
- periodic_vad = VadPeriodicTranscription()
- period_config = PeriodicTranscriptionConfig(periodic_duration=vadOptions.vadMaxMergeSize, max_prompt_window=vadOptions.vadPromptWindow)
- result = self.process_vad(audio_path, whisperCallable, periodic_vad, period_config, progressListener=progressListener)
-
- else:
- if (self._has_parallel_devices()):
- # Use a simple period transcription instead, as we need to use the parallel context
- periodic_vad = VadPeriodicTranscription()
- period_config = PeriodicTranscriptionConfig(periodic_duration=math.inf, max_prompt_window=1)
-
- result = self.process_vad(audio_path, whisperCallable, periodic_vad, period_config, progressListener=progressListener)
- else:
- # Default VAD
- result = whisperCallable.invoke(audio_path, 0, None, None, progress_listener=progressListener)
-
- return result
-
- def _create_progress_listener(self, progress: gr.Progress):
- if (progress is None):
- # Dummy progress listener
- return ProgressListener()
-
- class ForwardingProgressListener(ProgressListener):
- def __init__(self, progress: gr.Progress):
- self.progress = progress
-
- def on_progress(self, current: Union[int, float], total: Union[int, float]):
- # From 0 to 1
- self.progress(current / total)
-
- def on_finished(self):
- self.progress(1)
-
- return ForwardingProgressListener(progress)
-
- def process_vad(self, audio_path, whisperCallable, vadModel: AbstractTranscription, vadConfig: TranscriptionConfig,
- progressListener: ProgressListener = None):
- if (not self._has_parallel_devices()):
- # No parallel devices, so just run the VAD and Whisper in sequence
- return vadModel.transcribe(audio_path, whisperCallable, vadConfig, progressListener=progressListener)
-
- gpu_devices = self.parallel_device_list
-
- if (gpu_devices is None or len(gpu_devices) == 0):
- # No GPU devices specified, pass the current environment variable to the first GPU process. This may be NULL.
- gpu_devices = [os.environ.get("CUDA_VISIBLE_DEVICES", None)]
-
- # Create parallel context if needed
- if (self.gpu_parallel_context is None):
- # Create a context wih processes and automatically clear the pool after 1 hour of inactivity
- self.gpu_parallel_context = ParallelContext(num_processes=len(gpu_devices), auto_cleanup_timeout_seconds=self.vad_process_timeout)
- # We also need a CPU context for the VAD
- if (self.cpu_parallel_context is None):
- self.cpu_parallel_context = ParallelContext(num_processes=self.vad_cpu_cores, auto_cleanup_timeout_seconds=self.vad_process_timeout)
-
- parallel_vad = ParallelTranscription()
- return parallel_vad.transcribe_parallel(transcription=vadModel, audio=audio_path, whisperCallable=whisperCallable,
- config=vadConfig, cpu_device_count=self.vad_cpu_cores, gpu_devices=gpu_devices,
- cpu_parallel_context=self.cpu_parallel_context, gpu_parallel_context=self.gpu_parallel_context,
- progress_listener=progressListener)
-
- def _has_parallel_devices(self):
- return (self.parallel_device_list is not None and len(self.parallel_device_list) > 0) or self.vad_cpu_cores > 1
-
- def _concat_prompt(self, prompt1, prompt2):
- if (prompt1 is None):
- return prompt2
- elif (prompt2 is None):
- return prompt1
- else:
- return prompt1 + " " + prompt2
-
- def _create_silero_config(self, non_speech_strategy: NonSpeechStrategy, vadOptions: VadOptions):
- # Use Silero VAD
- if (self.vad_model is None):
- self.vad_model = VadSileroTranscription()
-
- config = TranscriptionConfig(non_speech_strategy = non_speech_strategy,
- max_silent_period=vadOptions.vadMergeWindow, max_merge_size=vadOptions.vadMaxMergeSize,
- segment_padding_left=vadOptions.vadPadding, segment_padding_right=vadOptions.vadPadding,
- max_prompt_window=vadOptions.vadPromptWindow)
-
- return config
-
- def write_result(self, result: dict, source_name: str, output_dir: str):
- if not os.path.exists(output_dir):
- os.makedirs(output_dir)
-
- text = result["text"]
- language = result["language"]
- languageMaxLineWidth = self.__get_max_line_width(language)
-
- print("Max line width " + str(languageMaxLineWidth))
- vtt = self.__get_subs(result["segments"], "vtt", languageMaxLineWidth)
- srt = self.__get_subs(result["segments"], "srt", languageMaxLineWidth)
-
- output_files = []
- output_files.append(self.__create_file(srt, output_dir, source_name + "-subs.srt"));
- output_files.append(self.__create_file(vtt, output_dir, source_name + "-subs.vtt"));
- output_files.append(self.__create_file(text, output_dir, source_name + "-transcript.txt"));
-
- return output_files, text, vtt
-
- def clear_cache(self):
- self.model_cache.clear()
- self.vad_model = None
-
- def __get_source(self, urlData, multipleFiles, microphoneData):
- return get_audio_source_collection(urlData, multipleFiles, microphoneData, self.inputAudioMaxDuration)
-
- def __get_max_line_width(self, language: str) -> int:
- if (language and language.lower() in ["japanese", "ja", "chinese", "zh"]):
- # Chinese characters and kana are wider, so limit line length to 40 characters
- return 40
- else:
- # TODO: Add more languages
- # 80 latin characters should fit on a 1080p/720p screen
- return 80
-
- def __get_subs(self, segments: Iterator[dict], format: str, maxLineWidth: int) -> str:
- segmentStream = StringIO()
-
- if format == 'vtt':
- write_vtt(segments, file=segmentStream, maxLineWidth=maxLineWidth)
- elif format == 'srt':
- write_srt(segments, file=segmentStream, maxLineWidth=maxLineWidth)
- else:
- raise Exception("Unknown format " + format)
-
- segmentStream.seek(0)
- return segmentStream.read()
-
- def __create_file(self, text: str, directory: str, fileName: str) -> str:
- # Write the text to a file
- with open(os.path.join(directory, fileName), 'w+', encoding="utf-8") as file:
- file.write(text)
-
- return file.name
-
- def close(self):
- print("Closing parallel contexts")
- self.clear_cache()
-
- if (self.gpu_parallel_context is not None):
- self.gpu_parallel_context.close()
- if (self.cpu_parallel_context is not None):
- self.cpu_parallel_context.close()
-
-
-def create_ui(app_config: ApplicationConfig):
- ui = WhisperTranscriber(app_config.input_audio_max_duration, app_config.vad_process_timeout, app_config.vad_cpu_cores,
- app_config.delete_uploaded_files, app_config.output_dir, app_config)
-
- # Specify a list of devices to use for parallel processing
- ui.set_parallel_devices(app_config.vad_parallel_devices)
- ui.set_auto_parallel(app_config.auto_parallel)
-
- is_whisper = False
-
- if app_config.whisper_implementation == "whisper":
- implementation_name = "Whisper"
- is_whisper = True
- elif app_config.whisper_implementation in ["faster-whisper", "faster_whisper"]:
- implementation_name = "Faster Whisper"
- else:
- # Try to convert from camel-case to title-case
- implementation_name = app_config.whisper_implementation.title().replace("_", " ").replace("-", " ")
-
- ui_description = implementation_name + " is a general-purpose speech recognition model. It is trained on a large dataset of diverse "
- ui_description += " audio and is also a multi-task model that can perform multilingual speech recognition "
- ui_description += " as well as speech translation and language identification. "
-
- ui_description += "\n\n\n\nFor longer audio files (>10 minutes) not in English, it is recommended that you select Silero VAD (Voice Activity Detector) in the VAD option."
-
- # Recommend faster-whisper
- if is_whisper:
- ui_description += "\n\n\n\nFor faster inference on GPU, try [faster-whisper](https://huggingface.co/spaces/aadnk/faster-whisper-webui)."
-
- if app_config.input_audio_max_duration > 0:
- ui_description += "\n\n" + "Max audio file length: " + str(app_config.input_audio_max_duration) + " s"
-
- ui_article = "Read the [documentation here](https://gitlab.com/aadnk/whisper-webui/-/blob/main/docs/options.md)."
-
- whisper_models = app_config.get_model_names()
-
- simple_inputs = lambda : [
- gr.Dropdown(choices=whisper_models, value=app_config.default_model_name, label="Model"),
- gr.Dropdown(choices=sorted(get_language_names()), label="Language", value=app_config.language),
- gr.Text(label="URL (YouTube, etc.)"),
- gr.File(label="Upload Files", file_count="multiple"),
- gr.Audio(source="microphone", type="filepath", label="Microphone Input"),
- gr.Dropdown(choices=["transcribe", "translate"], label="Task", value=app_config.task),
- gr.Dropdown(choices=["none", "silero-vad", "silero-vad-skip-gaps", "silero-vad-expand-into-gaps", "periodic-vad"], value=app_config.default_vad, label="VAD"),
- gr.Number(label="VAD - Merge Window (s)", precision=0, value=app_config.vad_merge_window),
- gr.Number(label="VAD - Max Merge Size (s)", precision=0, value=app_config.vad_max_merge_size),
- gr.Number(label="VAD - Padding (s)", precision=None, value=app_config.vad_padding),
- gr.Number(label="VAD - Prompt Window (s)", precision=None, value=app_config.vad_prompt_window),
- ]
-
- simple_transcribe = gr.Interface(fn=ui.transcribe_webui_simple, description=ui_description, article=ui_article, inputs=simple_inputs(), outputs=[
- gr.File(label="Download"),
- gr.Text(label="Transcription"),
- gr.Text(label="Segments")
- ])
-
- full_description = ui_description + "\n\n\n\n" + "Be careful when changing some of the options in the full interface - this can cause the model to crash."
-
- full_transcribe = gr.Interface(fn=ui.transcribe_webui_full, description=full_description, article=ui_article, inputs=[
- *simple_inputs(),
- gr.Dropdown(choices=["prepend_first_segment", "prepend_all_segments"], value=app_config.vad_initial_prompt_mode, label="VAD - Initial Prompt Mode"),
- gr.TextArea(label="Initial Prompt"),
- gr.Number(label="Temperature", value=app_config.temperature),
- gr.Number(label="Best Of - Non-zero temperature", value=app_config.best_of, precision=0),
- gr.Number(label="Beam Size - Zero temperature", value=app_config.beam_size, precision=0),
- gr.Number(label="Patience - Zero temperature", value=app_config.patience),
- gr.Number(label="Length Penalty - Any temperature", value=app_config.length_penalty),
- gr.Text(label="Suppress Tokens - Comma-separated list of token IDs", value=app_config.suppress_tokens),
- gr.Checkbox(label="Condition on previous text", value=app_config.condition_on_previous_text),
- gr.Checkbox(label="FP16", value=app_config.fp16),
- gr.Number(label="Temperature increment on fallback", value=app_config.temperature_increment_on_fallback),
- gr.Number(label="Compression ratio threshold", value=app_config.compression_ratio_threshold),
- gr.Number(label="Logprob threshold", value=app_config.logprob_threshold),
- gr.Number(label="No speech threshold", value=app_config.no_speech_threshold)
- ], outputs=[
- gr.File(label="Download"),
- gr.Text(label="Transcription"),
- gr.Text(label="Segments")
- ])
-
- demo = gr.TabbedInterface([simple_transcribe, full_transcribe], tab_names=["Simple", "Full"])
-
- # Queue up the demo
- if app_config.queue_concurrency_count is not None and app_config.queue_concurrency_count > 0:
- demo.queue(concurrency_count=app_config.queue_concurrency_count)
-
- demo.launch(share=app_config.share, server_name=app_config.server_name, server_port=app_config.server_port)
-
- # Clean up
- ui.close()
-
-if __name__ == '__main__':
- default_app_config = ApplicationConfig.create_default()
- whisper_models = default_app_config.get_model_names()
-
- # Environment variable overrides
- default_whisper_implementation = os.environ.get("WHISPER_IMPLEMENTATION", default_app_config.whisper_implementation)
-
- parser = argparse.ArgumentParser(formatter_class=argparse.ArgumentDefaultsHelpFormatter)
- parser.add_argument("--input_audio_max_duration", type=int, default=default_app_config.input_audio_max_duration, \
- help="Maximum audio file length in seconds, or -1 for no limit.") # 600
- parser.add_argument("--share", type=bool, default=default_app_config.share, \
- help="True to share the app on HuggingFace.") # False
- parser.add_argument("--server_name", type=str, default=default_app_config.server_name, \
- help="The host or IP to bind to. If None, bind to localhost.") # None
- parser.add_argument("--server_port", type=int, default=default_app_config.server_port, \
- help="The port to bind to.") # 7860
- parser.add_argument("--queue_concurrency_count", type=int, default=default_app_config.queue_concurrency_count, \
- help="The number of concurrent requests to process.") # 1
- parser.add_argument("--default_model_name", type=str, choices=whisper_models, default=default_app_config.default_model_name, \
- help="The default model name.") # medium
- parser.add_argument("--default_vad", type=str, default=default_app_config.default_vad, \
- help="The default VAD.") # silero-vad
- parser.add_argument("--vad_initial_prompt_mode", type=str, default=default_app_config.vad_initial_prompt_mode, choices=["prepend_all_segments", "prepend_first_segment"], \
- help="Whether or not to prepend the initial prompt to each VAD segment (prepend_all_segments), or just the first segment (prepend_first_segment)") # prepend_first_segment
- parser.add_argument("--vad_parallel_devices", type=str, default=default_app_config.vad_parallel_devices, \
- help="A commma delimited list of CUDA devices to use for parallel processing. If None, disable parallel processing.") # ""
- parser.add_argument("--vad_cpu_cores", type=int, default=default_app_config.vad_cpu_cores, \
- help="The number of CPU cores to use for VAD pre-processing.") # 1
- parser.add_argument("--vad_process_timeout", type=float, default=default_app_config.vad_process_timeout, \
- help="The number of seconds before inactivate processes are terminated. Use 0 to close processes immediately, or None for no timeout.") # 1800
- parser.add_argument("--auto_parallel", type=bool, default=default_app_config.auto_parallel, \
- help="True to use all available GPUs and CPU cores for processing. Use vad_cpu_cores/vad_parallel_devices to specify the number of CPU cores/GPUs to use.") # False
- parser.add_argument("--output_dir", "-o", type=str, default=default_app_config.output_dir, \
- help="directory to save the outputs")
- parser.add_argument("--whisper_implementation", type=str, default=default_whisper_implementation, choices=["whisper", "faster-whisper"],\
- help="the Whisper implementation to use")
- parser.add_argument("--compute_type", type=str, default=default_app_config.compute_type, choices=["default", "auto", "int8", "int8_float16", "int16", "float16", "float32"], \
- help="the compute type to use for inference")
-
- args = parser.parse_args().__dict__
-
- updated_config = default_app_config.update(**args)
-
- create_ui(app_config=updated_config)
\ No newline at end of file
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/common.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/common.py
deleted file mode 100644
index 1859fb79cc4e78850b69742fca56698041ce59f8..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_vendor/pyparsing/common.py
+++ /dev/null
@@ -1,424 +0,0 @@
-# common.py
-from .core import *
-from .helpers import delimited_list, any_open_tag, any_close_tag
-from datetime import datetime
-
-
-# some other useful expressions - using lower-case class name since we are really using this as a namespace
-class pyparsing_common:
- """Here are some common low-level expressions that may be useful in
- jump-starting parser development:
-
- - numeric forms (:class:`integers`, :class:`reals`,
- :class:`scientific notation`)
- - common :class:`programming identifiers`
- - network addresses (:class:`MAC`,
- :class:`IPv4`, :class:`IPv6`)
- - ISO8601 :class:`dates` and
- :class:`datetime`
- - :class:`UUID`
- - :class:`comma-separated list`
- - :class:`url`
-
- Parse actions:
-
- - :class:`convertToInteger`
- - :class:`convertToFloat`
- - :class:`convertToDate`
- - :class:`convertToDatetime`
- - :class:`stripHTMLTags`
- - :class:`upcaseTokens`
- - :class:`downcaseTokens`
-
- Example::
-
- pyparsing_common.number.runTests('''
- # any int or real number, returned as the appropriate type
- 100
- -100
- +100
- 3.14159
- 6.02e23
- 1e-12
- ''')
-
- pyparsing_common.fnumber.runTests('''
- # any int or real number, returned as float
- 100
- -100
- +100
- 3.14159
- 6.02e23
- 1e-12
- ''')
-
- pyparsing_common.hex_integer.runTests('''
- # hex numbers
- 100
- FF
- ''')
-
- pyparsing_common.fraction.runTests('''
- # fractions
- 1/2
- -3/4
- ''')
-
- pyparsing_common.mixed_integer.runTests('''
- # mixed fractions
- 1
- 1/2
- -3/4
- 1-3/4
- ''')
-
- import uuid
- pyparsing_common.uuid.setParseAction(tokenMap(uuid.UUID))
- pyparsing_common.uuid.runTests('''
- # uuid
- 12345678-1234-5678-1234-567812345678
- ''')
-
- prints::
-
- # any int or real number, returned as the appropriate type
- 100
- [100]
-
- -100
- [-100]
-
- +100
- [100]
-
- 3.14159
- [3.14159]
-
- 6.02e23
- [6.02e+23]
-
- 1e-12
- [1e-12]
-
- # any int or real number, returned as float
- 100
- [100.0]
-
- -100
- [-100.0]
-
- +100
- [100.0]
-
- 3.14159
- [3.14159]
-
- 6.02e23
- [6.02e+23]
-
- 1e-12
- [1e-12]
-
- # hex numbers
- 100
- [256]
-
- FF
- [255]
-
- # fractions
- 1/2
- [0.5]
-
- -3/4
- [-0.75]
-
- # mixed fractions
- 1
- [1]
-
- 1/2
- [0.5]
-
- -3/4
- [-0.75]
-
- 1-3/4
- [1.75]
-
- # uuid
- 12345678-1234-5678-1234-567812345678
- [UUID('12345678-1234-5678-1234-567812345678')]
- """
-
- convert_to_integer = token_map(int)
- """
- Parse action for converting parsed integers to Python int
- """
-
- convert_to_float = token_map(float)
- """
- Parse action for converting parsed numbers to Python float
- """
-
- integer = Word(nums).set_name("integer").set_parse_action(convert_to_integer)
- """expression that parses an unsigned integer, returns an int"""
-
- hex_integer = (
- Word(hexnums).set_name("hex integer").set_parse_action(token_map(int, 16))
- )
- """expression that parses a hexadecimal integer, returns an int"""
-
- signed_integer = (
- Regex(r"[+-]?\d+")
- .set_name("signed integer")
- .set_parse_action(convert_to_integer)
- )
- """expression that parses an integer with optional leading sign, returns an int"""
-
- fraction = (
- signed_integer().set_parse_action(convert_to_float)
- + "/"
- + signed_integer().set_parse_action(convert_to_float)
- ).set_name("fraction")
- """fractional expression of an integer divided by an integer, returns a float"""
- fraction.add_parse_action(lambda tt: tt[0] / tt[-1])
-
- mixed_integer = (
- fraction | signed_integer + Opt(Opt("-").suppress() + fraction)
- ).set_name("fraction or mixed integer-fraction")
- """mixed integer of the form 'integer - fraction', with optional leading integer, returns float"""
- mixed_integer.add_parse_action(sum)
-
- real = (
- Regex(r"[+-]?(?:\d+\.\d*|\.\d+)")
- .set_name("real number")
- .set_parse_action(convert_to_float)
- )
- """expression that parses a floating point number and returns a float"""
-
- sci_real = (
- Regex(r"[+-]?(?:\d+(?:[eE][+-]?\d+)|(?:\d+\.\d*|\.\d+)(?:[eE][+-]?\d+)?)")
- .set_name("real number with scientific notation")
- .set_parse_action(convert_to_float)
- )
- """expression that parses a floating point number with optional
- scientific notation and returns a float"""
-
- # streamlining this expression makes the docs nicer-looking
- number = (sci_real | real | signed_integer).setName("number").streamline()
- """any numeric expression, returns the corresponding Python type"""
-
- fnumber = (
- Regex(r"[+-]?\d+\.?\d*([eE][+-]?\d+)?")
- .set_name("fnumber")
- .set_parse_action(convert_to_float)
- )
- """any int or real number, returned as float"""
-
- identifier = Word(identchars, identbodychars).set_name("identifier")
- """typical code identifier (leading alpha or '_', followed by 0 or more alphas, nums, or '_')"""
-
- ipv4_address = Regex(
- r"(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})(\.(25[0-5]|2[0-4][0-9]|1?[0-9]{1,2})){3}"
- ).set_name("IPv4 address")
- "IPv4 address (``0.0.0.0 - 255.255.255.255``)"
-
- _ipv6_part = Regex(r"[0-9a-fA-F]{1,4}").set_name("hex_integer")
- _full_ipv6_address = (_ipv6_part + (":" + _ipv6_part) * 7).set_name(
- "full IPv6 address"
- )
- _short_ipv6_address = (
- Opt(_ipv6_part + (":" + _ipv6_part) * (0, 6))
- + "::"
- + Opt(_ipv6_part + (":" + _ipv6_part) * (0, 6))
- ).set_name("short IPv6 address")
- _short_ipv6_address.add_condition(
- lambda t: sum(1 for tt in t if pyparsing_common._ipv6_part.matches(tt)) < 8
- )
- _mixed_ipv6_address = ("::ffff:" + ipv4_address).set_name("mixed IPv6 address")
- ipv6_address = Combine(
- (_full_ipv6_address | _mixed_ipv6_address | _short_ipv6_address).set_name(
- "IPv6 address"
- )
- ).set_name("IPv6 address")
- "IPv6 address (long, short, or mixed form)"
-
- mac_address = Regex(
- r"[0-9a-fA-F]{2}([:.-])[0-9a-fA-F]{2}(?:\1[0-9a-fA-F]{2}){4}"
- ).set_name("MAC address")
- "MAC address xx:xx:xx:xx:xx (may also have '-' or '.' delimiters)"
-
- @staticmethod
- def convert_to_date(fmt: str = "%Y-%m-%d"):
- """
- Helper to create a parse action for converting parsed date string to Python datetime.date
-
- Params -
- - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%d"``)
-
- Example::
-
- date_expr = pyparsing_common.iso8601_date.copy()
- date_expr.setParseAction(pyparsing_common.convertToDate())
- print(date_expr.parseString("1999-12-31"))
-
- prints::
-
- [datetime.date(1999, 12, 31)]
- """
-
- def cvt_fn(ss, ll, tt):
- try:
- return datetime.strptime(tt[0], fmt).date()
- except ValueError as ve:
- raise ParseException(ss, ll, str(ve))
-
- return cvt_fn
-
- @staticmethod
- def convert_to_datetime(fmt: str = "%Y-%m-%dT%H:%M:%S.%f"):
- """Helper to create a parse action for converting parsed
- datetime string to Python datetime.datetime
-
- Params -
- - fmt - format to be passed to datetime.strptime (default= ``"%Y-%m-%dT%H:%M:%S.%f"``)
-
- Example::
-
- dt_expr = pyparsing_common.iso8601_datetime.copy()
- dt_expr.setParseAction(pyparsing_common.convertToDatetime())
- print(dt_expr.parseString("1999-12-31T23:59:59.999"))
-
- prints::
-
- [datetime.datetime(1999, 12, 31, 23, 59, 59, 999000)]
- """
-
- def cvt_fn(s, l, t):
- try:
- return datetime.strptime(t[0], fmt)
- except ValueError as ve:
- raise ParseException(s, l, str(ve))
-
- return cvt_fn
-
- iso8601_date = Regex(
- r"(?P\d{4})(?:-(?P\d\d)(?:-(?P\d\d))?)?"
- ).set_name("ISO8601 date")
- "ISO8601 date (``yyyy-mm-dd``)"
-
- iso8601_datetime = Regex(
- r"(?P\d{4})-(?P\d\d)-(?P\d\d)[T ](?P\d\d):(?P\d\d)(:(?P\d\d(\.\d*)?)?)?(?PZ|[+-]\d\d:?\d\d)?"
- ).set_name("ISO8601 datetime")
- "ISO8601 datetime (``yyyy-mm-ddThh:mm:ss.s(Z|+-00:00)``) - trailing seconds, milliseconds, and timezone optional; accepts separating ``'T'`` or ``' '``"
-
- uuid = Regex(r"[0-9a-fA-F]{8}(-[0-9a-fA-F]{4}){3}-[0-9a-fA-F]{12}").set_name("UUID")
- "UUID (``xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx``)"
-
- _html_stripper = any_open_tag.suppress() | any_close_tag.suppress()
-
- @staticmethod
- def strip_html_tags(s: str, l: int, tokens: ParseResults):
- """Parse action to remove HTML tags from web page HTML source
-
- Example::
-
- # strip HTML links from normal text
- text = 'More info at the pyparsing wiki page '
- td, td_end = makeHTMLTags("TD")
- table_text = td + SkipTo(td_end).setParseAction(pyparsing_common.stripHTMLTags)("body") + td_end
- print(table_text.parseString(text).body)
-
- Prints::
-
- More info at the pyparsing wiki page
- """
- return pyparsing_common._html_stripper.transform_string(tokens[0])
-
- _commasepitem = (
- Combine(
- OneOrMore(
- ~Literal(",")
- + ~LineEnd()
- + Word(printables, exclude_chars=",")
- + Opt(White(" \t") + ~FollowedBy(LineEnd() | ","))
- )
- )
- .streamline()
- .set_name("commaItem")
- )
- comma_separated_list = delimited_list(
- Opt(quoted_string.copy() | _commasepitem, default="")
- ).set_name("comma separated list")
- """Predefined expression of 1 or more printable words or quoted strings, separated by commas."""
-
- upcase_tokens = staticmethod(token_map(lambda t: t.upper()))
- """Parse action to convert tokens to upper case."""
-
- downcase_tokens = staticmethod(token_map(lambda t: t.lower()))
- """Parse action to convert tokens to lower case."""
-
- # fmt: off
- url = Regex(
- # https://mathiasbynens.be/demo/url-regex
- # https://gist.github.com/dperini/729294
- r"^" +
- # protocol identifier (optional)
- # short syntax // still required
- r"(?:(?:(?Phttps?|ftp):)?\/\/)" +
- # user:pass BasicAuth (optional)
- r"(?:(?P\S+(?::\S*)?)@)?" +
- r"(?P" +
- # IP address exclusion
- # private & local networks
- r"(?!(?:10|127)(?:\.\d{1,3}){3})" +
- r"(?!(?:169\.254|192\.168)(?:\.\d{1,3}){2})" +
- r"(?!172\.(?:1[6-9]|2\d|3[0-1])(?:\.\d{1,3}){2})" +
- # IP address dotted notation octets
- # excludes loopback network 0.0.0.0
- # excludes reserved space >= 224.0.0.0
- # excludes network & broadcast addresses
- # (first & last IP address of each class)
- r"(?:[1-9]\d?|1\d\d|2[01]\d|22[0-3])" +
- r"(?:\.(?:1?\d{1,2}|2[0-4]\d|25[0-5])){2}" +
- r"(?:\.(?:[1-9]\d?|1\d\d|2[0-4]\d|25[0-4]))" +
- r"|" +
- # host & domain names, may end with dot
- # can be replaced by a shortest alternative
- # (?![-_])(?:[-\w\u00a1-\uffff]{0,63}[^-_]\.)+
- r"(?:" +
- r"(?:" +
- r"[a-z0-9\u00a1-\uffff]" +
- r"[a-z0-9\u00a1-\uffff_-]{0,62}" +
- r")?" +
- r"[a-z0-9\u00a1-\uffff]\." +
- r")+" +
- # TLD identifier name, may end with dot
- r"(?:[a-z\u00a1-\uffff]{2,}\.?)" +
- r")" +
- # port number (optional)
- r"(:(?P\d{2,5}))?" +
- # resource path (optional)
- r"(?P\/[^?# ]*)?" +
- # query string (optional)
- r"(\?(?P[^#]*))?" +
- # fragment (optional)
- r"(#(?P\S*))?" +
- r"$"
- ).set_name("url")
- # fmt: on
-
- # pre-PEP8 compatibility names
- convertToInteger = convert_to_integer
- convertToFloat = convert_to_float
- convertToDate = convert_to_date
- convertToDatetime = convert_to_datetime
- stripHTMLTags = strip_html_tags
- upcaseTokens = upcase_tokens
- downcaseTokens = downcase_tokens
-
-
-_builtin_exprs = [
- v for v in vars(pyparsing_common).values() if isinstance(v, ParserElement)
-]
diff --git a/spaces/Realcat/image-matching-webui/third_party/r2d2/extract_kapture.py b/spaces/Realcat/image-matching-webui/third_party/r2d2/extract_kapture.py
deleted file mode 100644
index 8e46bb5306c943ce985a13168934105b1978deb9..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/third_party/r2d2/extract_kapture.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# Copyright 2019-present NAVER Corp.
-# CC BY-NC-SA 3.0
-# Available only for non-commercial use
-
-
-from PIL import Image
-
-from tools import common
-from tools.dataloader import norm_RGB
-from nets.patchnet import *
-from os import path
-
-from extract import load_network, NonMaxSuppression, extract_multiscale
-
-# Kapture is a pivot file format, based on text and binary files, used to describe SfM (Structure From Motion)
-# and more generally sensor-acquired data
-# it can be installed with
-# pip install kapture
-# for more information check out https://github.com/naver/kapture
-import kapture
-from kapture.io.records import get_image_fullpath
-from kapture.io.csv import kapture_from_dir
-from kapture.io.csv import (
- get_feature_csv_fullpath,
- keypoints_to_file,
- descriptors_to_file,
-)
-from kapture.io.features import (
- get_keypoints_fullpath,
- keypoints_check_dir,
- image_keypoints_to_file,
-)
-from kapture.io.features import (
- get_descriptors_fullpath,
- descriptors_check_dir,
- image_descriptors_to_file,
-)
-from kapture.io.csv import get_all_tar_handlers
-
-
-def extract_kapture_keypoints(args):
- """
- Extract r2d2 keypoints and descritors to the kapture format directly
- """
- print("extract_kapture_keypoints...")
- with get_all_tar_handlers(
- args.kapture_root,
- mode={
- kapture.Keypoints: "a",
- kapture.Descriptors: "a",
- kapture.GlobalFeatures: "r",
- kapture.Matches: "r",
- },
- ) as tar_handlers:
- kdata = kapture_from_dir(
- args.kapture_root,
- None,
- skip_list=[
- kapture.GlobalFeatures,
- kapture.Matches,
- kapture.Points3d,
- kapture.Observations,
- ],
- tar_handlers=tar_handlers,
- )
-
- assert kdata.records_camera is not None
- image_list = [
- filename for _, _, filename in kapture.flatten(kdata.records_camera)
- ]
- if args.keypoints_type is None:
- args.keypoints_type = path.splitext(path.basename(args.model))[0]
- print(f"keypoints_type set to {args.keypoints_type}")
- if args.descriptors_type is None:
- args.descriptors_type = path.splitext(path.basename(args.model))[0]
- print(f"descriptors_type set to {args.descriptors_type}")
-
- if (
- kdata.keypoints is not None
- and args.keypoints_type in kdata.keypoints
- and kdata.descriptors is not None
- and args.descriptors_type in kdata.descriptors
- ):
- print(
- "detected already computed features of same keypoints_type/descriptors_type, resuming extraction..."
- )
- image_list = [
- name
- for name in image_list
- if name not in kdata.keypoints[args.keypoints_type]
- or name not in kdata.descriptors[args.descriptors_type]
- ]
-
- if len(image_list) == 0:
- print("All features were already extracted")
- return
- else:
- print(f"Extracting r2d2 features for {len(image_list)} images")
-
- iscuda = common.torch_set_gpu(args.gpu)
-
- # load the network...
- net = load_network(args.model)
- if iscuda:
- net = net.cuda()
-
- # create the non-maxima detector
- detector = NonMaxSuppression(
- rel_thr=args.reliability_thr, rep_thr=args.repeatability_thr
- )
-
- if kdata.keypoints is None:
- kdata.keypoints = {}
- if kdata.descriptors is None:
- kdata.descriptors = {}
-
- if args.keypoints_type not in kdata.keypoints:
- keypoints_dtype = None
- keypoints_dsize = None
- else:
- keypoints_dtype = kdata.keypoints[args.keypoints_type].dtype
- keypoints_dsize = kdata.keypoints[args.keypoints_type].dsize
- if args.descriptors_type not in kdata.descriptors:
- descriptors_dtype = None
- descriptors_dsize = None
- else:
- descriptors_dtype = kdata.descriptors[args.descriptors_type].dtype
- descriptors_dsize = kdata.descriptors[args.descriptors_type].dsize
-
- for image_name in image_list:
- img_path = get_image_fullpath(args.kapture_root, image_name)
- print(f"\nExtracting features for {img_path}")
- img = Image.open(img_path).convert("RGB")
- W, H = img.size
- img = norm_RGB(img)[None]
- if iscuda:
- img = img.cuda()
-
- # extract keypoints/descriptors for a single image
- xys, desc, scores = extract_multiscale(
- net,
- img,
- detector,
- scale_f=args.scale_f,
- min_scale=args.min_scale,
- max_scale=args.max_scale,
- min_size=args.min_size,
- max_size=args.max_size,
- verbose=True,
- )
-
- xys = xys.cpu().numpy()
- desc = desc.cpu().numpy()
- scores = scores.cpu().numpy()
- idxs = scores.argsort()[-args.top_k or None :]
-
- xys = xys[idxs]
- desc = desc[idxs]
- if keypoints_dtype is None or descriptors_dtype is None:
- keypoints_dtype = xys.dtype
- descriptors_dtype = desc.dtype
-
- keypoints_dsize = xys.shape[1]
- descriptors_dsize = desc.shape[1]
-
- kdata.keypoints[args.keypoints_type] = kapture.Keypoints(
- "r2d2", keypoints_dtype, keypoints_dsize
- )
- kdata.descriptors[args.descriptors_type] = kapture.Descriptors(
- "r2d2",
- descriptors_dtype,
- descriptors_dsize,
- args.keypoints_type,
- "L2",
- )
- keypoints_config_absolute_path = get_feature_csv_fullpath(
- kapture.Keypoints, args.keypoints_type, args.kapture_root
- )
- descriptors_config_absolute_path = get_feature_csv_fullpath(
- kapture.Descriptors, args.descriptors_type, args.kapture_root
- )
- keypoints_to_file(
- keypoints_config_absolute_path, kdata.keypoints[args.keypoints_type]
- )
- descriptors_to_file(
- descriptors_config_absolute_path,
- kdata.descriptors[args.descriptors_type],
- )
- else:
- assert kdata.keypoints[args.keypoints_type].dtype == xys.dtype
- assert kdata.descriptors[args.descriptors_type].dtype == desc.dtype
- assert kdata.keypoints[args.keypoints_type].dsize == xys.shape[1]
- assert kdata.descriptors[args.descriptors_type].dsize == desc.shape[1]
- assert (
- kdata.descriptors[args.descriptors_type].keypoints_type
- == args.keypoints_type
- )
- assert kdata.descriptors[args.descriptors_type].metric_type == "L2"
-
- keypoints_fullpath = get_keypoints_fullpath(
- args.keypoints_type, args.kapture_root, image_name, tar_handlers
- )
- print(f"Saving {xys.shape[0]} keypoints to {keypoints_fullpath}")
- image_keypoints_to_file(keypoints_fullpath, xys)
- kdata.keypoints[args.keypoints_type].add(image_name)
-
- descriptors_fullpath = get_descriptors_fullpath(
- args.descriptors_type, args.kapture_root, image_name, tar_handlers
- )
- print(f"Saving {desc.shape[0]} descriptors to {descriptors_fullpath}")
- image_descriptors_to_file(descriptors_fullpath, desc)
- kdata.descriptors[args.descriptors_type].add(image_name)
-
- if not keypoints_check_dir(
- kdata.keypoints[args.keypoints_type],
- args.keypoints_type,
- args.kapture_root,
- tar_handlers,
- ) or not descriptors_check_dir(
- kdata.descriptors[args.descriptors_type],
- args.descriptors_type,
- args.kapture_root,
- tar_handlers,
- ):
- print(
- "local feature extraction ended successfully but not all files were saved"
- )
-
-
-if __name__ == "__main__":
- import argparse
-
- parser = argparse.ArgumentParser(
- "Extract r2d2 local features for all images in a dataset stored in the kapture format"
- )
- parser.add_argument("--model", type=str, required=True, help="model path")
- parser.add_argument(
- "--keypoints-type",
- default=None,
- help="keypoint type_name, default is filename of model",
- )
- parser.add_argument(
- "--descriptors-type",
- default=None,
- help="descriptors type_name, default is filename of model",
- )
-
- parser.add_argument(
- "--kapture-root", type=str, required=True, help="path to kapture root directory"
- )
-
- parser.add_argument("--top-k", type=int, default=5000, help="number of keypoints")
-
- parser.add_argument("--scale-f", type=float, default=2**0.25)
- parser.add_argument("--min-size", type=int, default=256)
- parser.add_argument("--max-size", type=int, default=1024)
- parser.add_argument("--min-scale", type=float, default=0)
- parser.add_argument("--max-scale", type=float, default=1)
-
- parser.add_argument("--reliability-thr", type=float, default=0.7)
- parser.add_argument("--repeatability-thr", type=float, default=0.7)
-
- parser.add_argument(
- "--gpu", type=int, nargs="+", default=[0], help="use -1 for CPU"
- )
- args = parser.parse_args()
-
- extract_kapture_keypoints(args)
diff --git a/spaces/Ricecake123/RVC-demo/train/utils.py b/spaces/Ricecake123/RVC-demo/train/utils.py
deleted file mode 100644
index 5bb88af3de88567bf9969e80c6332fc53c8df7dc..0000000000000000000000000000000000000000
--- a/spaces/Ricecake123/RVC-demo/train/utils.py
+++ /dev/null
@@ -1,486 +0,0 @@
-import os, traceback
-import glob
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-from scipy.io.wavfile import read
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint_d(checkpoint_path, combd, sbd, optimizer=None, load_opt=1):
- assert os.path.isfile(checkpoint_path)
- checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
-
- ##################
- def go(model, bkey):
- saved_state_dict = checkpoint_dict[bkey]
- if hasattr(model, "module"):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict = {}
- for k, v in state_dict.items(): # 模型需要的shape
- try:
- new_state_dict[k] = saved_state_dict[k]
- if saved_state_dict[k].shape != state_dict[k].shape:
- print(
- "shape-%s-mismatch|need-%s|get-%s"
- % (k, state_dict[k].shape, saved_state_dict[k].shape)
- ) #
- raise KeyError
- except:
- # logger.info(traceback.format_exc())
- logger.info("%s is not in the checkpoint" % k) # pretrain缺失的
- new_state_dict[k] = v # 模型自带的随机值
- if hasattr(model, "module"):
- model.module.load_state_dict(new_state_dict, strict=False)
- else:
- model.load_state_dict(new_state_dict, strict=False)
-
- go(combd, "combd")
- go(sbd, "sbd")
- #############
- logger.info("Loaded model weights")
-
- iteration = checkpoint_dict["iteration"]
- learning_rate = checkpoint_dict["learning_rate"]
- if (
- optimizer is not None and load_opt == 1
- ): ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
- # try:
- optimizer.load_state_dict(checkpoint_dict["optimizer"])
- # except:
- # traceback.print_exc()
- logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
- return model, optimizer, learning_rate, iteration
-
-
-# def load_checkpoint(checkpoint_path, model, optimizer=None):
-# assert os.path.isfile(checkpoint_path)
-# checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
-# iteration = checkpoint_dict['iteration']
-# learning_rate = checkpoint_dict['learning_rate']
-# if optimizer is not None:
-# optimizer.load_state_dict(checkpoint_dict['optimizer'])
-# # print(1111)
-# saved_state_dict = checkpoint_dict['model']
-# # print(1111)
-#
-# if hasattr(model, 'module'):
-# state_dict = model.module.state_dict()
-# else:
-# state_dict = model.state_dict()
-# new_state_dict= {}
-# for k, v in state_dict.items():
-# try:
-# new_state_dict[k] = saved_state_dict[k]
-# except:
-# logger.info("%s is not in the checkpoint" % k)
-# new_state_dict[k] = v
-# if hasattr(model, 'module'):
-# model.module.load_state_dict(new_state_dict)
-# else:
-# model.load_state_dict(new_state_dict)
-# logger.info("Loaded checkpoint '{}' (epoch {})" .format(
-# checkpoint_path, iteration))
-# return model, optimizer, learning_rate, iteration
-def load_checkpoint(checkpoint_path, model, optimizer=None, load_opt=1):
- assert os.path.isfile(checkpoint_path)
- checkpoint_dict = torch.load(checkpoint_path, map_location="cpu")
-
- saved_state_dict = checkpoint_dict["model"]
- if hasattr(model, "module"):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict = {}
- for k, v in state_dict.items(): # 模型需要的shape
- try:
- new_state_dict[k] = saved_state_dict[k]
- if saved_state_dict[k].shape != state_dict[k].shape:
- print(
- "shape-%s-mismatch|need-%s|get-%s"
- % (k, state_dict[k].shape, saved_state_dict[k].shape)
- ) #
- raise KeyError
- except:
- # logger.info(traceback.format_exc())
- logger.info("%s is not in the checkpoint" % k) # pretrain缺失的
- new_state_dict[k] = v # 模型自带的随机值
- if hasattr(model, "module"):
- model.module.load_state_dict(new_state_dict, strict=False)
- else:
- model.load_state_dict(new_state_dict, strict=False)
- logger.info("Loaded model weights")
-
- iteration = checkpoint_dict["iteration"]
- learning_rate = checkpoint_dict["learning_rate"]
- if (
- optimizer is not None and load_opt == 1
- ): ###加载不了，如果是空的的话，重新初始化，可能还会影响lr时间表的更新，因此在train文件最外围catch
- # try:
- optimizer.load_state_dict(checkpoint_dict["optimizer"])
- # except:
- # traceback.print_exc()
- logger.info("Loaded checkpoint '{}' (epoch {})".format(checkpoint_path, iteration))
- return model, optimizer, learning_rate, iteration
-
-
-def save_checkpoint(model, optimizer, learning_rate, iteration, checkpoint_path):
- logger.info(
- "Saving model and optimizer state at epoch {} to {}".format(
- iteration, checkpoint_path
- )
- )
- if hasattr(model, "module"):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- torch.save(
- {
- "model": state_dict,
- "iteration": iteration,
- "optimizer": optimizer.state_dict(),
- "learning_rate": learning_rate,
- },
- checkpoint_path,
- )
-
-
-def save_checkpoint_d(combd, sbd, optimizer, learning_rate, iteration, checkpoint_path):
- logger.info(
- "Saving model and optimizer state at epoch {} to {}".format(
- iteration, checkpoint_path
- )
- )
- if hasattr(combd, "module"):
- state_dict_combd = combd.module.state_dict()
- else:
- state_dict_combd = combd.state_dict()
- if hasattr(sbd, "module"):
- state_dict_sbd = sbd.module.state_dict()
- else:
- state_dict_sbd = sbd.state_dict()
- torch.save(
- {
- "combd": state_dict_combd,
- "sbd": state_dict_sbd,
- "iteration": iteration,
- "optimizer": optimizer.state_dict(),
- "learning_rate": learning_rate,
- },
- checkpoint_path,
- )
-
-
-def summarize(
- writer,
- global_step,
- scalars={},
- histograms={},
- images={},
- audios={},
- audio_sampling_rate=22050,
-):
- for k, v in scalars.items():
- writer.add_scalar(k, v, global_step)
- for k, v in histograms.items():
- writer.add_histogram(k, v, global_step)
- for k, v in images.items():
- writer.add_image(k, v, global_step, dataformats="HWC")
- for k, v in audios.items():
- writer.add_audio(k, v, global_step, audio_sampling_rate)
-
-
-def latest_checkpoint_path(dir_path, regex="G_*.pth"):
- f_list = glob.glob(os.path.join(dir_path, regex))
- f_list.sort(key=lambda f: int("".join(filter(str.isdigit, f))))
- x = f_list[-1]
- print(x)
- return x
-
-
-def plot_spectrogram_to_numpy(spectrogram):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
-
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger("matplotlib")
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(10, 2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower", interpolation="none")
- plt.colorbar(im, ax=ax)
- plt.xlabel("Frames")
- plt.ylabel("Channels")
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
-
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger("matplotlib")
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(6, 4))
- im = ax.imshow(
- alignment.transpose(), aspect="auto", origin="lower", interpolation="none"
- )
- fig.colorbar(im, ax=ax)
- xlabel = "Decoder timestep"
- if info is not None:
- xlabel += "\n\n" + info
- plt.xlabel(xlabel)
- plt.ylabel("Encoder timestep")
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep="")
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def load_wav_to_torch(full_path):
- sampling_rate, data = read(full_path)
- return torch.FloatTensor(data.astype(np.float32)), sampling_rate
-
-
-def load_filepaths_and_text(filename, split="|"):
- with open(filename, encoding="utf-8") as f:
- filepaths_and_text = [line.strip().split(split) for line in f]
- return filepaths_and_text
-
-
-def get_hparams(init=True):
- """
- todo:
- 结尾七人组：
- 保存频率、总epoch done
- bs done
- pretrainG、pretrainD done
- 卡号：os.en["CUDA_VISIBLE_DEVICES"] done
- if_latest done
- 模型：if_f0 done
- 采样率：自动选择config done
- 是否缓存数据集进GPU:if_cache_data_in_gpu done
-
- -m:
- 自动决定training_files路径,改掉train_nsf_load_pretrain.py里的hps.data.training_files done
- -c不要了
- """
- parser = argparse.ArgumentParser()
- # parser.add_argument('-c', '--config', type=str, default="configs/40k.json",help='JSON file for configuration')
- parser.add_argument(
- "-se",
- "--save_every_epoch",
- type=int,
- required=True,
- help="checkpoint save frequency (epoch)",
- )
- parser.add_argument(
- "-te", "--total_epoch", type=int, required=True, help="total_epoch"
- )
- parser.add_argument(
- "-pg", "--pretrainG", type=str, default="", help="Pretrained Discriminator path"
- )
- parser.add_argument(
- "-pd", "--pretrainD", type=str, default="", help="Pretrained Generator path"
- )
- parser.add_argument("-g", "--gpus", type=str, default="0", help="split by -")
- parser.add_argument(
- "-bs", "--batch_size", type=int, required=True, help="batch size"
- )
- parser.add_argument(
- "-e", "--experiment_dir", type=str, required=True, help="experiment dir"
- ) # -m
- parser.add_argument(
- "-sr", "--sample_rate", type=str, required=True, help="sample rate, 32k/40k/48k"
- )
- parser.add_argument(
- "-sw",
- "--save_every_weights",
- type=str,
- default="0",
- help="save the extracted model in weights directory when saving checkpoints",
- )
- parser.add_argument(
- "-v", "--version", type=str, required=True, help="model version"
- )
- parser.add_argument(
- "-f0",
- "--if_f0",
- type=int,
- required=True,
- help="use f0 as one of the inputs of the model, 1 or 0",
- )
- parser.add_argument(
- "-l",
- "--if_latest",
- type=int,
- required=True,
- help="if only save the latest G/D pth file, 1 or 0",
- )
- parser.add_argument(
- "-c",
- "--if_cache_data_in_gpu",
- type=int,
- required=True,
- help="if caching the dataset in GPU memory, 1 or 0",
- )
-
- args = parser.parse_args()
- name = args.experiment_dir
- experiment_dir = os.path.join("./logs", args.experiment_dir)
-
- if not os.path.exists(experiment_dir):
- os.makedirs(experiment_dir)
-
- if args.version == "v1" or args.sample_rate == "40k":
- config_path = "configs/%s.json" % args.sample_rate
- else:
- config_path = "configs/%s_v2.json" % args.sample_rate
- config_save_path = os.path.join(experiment_dir, "config.json")
- if init:
- with open(config_path, "r") as f:
- data = f.read()
- with open(config_save_path, "w") as f:
- f.write(data)
- else:
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = hparams.experiment_dir = experiment_dir
- hparams.save_every_epoch = args.save_every_epoch
- hparams.name = name
- hparams.total_epoch = args.total_epoch
- hparams.pretrainG = args.pretrainG
- hparams.pretrainD = args.pretrainD
- hparams.version = args.version
- hparams.gpus = args.gpus
- hparams.train.batch_size = args.batch_size
- hparams.sample_rate = args.sample_rate
- hparams.if_f0 = args.if_f0
- hparams.if_latest = args.if_latest
- hparams.save_every_weights = args.save_every_weights
- hparams.if_cache_data_in_gpu = args.if_cache_data_in_gpu
- hparams.data.training_files = "%s/filelist.txt" % experiment_dir
- return hparams
-
-
-def get_hparams_from_dir(model_dir):
- config_save_path = os.path.join(model_dir, "config.json")
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_file(config_path):
- with open(config_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- return hparams
-
-
-def check_git_hash(model_dir):
- source_dir = os.path.dirname(os.path.realpath(__file__))
- if not os.path.exists(os.path.join(source_dir, ".git")):
- logger.warn(
- "{} is not a git repository, therefore hash value comparison will be ignored.".format(
- source_dir
- )
- )
- return
-
- cur_hash = subprocess.getoutput("git rev-parse HEAD")
-
- path = os.path.join(model_dir, "githash")
- if os.path.exists(path):
- saved_hash = open(path).read()
- if saved_hash != cur_hash:
- logger.warn(
- "git hash values are different. {}(saved) != {}(current)".format(
- saved_hash[:8], cur_hash[:8]
- )
- )
- else:
- open(path, "w").write(cur_hash)
-
-
-def get_logger(model_dir, filename="train.log"):
- global logger
- logger = logging.getLogger(os.path.basename(model_dir))
- logger.setLevel(logging.DEBUG)
-
- formatter = logging.Formatter("%(asctime)s\t%(name)s\t%(levelname)s\t%(message)s")
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
- h = logging.FileHandler(os.path.join(model_dir, filename))
- h.setLevel(logging.DEBUG)
- h.setFormatter(formatter)
- logger.addHandler(h)
- return logger
-
-
-class HParams:
- def __init__(self, **kwargs):
- for k, v in kwargs.items():
- if type(v) == dict:
- v = HParams(**v)
- self[k] = v
-
- def keys(self):
- return self.__dict__.keys()
-
- def items(self):
- return self.__dict__.items()
-
- def values(self):
- return self.__dict__.values()
-
- def __len__(self):
- return len(self.__dict__)
-
- def __getitem__(self, key):
- return getattr(self, key)
-
- def __setitem__(self, key, value):
- return setattr(self, key, value)
-
- def __contains__(self, key):
- return key in self.__dict__
-
- def __repr__(self):
- return self.__dict__.__repr__()
diff --git a/spaces/Rothfeld/stable-diffusion-mat-outpainting-primer/metrics/frechet_inception_distance.py b/spaces/Rothfeld/stable-diffusion-mat-outpainting-primer/metrics/frechet_inception_distance.py
deleted file mode 100644
index 1d38ec731b33e6f4f20cd4601e58d7e5ce2eaaa3..0000000000000000000000000000000000000000
--- a/spaces/Rothfeld/stable-diffusion-mat-outpainting-primer/metrics/frechet_inception_distance.py
+++ /dev/null
@@ -1,41 +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.
-
-"""Frechet Inception Distance (FID) from the paper
-"GANs trained by a two time-scale update rule converge to a local Nash
-equilibrium". Matches the original implementation by Heusel et al. at
-https://github.com/bioinf-jku/TTUR/blob/master/fid.py"""
-
-import numpy as np
-import scipy.linalg
-from . import metric_utils
-
-#----------------------------------------------------------------------------
-
-def compute_fid(opts, max_real, num_gen):
- # Direct TorchScript translation of http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
- detector_url = 'https://nvlabs-fi-cdn.nvidia.com/stylegan2-ada-pytorch/pretrained/metrics/inception-2015-12-05.pt'
- detector_kwargs = dict(return_features=True) # Return raw features before the softmax layer.
-
- mu_real, sigma_real = metric_utils.compute_feature_stats_for_dataset(
- opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
- rel_lo=0, rel_hi=0, capture_mean_cov=True, max_items=max_real).get_mean_cov()
-
- mu_gen, sigma_gen = metric_utils.compute_feature_stats_for_generator(
- opts=opts, detector_url=detector_url, detector_kwargs=detector_kwargs,
- rel_lo=0, rel_hi=1, capture_mean_cov=True, max_items=num_gen).get_mean_cov()
-
- if opts.rank != 0:
- return float('nan')
-
- m = np.square(mu_gen - mu_real).sum()
- s, _ = scipy.linalg.sqrtm(np.dot(sigma_gen, sigma_real), disp=False) # pylint: disable=no-member
- fid = np.real(m + np.trace(sigma_gen + sigma_real - s * 2))
- return float(fid)
-
-#----------------------------------------------------------------------------
diff --git a/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/archs/vqgan_arch.py b/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/archs/vqgan_arch.py
deleted file mode 100644
index 51980ec048dc25e5c84ae26ba6bde384d1d2a94f..0000000000000000000000000000000000000000
--- a/spaces/SIGGRAPH2022/Text2Human/Text2Human/models/archs/vqgan_arch.py
+++ /dev/null
@@ -1,1203 +0,0 @@
-# pytorch_diffusion + derived encoder decoder
-import math
-from urllib.request import proxy_bypass
-
-import numpy as np
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from einops import rearrange
-
-
-class VectorQuantizer(nn.Module):
- """
- Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly
- avoids costly matrix multiplications and allows for post-hoc remapping of indices.
- """
-
- # NOTE: due to a bug the beta term was applied to the wrong term. for
- # backwards compatibility we use the buggy version by default, but you can
- # specify legacy=False to fix it.
- def __init__(self,
- n_e,
- e_dim,
- beta,
- remap=None,
- unknown_index="random",
- sane_index_shape=False,
- legacy=True):
- super().__init__()
- self.n_e = n_e
- self.e_dim = e_dim
- self.beta = beta
- self.legacy = legacy
-
- self.embedding = nn.Embedding(self.n_e, self.e_dim)
- self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
-
- self.remap = remap
- if self.remap is not None:
- self.register_buffer("used", torch.tensor(np.load(self.remap)))
- self.re_embed = self.used.shape[0]
- self.unknown_index = unknown_index # "random" or "extra" or integer
- if self.unknown_index == "extra":
- self.unknown_index = self.re_embed
- self.re_embed = self.re_embed + 1
- print(f"Remapping {self.n_e} indices to {self.re_embed} indices. "
- f"Using {self.unknown_index} for unknown indices.")
- else:
- self.re_embed = n_e
-
- self.sane_index_shape = sane_index_shape
-
- def remap_to_used(self, inds):
- ishape = inds.shape
- assert len(ishape) > 1
- inds = inds.reshape(ishape[0], -1)
- used = self.used.to(inds)
- match = (inds[:, :, None] == used[None, None, ...]).long()
- new = match.argmax(-1)
- unknown = match.sum(2) < 1
- if self.unknown_index == "random":
- new[unknown] = torch.randint(
- 0, self.re_embed,
- size=new[unknown].shape).to(device=new.device)
- else:
- new[unknown] = self.unknown_index
- return new.reshape(ishape)
-
- def unmap_to_all(self, inds):
- ishape = inds.shape
- assert len(ishape) > 1
- inds = inds.reshape(ishape[0], -1)
- used = self.used.to(inds)
- if self.re_embed > self.used.shape[0]: # extra token
- inds[inds >= self.used.shape[0]] = 0 # simply set to zero
- back = torch.gather(used[None, :][inds.shape[0] * [0], :], 1, inds)
- return back.reshape(ishape)
-
- def forward(self, z, temp=None, rescale_logits=False, return_logits=False):
- assert temp is None or temp == 1.0, "Only for interface compatible with Gumbel"
- assert rescale_logits == False, "Only for interface compatible with Gumbel"
- assert return_logits == False, "Only for interface compatible with Gumbel"
- # reshape z -> (batch, height, width, channel) and flatten
- z = rearrange(z, 'b c h w -> b h w c').contiguous()
- z_flattened = z.view(-1, self.e_dim)
- # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
-
- d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
- torch.sum(self.embedding.weight**2, dim=1) - 2 * \
- torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n'))
-
- min_encoding_indices = torch.argmin(d, dim=1)
- z_q = self.embedding(min_encoding_indices).view(z.shape)
- perplexity = None
- min_encodings = None
-
- # compute loss for embedding
- if not self.legacy:
- loss = self.beta * torch.mean((z_q.detach()-z)**2) + \
- torch.mean((z_q - z.detach()) ** 2)
- else:
- loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
- torch.mean((z_q - z.detach()) ** 2)
-
- # preserve gradients
- z_q = z + (z_q - z).detach()
-
- # reshape back to match original input shape
- z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous()
-
- if self.remap is not None:
- min_encoding_indices = min_encoding_indices.reshape(
- z.shape[0], -1) # add batch axis
- min_encoding_indices = self.remap_to_used(min_encoding_indices)
- min_encoding_indices = min_encoding_indices.reshape(-1,
- 1) # flatten
-
- if self.sane_index_shape:
- min_encoding_indices = min_encoding_indices.reshape(
- z_q.shape[0], z_q.shape[2], z_q.shape[3])
-
- return z_q, loss, (perplexity, min_encodings, min_encoding_indices)
-
- def get_codebook_entry(self, indices, shape):
- # shape specifying (batch, height, width, channel)
- if self.remap is not None:
- indices = indices.reshape(shape[0], -1) # add batch axis
- indices = self.unmap_to_all(indices)
- indices = indices.reshape(-1) # flatten again
-
- # get quantized latent vectors
- z_q = self.embedding(indices)
-
- if shape is not None:
- z_q = z_q.view(shape)
- # reshape back to match original input shape
- z_q = z_q.permute(0, 3, 1, 2).contiguous()
-
- return z_q
-
-
-class VectorQuantizerTexture(nn.Module):
- """
- Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly
- avoids costly matrix multiplications and allows for post-hoc remapping of indices.
- """
-
- # NOTE: due to a bug the beta term was applied to the wrong term. for
- # backwards compatibility we use the buggy version by default, but you can
- # specify legacy=False to fix it.
- def __init__(self,
- n_e,
- e_dim,
- beta,
- remap=None,
- unknown_index="random",
- sane_index_shape=False,
- legacy=True):
- super().__init__()
- self.n_e = n_e
- self.e_dim = e_dim
- self.beta = beta
- self.legacy = legacy
-
- # TODO: decide number of embeddings
- self.embedding_list = nn.ModuleList(
- [nn.Embedding(self.n_e, self.e_dim) for i in range(18)])
- for embedding in self.embedding_list:
- embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
-
- self.remap = remap
- if self.remap is not None:
- self.register_buffer("used", torch.tensor(np.load(self.remap)))
- self.re_embed = self.used.shape[0]
- self.unknown_index = unknown_index # "random" or "extra" or integer
- if self.unknown_index == "extra":
- self.unknown_index = self.re_embed
- self.re_embed = self.re_embed + 1
- print(f"Remapping {self.n_e} indices to {self.re_embed} indices. "
- f"Using {self.unknown_index} for unknown indices.")
- else:
- self.re_embed = n_e
-
- self.sane_index_shape = sane_index_shape
-
- def remap_to_used(self, inds):
- ishape = inds.shape
- assert len(ishape) > 1
- inds = inds.reshape(ishape[0], -1)
- used = self.used.to(inds)
- match = (inds[:, :, None] == used[None, None, ...]).long()
- new = match.argmax(-1)
- unknown = match.sum(2) < 1
- if self.unknown_index == "random":
- new[unknown] = torch.randint(
- 0, self.re_embed,
- size=new[unknown].shape).to(device=new.device)
- else:
- new[unknown] = self.unknown_index
- return new.reshape(ishape)
-
- def unmap_to_all(self, inds):
- ishape = inds.shape
- assert len(ishape) > 1
- inds = inds.reshape(ishape[0], -1)
- used = self.used.to(inds)
- if self.re_embed > self.used.shape[0]: # extra token
- inds[inds >= self.used.shape[0]] = 0 # simply set to zero
- back = torch.gather(used[None, :][inds.shape[0] * [0], :], 1, inds)
- return back.reshape(ishape)
-
- def forward(self,
- z,
- segm_map,
- temp=None,
- rescale_logits=False,
- return_logits=False):
- assert temp is None or temp == 1.0, "Only for interface compatible with Gumbel"
- assert rescale_logits == False, "Only for interface compatible with Gumbel"
- assert return_logits == False, "Only for interface compatible with Gumbel"
-
- segm_map = F.interpolate(segm_map, size=z.size()[2:], mode='nearest')
- # reshape z -> (batch, height, width, channel) and flatten
- z = rearrange(z, 'b c h w -> b h w c').contiguous()
- z_flattened = z.view(-1, self.e_dim)
-
- # flatten segm_map (b, h, w)
- segm_map_flatten = segm_map.view(-1)
-
- z_q = torch.zeros_like(z_flattened)
- min_encoding_indices_list = []
- min_encoding_indices_continual = torch.full(
- segm_map_flatten.size(),
- fill_value=-1,
- dtype=torch.long,
- device=segm_map_flatten.device)
- for codebook_idx in range(18):
- min_encoding_indices = torch.full(
- segm_map_flatten.size(),
- fill_value=-1,
- dtype=torch.long,
- device=segm_map_flatten.device)
- if torch.sum(segm_map_flatten == codebook_idx) > 0:
- z_selected = z_flattened[segm_map_flatten == codebook_idx]
- # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
- d_selected = torch.sum(
- z_selected**2, dim=1, keepdim=True) + torch.sum(
- self.embedding_list[codebook_idx].weight**2,
- dim=1) - 2 * torch.einsum(
- 'bd,dn->bn', z_selected,
- rearrange(self.embedding_list[codebook_idx].weight,
- 'n d -> d n'))
- min_encoding_indices_selected = torch.argmin(d_selected, dim=1)
- z_q_selected = self.embedding_list[codebook_idx](
- min_encoding_indices_selected)
- z_q[segm_map_flatten == codebook_idx] = z_q_selected
- min_encoding_indices[
- segm_map_flatten ==
- codebook_idx] = min_encoding_indices_selected
- min_encoding_indices_continual[
- segm_map_flatten ==
- codebook_idx] = min_encoding_indices_selected + 1024 * codebook_idx
- min_encoding_indices = min_encoding_indices.reshape(
- z.shape[0], z.shape[1], z.shape[2])
- min_encoding_indices_list.append(min_encoding_indices)
-
- min_encoding_indices_continual = min_encoding_indices_continual.reshape(
- z.shape[0], z.shape[1], z.shape[2])
- z_q = z_q.view(z.shape)
- perplexity = None
-
- # compute loss for embedding
- if not self.legacy:
- loss = self.beta * torch.mean((z_q.detach()-z)**2) + \
- torch.mean((z_q - z.detach()) ** 2)
- else:
- loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
- torch.mean((z_q - z.detach()) ** 2)
-
- # preserve gradients
- z_q = z + (z_q - z).detach()
-
- # reshape back to match original input shape
- z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous()
-
- return z_q, loss, (perplexity, min_encoding_indices_continual,
- min_encoding_indices_list)
-
- def get_codebook_entry(self, indices_list, segm_map, shape):
- # flatten segm_map (b, h, w)
- segm_map = F.interpolate(
- segm_map, size=(shape[1], shape[2]), mode='nearest')
- segm_map_flatten = segm_map.view(-1)
-
- z_q = torch.zeros((shape[0] * shape[1] * shape[2]),
- self.e_dim).to(segm_map.device)
- for codebook_idx in range(18):
- if torch.sum(segm_map_flatten == codebook_idx) > 0:
- min_encoding_indices_selected = indices_list[
- codebook_idx].view(-1)[segm_map_flatten == codebook_idx]
- z_q_selected = self.embedding_list[codebook_idx](
- min_encoding_indices_selected)
- z_q[segm_map_flatten == codebook_idx] = z_q_selected
-
- z_q = z_q.view(shape)
- # reshape back to match original input shape
- z_q = z_q.permute(0, 3, 1, 2).contiguous()
-
- return z_q
-
-
-def sample_patches(inputs, patch_size=3, stride=1):
- """Extract sliding local patches from an input feature tensor.
- The sampled pathes are row-major.
- Args:
- inputs (Tensor): the input feature maps, shape: (n, c, h, w).
- patch_size (int): the spatial size of sampled patches. Default: 3.
- stride (int): the stride of sampling. Default: 1.
- Returns:
- patches (Tensor): extracted patches, shape: (n, c * patch_size *
- patch_size, n_patches).
- """
-
- patches = F.unfold(inputs, (patch_size, patch_size), stride=stride)
-
- return patches
-
-
-class VectorQuantizerSpatialTextureAware(nn.Module):
- """
- Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly
- avoids costly matrix multiplications and allows for post-hoc remapping of indices.
- """
-
- # NOTE: due to a bug the beta term was applied to the wrong term. for
- # backwards compatibility we use the buggy version by default, but you can
- # specify legacy=False to fix it.
- def __init__(self,
- n_e,
- e_dim,
- beta,
- spatial_size,
- remap=None,
- unknown_index="random",
- sane_index_shape=False,
- legacy=True):
- super().__init__()
- self.n_e = n_e
- self.e_dim = e_dim * spatial_size * spatial_size
- self.beta = beta
- self.legacy = legacy
- self.spatial_size = spatial_size
-
- # TODO: decide number of embeddings
- self.embedding_list = nn.ModuleList(
- [nn.Embedding(self.n_e, self.e_dim) for i in range(18)])
- for embedding in self.embedding_list:
- embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
-
- self.remap = remap
- if self.remap is not None:
- self.register_buffer("used", torch.tensor(np.load(self.remap)))
- self.re_embed = self.used.shape[0]
- self.unknown_index = unknown_index # "random" or "extra" or integer
- if self.unknown_index == "extra":
- self.unknown_index = self.re_embed
- self.re_embed = self.re_embed + 1
- print(f"Remapping {self.n_e} indices to {self.re_embed} indices. "
- f"Using {self.unknown_index} for unknown indices.")
- else:
- self.re_embed = n_e
-
- self.sane_index_shape = sane_index_shape
-
- def forward(self,
- z,
- segm_map,
- temp=None,
- rescale_logits=False,
- return_logits=False):
- assert temp is None or temp == 1.0, "Only for interface compatible with Gumbel"
- assert rescale_logits == False, "Only for interface compatible with Gumbel"
- assert return_logits == False, "Only for interface compatible with Gumbel"
-
- segm_map = F.interpolate(
- segm_map,
- size=(z.size(2) // self.spatial_size,
- z.size(3) // self.spatial_size),
- mode='nearest')
-
- # reshape z -> (batch, height, width, channel) and flatten
- # z = rearrange(z, 'b c h w -> b h w c').contiguous() ?
- z_patches = sample_patches(
- z, patch_size=self.spatial_size,
- stride=self.spatial_size).permute(0, 2, 1)
- z_patches_flattened = z_patches.reshape(-1, self.e_dim)
- # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
-
- # flatten segm_map (b, h, w)
- segm_map_flatten = segm_map.view(-1)
-
- z_q = torch.zeros_like(z_patches_flattened)
- min_encoding_indices_list = []
- min_encoding_indices_continual = torch.full(
- segm_map_flatten.size(),
- fill_value=-1,
- dtype=torch.long,
- device=segm_map_flatten.device)
-
- for codebook_idx in range(18):
- min_encoding_indices = torch.full(
- segm_map_flatten.size(),
- fill_value=-1,
- dtype=torch.long,
- device=segm_map_flatten.device)
- if torch.sum(segm_map_flatten == codebook_idx) > 0:
- z_selected = z_patches_flattened[segm_map_flatten ==
- codebook_idx]
- # distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
- d_selected = torch.sum(
- z_selected**2, dim=1, keepdim=True) + torch.sum(
- self.embedding_list[codebook_idx].weight**2,
- dim=1) - 2 * torch.einsum(
- 'bd,dn->bn', z_selected,
- rearrange(self.embedding_list[codebook_idx].weight,
- 'n d -> d n'))
- min_encoding_indices_selected = torch.argmin(d_selected, dim=1)
- z_q_selected = self.embedding_list[codebook_idx](
- min_encoding_indices_selected)
- z_q[segm_map_flatten == codebook_idx] = z_q_selected
- min_encoding_indices[
- segm_map_flatten ==
- codebook_idx] = min_encoding_indices_selected
- min_encoding_indices_continual[
- segm_map_flatten ==
- codebook_idx] = min_encoding_indices_selected + self.n_e * codebook_idx
- min_encoding_indices = min_encoding_indices.reshape(
- z_patches.shape[0], segm_map.shape[2], segm_map.shape[3])
- min_encoding_indices_list.append(min_encoding_indices)
-
- z_q = F.fold(
- z_q.view(z_patches.shape).permute(0, 2, 1),
- z.size()[2:],
- kernel_size=(self.spatial_size, self.spatial_size),
- stride=self.spatial_size)
-
- perplexity = None
-
- # compute loss for embedding
- if not self.legacy:
- loss = self.beta * torch.mean((z_q.detach()-z)**2) + \
- torch.mean((z_q - z.detach()) ** 2)
- else:
- loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
- torch.mean((z_q - z.detach()) ** 2)
-
- # preserve gradients
- z_q = z + (z_q - z).detach()
-
- return z_q, loss, (perplexity, min_encoding_indices_continual,
- min_encoding_indices_list)
-
- def get_codebook_entry(self, indices_list, segm_map, shape):
- # flatten segm_map (b, h, w)
- segm_map = F.interpolate(
- segm_map, size=(shape[1], shape[2]), mode='nearest')
- segm_map_flatten = segm_map.view(-1)
-
- z_q = torch.zeros((shape[0] * shape[1] * shape[2]),
- self.e_dim).to(segm_map.device)
- for codebook_idx in range(18):
- if torch.sum(segm_map_flatten == codebook_idx) > 0:
- min_encoding_indices_selected = indices_list[
- codebook_idx].view(-1)[segm_map_flatten == codebook_idx]
- z_q_selected = self.embedding_list[codebook_idx](
- min_encoding_indices_selected)
- z_q[segm_map_flatten == codebook_idx] = z_q_selected
-
- z_q = F.fold(
- z_q.view(((shape[0], shape[1] * shape[2],
- self.e_dim))).permute(0, 2, 1),
- (shape[1] * self.spatial_size, shape[2] * self.spatial_size),
- kernel_size=(self.spatial_size, self.spatial_size),
- stride=self.spatial_size)
-
- return z_q
-
-
-def get_timestep_embedding(timesteps, embedding_dim):
- """
- This matches the implementation in Denoising Diffusion Probabilistic Models:
- From Fairseq.
- Build sinusoidal embeddings.
- This matches the implementation in tensor2tensor, but differs slightly
- from the description in Section 3.5 of "Attention Is All You Need".
- """
- assert len(timesteps.shape) == 1
-
- half_dim = embedding_dim // 2
- emb = math.log(10000) / (half_dim - 1)
- emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
- emb = emb.to(device=timesteps.device)
- emb = timesteps.float()[:, None] * emb[None, :]
- emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
- if embedding_dim % 2 == 1: # zero pad
- emb = torch.nn.functional.pad(emb, (0, 1, 0, 0))
- return emb
-
-
-def nonlinearity(x):
- # swish
- return x * torch.sigmoid(x)
-
-
-def Normalize(in_channels):
- return torch.nn.GroupNorm(
- num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
-
-
-class Upsample(nn.Module):
-
- def __init__(self, in_channels, with_conv):
- super().__init__()
- self.with_conv = with_conv
- if self.with_conv:
- self.conv = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=3, stride=1, padding=1)
-
- def forward(self, x):
- x = torch.nn.functional.interpolate(
- x, scale_factor=2.0, mode="nearest")
- if self.with_conv:
- x = self.conv(x)
- return x
-
-
-class Downsample(nn.Module):
-
- def __init__(self, in_channels, with_conv):
- super().__init__()
- self.with_conv = with_conv
- if self.with_conv:
- # no asymmetric padding in torch conv, must do it ourselves
- self.conv = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=3, stride=2, padding=0)
-
- def forward(self, x):
- if self.with_conv:
- pad = (0, 1, 0, 1)
- x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
- x = self.conv(x)
- else:
- x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
- return x
-
-
-class ResnetBlock(nn.Module):
-
- def __init__(self,
- *,
- in_channels,
- out_channels=None,
- conv_shortcut=False,
- dropout,
- temb_channels=512):
- super().__init__()
- self.in_channels = in_channels
- out_channels = in_channels if out_channels is None else out_channels
- self.out_channels = out_channels
- self.use_conv_shortcut = conv_shortcut
-
- self.norm1 = Normalize(in_channels)
- self.conv1 = torch.nn.Conv2d(
- in_channels, out_channels, kernel_size=3, stride=1, padding=1)
- if temb_channels > 0:
- self.temb_proj = torch.nn.Linear(temb_channels, out_channels)
- self.norm2 = Normalize(out_channels)
- self.dropout = torch.nn.Dropout(dropout)
- self.conv2 = torch.nn.Conv2d(
- out_channels, out_channels, kernel_size=3, stride=1, padding=1)
- if self.in_channels != self.out_channels:
- if self.use_conv_shortcut:
- self.conv_shortcut = torch.nn.Conv2d(
- in_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1)
- else:
- self.nin_shortcut = torch.nn.Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=1,
- padding=0)
-
- def forward(self, x, temb):
- h = x
- h = self.norm1(h)
- h = nonlinearity(h)
- h = self.conv1(h)
-
- if temb is not None:
- h = h + self.temb_proj(nonlinearity(temb))[:, :, None, None]
-
- h = self.norm2(h)
- h = nonlinearity(h)
- h = self.dropout(h)
- h = self.conv2(h)
-
- if self.in_channels != self.out_channels:
- if self.use_conv_shortcut:
- x = self.conv_shortcut(x)
- else:
- x = self.nin_shortcut(x)
-
- return x + h
-
-
-class AttnBlock(nn.Module):
-
- def __init__(self, in_channels):
- super().__init__()
- self.in_channels = in_channels
-
- self.norm = Normalize(in_channels)
- self.q = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=1, stride=1, padding=0)
- self.k = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=1, stride=1, padding=0)
- self.v = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=1, stride=1, padding=0)
- self.proj_out = torch.nn.Conv2d(
- in_channels, in_channels, kernel_size=1, stride=1, padding=0)
-
- def forward(self, x):
- h_ = x
- h_ = self.norm(h_)
- q = self.q(h_)
- k = self.k(h_)
- v = self.v(h_)
-
- # compute attention
- b, c, h, w = q.shape
- q = q.reshape(b, c, h * w)
- q = q.permute(0, 2, 1) # b,hw,c
- k = k.reshape(b, c, h * w) # b,c,hw
- w_ = torch.bmm(q, k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
- w_ = w_ * (int(c)**(-0.5))
- w_ = torch.nn.functional.softmax(w_, dim=2)
-
- # attend to values
- v = v.reshape(b, c, h * w)
- w_ = w_.permute(0, 2, 1) # b,hw,hw (first hw of k, second of q)
- h_ = torch.bmm(
- v, w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
- h_ = h_.reshape(b, c, h, w)
-
- h_ = self.proj_out(h_)
-
- return x + h_
-
-
-class Model(nn.Module):
-
- def __init__(self,
- *,
- ch,
- out_ch,
- ch_mult=(1, 2, 4, 8),
- num_res_blocks,
- attn_resolutions,
- dropout=0.0,
- resamp_with_conv=True,
- in_channels,
- resolution,
- use_timestep=True):
- super().__init__()
- self.ch = ch
- self.temb_ch = self.ch * 4
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
-
- self.use_timestep = use_timestep
- if self.use_timestep:
- # timestep embedding
- self.temb = nn.Module()
- self.temb.dense = nn.ModuleList([
- torch.nn.Linear(self.ch, self.temb_ch),
- torch.nn.Linear(self.temb_ch, self.temb_ch),
- ])
-
- # downsampling
- self.conv_in = torch.nn.Conv2d(
- in_channels, self.ch, kernel_size=3, stride=1, padding=1)
-
- curr_res = resolution
- in_ch_mult = (1, ) + tuple(ch_mult)
- self.down = nn.ModuleList()
- for i_level in range(self.num_resolutions):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_in = ch * in_ch_mult[i_level]
- block_out = ch * ch_mult[i_level]
- for i_block in range(self.num_res_blocks):
- block.append(
- ResnetBlock(
- in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(AttnBlock(block_in))
- down = nn.Module()
- down.block = block
- down.attn = attn
- if i_level != self.num_resolutions - 1:
- down.downsample = Downsample(block_in, resamp_with_conv)
- curr_res = curr_res // 2
- self.down.append(down)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = AttnBlock(block_in)
- self.mid.block_2 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # upsampling
- self.up = nn.ModuleList()
- for i_level in reversed(range(self.num_resolutions)):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_out = ch * ch_mult[i_level]
- skip_in = ch * ch_mult[i_level]
- for i_block in range(self.num_res_blocks + 1):
- if i_block == self.num_res_blocks:
- skip_in = ch * in_ch_mult[i_level]
- block.append(
- ResnetBlock(
- in_channels=block_in + skip_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(AttnBlock(block_in))
- up = nn.Module()
- up.block = block
- up.attn = attn
- if i_level != 0:
- up.upsample = Upsample(block_in, resamp_with_conv)
- curr_res = curr_res * 2
- self.up.insert(0, up) # prepend to get consistent order
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(
- block_in, out_ch, kernel_size=3, stride=1, padding=1)
-
- def forward(self, x, t=None):
- #assert x.shape[2] == x.shape[3] == self.resolution
-
- if self.use_timestep:
- # timestep embedding
- assert t is not None
- temb = get_timestep_embedding(t, self.ch)
- temb = self.temb.dense[0](temb)
- temb = nonlinearity(temb)
- temb = self.temb.dense[1](temb)
- else:
- temb = None
-
- # downsampling
- hs = [self.conv_in(x)]
- for i_level in range(self.num_resolutions):
- for i_block in range(self.num_res_blocks):
- h = self.down[i_level].block[i_block](hs[-1], temb)
- if len(self.down[i_level].attn) > 0:
- h = self.down[i_level].attn[i_block](h)
- hs.append(h)
- if i_level != self.num_resolutions - 1:
- hs.append(self.down[i_level].downsample(hs[-1]))
-
- # middle
- h = hs[-1]
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks + 1):
- h = self.up[i_level].block[i_block](torch.cat([h, hs.pop()],
- dim=1), temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
-
- # end
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
-
-class Encoder(nn.Module):
-
- def __init__(self,
- ch,
- num_res_blocks,
- attn_resolutions,
- in_channels,
- resolution,
- z_channels,
- ch_mult=(1, 2, 4, 8),
- dropout=0.0,
- resamp_with_conv=True,
- double_z=True):
- super().__init__()
- self.ch = ch
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
-
- # downsampling
- self.conv_in = torch.nn.Conv2d(
- in_channels, self.ch, kernel_size=3, stride=1, padding=1)
-
- curr_res = resolution
- in_ch_mult = (1, ) + tuple(ch_mult)
- self.down = nn.ModuleList()
- for i_level in range(self.num_resolutions):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_in = ch * in_ch_mult[i_level]
- block_out = ch * ch_mult[i_level]
- for i_block in range(self.num_res_blocks):
- block.append(
- ResnetBlock(
- in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(AttnBlock(block_in))
- down = nn.Module()
- down.block = block
- down.attn = attn
- if i_level != self.num_resolutions - 1:
- down.downsample = Downsample(block_in, resamp_with_conv)
- curr_res = curr_res // 2
- self.down.append(down)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = AttnBlock(block_in)
- self.mid.block_2 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(
- block_in,
- 2 * z_channels if double_z else z_channels,
- kernel_size=3,
- stride=1,
- padding=1)
-
- def forward(self, x):
- #assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution)
-
- # timestep embedding
- temb = None
-
- # downsampling
- hs = [self.conv_in(x)]
- for i_level in range(self.num_resolutions):
- for i_block in range(self.num_res_blocks):
- h = self.down[i_level].block[i_block](hs[-1], temb)
- if len(self.down[i_level].attn) > 0:
- h = self.down[i_level].attn[i_block](h)
- hs.append(h)
- if i_level != self.num_resolutions - 1:
- hs.append(self.down[i_level].downsample(hs[-1]))
-
- # middle
- h = hs[-1]
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # end
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
-
-class Decoder(nn.Module):
-
- def __init__(self,
- in_channels,
- resolution,
- z_channels,
- ch,
- out_ch,
- num_res_blocks,
- attn_resolutions,
- ch_mult=(1, 2, 4, 8),
- dropout=0.0,
- resamp_with_conv=True,
- give_pre_end=False):
- super().__init__()
- self.ch = ch
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
- self.give_pre_end = give_pre_end
-
- # compute in_ch_mult, block_in and curr_res at lowest res
- in_ch_mult = (1, ) + tuple(ch_mult)
- block_in = ch * ch_mult[self.num_resolutions - 1]
- curr_res = resolution // 2**(self.num_resolutions - 1)
- self.z_shape = (1, z_channels, curr_res, curr_res // 2)
- print("Working with z of shape {} = {} dimensions.".format(
- self.z_shape, np.prod(self.z_shape)))
-
- # z to block_in
- self.conv_in = torch.nn.Conv2d(
- z_channels, block_in, kernel_size=3, stride=1, padding=1)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = AttnBlock(block_in)
- self.mid.block_2 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- # upsampling
- self.up = nn.ModuleList()
- for i_level in reversed(range(self.num_resolutions)):
- block = nn.ModuleList()
- attn = nn.ModuleList()
- block_out = ch * ch_mult[i_level]
- for i_block in range(self.num_res_blocks + 1):
- block.append(
- ResnetBlock(
- in_channels=block_in,
- out_channels=block_out,
- temb_channels=self.temb_ch,
- dropout=dropout))
- block_in = block_out
- if curr_res in attn_resolutions:
- attn.append(AttnBlock(block_in))
- up = nn.Module()
- up.block = block
- up.attn = attn
- if i_level != 0:
- up.upsample = Upsample(block_in, resamp_with_conv)
- curr_res = curr_res * 2
- self.up.insert(0, up) # prepend to get consistent order
-
- # end
- self.norm_out = Normalize(block_in)
- self.conv_out = torch.nn.Conv2d(
- block_in, out_ch, kernel_size=3, stride=1, padding=1)
-
- def forward(self, z, bot_h=None):
- #assert z.shape[1:] == self.z_shape[1:]
- self.last_z_shape = z.shape
-
- # timestep embedding
- temb = None
-
- # z to block_in
- h = self.conv_in(z)
-
- # middle
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks + 1):
- h = self.up[i_level].block[i_block](h, temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
- if i_level == 4 and bot_h is not None:
- h += bot_h
-
- # end
- if self.give_pre_end:
- return h
-
- h = self.norm_out(h)
- h = nonlinearity(h)
- h = self.conv_out(h)
- return h
-
- def get_feature_top(self, z):
- #assert z.shape[1:] == self.z_shape[1:]
- self.last_z_shape = z.shape
-
- # timestep embedding
- temb = None
-
- # z to block_in
- h = self.conv_in(z)
-
- # middle
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks + 1):
- h = self.up[i_level].block[i_block](h, temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
- if i_level == 4:
- return h
-
- def get_feature_middle(self, z, mid_h):
- #assert z.shape[1:] == self.z_shape[1:]
- self.last_z_shape = z.shape
-
- # timestep embedding
- temb = None
-
- # z to block_in
- h = self.conv_in(z)
-
- # middle
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- # upsampling
- for i_level in reversed(range(self.num_resolutions)):
- for i_block in range(self.num_res_blocks + 1):
- h = self.up[i_level].block[i_block](h, temb)
- if len(self.up[i_level].attn) > 0:
- h = self.up[i_level].attn[i_block](h)
- if i_level != 0:
- h = self.up[i_level].upsample(h)
- if i_level == 4:
- h += mid_h
- if i_level == 3:
- return h
-
-
-class DecoderRes(nn.Module):
-
- def __init__(self,
- in_channels,
- resolution,
- z_channels,
- ch,
- num_res_blocks,
- ch_mult=(1, 2, 4, 8),
- dropout=0.0,
- give_pre_end=False):
- super().__init__()
- self.ch = ch
- self.temb_ch = 0
- self.num_resolutions = len(ch_mult)
- self.num_res_blocks = num_res_blocks
- self.resolution = resolution
- self.in_channels = in_channels
- self.give_pre_end = give_pre_end
-
- # compute in_ch_mult, block_in and curr_res at lowest res
- in_ch_mult = (1, ) + tuple(ch_mult)
- block_in = ch * ch_mult[self.num_resolutions - 1]
- curr_res = resolution // 2**(self.num_resolutions - 1)
- self.z_shape = (1, z_channels, curr_res, curr_res // 2)
- print("Working with z of shape {} = {} dimensions.".format(
- self.z_shape, np.prod(self.z_shape)))
-
- # z to block_in
- self.conv_in = torch.nn.Conv2d(
- z_channels, block_in, kernel_size=3, stride=1, padding=1)
-
- # middle
- self.mid = nn.Module()
- self.mid.block_1 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
- self.mid.attn_1 = AttnBlock(block_in)
- self.mid.block_2 = ResnetBlock(
- in_channels=block_in,
- out_channels=block_in,
- temb_channels=self.temb_ch,
- dropout=dropout)
-
- def forward(self, z):
- #assert z.shape[1:] == self.z_shape[1:]
- self.last_z_shape = z.shape
-
- # timestep embedding
- temb = None
-
- # z to block_in
- h = self.conv_in(z)
-
- # middle
- h = self.mid.block_1(h, temb)
- h = self.mid.attn_1(h)
- h = self.mid.block_2(h, temb)
-
- return h
-
-
-# patch based discriminator
-class Discriminator(nn.Module):
-
- def __init__(self, nc, ndf, n_layers=3):
- super().__init__()
-
- layers = [
- nn.Conv2d(nc, ndf, kernel_size=4, stride=2, padding=1),
- nn.LeakyReLU(0.2, True)
- ]
- ndf_mult = 1
- ndf_mult_prev = 1
- for n in range(1,
- n_layers): # gradually increase the number of filters
- ndf_mult_prev = ndf_mult
- ndf_mult = min(2**n, 8)
- layers += [
- nn.Conv2d(
- ndf * ndf_mult_prev,
- ndf * ndf_mult,
- kernel_size=4,
- stride=2,
- padding=1,
- bias=False),
- nn.BatchNorm2d(ndf * ndf_mult),
- nn.LeakyReLU(0.2, True)
- ]
-
- ndf_mult_prev = ndf_mult
- ndf_mult = min(2**n_layers, 8)
-
- layers += [
- nn.Conv2d(
- ndf * ndf_mult_prev,
- ndf * ndf_mult,
- kernel_size=4,
- stride=1,
- padding=1,
- bias=False),
- nn.BatchNorm2d(ndf * ndf_mult),
- nn.LeakyReLU(0.2, True)
- ]
-
- layers += [
- nn.Conv2d(ndf * ndf_mult, 1, kernel_size=4, stride=1, padding=1)
- ] # output 1 channel prediction map
- self.main = nn.Sequential(*layers)
-
- def forward(self, x):
- return self.main(x)
diff --git a/spaces/Sagar48/claudfuen-photorealistic-fuen-v1/README.md b/spaces/Sagar48/claudfuen-photorealistic-fuen-v1/README.md
deleted file mode 100644
index d81c3e5a018379a0829bc201d5c03bdcd6ae4355..0000000000000000000000000000000000000000
--- a/spaces/Sagar48/claudfuen-photorealistic-fuen-v1/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Claudfuen Photorealistic Fuen V1
-emoji: 🦀
-colorFrom: gray
-colorTo: red
-sdk: gradio
-sdk_version: 3.29.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/SalahZa/Tunisian-ASR-v0/partly_frozen_splitted_wavlm/1986/ctc_train.py b/spaces/SalahZa/Tunisian-ASR-v0/partly_frozen_splitted_wavlm/1986/ctc_train.py
deleted file mode 100644
index 39b6b13ff99870adb71e2bcffca4ce2479405a08..0000000000000000000000000000000000000000
--- a/spaces/SalahZa/Tunisian-ASR-v0/partly_frozen_splitted_wavlm/1986/ctc_train.py
+++ /dev/null
@@ -1,339 +0,0 @@
-#!/usr/bin/env/python3
-"""Recipe for training a wav2vec-based ctc ASR system with librispeech.
-The system employs wav2vec as its encoder. Decoding is performed with
-ctc greedy decoder.
-To run this recipe, do the following:
-> python train_with_wav2vec.py hparams/train_with_wav2vec.yaml
-The neural network is trained on CTC likelihood target and character units
-are used as basic recognition tokens. Training is performed on the full
-LibriSpeech dataset (960 h).
-
-Authors
- * Sung-Lin Yeh 2021
- * Titouan Parcollet 2021
- * Ju-Chieh Chou 2020
- * Mirco Ravanelli 2020
- * Abdel Heba 2020
- * Peter Plantinga 2020
- * Samuele Cornell 2020
-"""
-
-import os
-import sys
-import torch
-import logging
-import speechbrain as sb
-from speechbrain.utils.distributed import run_on_main
-from hyperpyyaml import load_hyperpyyaml
-from pathlib import Path
-import torchaudio.transforms as T
-logger = logging.getLogger(__name__)
-
-# Define training procedure
-class ASR(sb.Brain):
- def compute_forward(self, batch, stage):
- """Forward computations from the waveform batches to the output probabilities."""
- batch = batch.to(self.device)
- wavs, wav_lens = batch.sig
- tokens_bos, _ = batch.tokens_bos
- wavs, wav_lens = wavs.to(self.device), wav_lens.to(self.device)
-
- # Forward pass
- feats = self.modules.wav2vec2(wavs)
- x = self.modules.enc(feats)
- # Compute outputs
- p_tokens = None
- logits = self.modules.ctc_lin(x)
- p_ctc = self.hparams.log_softmax(logits)
- if stage != sb.Stage.TRAIN:
- p_tokens = sb.decoders.ctc_greedy_decode(
- p_ctc, wav_lens, blank_id=self.hparams.blank_index
- )
- return p_ctc, wav_lens, p_tokens
-
- def compute_objectives(self, predictions, batch, stage):
- """Computes the loss (CTC+NLL) given predictions and targets."""
-
- p_ctc, wav_lens, predicted_tokens = predictions
-
- ids = batch.id
- tokens_eos, tokens_eos_lens = batch.tokens_eos
- tokens, tokens_lens = batch.tokens
-
- if hasattr(self.modules, "env_corrupt") and stage == sb.Stage.TRAIN:
- tokens_eos = torch.cat([tokens_eos, tokens_eos], dim=0)
- tokens_eos_lens = torch.cat(
- [tokens_eos_lens, tokens_eos_lens], dim=0
- )
- tokens = torch.cat([tokens, tokens], dim=0)
- tokens_lens = torch.cat([tokens_lens, tokens_lens], dim=0)
-
- loss_ctc = self.hparams.ctc_cost(p_ctc, tokens, wav_lens, tokens_lens)
- loss = loss_ctc
-
- if stage != sb.Stage.TRAIN:
- # Decode token terms to words
- predicted_words = [
- "".join(self.tokenizer.decode_ndim(utt_seq)).split(" ")
- for utt_seq in predicted_tokens
- ]
- target_words = [wrd.split(" ") for wrd in batch.wrd]
- self.wer_metric.append(ids, predicted_words, target_words)
- self.cer_metric.append(ids, predicted_words, target_words)
-
- return loss
-
- def fit_batch(self, batch):
- """Train the parameters given a single batch in input"""
- predictions = self.compute_forward(batch, sb.Stage.TRAIN)
- loss = self.compute_objectives(predictions, batch, sb.Stage.TRAIN)
- loss.backward()
- if self.check_gradients(loss):
- self.wav2vec_optimizer.step()
- self.model_optimizer.step()
-
- self.wav2vec_optimizer.zero_grad()
- self.model_optimizer.zero_grad()
-
- return loss.detach()
-
- def evaluate_batch(self, batch, stage):
- """Computations needed for validation/test batches"""
- predictions = self.compute_forward(batch, stage=stage)
- with torch.no_grad():
- loss = self.compute_objectives(predictions, batch, stage=stage)
- return loss.detach()
-
- def on_stage_start(self, stage, epoch):
- """Gets called at the beginning of each epoch"""
- if stage != sb.Stage.TRAIN:
- self.cer_metric = self.hparams.cer_computer()
- self.wer_metric = self.hparams.error_rate_computer()
-
- def on_stage_end(self, stage, stage_loss, epoch):
- """Gets called at the end of an epoch."""
- # Compute/store important stats
- stage_stats = {"loss": stage_loss}
- if stage == sb.Stage.TRAIN:
- self.train_stats = stage_stats
- else:
- stage_stats["CER"] = self.cer_metric.summarize("error_rate")
- stage_stats["WER"] = self.wer_metric.summarize("error_rate")
-
- # Perform end-of-iteration things, like annealing, logging, etc.
- if stage == sb.Stage.VALID:
- old_lr_model, new_lr_model = self.hparams.lr_annealing_model(
- stage_stats["loss"]
- )
- old_lr_wav2vec, new_lr_wav2vec = self.hparams.lr_annealing_wav2vec(
- stage_stats["loss"]
- )
- sb.nnet.schedulers.update_learning_rate(
- self.model_optimizer, new_lr_model
- )
- sb.nnet.schedulers.update_learning_rate(
- self.wav2vec_optimizer, new_lr_wav2vec
- )
- self.hparams.train_logger.log_stats(
- stats_meta={
- "epoch": epoch,
- "lr_model": old_lr_model,
- "lr_wav2vec": old_lr_wav2vec,
- },
- train_stats=self.train_stats,
- valid_stats=stage_stats,
- )
- self.checkpointer.save_and_keep_only(
- meta={"WER": stage_stats["WER"]}, min_keys=["WER"],
- )
- elif stage == sb.Stage.TEST:
- self.hparams.train_logger.log_stats(
- stats_meta={"Epoch loaded": self.hparams.epoch_counter.current},
- test_stats=stage_stats,
- )
- with open(self.hparams.wer_file, "w") as w:
- self.wer_metric.write_stats(w)
-
- def init_optimizers(self):
- "Initializes the wav2vec2 optimizer and model optimizer"
- self.wav2vec_optimizer = self.hparams.wav2vec_opt_class(
- self.modules.wav2vec2.parameters()
- )
- self.model_optimizer = self.hparams.model_opt_class(
- self.hparams.model.parameters()
- )
-
- if self.checkpointer is not None:
- self.checkpointer.add_recoverable(
- "wav2vec_opt", self.wav2vec_optimizer
- )
- self.checkpointer.add_recoverable("modelopt", self.model_optimizer)
-
-
-def dataio_prepare(hparams):
- """This function prepares the datasets to be used in the brain class.
- It also defines the data processing pipeline through user-defined functions."""
- data_folder = hparams["data_folder"]
-
- train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=hparams["train_csv"], replacements={"data_root": data_folder},
- )
-
- if hparams["sorting"] == "ascending":
- # we sort training data to speed up training and get better results.
- train_data = train_data.filtered_sorted(sort_key="duration")
- # when sorting do not shuffle in dataloader ! otherwise is pointless
- hparams["train_dataloader_opts"]["shuffle"] = False
-
- elif hparams["sorting"] == "descending":
- train_data = train_data.filtered_sorted(
- sort_key="duration", reverse=True
- )
- # when sorting do not shuffle in dataloader ! otherwise is pointless
- hparams["train_dataloader_opts"]["shuffle"] = False
-
- elif hparams["sorting"] == "random":
- pass
-
- else:
- raise NotImplementedError(
- "sorting must be random, ascending or descending"
- )
-
- valid_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=hparams["valid_csv"], replacements={"data_root": data_folder},
- )
- valid_data = valid_data.filtered_sorted(sort_key="duration")
-
- # test is separate
- test_datasets = {}
- for csv_file in hparams["test_csv"]:
- name = Path(csv_file).stem
- test_datasets[name] = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=csv_file, replacements={"data_root": data_folder}
- )
- test_datasets[name] = test_datasets[name].filtered_sorted(
- sort_key="duration"
- )
-
- datasets = [train_data, valid_data] + [i for k, i in test_datasets.items()]
-
- # 2. Define audio pipeline:
- @sb.utils.data_pipeline.takes("wav", "sr")
- @sb.utils.data_pipeline.provides("sig")
- def audio_pipeline(wav, sr):
- sig = sb.dataio.dataio.read_audio(wav)
- sig = resamplers[sr](sig)
- return sig
-
- sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)
- label_encoder = sb.dataio.encoder.CTCTextEncoder()
-
- # 3. Define text pipeline:
- @sb.utils.data_pipeline.takes("wrd")
- @sb.utils.data_pipeline.provides(
- "wrd", "char_list", "tokens_list", "tokens_bos", "tokens_eos", "tokens"
- )
- def text_pipeline(wrd):
- yield wrd
- char_list = list(wrd)
- yield char_list
- tokens_list = label_encoder.encode_sequence(char_list)
- yield tokens_list
- tokens_bos = torch.LongTensor([hparams["bos_index"]] + (tokens_list))
- yield tokens_bos
- tokens_eos = torch.LongTensor(tokens_list + [hparams["eos_index"]])
- yield tokens_eos
- tokens = torch.LongTensor(tokens_list)
- yield tokens
-
- sb.dataio.dataset.add_dynamic_item(datasets, text_pipeline)
-
- lab_enc_file = os.path.join(hparams["save_folder"], "label_encoder.txt")
- special_labels = {
- "bos_label": hparams["bos_index"],
- "eos_label": hparams["eos_index"],
- "blank_label": hparams["blank_index"],
- }
- label_encoder.load_or_create(
- path=lab_enc_file,
- from_didatasets=[train_data],
- output_key="char_list",
- special_labels=special_labels,
- sequence_input=True,
- )
-
- # 4. Set output:
- sb.dataio.dataset.set_output_keys(
- datasets,
- ["id", "sig", "wrd", "char_list", "tokens_bos", "tokens_eos", "tokens"],
- )
- return train_data, valid_data, test_datasets, label_encoder
-
-
-if __name__ == "__main__":
-
- # CLI:
- hparams_file, run_opts, overrides = sb.parse_arguments(sys.argv[1:])
-
- # If distributed_launch=True then
- # create ddp_group with the right communication protocol
- sb.utils.distributed.ddp_init_group(run_opts)
-
- with open(hparams_file) as fin:
- hparams = load_hyperpyyaml(fin, overrides)
-
- # Create experiment directory
- sb.create_experiment_directory(
- experiment_directory=hparams["output_folder"],
- hyperparams_to_save=hparams_file,
- overrides=overrides,
- )
-
- # Dataset prep (parsing Librispeech)
-
- resampler_8000 = T.Resample(8000, 16000, dtype=torch.float)
-
- resampler_44100 =T.Resample(44100, 16000, dtype=torch.float)
- resampler_32000 =T.Resample(32000, 16000, dtype=torch.float)
- resampler_48000 =T.Resample(48000, 16000, dtype=torch.float)
-
-
- resamplers = {"48000": resampler_48000,"8000": resampler_8000, "44100":resampler_44100, "32000":resampler_32000}
-
- # here we create the datasets objects as well as tokenization and encoding
- train_data, valid_data, test_datasets, label_encoder = dataio_prepare(
- hparams
- )
-
- # Trainer initialization
- asr_brain = ASR(
- modules=hparams["modules"],
- hparams=hparams,
- run_opts=run_opts,
- checkpointer=hparams["checkpointer"],
- )
- asr_brain.device= "cpu"
- asr_brain.modules.to("cpu")
-
- # We dynamicaly add the tokenizer to our brain class.
- # NB: This tokenizer corresponds to the one used for the LM!!
- asr_brain.tokenizer = label_encoder
-
- # Training
- asr_brain.fit(
- asr_brain.hparams.epoch_counter,
- train_data,
- valid_data,
- train_loader_kwargs=hparams["train_dataloader_opts"],
- valid_loader_kwargs=hparams["valid_dataloader_opts"],
- )
-
- # Testing
- for k in test_datasets.keys(): # keys are test_clean, test_other etc
- asr_brain.hparams.wer_file = os.path.join(
- hparams["output_folder"], "wer_{}.txt".format(k)
- )
- asr_brain.evaluate(
- test_datasets[k], test_loader_kwargs=hparams["test_dataloader_opts"]
- )
diff --git a/spaces/Sandiago21/speech-to-speech-translation-german-2/app.py b/spaces/Sandiago21/speech-to-speech-translation-german-2/app.py
deleted file mode 100644
index dc659c72ec8ec6127cc94143f998fd17940d204f..0000000000000000000000000000000000000000
--- a/spaces/Sandiago21/speech-to-speech-translation-german-2/app.py
+++ /dev/null
@@ -1,168 +0,0 @@
-import gradio as gr
-import numpy as np
-import torch
-from datasets import load_dataset
-from transformers import SpeechT5ForTextToSpeech, SpeechT5HifiGan, SpeechT5Processor, pipeline
-
-
-device = "cuda:0" if torch.cuda.is_available() else "cpu"
-
-# load speech translation checkpoint
-asr_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-large-v2", device=device)
-german_translation_pipe = pipeline("translation", model="Helsinki-NLP/opus-mt-en-de")
-
-# load text-to-speech checkpoint and speaker embeddings
-model_id = "microsoft/speecht5_tts" # update with your model id
-# pipe = pipeline("automatic-speech-recognition", model=model_id)
-model = SpeechT5ForTextToSpeech.from_pretrained(model_id)
-vocoder = SpeechT5HifiGan.from_pretrained("microsoft/speecht5_hifigan")
-embeddings_dataset = load_dataset("Matthijs/cmu-arctic-xvectors", split="validation")
-speaker_embeddings = torch.tensor(embeddings_dataset[7440]["xvector"]).unsqueeze(0)
-
-processor = SpeechT5Processor.from_pretrained(model_id)
-
-model_id_german = "Sandiago21/speecht5_finetuned_mozilla_foundation_common_voice_13_german"
-model_german = SpeechT5ForTextToSpeech.from_pretrained(model_id_german)
-processor_german = SpeechT5Processor.from_pretrained(model_id_german)
-
-replacements = [
- ("Ä", "E"),
- ("Æ", "E"),
- ("Ç", "C"),
- ("É", "E"),
- ("Í", "I"),
- ("Ó", "O"),
- ("Ö", "E"),
- ("Ü", "Y"),
- ("ß", "S"),
- ("à", "a"),
- ("á", "a"),
- ("ã", "a"),
- ("ä", "e"),
- ("å", "a"),
- ("ë", "e"),
- ("í", "i"),
- ("ï", "i"),
- ("ð", "o"),
- ("ñ", "n"),
- ("ò", "o"),
- ("ó", "o"),
- ("ô", "o"),
- ("ö", "u"),
- ("ú", "u"),
- ("ü", "y"),
- ("ý", "y"),
- ("Ā", "A"),
- ("ā", "a"),
- ("ă", "a"),
- ("ą", "a"),
- ("ć", "c"),
- ("Č", "C"),
- ("č", "c"),
- ("ď", "d"),
- ("Đ", "D"),
- ("ę", "e"),
- ("ě", "e"),
- ("ğ", "g"),
- ("İ", "I"),
- ("О", "O"),
- ("Ł", "L"),
- ("ń", "n"),
- ("ň", "n"),
- ("Ō", "O"),
- ("ō", "o"),
- ("ő", "o"),
- ("ř", "r"),
- ("Ś", "S"),
- ("ś", "s"),
- ("Ş", "S"),
- ("ş", "s"),
- ("Š", "S"),
- ("š", "s"),
- ("ū", "u"),
- ("ź", "z"),
- ("Ż", "Z"),
- ("Ž", "Z"),
- ("ǐ", "i"),
- ("ǐ", "i"),
- ("ș", "s"),
- ("ț", "t"),
-]
-
-def cleanup_text(text):
- for src, dst in replacements:
- text = text.replace(src, dst)
- return text
-
-
-def synthesize_speech(text):
- text = cleanup_text(text)
- inputs = processor(text=text, return_tensors="pt")
- speech = model.generate_speech(inputs["input_ids"].to(device), speaker_embeddings.to(device), vocoder=vocoder)
-
- return gr.Audio.update(value=(16000, speech.cpu().numpy()))
-
-
-def translate_to_english(audio):
- outputs = asr_pipe(audio, max_new_tokens=256, generate_kwargs={"task": "translate", "language": "english"})
- return outputs["text"]
-
-
-def synthesise_from_english(text):
- text = cleanup_text(text)
- inputs = processor(text=text, return_tensors="pt")
- speech = model.generate_speech(inputs["input_ids"].to(device), speaker_embeddings.to(device), vocoder=vocoder)
- return speech.cpu().numpy()
-
-
-def translate_from_english_to_german(text):
- return german_translation_pipe(text)[0]["translation_text"]
-
-
-def synthesise_from_german(text):
- text = cleanup_text(text)
- inputs = processor_german(text=text, return_tensors="pt")
- speech = model_german.generate_speech(inputs["input_ids"].to(device), speaker_embeddings.to(device), vocoder=vocoder)
- return speech.cpu()
-
-
-def speech_to_speech_translation(audio):
- translated_text = translate_to_english(audio)
- translated_text = translate_from_english_to_german(translated_text)
-# synthesised_speech = synthesise_from_english(translated_text)
-# translated_text = translate_from_english_to_german(synthesised_speech)
- synthesised_speech = synthesise_from_german(translated_text)
- synthesised_speech = (synthesised_speech.numpy() * 32767).astype(np.int16)
- return ((16000, synthesised_speech), translated_text)
-
-
-title = "Cascaded STST"
-description = """
-Demo for cascaded speech-to-speech translation (STST), mapping from source speech in any language to target speech in German. Demo uses OpenAI's [Whisper Large v2](https://huggingface.co/openai/whisper-large-v2) model for speech translation, and [Sandiago21/speecht5_finetuned_google_fleurs_german](https://huggingface.co/Sandiago21/speecht5_finetuned_google_fleurs_german) checkpoint for text-to-speech, which is based on Microsoft's
-[SpeechT5 TTS](https://huggingface.co/microsoft/speecht5_tts) model for text-to-speech, fine-tuned in German Audio dataset:
-
-"""
-
-demo = gr.Blocks()
-
-mic_translate = gr.Interface(
- fn=speech_to_speech_translation,
- inputs=gr.Audio(source="microphone", type="filepath"),
- outputs=[gr.Audio(label="Generated Speech", type="numpy"), gr.outputs.Textbox()],
- title=title,
- description=description,
-)
-
-file_translate = gr.Interface(
- fn=speech_to_speech_translation,
- inputs=gr.Audio(source="upload", type="filepath"),
- outputs=[gr.Audio(label="Generated Speech", type="numpy"), gr.outputs.Textbox()],
- examples=[["./example.wav"]],
- title=title,
- description=description,
-)
-
-with demo:
- gr.TabbedInterface([mic_translate, file_translate], ["Microphone", "Audio File"])
-
-demo.launch()
diff --git a/spaces/SankarSrin/image-matting-app/ppmatting/models/__init__.py b/spaces/SankarSrin/image-matting-app/ppmatting/models/__init__.py
deleted file mode 100644
index d446649bc75b44f5ff3f9183e22f057f128b5fa2..0000000000000000000000000000000000000000
--- a/spaces/SankarSrin/image-matting-app/ppmatting/models/__init__.py
+++ /dev/null
@@ -1,7 +0,0 @@
-from .backbone import *
-from .losses import *
-from .modnet import MODNet
-from .human_matting import HumanMatting
-from .dim import DIM
-from .ppmatting import PPMatting
-from .gca import GCABaseline, GCA
diff --git a/spaces/SarthakSidhant/Go-Cattle/diseases/respiratory syncytial virus infection.md b/spaces/SarthakSidhant/Go-Cattle/diseases/respiratory syncytial virus infection.md
deleted file mode 100644
index 4d07db62532486c4449dbfa7b44174ee5dffb457..0000000000000000000000000000000000000000
--- a/spaces/SarthakSidhant/Go-Cattle/diseases/respiratory syncytial virus infection.md
+++ /dev/null
@@ -1,30 +0,0 @@
-## Respiratory syncytial virus infection (RSV)
-
-**Information**
-
-Respiratory syncytial virus (RSV) is a respiratory virus that affects cattle. It is closely related to the human respiratory syncytial virus (HRSV). RSV infection can cause a range of symptoms in cattle, from mild respiratory illness to severe pneumonia.
-
-**Symptoms**
-
-The symptoms of RSV infection in cattle can vary depending on the severity of the infection. Mild cases may only cause a runny nose, cough, and fever. More severe cases can cause pneumonia, which can lead to respiratory distress, weight loss, and death.
-
-**Remedies**
-
-There is no specific treatment for RSV infection in cattle. Treatment is usually supportive and may include:
-
-* Providing fluids and electrolytes
-* Treating secondary bacterial infections
-* Administering bronchodilators
-
-**Causes**
-
-RSV infection is caused by a virus called respiratory syncytial virus (RSV). RSV is a respiratory virus that can infect a wide range of animals, including cattle, humans, and other mammals.
-
-**Prevention**
-
-There is no vaccine available for RSV infection in cattle. However, there are some preventive measures that can be taken to reduce the risk of infection, such as:
-
-* Vaccinating cattle against other respiratory viruses, such as bovine viral diarrhea virus (BVDV) and parainfluenza 3 virus (PI3)
-* Providing good ventilation and air quality in livestock facilities
-* Isolating sick animals from healthy animals
-
diff --git a/spaces/SerdarHelli/Knee-View-Merchant-Landmark-Detection/README.md b/spaces/SerdarHelli/Knee-View-Merchant-Landmark-Detection/README.md
deleted file mode 100644
index 3507ba51172bb13f26e12ad5c71573d2b50c7141..0000000000000000000000000000000000000000
--- a/spaces/SerdarHelli/Knee-View-Merchant-Landmark-Detection/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Knee View Merchant Landmark Detection
-emoji: 🏢
-colorFrom: indigo
-colorTo: green
-sdk: streamlit
-sdk_version: 1.2.0
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/Severian/ANIMA-7B-Biomimicry-LLM/app.py b/spaces/Severian/ANIMA-7B-Biomimicry-LLM/app.py
deleted file mode 100644
index 702603516f0e3576bea0cba691d2bda7efa0a199..0000000000000000000000000000000000000000
--- a/spaces/Severian/ANIMA-7B-Biomimicry-LLM/app.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import gradio as gr
-
-import copy
-import random
-import os
-import requests
-import time
-import sys
-
-from huggingface_hub import snapshot_download
-from llama_cpp import Llama
-
-# Initial system prompt
-SYSTEM_PROMPT = ("Your name is ANIMA, an Advanced Nature Inspired Multidisciplinary Assistant, and a leading expert "
- "in biomimicry, biology, engineering, industrial design, environmental science, physiology, and paleontology. "
- "Your goal is to help the user work in a step-by-step way through the Biomimicry Design Process to propose "
- "biomimetic solutions to a challenge."
- "Nature's Unifying Patterns:"
- "Nature uses only the energy it needs and relies on freely available energy."
- "Nature recycles all materials."
- "Nature is resilient to disturbances."
- "Nature tends to optimize rather than maximize."
- "Nature provides mutual benefits."
- "Nature runs on information."
- "Nature uses chemistry and materials that are safe for living beings."
- "Nature builds using abundant resources, incorporating rare resources only sparingly."
- "Nature is locally attuned and responsive."
- "Nature uses shape to determine functionality.")
-
-# Download model snapshot
-repo_name = "Severian/ANIMA-Phi-Neptune-Mistral-7B-gguf"
-model_name = "ANIMA-Phi-Neptune-Mistral-7B-gguf"
-snapshot_download(repo_id=repo_name, local_dir=".", allow_patterns=model_name)
-
-# Initialize Llama model
-model = Llama(
- model_path=model_name,
- n_ctx=1024,
- n_parts=1,
-)
-
-# Maximum number of new tokens to generate
-max_new_tokens = 500
-
-# User message function
-def user(message, history):
- new_history = history + [[message, None]]
- return "", new_history
-
-# Bot message function
-def bot(history, system_prompt):
- tokens = model.tokenize(system_prompt.encode("utf-8"))
-
- for user_message, bot_message in history[:-1]:
- message_tokens = model.tokenize(user_message.encode("utf-8"))
- tokens.extend(message_tokens)
-
- if bot_message:
- message_tokens = model.tokenize(bot_message.encode("utf-8"))
- tokens.extend(message_tokens)
-
- last_user_message = history[-1][0]
- message_tokens = model.tokenize(last_user_message.encode("utf-8"))
- tokens.extend(message_tokens)
-
- generator = model.generate(tokens)
-
- partial_text = ""
- for i, token in enumerate(generator):
- if token == model.token_eos() or (max_new_tokens is not None and i >= max_new_tokens):
- break
- partial_text += model.detokenize([token]).decode("utf-8", "ignore")
- history[-1][1] = partial_text
- return history
-
-# Gradio UI
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
- favicon = '
'
- gr.Markdown(f"""
ANIMA is an expert in various scientific disciplines.""")
- with gr.Row():
- with gr.Column(scale=5):
- system_prompt = gr.Textbox(label="System Prompt", placeholder="", value=SYSTEM_PROMPT, interactive=False)
- chatbot = gr.Chatbot(label="Dialogue").style(height=400)
- with gr.Row():
- with gr.Column():
- msg = gr.Textbox(label="Send Message", placeholder="Send Message", show_label=False).style(container=False)
- with gr.Column():
- with gr.Row():
- submit = gr.Button("Send")
- stop = gr.Button("Stop")
- clear = gr.Button("Clear")
- with gr.Row():
- gr.Markdown("""WARNING: The model may generate factually or ethically incorrect texts. We are not responsible for this.""")
-
- submit_event = msg.submit(fn=user, inputs=[msg, chatbot], outputs=[msg, chatbot], queue=False).success(fn=bot, inputs=[chatbot, system_prompt], outputs=chatbot, queue=True)
- submit_click_event = submit.click(fn=user, inputs=[msg, chatbot], outputs=[msg, chatbot], queue=False).success(fn=bot, inputs=[chatbot, system_prompt], outputs=chatbot, queue=True)
- stop.click(fn=None, inputs=None, outputs=None, cancels=[submit_event, submit_click_event], queue=False)
- clear.click(lambda: None, None, chatbot, queue=False)
-
-demo.queue(max_size=128, concurrency_count=1)
-demo.launch()
diff --git a/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py b/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py
deleted file mode 100644
index 3bba48a4aab5c8d07fe15e5de734fa8ddebe2abb..0000000000000000000000000000000000000000
--- a/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py
+++ /dev/null
@@ -1,263 +0,0 @@
-
-
-
-import tensorflow as tf
-import tensorlayer as tl
-import numpy as np
-
-# The HDR reconstruction autoencoder fully convolutional neural network
-def model(x, batch_size=1, is_training=False):
-
- # Encoder network (VGG16, until pool5)
- x_in = tf.scalar_mul(255.0, x)
- net_in = tl.layers.InputLayer(x_in, name='input_layer')
- conv_layers, skip_layers = encoder(net_in)
-
- # Fully convolutional layers on top of VGG16 conv layers
- network = tl.layers.Conv2dLayer(conv_layers,
- act = tf.identity,
- shape = [3, 3, 512, 512],
- strides = [1, 1, 1, 1],
- padding='SAME',
- name ='encoder/h6/conv')
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='encoder/h6/batch_norm')
- network.outputs = tf.nn.relu(network.outputs, name='encoder/h6/relu')
-
- # Decoder network
- network = decoder(network, skip_layers, batch_size, is_training)
-
- if is_training:
- return network, conv_layers
-
- return network
-
-
-# Final prediction of the model, including blending with input
-def get_final(network, x_in):
- sb, sy, sx, sf = x_in.get_shape().as_list()
- y_predict = network.outputs
-
- # Highlight mask
- thr = 0.05
- alpha = tf.reduce_max(x_in, reduction_indices=[3])
- alpha = tf.minimum(1.0, tf.maximum(0.0, alpha-1.0+thr)/thr)
- alpha = tf.reshape(alpha, [-1, sy, sx, 1])
- alpha = tf.tile(alpha, [1,1,1,3])
-
- # Linearied input and prediction
- x_lin = tf.pow(x_in, 2.0)
- y_predict = tf.exp(y_predict)-1.0/255.0
-
- # Alpha blending
- y_final = (1-alpha)*x_lin + alpha*y_predict
-
- return y_final
-
-
-# Convolutional layers of the VGG16 model used as encoder network
-def encoder(input_layer):
-
- VGG_MEAN = [103.939, 116.779, 123.68]
-
- # Convert RGB to BGR
- red, green, blue = tf.split(input_layer.outputs, 3, 3)
- bgr = tf.concat([ blue - VGG_MEAN[0], green - VGG_MEAN[1], red - VGG_MEAN[2] ], axis=3)
-
- network = tl.layers.InputLayer(bgr, name='encoder/input_layer_bgr')
-
- # Convolutional layers size 1
- network = conv_layer(network, [ 3, 64], 'encoder/h1/conv_1')
- beforepool1 = conv_layer(network, [64, 64], 'encoder/h1/conv_2')
- network = pool_layer(beforepool1, 'encoder/h1/pool')
-
- # Convolutional layers size 2
- network = conv_layer(network, [64, 128], 'encoder/h2/conv_1')
- beforepool2 = conv_layer(network, [128, 128], 'encoder/h2/conv_2')
- network = pool_layer(beforepool2, 'encoder/h2/pool')
-
- # Convolutional layers size 3
- network = conv_layer(network, [128, 256], 'encoder/h3/conv_1')
- network = conv_layer(network, [256, 256], 'encoder/h3/conv_2')
- beforepool3 = conv_layer(network, [256, 256], 'encoder/h3/conv_3')
- network = pool_layer(beforepool3, 'encoder/h3/pool')
-
- # Convolutional layers size 4
- network = conv_layer(network, [256, 512], 'encoder/h4/conv_1')
- network = conv_layer(network, [512, 512], 'encoder/h4/conv_2')
- beforepool4 = conv_layer(network, [512, 512], 'encoder/h4/conv_3')
- network = pool_layer(beforepool4, 'encoder/h4/pool')
-
- # Convolutional layers size 5
- network = conv_layer(network, [512, 512], 'encoder/h5/conv_1')
- network = conv_layer(network, [512, 512], 'encoder/h5/conv_2')
- beforepool5 = conv_layer(network, [512, 512], 'encoder/h5/conv_3')
- network = pool_layer(beforepool5, 'encoder/h5/pool')
-
- return network, (input_layer, beforepool1, beforepool2, beforepool3, beforepool4, beforepool5)
-
-
-# Decoder network
-def decoder(input_layer, skip_layers, batch_size=1, is_training=False):
- sb, sx, sy, sf = input_layer.outputs.get_shape().as_list()
- alpha = 0.0
-
- # Upsampling 1
- network = deconv_layer(input_layer, (batch_size,sx,sy,sf,sf), 'decoder/h1/decon2d', alpha, is_training)
-
- # Upsampling 2
- network = skip_connection_layer(network, skip_layers[5], 'decoder/h2/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,2*sx,2*sy,sf,sf), 'decoder/h2/decon2d', alpha, is_training)
-
- # Upsampling 3
- network = skip_connection_layer(network, skip_layers[4], 'decoder/h3/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,4*sx,4*sy,sf,sf/2), 'decoder/h3/decon2d', alpha, is_training)
-
- # Upsampling 4
- network = skip_connection_layer(network, skip_layers[3], 'decoder/h4/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,8*sx,8*sy,sf/2,sf/4), 'decoder/h4/decon2d', alpha, is_training)
-
- # Upsampling 5
- network = skip_connection_layer(network, skip_layers[2], 'decoder/h5/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,16*sx,16*sy,sf/4,sf/8), 'decoder/h5/decon2d', alpha, is_training)
-
- # Skip-connection at full size
- network = skip_connection_layer(network, skip_layers[1], 'decoder/h6/fuse_skip_connection', is_training)
-
- # Final convolution
- network = tl.layers.Conv2dLayer(network,
- act = tf.identity,
- shape = [1, 1, int(sf/8), 3],
- strides=[1, 1, 1, 1],
- padding='SAME',
- W_init = tf.contrib.layers.xavier_initializer(uniform=False),
- b_init = tf.constant_initializer(value=0.0),
- name ='decoder/h7/conv2d')
-
- # Final skip-connection
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='decoder/h7/batch_norm')
- network.outputs = tf.maximum(alpha*network.outputs, network.outputs, name='decoder/h7/leaky_relu')
- network = skip_connection_layer(network, skip_layers[0], 'decoder/h7/fuse_skip_connection')
-
- return network
-
-
-# Load weights for VGG16 encoder convolutional layers
-# Weights are from a .npy file generated with the caffe-tensorflow tool
-def load_vgg_weights(network, weight_file, session):
- params = []
-
- if weight_file.lower().endswith('.npy'):
- npy = np.load(weight_file, encoding='latin1')
- for key, val in sorted(npy.item().items()):
- if(key[:4] == "conv"):
- print(" Loading %s" % (key))
- print(" weights with size %s " % str(val['weights'].shape))
- print(" and biases with size %s " % str(val['biases'].shape))
- params.append(val['weights'])
- params.append(val['biases'])
- else:
- print('No weights in suitable .npy format found for path ', weight_file)
-
- print('Assigning loaded weights..')
- tl.files.assign_params(session, params, network)
-
- return network
-
-
-# === Layers ==================================================================
-
-# Convolutional layer
-def conv_layer(input_layer, sz, str):
- network = tl.layers.Conv2dLayer(input_layer,
- act = tf.nn.relu,
- shape = [3, 3, sz[0], sz[1]],
- strides = [1, 1, 1, 1],
- padding = 'SAME',
- name = str)
-
- return network
-
-
-# Max-pooling layer
-def pool_layer(input_layer, str):
- network = tl.layers.PoolLayer(input_layer,
- ksize=[1, 2, 2, 1],
- strides=[1, 2, 2, 1],
- padding='SAME',
- pool = tf.nn.max_pool,
- name = str)
-
- return network
-
-
-# Concatenating fusion of skip-connections
-def skip_connection_layer(input_layer, skip_layer, str, is_training=False):
- _, sx, sy, sf = input_layer.outputs.get_shape().as_list()
- _, sx_, sy_, sf_ = skip_layer.outputs.get_shape().as_list()
-
- assert (sx_,sy_,sf_) == (sx,sy,sf)
-
- # skip-connection domain transformation, from LDR encoder to log HDR decoder
- skip_layer.outputs = tf.log(tf.pow(tf.scalar_mul(1.0/255, skip_layer.outputs), 2.0)+1.0/255.0)
-
- # specify weights for fusion of concatenation, so that it performs an element-wise addition
- weights = np.zeros((1, 1, sf+sf_, sf))
- for i in range(sf):
- weights[0, 0, i, i] = 1
- weights[:, :, i+sf_, i] = 1
- add_init = tf.constant_initializer(value=weights, dtype=tf.float32)
-
- # concatenate layers
- network = tl.layers.ConcatLayer([input_layer,skip_layer], concat_dim=3, name ='%s/skip_connection'%str)
-
- # fuse concatenated layers using the specified weights for initialization
- network = tl.layers.Conv2dLayer(network,
- act = tf.identity,
- shape = [1, 1, sf+sf_, sf],
- strides = [1, 1, 1, 1],
- padding = 'SAME',
- W_init = add_init,
- b_init = tf.constant_initializer(value=0.0),
- name = str)
-
- return network
-
-
-# Deconvolution layer
-def deconv_layer(input_layer, sz, str, alpha, is_training=False):
- scale = 2
-
- filter_size = (2 * scale - scale % 2)
- num_in_channels = int(sz[3])
- num_out_channels = int(sz[4])
-
- # create bilinear weights in numpy array
- bilinear_kernel = np.zeros([filter_size, filter_size], dtype=np.float32)
- scale_factor = (filter_size + 1) // 2
- if filter_size % 2 == 1:
- center = scale_factor - 1
- else:
- center = scale_factor - 0.5
- for x in range(filter_size):
- for y in range(filter_size):
- bilinear_kernel[x,y] = (1 - abs(x - center) / scale_factor) * \
- (1 - abs(y - center) / scale_factor)
- weights = np.zeros((filter_size, filter_size, num_out_channels, num_in_channels))
- for i in range(num_out_channels):
- weights[:, :, i, i] = bilinear_kernel
-
- init_matrix = tf.constant_initializer(value=weights, dtype=tf.float32)
-
- network = tl.layers.DeConv2dLayer(input_layer,
- shape = [filter_size, filter_size, num_out_channels, num_in_channels],
- output_shape = [sz[0], sz[1]*scale, sz[2]*scale, num_out_channels],
- strides=[1, scale, scale, 1],
- W_init=init_matrix,
- padding='SAME',
- act=tf.identity,
- name=str)
-
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='%s/batch_norm_dc'%str)
- network.outputs = tf.maximum(alpha*network.outputs, network.outputs, name='%s/leaky_relu_dc'%str)
-
- return network
diff --git a/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h b/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h
deleted file mode 100644
index a1c0cac61839a6f66a42c341f50d5e36faad9a93..0000000000000000000000000000000000000000
--- a/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich
-#ifndef JPEG_DECODER_H
-#define JPEG_DECODER_H
-
-#include
-#include
-#include
-
-namespace jpgd
-{
- typedef unsigned char uint8;
- typedef signed short int16;
- typedef unsigned short uint16;
- typedef unsigned int uint;
- typedef signed int int32;
-
- // Loads a JPEG image from a memory buffer or a file.
- // req_comps can be 1 (grayscale), 3 (RGB), or 4 (RGBA).
- // On return, width/height will be set to the image's dimensions, and actual_comps will be set to the either 1 (grayscale) or 3 (RGB).
- // Notes: For more control over where and how the source data is read, see the decompress_jpeg_image_from_stream() function below, or call the jpeg_decoder class directly.
- // Requesting a 8 or 32bpp image is currently a little faster than 24bpp because the jpeg_decoder class itself currently always unpacks to either 8 or 32bpp.
-// BEGIN EPIC MOD
-//unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps);
- unsigned char *decompress_jpeg_image_from_memory(const unsigned char *pSrc_data, int src_data_size, int *width, int *height, int *actual_comps, int req_comps, int format);
-// END EPIC MOD
- unsigned char *decompress_jpeg_image_from_file(const char *pSrc_filename, int *width, int *height, int *actual_comps, int req_comps);
-
- // Success/failure error codes.
- enum jpgd_status
- {
- JPGD_SUCCESS = 0, JPGD_FAILED = -1, JPGD_DONE = 1,
- JPGD_BAD_DHT_COUNTS = -256, JPGD_BAD_DHT_INDEX, JPGD_BAD_DHT_MARKER, JPGD_BAD_DQT_MARKER, JPGD_BAD_DQT_TABLE,
- JPGD_BAD_PRECISION, JPGD_BAD_HEIGHT, JPGD_BAD_WIDTH, JPGD_TOO_MANY_COMPONENTS,
- JPGD_BAD_SOF_LENGTH, JPGD_BAD_VARIABLE_MARKER, JPGD_BAD_DRI_LENGTH, JPGD_BAD_SOS_LENGTH,
- JPGD_BAD_SOS_COMP_ID, JPGD_W_EXTRA_BYTES_BEFORE_MARKER, JPGD_NO_ARITHMITIC_SUPPORT, JPGD_UNEXPECTED_MARKER,
- JPGD_NOT_JPEG, JPGD_UNSUPPORTED_MARKER, JPGD_BAD_DQT_LENGTH, JPGD_TOO_MANY_BLOCKS,
- JPGD_UNDEFINED_QUANT_TABLE, JPGD_UNDEFINED_HUFF_TABLE, JPGD_NOT_SINGLE_SCAN, JPGD_UNSUPPORTED_COLORSPACE,
- JPGD_UNSUPPORTED_SAMP_FACTORS, JPGD_DECODE_ERROR, JPGD_BAD_RESTART_MARKER, JPGD_ASSERTION_ERROR,
- JPGD_BAD_SOS_SPECTRAL, JPGD_BAD_SOS_SUCCESSIVE, JPGD_STREAM_READ, JPGD_NOTENOUGHMEM
- };
-
- // Input stream interface.
- // Derive from this class to read input data from sources other than files or memory. Set m_eof_flag to true when no more data is available.
- // The decoder is rather greedy: it will keep on calling this method until its internal input buffer is full, or until the EOF flag is set.
- // It the input stream contains data after the JPEG stream's EOI (end of image) marker it will probably be pulled into the internal buffer.
- // Call the get_total_bytes_read() method to determine the actual size of the JPEG stream after successful decoding.
- class jpeg_decoder_stream
- {
- public:
- jpeg_decoder_stream() { }
- virtual ~jpeg_decoder_stream() { }
-
- // The read() method is called when the internal input buffer is empty.
- // Parameters:
- // pBuf - input buffer
- // max_bytes_to_read - maximum bytes that can be written to pBuf
- // pEOF_flag - set this to true if at end of stream (no more bytes remaining)
- // Returns -1 on error, otherwise return the number of bytes actually written to the buffer (which may be 0).
- // Notes: This method will be called in a loop until you set *pEOF_flag to true or the internal buffer is full.
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag) = 0;
- };
-
- // stdio FILE stream class.
- class jpeg_decoder_file_stream : public jpeg_decoder_stream
- {
- jpeg_decoder_file_stream(const jpeg_decoder_file_stream &);
- jpeg_decoder_file_stream &operator =(const jpeg_decoder_file_stream &);
-
- FILE *m_pFile;
- bool m_eof_flag, m_error_flag;
-
- public:
- jpeg_decoder_file_stream();
- virtual ~jpeg_decoder_file_stream();
-
- bool open(const char *Pfilename);
- void close();
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Memory stream class.
- class jpeg_decoder_mem_stream : public jpeg_decoder_stream
- {
- const uint8 *m_pSrc_data;
- uint m_ofs, m_size;
-
- public:
- jpeg_decoder_mem_stream() : m_pSrc_data(NULL), m_ofs(0), m_size(0) { }
- jpeg_decoder_mem_stream(const uint8 *pSrc_data, uint size) : m_pSrc_data(pSrc_data), m_ofs(0), m_size(size) { }
-
- virtual ~jpeg_decoder_mem_stream() { }
-
- bool open(const uint8 *pSrc_data, uint size);
- void close() { m_pSrc_data = NULL; m_ofs = 0; m_size = 0; }
-
- virtual int read(uint8 *pBuf, int max_bytes_to_read, bool *pEOF_flag);
- };
-
- // Loads JPEG file from a jpeg_decoder_stream.
- unsigned char *decompress_jpeg_image_from_stream(jpeg_decoder_stream *pStream, int *width, int *height, int *actual_comps, int req_comps);
-
- enum
- {
- JPGD_IN_BUF_SIZE = 8192, JPGD_MAX_BLOCKS_PER_MCU = 10, JPGD_MAX_HUFF_TABLES = 8, JPGD_MAX_QUANT_TABLES = 4,
- JPGD_MAX_COMPONENTS = 4, JPGD_MAX_COMPS_IN_SCAN = 4, JPGD_MAX_BLOCKS_PER_ROW = 8192, JPGD_MAX_HEIGHT = 16384, JPGD_MAX_WIDTH = 16384
- };
-
- typedef int16 jpgd_quant_t;
- typedef int16 jpgd_block_t;
-
- class jpeg_decoder
- {
- public:
- // Call get_error_code() after constructing to determine if the stream is valid or not. You may call the get_width(), get_height(), etc.
- // methods after the constructor is called. You may then either destruct the object, or begin decoding the image by calling begin_decoding(), then decode() on each scanline.
- jpeg_decoder(jpeg_decoder_stream *pStream);
-
- ~jpeg_decoder();
-
- // Call this method after constructing the object to begin decompression.
- // If JPGD_SUCCESS is returned you may then call decode() on each scanline.
- int begin_decoding();
-
- // Returns the next scan line.
- // For grayscale images, pScan_line will point to a buffer containing 8-bit pixels (get_bytes_per_pixel() will return 1).
- // Otherwise, it will always point to a buffer containing 32-bit RGBA pixels (A will always be 255, and get_bytes_per_pixel() will return 4).
- // Returns JPGD_SUCCESS if a scan line has been returned.
- // Returns JPGD_DONE if all scan lines have been returned.
- // Returns JPGD_FAILED if an error occurred. Call get_error_code() for a more info.
- int decode(const void** pScan_line, uint* pScan_line_len);
-
- inline jpgd_status get_error_code() const { return m_error_code; }
-
- inline int get_width() const { return m_image_x_size; }
- inline int get_height() const { return m_image_y_size; }
-
- inline int get_num_components() const { return m_comps_in_frame; }
-
- inline int get_bytes_per_pixel() const { return m_dest_bytes_per_pixel; }
- inline int get_bytes_per_scan_line() const { return m_image_x_size * get_bytes_per_pixel(); }
-
- // Returns the total number of bytes actually consumed by the decoder (which should equal the actual size of the JPEG file).
- inline int get_total_bytes_read() const { return m_total_bytes_read; }
-
- private:
- jpeg_decoder(const jpeg_decoder &);
- jpeg_decoder &operator =(const jpeg_decoder &);
-
- typedef void (*pDecode_block_func)(jpeg_decoder *, int, int, int);
-
- struct huff_tables
- {
- bool ac_table;
- uint look_up[256];
- uint look_up2[256];
- uint8 code_size[256];
- uint tree[512];
- };
-
- struct coeff_buf
- {
- uint8 *pData;
- int block_num_x, block_num_y;
- int block_len_x, block_len_y;
- int block_size;
- };
-
- struct mem_block
- {
- mem_block *m_pNext;
- size_t m_used_count;
- size_t m_size;
- char m_data[1];
- };
-
- jmp_buf m_jmp_state;
- mem_block *m_pMem_blocks;
- int m_image_x_size;
- int m_image_y_size;
- jpeg_decoder_stream *m_pStream;
- int m_progressive_flag;
- uint8 m_huff_ac[JPGD_MAX_HUFF_TABLES];
- uint8* m_huff_num[JPGD_MAX_HUFF_TABLES]; // pointer to number of Huffman codes per bit size
- uint8* m_huff_val[JPGD_MAX_HUFF_TABLES]; // pointer to Huffman codes per bit size
- jpgd_quant_t* m_quant[JPGD_MAX_QUANT_TABLES]; // pointer to quantization tables
- int m_scan_type; // Gray, Yh1v1, Yh1v2, Yh2v1, Yh2v2 (CMYK111, CMYK4114 no longer supported)
- int m_comps_in_frame; // # of components in frame
- int m_comp_h_samp[JPGD_MAX_COMPONENTS]; // component's horizontal sampling factor
- int m_comp_v_samp[JPGD_MAX_COMPONENTS]; // component's vertical sampling factor
- int m_comp_quant[JPGD_MAX_COMPONENTS]; // component's quantization table selector
- int m_comp_ident[JPGD_MAX_COMPONENTS]; // component's ID
- int m_comp_h_blocks[JPGD_MAX_COMPONENTS];
- int m_comp_v_blocks[JPGD_MAX_COMPONENTS];
- int m_comps_in_scan; // # of components in scan
- int m_comp_list[JPGD_MAX_COMPS_IN_SCAN]; // components in this scan
- int m_comp_dc_tab[JPGD_MAX_COMPONENTS]; // component's DC Huffman coding table selector
- int m_comp_ac_tab[JPGD_MAX_COMPONENTS]; // component's AC Huffman coding table selector
- int m_spectral_start; // spectral selection start
- int m_spectral_end; // spectral selection end
- int m_successive_low; // successive approximation low
- int m_successive_high; // successive approximation high
- int m_max_mcu_x_size; // MCU's max. X size in pixels
- int m_max_mcu_y_size; // MCU's max. Y size in pixels
- int m_blocks_per_mcu;
- int m_max_blocks_per_row;
- int m_mcus_per_row, m_mcus_per_col;
- int m_mcu_org[JPGD_MAX_BLOCKS_PER_MCU];
- int m_total_lines_left; // total # lines left in image
- int m_mcu_lines_left; // total # lines left in this MCU
- int m_real_dest_bytes_per_scan_line;
- int m_dest_bytes_per_scan_line; // rounded up
- int m_dest_bytes_per_pixel; // 4 (RGB) or 1 (Y)
- huff_tables* m_pHuff_tabs[JPGD_MAX_HUFF_TABLES];
- coeff_buf* m_dc_coeffs[JPGD_MAX_COMPONENTS];
- coeff_buf* m_ac_coeffs[JPGD_MAX_COMPONENTS];
- int m_eob_run;
- int m_block_y_mcu[JPGD_MAX_COMPONENTS];
- uint8* m_pIn_buf_ofs;
- int m_in_buf_left;
- int m_tem_flag;
- bool m_eof_flag;
- uint8 m_in_buf_pad_start[128];
- uint8 m_in_buf[JPGD_IN_BUF_SIZE + 128];
- uint8 m_in_buf_pad_end[128];
- int m_bits_left;
- uint m_bit_buf;
- int m_restart_interval;
- int m_restarts_left;
- int m_next_restart_num;
- int m_max_mcus_per_row;
- int m_max_blocks_per_mcu;
- int m_expanded_blocks_per_mcu;
- int m_expanded_blocks_per_row;
- int m_expanded_blocks_per_component;
- bool m_freq_domain_chroma_upsample;
- int m_max_mcus_per_col;
- uint m_last_dc_val[JPGD_MAX_COMPONENTS];
- jpgd_block_t* m_pMCU_coefficients;
- int m_mcu_block_max_zag[JPGD_MAX_BLOCKS_PER_MCU];
- uint8* m_pSample_buf;
- int m_crr[256];
- int m_cbb[256];
- int m_crg[256];
- int m_cbg[256];
- uint8* m_pScan_line_0;
- uint8* m_pScan_line_1;
- jpgd_status m_error_code;
- bool m_ready_flag;
- int m_total_bytes_read;
-
- void free_all_blocks();
- // BEGIN EPIC MOD
- UE_NORETURN void stop_decoding(jpgd_status status);
- // END EPIC MOD
- void *alloc(size_t n, bool zero = false);
- void word_clear(void *p, uint16 c, uint n);
- void prep_in_buffer();
- void read_dht_marker();
- void read_dqt_marker();
- void read_sof_marker();
- void skip_variable_marker();
- void read_dri_marker();
- void read_sos_marker();
- int next_marker();
- int process_markers();
- void locate_soi_marker();
- void locate_sof_marker();
- int locate_sos_marker();
- void init(jpeg_decoder_stream * pStream);
- void create_look_ups();
- void fix_in_buffer();
- void transform_mcu(int mcu_row);
- void transform_mcu_expand(int mcu_row);
- coeff_buf* coeff_buf_open(int block_num_x, int block_num_y, int block_len_x, int block_len_y);
- inline jpgd_block_t *coeff_buf_getp(coeff_buf *cb, int block_x, int block_y);
- void load_next_row();
- void decode_next_row();
- void make_huff_table(int index, huff_tables *pH);
- void check_quant_tables();
- void check_huff_tables();
- void calc_mcu_block_order();
- int init_scan();
- void init_frame();
- void process_restart();
- void decode_scan(pDecode_block_func decode_block_func);
- void init_progressive();
- void init_sequential();
- void decode_start();
- void decode_init(jpeg_decoder_stream * pStream);
- void H2V2Convert();
- void H2V1Convert();
- void H1V2Convert();
- void H1V1Convert();
- void gray_convert();
- void expanded_convert();
- void find_eoi();
- inline uint get_char();
- inline uint get_char(bool *pPadding_flag);
- inline void stuff_char(uint8 q);
- inline uint8 get_octet();
- inline uint get_bits(int num_bits);
- inline uint get_bits_no_markers(int numbits);
- inline int huff_decode(huff_tables *pH);
- inline int huff_decode(huff_tables *pH, int& extrabits);
- static inline uint8 clamp(int i);
- static void decode_block_dc_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_dc_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_first(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- static void decode_block_ac_refine(jpeg_decoder *pD, int component_id, int block_x, int block_y);
- };
-
-} // namespace jpgd
-
-#endif // JPEG_DECODER_H
diff --git a/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/loaders.py b/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/loaders.py
deleted file mode 100644
index 9c7808a0588bd1a8084157b072bae42aa7efaf84..0000000000000000000000000000000000000000
--- a/spaces/SuYuanS/AudioCraft_Plus/audiocraft/models/loaders.py
+++ /dev/null
@@ -1,141 +0,0 @@
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# All rights reserved.
-#
-# This source code is licensed under the license found in the
-# LICENSE file in the root directory of this source tree.
-
-"""
-Utility functions to load from the checkpoints.
-Each checkpoint is a torch.saved dict with the following keys:
-- 'xp.cfg': the hydra config as dumped during training. This should be used
- to rebuild the object using the audiocraft.models.builders functions,
-- 'model_best_state': a readily loadable best state for the model, including
- the conditioner. The model obtained from `xp.cfg` should be compatible
- with this state dict. In the case of a LM, the encodec model would not be
- bundled along but instead provided separately.
-
-Those functions also support loading from a remote location with the Torch Hub API.
-They also support overriding some parameters, in particular the device and dtype
-of the returned model.
-"""
-
-from pathlib import Path
-from huggingface_hub import hf_hub_download
-import typing as tp
-import os
-
-from omegaconf import OmegaConf, DictConfig
-import torch
-
-from . import builders
-from .encodec import CompressionModel
-
-
-def get_audiocraft_cache_dir() -> tp.Optional[str]:
- return os.environ.get('AUDIOCRAFT_CACHE_DIR', None)
-
-
-def _get_state_dict(
- file_or_url_or_id: tp.Union[Path, str],
- filename: tp.Optional[str] = None,
- device='cpu',
- cache_dir: tp.Optional[str] = None,
-):
- if cache_dir is None:
- cache_dir = get_audiocraft_cache_dir()
- # Return the state dict either from a file or url
- file_or_url_or_id = str(file_or_url_or_id)
- assert isinstance(file_or_url_or_id, str)
-
- if os.path.isfile(file_or_url_or_id):
- return torch.load(file_or_url_or_id, map_location=device)
-
- if os.path.isdir(file_or_url_or_id):
- file = f"{file_or_url_or_id}/{filename}"
- return torch.load(file, map_location=device)
-
- elif file_or_url_or_id.startswith('https://'):
- return torch.hub.load_state_dict_from_url(file_or_url_or_id, map_location=device, check_hash=True)
-
- else:
- assert filename is not None, "filename needs to be defined if using HF checkpoints"
-
- file = hf_hub_download(repo_id=file_or_url_or_id, filename=filename, cache_dir=cache_dir)
- return torch.load(file, map_location=device)
-
-
-def load_compression_model_ckpt(file_or_url_or_id: tp.Union[Path, str], cache_dir: tp.Optional[str] = None):
- return _get_state_dict(file_or_url_or_id, filename="compression_state_dict.bin", cache_dir=cache_dir)
-
-
-def load_compression_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
- pkg = load_compression_model_ckpt(file_or_url_or_id, cache_dir=cache_dir)
- if 'pretrained' in pkg:
- return CompressionModel.get_pretrained(pkg['pretrained'], device=device)
- cfg = OmegaConf.create(pkg['xp.cfg'])
- cfg.device = str(device)
- model = builders.get_compression_model(cfg)
- model.load_state_dict(pkg['best_state'])
- model.eval()
- return model
-
-
-def load_lm_model_ckpt(file_or_url_or_id: tp.Union[Path, str], cache_dir: tp.Optional[str] = None):
- return _get_state_dict(file_or_url_or_id, filename="state_dict.bin", cache_dir=cache_dir)
-
-
-def _delete_param(cfg: DictConfig, full_name: str):
- parts = full_name.split('.')
- for part in parts[:-1]:
- if part in cfg:
- cfg = cfg[part]
- else:
- return
- OmegaConf.set_struct(cfg, False)
- if parts[-1] in cfg:
- del cfg[parts[-1]]
- OmegaConf.set_struct(cfg, True)
-
-
-def load_lm_model(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
- pkg = load_lm_model_ckpt(file_or_url_or_id, cache_dir=cache_dir)
- cfg = OmegaConf.create(pkg['xp.cfg'])
- cfg.device = str(device)
- if cfg.device == 'cpu':
- cfg.dtype = 'float32'
- else:
- cfg.dtype = 'float16'
- _delete_param(cfg, 'conditioners.self_wav.chroma_stem.cache_path')
- _delete_param(cfg, 'conditioners.args.merge_text_conditions_p')
- _delete_param(cfg, 'conditioners.args.drop_desc_p')
- model = builders.get_lm_model(cfg)
- model.load_state_dict(pkg['best_state'])
- model.eval()
- model.cfg = cfg
- return model
-
-
-def load_mbd_ckpt(file_or_url_or_id: tp.Union[Path, str], cache_dir: tp.Optional[str] = None):
- return _get_state_dict(file_or_url_or_id, filename="all_in_one.pt", cache_dir=cache_dir)
-
-
-def load_diffusion_models(file_or_url_or_id: tp.Union[Path, str], device='cpu', cache_dir: tp.Optional[str] = None):
- pkg = load_mbd_ckpt(file_or_url_or_id, cache_dir=cache_dir)
- models = []
- processors = []
- cfgs = []
- sample_rate = pkg['sample_rate']
- for i in range(pkg['n_bands']):
- cfg = pkg[i]['cfg']
- model = builders.get_diffusion_model(cfg)
- model_dict = pkg[i]['model_state']
- model.load_state_dict(model_dict)
- model.to(device)
- processor = builders.get_processor(cfg=cfg.processor, sample_rate=sample_rate)
- processor_dict = pkg[i]['processor_state']
- processor.load_state_dict(processor_dict)
- processor.to(device)
- models.append(model)
- processors.append(processor)
- cfgs.append(cfg)
- return models, processors, cfgs
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/terminal/shortcuts/filters.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/terminal/shortcuts/filters.py
deleted file mode 100644
index 7c9d6a9c41d71d69b31e9ee9310a623f01855fe7..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/terminal/shortcuts/filters.py
+++ /dev/null
@@ -1,322 +0,0 @@
-"""
-Filters restricting scope of IPython Terminal shortcuts.
-"""
-
-# Copyright (c) IPython Development Team.
-# Distributed under the terms of the Modified BSD License.
-
-import ast
-import re
-import signal
-import sys
-from typing import Callable, Dict, Union
-
-from prompt_toolkit.application.current import get_app
-from prompt_toolkit.enums import DEFAULT_BUFFER, SEARCH_BUFFER
-from prompt_toolkit.key_binding import KeyPressEvent
-from prompt_toolkit.filters import Condition, Filter, emacs_insert_mode, has_completions
-from prompt_toolkit.filters import has_focus as has_focus_impl
-from prompt_toolkit.filters import (
- Always,
- Never,
- has_selection,
- has_suggestion,
- vi_insert_mode,
- vi_mode,
-)
-from prompt_toolkit.layout.layout import FocusableElement
-
-from IPython.core.getipython import get_ipython
-from IPython.core.guarded_eval import _find_dunder, BINARY_OP_DUNDERS, UNARY_OP_DUNDERS
-from IPython.terminal.shortcuts import auto_suggest
-from IPython.utils.decorators import undoc
-
-
-@undoc
-@Condition
-def cursor_in_leading_ws():
- before = get_app().current_buffer.document.current_line_before_cursor
- return (not before) or before.isspace()
-
-
-def has_focus(value: FocusableElement):
- """Wrapper around has_focus adding a nice `__name__` to tester function"""
- tester = has_focus_impl(value).func
- tester.__name__ = f"is_focused({value})"
- return Condition(tester)
-
-
-@undoc
-@Condition
-def has_line_below() -> bool:
- document = get_app().current_buffer.document
- return document.cursor_position_row < len(document.lines) - 1
-
-
-@undoc
-@Condition
-def is_cursor_at_the_end_of_line() -> bool:
- document = get_app().current_buffer.document
- return document.is_cursor_at_the_end_of_line
-
-
-@undoc
-@Condition
-def has_line_above() -> bool:
- document = get_app().current_buffer.document
- return document.cursor_position_row != 0
-
-
-@Condition
-def ebivim():
- shell = get_ipython()
- return shell.emacs_bindings_in_vi_insert_mode
-
-
-@Condition
-def supports_suspend():
- return hasattr(signal, "SIGTSTP")
-
-
-@Condition
-def auto_match():
- shell = get_ipython()
- return shell.auto_match
-
-
-def all_quotes_paired(quote, buf):
- paired = True
- i = 0
- while i < len(buf):
- c = buf[i]
- if c == quote:
- paired = not paired
- elif c == "\\":
- i += 1
- i += 1
- return paired
-
-
-_preceding_text_cache: Dict[Union[str, Callable], Condition] = {}
-_following_text_cache: Dict[Union[str, Callable], Condition] = {}
-
-
-def preceding_text(pattern: Union[str, Callable]):
- if pattern in _preceding_text_cache:
- return _preceding_text_cache[pattern]
-
- if callable(pattern):
-
- def _preceding_text():
- app = get_app()
- before_cursor = app.current_buffer.document.current_line_before_cursor
- # mypy can't infer if(callable): https://github.com/python/mypy/issues/3603
- return bool(pattern(before_cursor)) # type: ignore[operator]
-
- else:
- m = re.compile(pattern)
-
- def _preceding_text():
- app = get_app()
- before_cursor = app.current_buffer.document.current_line_before_cursor
- return bool(m.match(before_cursor))
-
- _preceding_text.__name__ = f"preceding_text({pattern!r})"
-
- condition = Condition(_preceding_text)
- _preceding_text_cache[pattern] = condition
- return condition
-
-
-def following_text(pattern):
- try:
- return _following_text_cache[pattern]
- except KeyError:
- pass
- m = re.compile(pattern)
-
- def _following_text():
- app = get_app()
- return bool(m.match(app.current_buffer.document.current_line_after_cursor))
-
- _following_text.__name__ = f"following_text({pattern!r})"
-
- condition = Condition(_following_text)
- _following_text_cache[pattern] = condition
- return condition
-
-
-@Condition
-def not_inside_unclosed_string():
- app = get_app()
- s = app.current_buffer.document.text_before_cursor
- # remove escaped quotes
- s = s.replace('\\"', "").replace("\\'", "")
- # remove triple-quoted string literals
- s = re.sub(r"(?:\"\"\"[\s\S]*\"\"\"|'''[\s\S]*''')", "", s)
- # remove single-quoted string literals
- s = re.sub(r"""(?:"[^"]*["\n]|'[^']*['\n])""", "", s)
- return not ('"' in s or "'" in s)
-
-
-@Condition
-def navigable_suggestions():
- shell = get_ipython()
- return isinstance(shell.auto_suggest, auto_suggest.NavigableAutoSuggestFromHistory)
-
-
-@Condition
-def readline_like_completions():
- shell = get_ipython()
- return shell.display_completions == "readlinelike"
-
-
-@Condition
-def is_windows_os():
- return sys.platform == "win32"
-
-
-class PassThrough(Filter):
- """A filter allowing to implement pass-through behaviour of keybindings.
-
- Prompt toolkit key processor dispatches only one event per binding match,
- which means that adding a new shortcut will suppress the old shortcut
- if the keybindings are the same (unless one is filtered out).
-
- To stop a shortcut binding from suppressing other shortcuts:
- - add the `pass_through` filter to list of filter, and
- - call `pass_through.reply(event)` in the shortcut handler.
- """
-
- def __init__(self):
- self._is_replying = False
-
- def reply(self, event: KeyPressEvent):
- self._is_replying = True
- try:
- event.key_processor.reset()
- event.key_processor.feed_multiple(event.key_sequence)
- event.key_processor.process_keys()
- finally:
- self._is_replying = False
-
- def __call__(self):
- return not self._is_replying
-
-
-pass_through = PassThrough()
-
-# these one is callable and re-used multiple times hence needs to be
-# only defined once beforhand so that transforming back to human-readable
-# names works well in the documentation.
-default_buffer_focused = has_focus(DEFAULT_BUFFER)
-
-KEYBINDING_FILTERS = {
- "always": Always(),
- # never is used for exposing commands which have no default keybindings
- "never": Never(),
- "has_line_below": has_line_below,
- "has_line_above": has_line_above,
- "is_cursor_at_the_end_of_line": is_cursor_at_the_end_of_line,
- "has_selection": has_selection,
- "has_suggestion": has_suggestion,
- "vi_mode": vi_mode,
- "vi_insert_mode": vi_insert_mode,
- "emacs_insert_mode": emacs_insert_mode,
- # https://github.com/ipython/ipython/pull/12603 argued for inclusion of
- # emacs key bindings with a configurable `emacs_bindings_in_vi_insert_mode`
- # toggle; when the toggle is on user can access keybindigns like `ctrl + e`
- # in vi insert mode. Because some of the emacs bindings involve `escape`
- # followed by another key, e.g. `escape` followed by `f`, prompt-toolkit
- # needs to wait to see if there will be another character typed in before
- # executing pure `escape` keybinding; in vi insert mode `escape` switches to
- # command mode which is common and performance critical action for vi users.
- # To avoid the delay users employ a workaround:
- # https://github.com/ipython/ipython/issues/13443#issuecomment-1032753703
- # which involves switching `emacs_bindings_in_vi_insert_mode` off.
- #
- # For the workaround to work:
- # 1) end users need to toggle `emacs_bindings_in_vi_insert_mode` off
- # 2) all keybindings which would involve `escape` need to respect that
- # toggle by including either:
- # - `vi_insert_mode & ebivim` for actions which have emacs keybindings
- # predefined upstream in prompt-toolkit, or
- # - `emacs_like_insert_mode` for actions which do not have existing
- # emacs keybindings predefined upstream (or need overriding of the
- # upstream bindings to modify behaviour), defined below.
- "emacs_like_insert_mode": (vi_insert_mode & ebivim) | emacs_insert_mode,
- "has_completions": has_completions,
- "insert_mode": vi_insert_mode | emacs_insert_mode,
- "default_buffer_focused": default_buffer_focused,
- "search_buffer_focused": has_focus(SEARCH_BUFFER),
- # `ebivim` stands for emacs bindings in vi insert mode
- "ebivim": ebivim,
- "supports_suspend": supports_suspend,
- "is_windows_os": is_windows_os,
- "auto_match": auto_match,
- "focused_insert": (vi_insert_mode | emacs_insert_mode) & default_buffer_focused,
- "not_inside_unclosed_string": not_inside_unclosed_string,
- "readline_like_completions": readline_like_completions,
- "preceded_by_paired_double_quotes": preceding_text(
- lambda line: all_quotes_paired('"', line)
- ),
- "preceded_by_paired_single_quotes": preceding_text(
- lambda line: all_quotes_paired("'", line)
- ),
- "preceded_by_raw_str_prefix": preceding_text(r".*(r|R)[\"'](-*)$"),
- "preceded_by_two_double_quotes": preceding_text(r'^.*""$'),
- "preceded_by_two_single_quotes": preceding_text(r"^.*''$"),
- "followed_by_closing_paren_or_end": following_text(r"[,)}\]]|$"),
- "preceded_by_opening_round_paren": preceding_text(r".*\($"),
- "preceded_by_opening_bracket": preceding_text(r".*\[$"),
- "preceded_by_opening_brace": preceding_text(r".*\{$"),
- "preceded_by_double_quote": preceding_text('.*"$'),
- "preceded_by_single_quote": preceding_text(r".*'$"),
- "followed_by_closing_round_paren": following_text(r"^\)"),
- "followed_by_closing_bracket": following_text(r"^\]"),
- "followed_by_closing_brace": following_text(r"^\}"),
- "followed_by_double_quote": following_text('^"'),
- "followed_by_single_quote": following_text("^'"),
- "navigable_suggestions": navigable_suggestions,
- "cursor_in_leading_ws": cursor_in_leading_ws,
- "pass_through": pass_through,
-}
-
-
-def eval_node(node: Union[ast.AST, None]):
- if node is None:
- return None
- if isinstance(node, ast.Expression):
- return eval_node(node.body)
- if isinstance(node, ast.BinOp):
- left = eval_node(node.left)
- right = eval_node(node.right)
- dunders = _find_dunder(node.op, BINARY_OP_DUNDERS)
- if dunders:
- return getattr(left, dunders[0])(right)
- raise ValueError(f"Unknown binary operation: {node.op}")
- if isinstance(node, ast.UnaryOp):
- value = eval_node(node.operand)
- dunders = _find_dunder(node.op, UNARY_OP_DUNDERS)
- if dunders:
- return getattr(value, dunders[0])()
- raise ValueError(f"Unknown unary operation: {node.op}")
- if isinstance(node, ast.Name):
- if node.id in KEYBINDING_FILTERS:
- return KEYBINDING_FILTERS[node.id]
- else:
- sep = "\n - "
- known_filters = sep.join(sorted(KEYBINDING_FILTERS))
- raise NameError(
- f"{node.id} is not a known shortcut filter."
- f" Known filters are: {sep}{known_filters}."
- )
- raise ValueError("Unhandled node", ast.dump(node))
-
-
-def filter_from_string(code: str):
- expression = ast.parse(code, mode="eval")
- return eval_node(expression)
-
-
-__all__ = ["KEYBINDING_FILTERS", "filter_from_string"]
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/testing/skipdoctest.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/testing/skipdoctest.py
deleted file mode 100644
index f440ea14b274de05919ce9e77bada084d8725218..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/IPython/testing/skipdoctest.py
+++ /dev/null
@@ -1,19 +0,0 @@
-"""Decorators marks that a doctest should be skipped.
-
-The IPython.testing.decorators module triggers various extra imports, including
-numpy and sympy if they're present. Since this decorator is used in core parts
-of IPython, it's in a separate module so that running IPython doesn't trigger
-those imports."""
-
-# Copyright (C) IPython Development Team
-# Distributed under the terms of the Modified BSD License.
-
-
-def skip_doctest(f):
- """Decorator - mark a function or method for skipping its doctest.
-
- This decorator allows you to mark a function whose docstring you wish to
- omit from testing, while preserving the docstring for introspection, help,
- etc."""
- f.__skip_doctest__ = True
- return f
diff --git a/spaces/TandCAcceptMe/face-swap-docker/clip/model.py b/spaces/TandCAcceptMe/face-swap-docker/clip/model.py
deleted file mode 100644
index 232b7792eb97440642547bd462cf128df9243933..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/clip/model.py
+++ /dev/null
@@ -1,436 +0,0 @@
-from collections import OrderedDict
-from typing import Tuple, Union
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-
-class Bottleneck(nn.Module):
- expansion = 4
-
- def __init__(self, inplanes, planes, stride=1):
- super().__init__()
-
- # all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
- self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
- self.bn1 = nn.BatchNorm2d(planes)
- self.relu1 = nn.ReLU(inplace=True)
-
- self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
- self.bn2 = nn.BatchNorm2d(planes)
- self.relu2 = nn.ReLU(inplace=True)
-
- self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
-
- self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
- self.bn3 = nn.BatchNorm2d(planes * self.expansion)
- self.relu3 = nn.ReLU(inplace=True)
-
- self.downsample = None
- self.stride = stride
-
- if stride > 1 or inplanes != planes * Bottleneck.expansion:
- # downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
- self.downsample = nn.Sequential(OrderedDict([
- ("-1", nn.AvgPool2d(stride)),
- ("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
- ("1", nn.BatchNorm2d(planes * self.expansion))
- ]))
-
- def forward(self, x: torch.Tensor):
- identity = x
-
- out = self.relu1(self.bn1(self.conv1(x)))
- out = self.relu2(self.bn2(self.conv2(out)))
- out = self.avgpool(out)
- out = self.bn3(self.conv3(out))
-
- if self.downsample is not None:
- identity = self.downsample(x)
-
- out += identity
- out = self.relu3(out)
- return out
-
-
-class AttentionPool2d(nn.Module):
- def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
- super().__init__()
- self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
- self.k_proj = nn.Linear(embed_dim, embed_dim)
- self.q_proj = nn.Linear(embed_dim, embed_dim)
- self.v_proj = nn.Linear(embed_dim, embed_dim)
- self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
- self.num_heads = num_heads
-
- def forward(self, x):
- x = x.flatten(start_dim=2).permute(2, 0, 1) # NCHW -> (HW)NC
- x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC
- x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC
- x, _ = F.multi_head_attention_forward(
- query=x[:1], key=x, value=x,
- embed_dim_to_check=x.shape[-1],
- num_heads=self.num_heads,
- q_proj_weight=self.q_proj.weight,
- k_proj_weight=self.k_proj.weight,
- v_proj_weight=self.v_proj.weight,
- in_proj_weight=None,
- in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
- bias_k=None,
- bias_v=None,
- add_zero_attn=False,
- dropout_p=0,
- out_proj_weight=self.c_proj.weight,
- out_proj_bias=self.c_proj.bias,
- use_separate_proj_weight=True,
- training=self.training,
- need_weights=False
- )
- return x.squeeze(0)
-
-
-class ModifiedResNet(nn.Module):
- """
- A ResNet class that is similar to torchvision's but contains the following changes:
- - There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
- - Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
- - The final pooling layer is a QKV attention instead of an average pool
- """
-
- def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
- super().__init__()
- self.output_dim = output_dim
- self.input_resolution = input_resolution
-
- # the 3-layer stem
- self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
- self.bn1 = nn.BatchNorm2d(width // 2)
- self.relu1 = nn.ReLU(inplace=True)
- self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
- self.bn2 = nn.BatchNorm2d(width // 2)
- self.relu2 = nn.ReLU(inplace=True)
- self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
- self.bn3 = nn.BatchNorm2d(width)
- self.relu3 = nn.ReLU(inplace=True)
- self.avgpool = nn.AvgPool2d(2)
-
- # residual layers
- self._inplanes = width # this is a *mutable* variable used during construction
- self.layer1 = self._make_layer(width, layers[0])
- self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
- self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
- self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
-
- embed_dim = width * 32 # the ResNet feature dimension
- self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim)
-
- def _make_layer(self, planes, blocks, stride=1):
- layers = [Bottleneck(self._inplanes, planes, stride)]
-
- self._inplanes = planes * Bottleneck.expansion
- for _ in range(1, blocks):
- layers.append(Bottleneck(self._inplanes, planes))
-
- return nn.Sequential(*layers)
-
- def forward(self, x):
- def stem(x):
- x = self.relu1(self.bn1(self.conv1(x)))
- x = self.relu2(self.bn2(self.conv2(x)))
- x = self.relu3(self.bn3(self.conv3(x)))
- x = self.avgpool(x)
- return x
-
- x = x.type(self.conv1.weight.dtype)
- x = stem(x)
- x = self.layer1(x)
- x = self.layer2(x)
- x = self.layer3(x)
- x = self.layer4(x)
- x = self.attnpool(x)
-
- return x
-
-
-class LayerNorm(nn.LayerNorm):
- """Subclass torch's LayerNorm to handle fp16."""
-
- def forward(self, x: torch.Tensor):
- orig_type = x.dtype
- ret = super().forward(x.type(torch.float32))
- return ret.type(orig_type)
-
-
-class QuickGELU(nn.Module):
- def forward(self, x: torch.Tensor):
- return x * torch.sigmoid(1.702 * x)
-
-
-class ResidualAttentionBlock(nn.Module):
- def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
- super().__init__()
-
- self.attn = nn.MultiheadAttention(d_model, n_head)
- self.ln_1 = LayerNorm(d_model)
- self.mlp = nn.Sequential(OrderedDict([
- ("c_fc", nn.Linear(d_model, d_model * 4)),
- ("gelu", QuickGELU()),
- ("c_proj", nn.Linear(d_model * 4, d_model))
- ]))
- self.ln_2 = LayerNorm(d_model)
- self.attn_mask = attn_mask
-
- def attention(self, x: torch.Tensor):
- self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
- return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
-
- def forward(self, x: torch.Tensor):
- x = x + self.attention(self.ln_1(x))
- x = x + self.mlp(self.ln_2(x))
- return x
-
-
-class Transformer(nn.Module):
- def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
- super().__init__()
- self.width = width
- self.layers = layers
- self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
-
- def forward(self, x: torch.Tensor):
- return self.resblocks(x)
-
-
-class VisionTransformer(nn.Module):
- def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
- super().__init__()
- self.input_resolution = input_resolution
- self.output_dim = output_dim
- self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)
-
- scale = width ** -0.5
- self.class_embedding = nn.Parameter(scale * torch.randn(width))
- self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
- self.ln_pre = LayerNorm(width)
-
- self.transformer = Transformer(width, layers, heads)
-
- self.ln_post = LayerNorm(width)
- self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
-
- def forward(self, x: torch.Tensor):
- x = self.conv1(x) # shape = [*, width, grid, grid]
- x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]
- x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]
- x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width]
- x = x + self.positional_embedding.to(x.dtype)
- x = self.ln_pre(x)
-
- x = x.permute(1, 0, 2) # NLD -> LND
- x = self.transformer(x)
- x = x.permute(1, 0, 2) # LND -> NLD
-
- x = self.ln_post(x[:, 0, :])
-
- if self.proj is not None:
- x = x @ self.proj
-
- return x
-
-
-class CLIP(nn.Module):
- def __init__(self,
- embed_dim: int,
- # vision
- image_resolution: int,
- vision_layers: Union[Tuple[int, int, int, int], int],
- vision_width: int,
- vision_patch_size: int,
- # text
- context_length: int,
- vocab_size: int,
- transformer_width: int,
- transformer_heads: int,
- transformer_layers: int
- ):
- super().__init__()
-
- self.context_length = context_length
-
- if isinstance(vision_layers, (tuple, list)):
- vision_heads = vision_width * 32 // 64
- self.visual = ModifiedResNet(
- layers=vision_layers,
- output_dim=embed_dim,
- heads=vision_heads,
- input_resolution=image_resolution,
- width=vision_width
- )
- else:
- vision_heads = vision_width // 64
- self.visual = VisionTransformer(
- input_resolution=image_resolution,
- patch_size=vision_patch_size,
- width=vision_width,
- layers=vision_layers,
- heads=vision_heads,
- output_dim=embed_dim
- )
-
- self.transformer = Transformer(
- width=transformer_width,
- layers=transformer_layers,
- heads=transformer_heads,
- attn_mask=self.build_attention_mask()
- )
-
- self.vocab_size = vocab_size
- self.token_embedding = nn.Embedding(vocab_size, transformer_width)
- self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
- self.ln_final = LayerNorm(transformer_width)
-
- self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
- self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
-
- self.initialize_parameters()
-
- def initialize_parameters(self):
- nn.init.normal_(self.token_embedding.weight, std=0.02)
- nn.init.normal_(self.positional_embedding, std=0.01)
-
- if isinstance(self.visual, ModifiedResNet):
- if self.visual.attnpool is not None:
- std = self.visual.attnpool.c_proj.in_features ** -0.5
- nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)
- nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)
- nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)
- nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)
-
- for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:
- for name, param in resnet_block.named_parameters():
- if name.endswith("bn3.weight"):
- nn.init.zeros_(param)
-
- proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
- attn_std = self.transformer.width ** -0.5
- fc_std = (2 * self.transformer.width) ** -0.5
- for block in self.transformer.resblocks:
- nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
- nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
- nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
- nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
-
- if self.text_projection is not None:
- nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
-
- def build_attention_mask(self):
- # lazily create causal attention mask, with full attention between the vision tokens
- # pytorch uses additive attention mask; fill with -inf
- mask = torch.empty(self.context_length, self.context_length)
- mask.fill_(float("-inf"))
- mask.triu_(1) # zero out the lower diagonal
- return mask
-
- @property
- def dtype(self):
- return self.visual.conv1.weight.dtype
-
- def encode_image(self, image):
- return self.visual(image.type(self.dtype))
-
- def encode_text(self, text):
- x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model]
-
- x = x + self.positional_embedding.type(self.dtype)
- x = x.permute(1, 0, 2) # NLD -> LND
- x = self.transformer(x)
- x = x.permute(1, 0, 2) # LND -> NLD
- x = self.ln_final(x).type(self.dtype)
-
- # x.shape = [batch_size, n_ctx, transformer.width]
- # take features from the eot embedding (eot_token is the highest number in each sequence)
- x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
-
- return x
-
- def forward(self, image, text):
- image_features = self.encode_image(image)
- text_features = self.encode_text(text)
-
- # normalized features
- image_features = image_features / image_features.norm(dim=1, keepdim=True)
- text_features = text_features / text_features.norm(dim=1, keepdim=True)
-
- # cosine similarity as logits
- logit_scale = self.logit_scale.exp()
- logits_per_image = logit_scale * image_features @ text_features.t()
- logits_per_text = logits_per_image.t()
-
- # shape = [global_batch_size, global_batch_size]
- return logits_per_image, logits_per_text
-
-
-def convert_weights(model: nn.Module):
- """Convert applicable model parameters to fp16"""
-
- def _convert_weights_to_fp16(l):
- if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
- l.weight.data = l.weight.data.half()
- if l.bias is not None:
- l.bias.data = l.bias.data.half()
-
- if isinstance(l, nn.MultiheadAttention):
- for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
- tensor = getattr(l, attr)
- if tensor is not None:
- tensor.data = tensor.data.half()
-
- for name in ["text_projection", "proj"]:
- if hasattr(l, name):
- attr = getattr(l, name)
- if attr is not None:
- attr.data = attr.data.half()
-
- model.apply(_convert_weights_to_fp16)
-
-
-def build_model(state_dict: dict):
- vit = "visual.proj" in state_dict
-
- if vit:
- vision_width = state_dict["visual.conv1.weight"].shape[0]
- vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
- vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
- grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
- image_resolution = vision_patch_size * grid_size
- else:
- counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
- vision_layers = tuple(counts)
- vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
- output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
- vision_patch_size = None
- assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
- image_resolution = output_width * 32
-
- embed_dim = state_dict["text_projection"].shape[1]
- context_length = state_dict["positional_embedding"].shape[0]
- vocab_size = state_dict["token_embedding.weight"].shape[0]
- transformer_width = state_dict["ln_final.weight"].shape[0]
- transformer_heads = transformer_width // 64
- transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith("transformer.resblocks")))
-
- model = CLIP(
- embed_dim,
- image_resolution, vision_layers, vision_width, vision_patch_size,
- context_length, vocab_size, transformer_width, transformer_heads, transformer_layers
- )
-
- for key in ["input_resolution", "context_length", "vocab_size"]:
- if key in state_dict:
- del state_dict[key]
-
- convert_weights(model)
- model.load_state_dict(state_dict)
- return model.eval()
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/console.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/console.py
deleted file mode 100644
index e559cbb43c18392606d1212cfbde76339719a6a0..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/rich/console.py
+++ /dev/null
@@ -1,2633 +0,0 @@
-import inspect
-import os
-import platform
-import sys
-import threading
-import zlib
-from abc import ABC, abstractmethod
-from dataclasses import dataclass, field
-from datetime import datetime
-from functools import wraps
-from getpass import getpass
-from html import escape
-from inspect import isclass
-from itertools import islice
-from math import ceil
-from time import monotonic
-from types import FrameType, ModuleType, TracebackType
-from typing import (
- IO,
- TYPE_CHECKING,
- Any,
- Callable,
- Dict,
- Iterable,
- List,
- Mapping,
- NamedTuple,
- Optional,
- TextIO,
- Tuple,
- Type,
- Union,
- cast,
-)
-
-from pip._vendor.rich._null_file import NULL_FILE
-
-if sys.version_info >= (3, 8):
- from typing import Literal, Protocol, runtime_checkable
-else:
- from pip._vendor.typing_extensions import (
- Literal,
- Protocol,
- runtime_checkable,
- ) # pragma: no cover
-
-from . import errors, themes
-from ._emoji_replace import _emoji_replace
-from ._export_format import CONSOLE_HTML_FORMAT, CONSOLE_SVG_FORMAT
-from ._fileno import get_fileno
-from ._log_render import FormatTimeCallable, LogRender
-from .align import Align, AlignMethod
-from .color import ColorSystem, blend_rgb
-from .control import Control
-from .emoji import EmojiVariant
-from .highlighter import NullHighlighter, ReprHighlighter
-from .markup import render as render_markup
-from .measure import Measurement, measure_renderables
-from .pager import Pager, SystemPager
-from .pretty import Pretty, is_expandable
-from .protocol import rich_cast
-from .region import Region
-from .scope import render_scope
-from .screen import Screen
-from .segment import Segment
-from .style import Style, StyleType
-from .styled import Styled
-from .terminal_theme import DEFAULT_TERMINAL_THEME, SVG_EXPORT_THEME, TerminalTheme
-from .text import Text, TextType
-from .theme import Theme, ThemeStack
-
-if TYPE_CHECKING:
- from ._windows import WindowsConsoleFeatures
- from .live import Live
- from .status import Status
-
-JUPYTER_DEFAULT_COLUMNS = 115
-JUPYTER_DEFAULT_LINES = 100
-WINDOWS = platform.system() == "Windows"
-
-HighlighterType = Callable[[Union[str, "Text"]], "Text"]
-JustifyMethod = Literal["default", "left", "center", "right", "full"]
-OverflowMethod = Literal["fold", "crop", "ellipsis", "ignore"]
-
-
-class NoChange:
- pass
-
-
-NO_CHANGE = NoChange()
-
-try:
- _STDIN_FILENO = sys.__stdin__.fileno()
-except Exception:
- _STDIN_FILENO = 0
-try:
- _STDOUT_FILENO = sys.__stdout__.fileno()
-except Exception:
- _STDOUT_FILENO = 1
-try:
- _STDERR_FILENO = sys.__stderr__.fileno()
-except Exception:
- _STDERR_FILENO = 2
-
-_STD_STREAMS = (_STDIN_FILENO, _STDOUT_FILENO, _STDERR_FILENO)
-_STD_STREAMS_OUTPUT = (_STDOUT_FILENO, _STDERR_FILENO)
-
-
-_TERM_COLORS = {
- "kitty": ColorSystem.EIGHT_BIT,
- "256color": ColorSystem.EIGHT_BIT,
- "16color": ColorSystem.STANDARD,
-}
-
-
-class ConsoleDimensions(NamedTuple):
- """Size of the terminal."""
-
- width: int
- """The width of the console in 'cells'."""
- height: int
- """The height of the console in lines."""
-
-
-@dataclass
-class ConsoleOptions:
- """Options for __rich_console__ method."""
-
- size: ConsoleDimensions
- """Size of console."""
- legacy_windows: bool
- """legacy_windows: flag for legacy windows."""
- min_width: int
- """Minimum width of renderable."""
- max_width: int
- """Maximum width of renderable."""
- is_terminal: bool
- """True if the target is a terminal, otherwise False."""
- encoding: str
- """Encoding of terminal."""
- max_height: int
- """Height of container (starts as terminal)"""
- justify: Optional[JustifyMethod] = None
- """Justify value override for renderable."""
- overflow: Optional[OverflowMethod] = None
- """Overflow value override for renderable."""
- no_wrap: Optional[bool] = False
- """Disable wrapping for text."""
- highlight: Optional[bool] = None
- """Highlight override for render_str."""
- markup: Optional[bool] = None
- """Enable markup when rendering strings."""
- height: Optional[int] = None
-
- @property
- def ascii_only(self) -> bool:
- """Check if renderables should use ascii only."""
- return not self.encoding.startswith("utf")
-
- def copy(self) -> "ConsoleOptions":
- """Return a copy of the options.
-
- Returns:
- ConsoleOptions: a copy of self.
- """
- options: ConsoleOptions = ConsoleOptions.__new__(ConsoleOptions)
- options.__dict__ = self.__dict__.copy()
- return options
-
- def update(
- self,
- *,
- width: Union[int, NoChange] = NO_CHANGE,
- min_width: Union[int, NoChange] = NO_CHANGE,
- max_width: Union[int, NoChange] = NO_CHANGE,
- justify: Union[Optional[JustifyMethod], NoChange] = NO_CHANGE,
- overflow: Union[Optional[OverflowMethod], NoChange] = NO_CHANGE,
- no_wrap: Union[Optional[bool], NoChange] = NO_CHANGE,
- highlight: Union[Optional[bool], NoChange] = NO_CHANGE,
- markup: Union[Optional[bool], NoChange] = NO_CHANGE,
- height: Union[Optional[int], NoChange] = NO_CHANGE,
- ) -> "ConsoleOptions":
- """Update values, return a copy."""
- options = self.copy()
- if not isinstance(width, NoChange):
- options.min_width = options.max_width = max(0, width)
- if not isinstance(min_width, NoChange):
- options.min_width = min_width
- if not isinstance(max_width, NoChange):
- options.max_width = max_width
- if not isinstance(justify, NoChange):
- options.justify = justify
- if not isinstance(overflow, NoChange):
- options.overflow = overflow
- if not isinstance(no_wrap, NoChange):
- options.no_wrap = no_wrap
- if not isinstance(highlight, NoChange):
- options.highlight = highlight
- if not isinstance(markup, NoChange):
- options.markup = markup
- if not isinstance(height, NoChange):
- if height is not None:
- options.max_height = height
- options.height = None if height is None else max(0, height)
- return options
-
- def update_width(self, width: int) -> "ConsoleOptions":
- """Update just the width, return a copy.
-
- Args:
- width (int): New width (sets both min_width and max_width)
-
- Returns:
- ~ConsoleOptions: New console options instance.
- """
- options = self.copy()
- options.min_width = options.max_width = max(0, width)
- return options
-
- def update_height(self, height: int) -> "ConsoleOptions":
- """Update the height, and return a copy.
-
- Args:
- height (int): New height
-
- Returns:
- ~ConsoleOptions: New Console options instance.
- """
- options = self.copy()
- options.max_height = options.height = height
- return options
-
- def reset_height(self) -> "ConsoleOptions":
- """Return a copy of the options with height set to ``None``.
-
- Returns:
- ~ConsoleOptions: New console options instance.
- """
- options = self.copy()
- options.height = None
- return options
-
- def update_dimensions(self, width: int, height: int) -> "ConsoleOptions":
- """Update the width and height, and return a copy.
-
- Args:
- width (int): New width (sets both min_width and max_width).
- height (int): New height.
-
- Returns:
- ~ConsoleOptions: New console options instance.
- """
- options = self.copy()
- options.min_width = options.max_width = max(0, width)
- options.height = options.max_height = height
- return options
-
-
-@runtime_checkable
-class RichCast(Protocol):
- """An object that may be 'cast' to a console renderable."""
-
- def __rich__(
- self,
- ) -> Union["ConsoleRenderable", "RichCast", str]: # pragma: no cover
- ...
-
-
-@runtime_checkable
-class ConsoleRenderable(Protocol):
- """An object that supports the console protocol."""
-
- def __rich_console__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> "RenderResult": # pragma: no cover
- ...
-
-
-# A type that may be rendered by Console.
-RenderableType = Union[ConsoleRenderable, RichCast, str]
-
-# The result of calling a __rich_console__ method.
-RenderResult = Iterable[Union[RenderableType, Segment]]
-
-_null_highlighter = NullHighlighter()
-
-
-class CaptureError(Exception):
- """An error in the Capture context manager."""
-
-
-class NewLine:
- """A renderable to generate new line(s)"""
-
- def __init__(self, count: int = 1) -> None:
- self.count = count
-
- def __rich_console__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> Iterable[Segment]:
- yield Segment("\n" * self.count)
-
-
-class ScreenUpdate:
- """Render a list of lines at a given offset."""
-
- def __init__(self, lines: List[List[Segment]], x: int, y: int) -> None:
- self._lines = lines
- self.x = x
- self.y = y
-
- def __rich_console__(
- self, console: "Console", options: ConsoleOptions
- ) -> RenderResult:
- x = self.x
- move_to = Control.move_to
- for offset, line in enumerate(self._lines, self.y):
- yield move_to(x, offset)
- yield from line
-
-
-class Capture:
- """Context manager to capture the result of printing to the console.
- See :meth:`~rich.console.Console.capture` for how to use.
-
- Args:
- console (Console): A console instance to capture output.
- """
-
- def __init__(self, console: "Console") -> None:
- self._console = console
- self._result: Optional[str] = None
-
- def __enter__(self) -> "Capture":
- self._console.begin_capture()
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- self._result = self._console.end_capture()
-
- def get(self) -> str:
- """Get the result of the capture."""
- if self._result is None:
- raise CaptureError(
- "Capture result is not available until context manager exits."
- )
- return self._result
-
-
-class ThemeContext:
- """A context manager to use a temporary theme. See :meth:`~rich.console.Console.use_theme` for usage."""
-
- def __init__(self, console: "Console", theme: Theme, inherit: bool = True) -> None:
- self.console = console
- self.theme = theme
- self.inherit = inherit
-
- def __enter__(self) -> "ThemeContext":
- self.console.push_theme(self.theme)
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- self.console.pop_theme()
-
-
-class PagerContext:
- """A context manager that 'pages' content. See :meth:`~rich.console.Console.pager` for usage."""
-
- def __init__(
- self,
- console: "Console",
- pager: Optional[Pager] = None,
- styles: bool = False,
- links: bool = False,
- ) -> None:
- self._console = console
- self.pager = SystemPager() if pager is None else pager
- self.styles = styles
- self.links = links
-
- def __enter__(self) -> "PagerContext":
- self._console._enter_buffer()
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- if exc_type is None:
- with self._console._lock:
- buffer: List[Segment] = self._console._buffer[:]
- del self._console._buffer[:]
- segments: Iterable[Segment] = buffer
- if not self.styles:
- segments = Segment.strip_styles(segments)
- elif not self.links:
- segments = Segment.strip_links(segments)
- content = self._console._render_buffer(segments)
- self.pager.show(content)
- self._console._exit_buffer()
-
-
-class ScreenContext:
- """A context manager that enables an alternative screen. See :meth:`~rich.console.Console.screen` for usage."""
-
- def __init__(
- self, console: "Console", hide_cursor: bool, style: StyleType = ""
- ) -> None:
- self.console = console
- self.hide_cursor = hide_cursor
- self.screen = Screen(style=style)
- self._changed = False
-
- def update(
- self, *renderables: RenderableType, style: Optional[StyleType] = None
- ) -> None:
- """Update the screen.
-
- Args:
- renderable (RenderableType, optional): Optional renderable to replace current renderable,
- or None for no change. Defaults to None.
- style: (Style, optional): Replacement style, or None for no change. Defaults to None.
- """
- if renderables:
- self.screen.renderable = (
- Group(*renderables) if len(renderables) > 1 else renderables[0]
- )
- if style is not None:
- self.screen.style = style
- self.console.print(self.screen, end="")
-
- def __enter__(self) -> "ScreenContext":
- self._changed = self.console.set_alt_screen(True)
- if self._changed and self.hide_cursor:
- self.console.show_cursor(False)
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- if self._changed:
- self.console.set_alt_screen(False)
- if self.hide_cursor:
- self.console.show_cursor(True)
-
-
-class Group:
- """Takes a group of renderables and returns a renderable object that renders the group.
-
- Args:
- renderables (Iterable[RenderableType]): An iterable of renderable objects.
- fit (bool, optional): Fit dimension of group to contents, or fill available space. Defaults to True.
- """
-
- def __init__(self, *renderables: "RenderableType", fit: bool = True) -> None:
- self._renderables = renderables
- self.fit = fit
- self._render: Optional[List[RenderableType]] = None
-
- @property
- def renderables(self) -> List["RenderableType"]:
- if self._render is None:
- self._render = list(self._renderables)
- return self._render
-
- def __rich_measure__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> "Measurement":
- if self.fit:
- return measure_renderables(console, options, self.renderables)
- else:
- return Measurement(options.max_width, options.max_width)
-
- def __rich_console__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> RenderResult:
- yield from self.renderables
-
-
-def group(fit: bool = True) -> Callable[..., Callable[..., Group]]:
- """A decorator that turns an iterable of renderables in to a group.
-
- Args:
- fit (bool, optional): Fit dimension of group to contents, or fill available space. Defaults to True.
- """
-
- def decorator(
- method: Callable[..., Iterable[RenderableType]]
- ) -> Callable[..., Group]:
- """Convert a method that returns an iterable of renderables in to a Group."""
-
- @wraps(method)
- def _replace(*args: Any, **kwargs: Any) -> Group:
- renderables = method(*args, **kwargs)
- return Group(*renderables, fit=fit)
-
- return _replace
-
- return decorator
-
-
-def _is_jupyter() -> bool: # pragma: no cover
- """Check if we're running in a Jupyter notebook."""
- try:
- get_ipython # type: ignore[name-defined]
- except NameError:
- return False
- ipython = get_ipython() # type: ignore[name-defined]
- shell = ipython.__class__.__name__
- if (
- "google.colab" in str(ipython.__class__)
- or os.getenv("DATABRICKS_RUNTIME_VERSION")
- or shell == "ZMQInteractiveShell"
- ):
- return True # Jupyter notebook or qtconsole
- elif shell == "TerminalInteractiveShell":
- return False # Terminal running IPython
- else:
- return False # Other type (?)
-
-
-COLOR_SYSTEMS = {
- "standard": ColorSystem.STANDARD,
- "256": ColorSystem.EIGHT_BIT,
- "truecolor": ColorSystem.TRUECOLOR,
- "windows": ColorSystem.WINDOWS,
-}
-
-_COLOR_SYSTEMS_NAMES = {system: name for name, system in COLOR_SYSTEMS.items()}
-
-
-@dataclass
-class ConsoleThreadLocals(threading.local):
- """Thread local values for Console context."""
-
- theme_stack: ThemeStack
- buffer: List[Segment] = field(default_factory=list)
- buffer_index: int = 0
-
-
-class RenderHook(ABC):
- """Provides hooks in to the render process."""
-
- @abstractmethod
- def process_renderables(
- self, renderables: List[ConsoleRenderable]
- ) -> List[ConsoleRenderable]:
- """Called with a list of objects to render.
-
- This method can return a new list of renderables, or modify and return the same list.
-
- Args:
- renderables (List[ConsoleRenderable]): A number of renderable objects.
-
- Returns:
- List[ConsoleRenderable]: A replacement list of renderables.
- """
-
-
-_windows_console_features: Optional["WindowsConsoleFeatures"] = None
-
-
-def get_windows_console_features() -> "WindowsConsoleFeatures": # pragma: no cover
- global _windows_console_features
- if _windows_console_features is not None:
- return _windows_console_features
- from ._windows import get_windows_console_features
-
- _windows_console_features = get_windows_console_features()
- return _windows_console_features
-
-
-def detect_legacy_windows() -> bool:
- """Detect legacy Windows."""
- return WINDOWS and not get_windows_console_features().vt
-
-
-class Console:
- """A high level console interface.
-
- Args:
- color_system (str, optional): The color system supported by your terminal,
- either ``"standard"``, ``"256"`` or ``"truecolor"``. Leave as ``"auto"`` to autodetect.
- force_terminal (Optional[bool], optional): Enable/disable terminal control codes, or None to auto-detect terminal. Defaults to None.
- force_jupyter (Optional[bool], optional): Enable/disable Jupyter rendering, or None to auto-detect Jupyter. Defaults to None.
- force_interactive (Optional[bool], optional): Enable/disable interactive mode, or None to auto detect. Defaults to None.
- soft_wrap (Optional[bool], optional): Set soft wrap default on print method. Defaults to False.
- theme (Theme, optional): An optional style theme object, or ``None`` for default theme.
- stderr (bool, optional): Use stderr rather than stdout if ``file`` is not specified. Defaults to False.
- file (IO, optional): A file object where the console should write to. Defaults to stdout.
- quiet (bool, Optional): Boolean to suppress all output. Defaults to False.
- width (int, optional): The width of the terminal. Leave as default to auto-detect width.
- height (int, optional): The height of the terminal. Leave as default to auto-detect height.
- style (StyleType, optional): Style to apply to all output, or None for no style. Defaults to None.
- no_color (Optional[bool], optional): Enabled no color mode, or None to auto detect. Defaults to None.
- tab_size (int, optional): Number of spaces used to replace a tab character. Defaults to 8.
- record (bool, optional): Boolean to enable recording of terminal output,
- required to call :meth:`export_html`, :meth:`export_svg`, and :meth:`export_text`. Defaults to False.
- markup (bool, optional): Boolean to enable :ref:`console_markup`. Defaults to True.
- emoji (bool, optional): Enable emoji code. Defaults to True.
- emoji_variant (str, optional): Optional emoji variant, either "text" or "emoji". Defaults to None.
- highlight (bool, optional): Enable automatic highlighting. Defaults to True.
- log_time (bool, optional): Boolean to enable logging of time by :meth:`log` methods. Defaults to True.
- log_path (bool, optional): Boolean to enable the logging of the caller by :meth:`log`. Defaults to True.
- log_time_format (Union[str, TimeFormatterCallable], optional): If ``log_time`` is enabled, either string for strftime or callable that formats the time. Defaults to "[%X] ".
- highlighter (HighlighterType, optional): Default highlighter.
- legacy_windows (bool, optional): Enable legacy Windows mode, or ``None`` to auto detect. Defaults to ``None``.
- safe_box (bool, optional): Restrict box options that don't render on legacy Windows.
- get_datetime (Callable[[], datetime], optional): Callable that gets the current time as a datetime.datetime object (used by Console.log),
- or None for datetime.now.
- get_time (Callable[[], time], optional): Callable that gets the current time in seconds, default uses time.monotonic.
- """
-
- _environ: Mapping[str, str] = os.environ
-
- def __init__(
- self,
- *,
- color_system: Optional[
- Literal["auto", "standard", "256", "truecolor", "windows"]
- ] = "auto",
- force_terminal: Optional[bool] = None,
- force_jupyter: Optional[bool] = None,
- force_interactive: Optional[bool] = None,
- soft_wrap: bool = False,
- theme: Optional[Theme] = None,
- stderr: bool = False,
- file: Optional[IO[str]] = None,
- quiet: bool = False,
- width: Optional[int] = None,
- height: Optional[int] = None,
- style: Optional[StyleType] = None,
- no_color: Optional[bool] = None,
- tab_size: int = 8,
- record: bool = False,
- markup: bool = True,
- emoji: bool = True,
- emoji_variant: Optional[EmojiVariant] = None,
- highlight: bool = True,
- log_time: bool = True,
- log_path: bool = True,
- log_time_format: Union[str, FormatTimeCallable] = "[%X]",
- highlighter: Optional["HighlighterType"] = ReprHighlighter(),
- legacy_windows: Optional[bool] = None,
- safe_box: bool = True,
- get_datetime: Optional[Callable[[], datetime]] = None,
- get_time: Optional[Callable[[], float]] = None,
- _environ: Optional[Mapping[str, str]] = None,
- ):
- # Copy of os.environ allows us to replace it for testing
- if _environ is not None:
- self._environ = _environ
-
- self.is_jupyter = _is_jupyter() if force_jupyter is None else force_jupyter
- if self.is_jupyter:
- if width is None:
- jupyter_columns = self._environ.get("JUPYTER_COLUMNS")
- if jupyter_columns is not None and jupyter_columns.isdigit():
- width = int(jupyter_columns)
- else:
- width = JUPYTER_DEFAULT_COLUMNS
- if height is None:
- jupyter_lines = self._environ.get("JUPYTER_LINES")
- if jupyter_lines is not None and jupyter_lines.isdigit():
- height = int(jupyter_lines)
- else:
- height = JUPYTER_DEFAULT_LINES
-
- self.tab_size = tab_size
- self.record = record
- self._markup = markup
- self._emoji = emoji
- self._emoji_variant: Optional[EmojiVariant] = emoji_variant
- self._highlight = highlight
- self.legacy_windows: bool = (
- (detect_legacy_windows() and not self.is_jupyter)
- if legacy_windows is None
- else legacy_windows
- )
-
- if width is None:
- columns = self._environ.get("COLUMNS")
- if columns is not None and columns.isdigit():
- width = int(columns) - self.legacy_windows
- if height is None:
- lines = self._environ.get("LINES")
- if lines is not None and lines.isdigit():
- height = int(lines)
-
- self.soft_wrap = soft_wrap
- self._width = width
- self._height = height
-
- self._color_system: Optional[ColorSystem]
-
- self._force_terminal = None
- if force_terminal is not None:
- self._force_terminal = force_terminal
-
- self._file = file
- self.quiet = quiet
- self.stderr = stderr
-
- if color_system is None:
- self._color_system = None
- elif color_system == "auto":
- self._color_system = self._detect_color_system()
- else:
- self._color_system = COLOR_SYSTEMS[color_system]
-
- self._lock = threading.RLock()
- self._log_render = LogRender(
- show_time=log_time,
- show_path=log_path,
- time_format=log_time_format,
- )
- self.highlighter: HighlighterType = highlighter or _null_highlighter
- self.safe_box = safe_box
- self.get_datetime = get_datetime or datetime.now
- self.get_time = get_time or monotonic
- self.style = style
- self.no_color = (
- no_color if no_color is not None else "NO_COLOR" in self._environ
- )
- self.is_interactive = (
- (self.is_terminal and not self.is_dumb_terminal)
- if force_interactive is None
- else force_interactive
- )
-
- self._record_buffer_lock = threading.RLock()
- self._thread_locals = ConsoleThreadLocals(
- theme_stack=ThemeStack(themes.DEFAULT if theme is None else theme)
- )
- self._record_buffer: List[Segment] = []
- self._render_hooks: List[RenderHook] = []
- self._live: Optional["Live"] = None
- self._is_alt_screen = False
-
- def __repr__(self) -> str:
- return f""
-
- @property
- def file(self) -> IO[str]:
- """Get the file object to write to."""
- file = self._file or (sys.stderr if self.stderr else sys.stdout)
- file = getattr(file, "rich_proxied_file", file)
- if file is None:
- file = NULL_FILE
- return file
-
- @file.setter
- def file(self, new_file: IO[str]) -> None:
- """Set a new file object."""
- self._file = new_file
-
- @property
- def _buffer(self) -> List[Segment]:
- """Get a thread local buffer."""
- return self._thread_locals.buffer
-
- @property
- def _buffer_index(self) -> int:
- """Get a thread local buffer."""
- return self._thread_locals.buffer_index
-
- @_buffer_index.setter
- def _buffer_index(self, value: int) -> None:
- self._thread_locals.buffer_index = value
-
- @property
- def _theme_stack(self) -> ThemeStack:
- """Get the thread local theme stack."""
- return self._thread_locals.theme_stack
-
- def _detect_color_system(self) -> Optional[ColorSystem]:
- """Detect color system from env vars."""
- if self.is_jupyter:
- return ColorSystem.TRUECOLOR
- if not self.is_terminal or self.is_dumb_terminal:
- return None
- if WINDOWS: # pragma: no cover
- if self.legacy_windows: # pragma: no cover
- return ColorSystem.WINDOWS
- windows_console_features = get_windows_console_features()
- return (
- ColorSystem.TRUECOLOR
- if windows_console_features.truecolor
- else ColorSystem.EIGHT_BIT
- )
- else:
- color_term = self._environ.get("COLORTERM", "").strip().lower()
- if color_term in ("truecolor", "24bit"):
- return ColorSystem.TRUECOLOR
- term = self._environ.get("TERM", "").strip().lower()
- _term_name, _hyphen, colors = term.rpartition("-")
- color_system = _TERM_COLORS.get(colors, ColorSystem.STANDARD)
- return color_system
-
- def _enter_buffer(self) -> None:
- """Enter in to a buffer context, and buffer all output."""
- self._buffer_index += 1
-
- def _exit_buffer(self) -> None:
- """Leave buffer context, and render content if required."""
- self._buffer_index -= 1
- self._check_buffer()
-
- def set_live(self, live: "Live") -> None:
- """Set Live instance. Used by Live context manager.
-
- Args:
- live (Live): Live instance using this Console.
-
- Raises:
- errors.LiveError: If this Console has a Live context currently active.
- """
- with self._lock:
- if self._live is not None:
- raise errors.LiveError("Only one live display may be active at once")
- self._live = live
-
- def clear_live(self) -> None:
- """Clear the Live instance."""
- with self._lock:
- self._live = None
-
- def push_render_hook(self, hook: RenderHook) -> None:
- """Add a new render hook to the stack.
-
- Args:
- hook (RenderHook): Render hook instance.
- """
- with self._lock:
- self._render_hooks.append(hook)
-
- def pop_render_hook(self) -> None:
- """Pop the last renderhook from the stack."""
- with self._lock:
- self._render_hooks.pop()
-
- def __enter__(self) -> "Console":
- """Own context manager to enter buffer context."""
- self._enter_buffer()
- return self
-
- def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
- """Exit buffer context."""
- self._exit_buffer()
-
- def begin_capture(self) -> None:
- """Begin capturing console output. Call :meth:`end_capture` to exit capture mode and return output."""
- self._enter_buffer()
-
- def end_capture(self) -> str:
- """End capture mode and return captured string.
-
- Returns:
- str: Console output.
- """
- render_result = self._render_buffer(self._buffer)
- del self._buffer[:]
- self._exit_buffer()
- return render_result
-
- def push_theme(self, theme: Theme, *, inherit: bool = True) -> None:
- """Push a new theme on to the top of the stack, replacing the styles from the previous theme.
- Generally speaking, you should call :meth:`~rich.console.Console.use_theme` to get a context manager, rather
- than calling this method directly.
-
- Args:
- theme (Theme): A theme instance.
- inherit (bool, optional): Inherit existing styles. Defaults to True.
- """
- self._theme_stack.push_theme(theme, inherit=inherit)
-
- def pop_theme(self) -> None:
- """Remove theme from top of stack, restoring previous theme."""
- self._theme_stack.pop_theme()
-
- def use_theme(self, theme: Theme, *, inherit: bool = True) -> ThemeContext:
- """Use a different theme for the duration of the context manager.
-
- Args:
- theme (Theme): Theme instance to user.
- inherit (bool, optional): Inherit existing console styles. Defaults to True.
-
- Returns:
- ThemeContext: [description]
- """
- return ThemeContext(self, theme, inherit)
-
- @property
- def color_system(self) -> Optional[str]:
- """Get color system string.
-
- Returns:
- Optional[str]: "standard", "256" or "truecolor".
- """
-
- if self._color_system is not None:
- return _COLOR_SYSTEMS_NAMES[self._color_system]
- else:
- return None
-
- @property
- def encoding(self) -> str:
- """Get the encoding of the console file, e.g. ``"utf-8"``.
-
- Returns:
- str: A standard encoding string.
- """
- return (getattr(self.file, "encoding", "utf-8") or "utf-8").lower()
-
- @property
- def is_terminal(self) -> bool:
- """Check if the console is writing to a terminal.
-
- Returns:
- bool: True if the console writing to a device capable of
- understanding terminal codes, otherwise False.
- """
- if self._force_terminal is not None:
- return self._force_terminal
-
- if hasattr(sys.stdin, "__module__") and sys.stdin.__module__.startswith(
- "idlelib"
- ):
- # Return False for Idle which claims to be a tty but can't handle ansi codes
- return False
-
- if self.is_jupyter:
- # return False for Jupyter, which may have FORCE_COLOR set
- return False
-
- # If FORCE_COLOR env var has any value at all, we assume a terminal.
- force_color = self._environ.get("FORCE_COLOR")
- if force_color is not None:
- self._force_terminal = True
- return True
-
- isatty: Optional[Callable[[], bool]] = getattr(self.file, "isatty", None)
- try:
- return False if isatty is None else isatty()
- except ValueError:
- # in some situation (at the end of a pytest run for example) isatty() can raise
- # ValueError: I/O operation on closed file
- # return False because we aren't in a terminal anymore
- return False
-
- @property
- def is_dumb_terminal(self) -> bool:
- """Detect dumb terminal.
-
- Returns:
- bool: True if writing to a dumb terminal, otherwise False.
-
- """
- _term = self._environ.get("TERM", "")
- is_dumb = _term.lower() in ("dumb", "unknown")
- return self.is_terminal and is_dumb
-
- @property
- def options(self) -> ConsoleOptions:
- """Get default console options."""
- return ConsoleOptions(
- max_height=self.size.height,
- size=self.size,
- legacy_windows=self.legacy_windows,
- min_width=1,
- max_width=self.width,
- encoding=self.encoding,
- is_terminal=self.is_terminal,
- )
-
- @property
- def size(self) -> ConsoleDimensions:
- """Get the size of the console.
-
- Returns:
- ConsoleDimensions: A named tuple containing the dimensions.
- """
-
- if self._width is not None and self._height is not None:
- return ConsoleDimensions(self._width - self.legacy_windows, self._height)
-
- if self.is_dumb_terminal:
- return ConsoleDimensions(80, 25)
-
- width: Optional[int] = None
- height: Optional[int] = None
-
- if WINDOWS: # pragma: no cover
- try:
- width, height = os.get_terminal_size()
- except (AttributeError, ValueError, OSError): # Probably not a terminal
- pass
- else:
- for file_descriptor in _STD_STREAMS:
- try:
- width, height = os.get_terminal_size(file_descriptor)
- except (AttributeError, ValueError, OSError):
- pass
- else:
- break
-
- columns = self._environ.get("COLUMNS")
- if columns is not None and columns.isdigit():
- width = int(columns)
- lines = self._environ.get("LINES")
- if lines is not None and lines.isdigit():
- height = int(lines)
-
- # get_terminal_size can report 0, 0 if run from pseudo-terminal
- width = width or 80
- height = height or 25
- return ConsoleDimensions(
- width - self.legacy_windows if self._width is None else self._width,
- height if self._height is None else self._height,
- )
-
- @size.setter
- def size(self, new_size: Tuple[int, int]) -> None:
- """Set a new size for the terminal.
-
- Args:
- new_size (Tuple[int, int]): New width and height.
- """
- width, height = new_size
- self._width = width
- self._height = height
-
- @property
- def width(self) -> int:
- """Get the width of the console.
-
- Returns:
- int: The width (in characters) of the console.
- """
- return self.size.width
-
- @width.setter
- def width(self, width: int) -> None:
- """Set width.
-
- Args:
- width (int): New width.
- """
- self._width = width
-
- @property
- def height(self) -> int:
- """Get the height of the console.
-
- Returns:
- int: The height (in lines) of the console.
- """
- return self.size.height
-
- @height.setter
- def height(self, height: int) -> None:
- """Set height.
-
- Args:
- height (int): new height.
- """
- self._height = height
-
- def bell(self) -> None:
- """Play a 'bell' sound (if supported by the terminal)."""
- self.control(Control.bell())
-
- def capture(self) -> Capture:
- """A context manager to *capture* the result of print() or log() in a string,
- rather than writing it to the console.
-
- Example:
- >>> from rich.console import Console
- >>> console = Console()
- >>> with console.capture() as capture:
- ... console.print("[bold magenta]Hello World[/]")
- >>> print(capture.get())
-
- Returns:
- Capture: Context manager with disables writing to the terminal.
- """
- capture = Capture(self)
- return capture
-
- def pager(
- self, pager: Optional[Pager] = None, styles: bool = False, links: bool = False
- ) -> PagerContext:
- """A context manager to display anything printed within a "pager". The pager application
- is defined by the system and will typically support at least pressing a key to scroll.
-
- Args:
- pager (Pager, optional): A pager object, or None to use :class:`~rich.pager.SystemPager`. Defaults to None.
- styles (bool, optional): Show styles in pager. Defaults to False.
- links (bool, optional): Show links in pager. Defaults to False.
-
- Example:
- >>> from rich.console import Console
- >>> from rich.__main__ import make_test_card
- >>> console = Console()
- >>> with console.pager():
- console.print(make_test_card())
-
- Returns:
- PagerContext: A context manager.
- """
- return PagerContext(self, pager=pager, styles=styles, links=links)
-
- def line(self, count: int = 1) -> None:
- """Write new line(s).
-
- Args:
- count (int, optional): Number of new lines. Defaults to 1.
- """
-
- assert count >= 0, "count must be >= 0"
- self.print(NewLine(count))
-
- def clear(self, home: bool = True) -> None:
- """Clear the screen.
-
- Args:
- home (bool, optional): Also move the cursor to 'home' position. Defaults to True.
- """
- if home:
- self.control(Control.clear(), Control.home())
- else:
- self.control(Control.clear())
-
- def status(
- self,
- status: RenderableType,
- *,
- spinner: str = "dots",
- spinner_style: StyleType = "status.spinner",
- speed: float = 1.0,
- refresh_per_second: float = 12.5,
- ) -> "Status":
- """Display a status and spinner.
-
- Args:
- status (RenderableType): A status renderable (str or Text typically).
- spinner (str, optional): Name of spinner animation (see python -m rich.spinner). Defaults to "dots".
- spinner_style (StyleType, optional): Style of spinner. Defaults to "status.spinner".
- speed (float, optional): Speed factor for spinner animation. Defaults to 1.0.
- refresh_per_second (float, optional): Number of refreshes per second. Defaults to 12.5.
-
- Returns:
- Status: A Status object that may be used as a context manager.
- """
- from .status import Status
-
- status_renderable = Status(
- status,
- console=self,
- spinner=spinner,
- spinner_style=spinner_style,
- speed=speed,
- refresh_per_second=refresh_per_second,
- )
- return status_renderable
-
- def show_cursor(self, show: bool = True) -> bool:
- """Show or hide the cursor.
-
- Args:
- show (bool, optional): Set visibility of the cursor.
- """
- if self.is_terminal:
- self.control(Control.show_cursor(show))
- return True
- return False
-
- def set_alt_screen(self, enable: bool = True) -> bool:
- """Enables alternative screen mode.
-
- Note, if you enable this mode, you should ensure that is disabled before
- the application exits. See :meth:`~rich.Console.screen` for a context manager
- that handles this for you.
-
- Args:
- enable (bool, optional): Enable (True) or disable (False) alternate screen. Defaults to True.
-
- Returns:
- bool: True if the control codes were written.
-
- """
- changed = False
- if self.is_terminal and not self.legacy_windows:
- self.control(Control.alt_screen(enable))
- changed = True
- self._is_alt_screen = enable
- return changed
-
- @property
- def is_alt_screen(self) -> bool:
- """Check if the alt screen was enabled.
-
- Returns:
- bool: True if the alt screen was enabled, otherwise False.
- """
- return self._is_alt_screen
-
- def set_window_title(self, title: str) -> bool:
- """Set the title of the console terminal window.
-
- Warning: There is no means within Rich of "resetting" the window title to its
- previous value, meaning the title you set will persist even after your application
- exits.
-
- ``fish`` shell resets the window title before and after each command by default,
- negating this issue. Windows Terminal and command prompt will also reset the title for you.
- Most other shells and terminals, however, do not do this.
-
- Some terminals may require configuration changes before you can set the title.
- Some terminals may not support setting the title at all.
-
- Other software (including the terminal itself, the shell, custom prompts, plugins, etc.)
- may also set the terminal window title. This could result in whatever value you write
- using this method being overwritten.
-
- Args:
- title (str): The new title of the terminal window.
-
- Returns:
- bool: True if the control code to change the terminal title was
- written, otherwise False. Note that a return value of True
- does not guarantee that the window title has actually changed,
- since the feature may be unsupported/disabled in some terminals.
- """
- if self.is_terminal:
- self.control(Control.title(title))
- return True
- return False
-
- def screen(
- self, hide_cursor: bool = True, style: Optional[StyleType] = None
- ) -> "ScreenContext":
- """Context manager to enable and disable 'alternative screen' mode.
-
- Args:
- hide_cursor (bool, optional): Also hide the cursor. Defaults to False.
- style (Style, optional): Optional style for screen. Defaults to None.
-
- Returns:
- ~ScreenContext: Context which enables alternate screen on enter, and disables it on exit.
- """
- return ScreenContext(self, hide_cursor=hide_cursor, style=style or "")
-
- def measure(
- self, renderable: RenderableType, *, options: Optional[ConsoleOptions] = None
- ) -> Measurement:
- """Measure a renderable. Returns a :class:`~rich.measure.Measurement` object which contains
- information regarding the number of characters required to print the renderable.
-
- Args:
- renderable (RenderableType): Any renderable or string.
- options (Optional[ConsoleOptions], optional): Options to use when measuring, or None
- to use default options. Defaults to None.
-
- Returns:
- Measurement: A measurement of the renderable.
- """
- measurement = Measurement.get(self, options or self.options, renderable)
- return measurement
-
- def render(
- self, renderable: RenderableType, options: Optional[ConsoleOptions] = None
- ) -> Iterable[Segment]:
- """Render an object in to an iterable of `Segment` instances.
-
- This method contains the logic for rendering objects with the console protocol.
- You are unlikely to need to use it directly, unless you are extending the library.
-
- Args:
- renderable (RenderableType): An object supporting the console protocol, or
- an object that may be converted to a string.
- options (ConsoleOptions, optional): An options object, or None to use self.options. Defaults to None.
-
- Returns:
- Iterable[Segment]: An iterable of segments that may be rendered.
- """
-
- _options = options or self.options
- if _options.max_width < 1:
- # No space to render anything. This prevents potential recursion errors.
- return
- render_iterable: RenderResult
-
- renderable = rich_cast(renderable)
- if hasattr(renderable, "__rich_console__") and not isclass(renderable):
- render_iterable = renderable.__rich_console__(self, _options) # type: ignore[union-attr]
- elif isinstance(renderable, str):
- text_renderable = self.render_str(
- renderable, highlight=_options.highlight, markup=_options.markup
- )
- render_iterable = text_renderable.__rich_console__(self, _options)
- else:
- raise errors.NotRenderableError(
- f"Unable to render {renderable!r}; "
- "A str, Segment or object with __rich_console__ method is required"
- )
-
- try:
- iter_render = iter(render_iterable)
- except TypeError:
- raise errors.NotRenderableError(
- f"object {render_iterable!r} is not renderable"
- )
- _Segment = Segment
- _options = _options.reset_height()
- for render_output in iter_render:
- if isinstance(render_output, _Segment):
- yield render_output
- else:
- yield from self.render(render_output, _options)
-
- def render_lines(
- self,
- renderable: RenderableType,
- options: Optional[ConsoleOptions] = None,
- *,
- style: Optional[Style] = None,
- pad: bool = True,
- new_lines: bool = False,
- ) -> List[List[Segment]]:
- """Render objects in to a list of lines.
-
- The output of render_lines is useful when further formatting of rendered console text
- is required, such as the Panel class which draws a border around any renderable object.
-
- Args:
- renderable (RenderableType): Any object renderable in the console.
- options (Optional[ConsoleOptions], optional): Console options, or None to use self.options. Default to ``None``.
- style (Style, optional): Optional style to apply to renderables. Defaults to ``None``.
- pad (bool, optional): Pad lines shorter than render width. Defaults to ``True``.
- new_lines (bool, optional): Include "\n" characters at end of lines.
-
- Returns:
- List[List[Segment]]: A list of lines, where a line is a list of Segment objects.
- """
- with self._lock:
- render_options = options or self.options
- _rendered = self.render(renderable, render_options)
- if style:
- _rendered = Segment.apply_style(_rendered, style)
-
- render_height = render_options.height
- if render_height is not None:
- render_height = max(0, render_height)
-
- lines = list(
- islice(
- Segment.split_and_crop_lines(
- _rendered,
- render_options.max_width,
- include_new_lines=new_lines,
- pad=pad,
- style=style,
- ),
- None,
- render_height,
- )
- )
- if render_options.height is not None:
- extra_lines = render_options.height - len(lines)
- if extra_lines > 0:
- pad_line = [
- [Segment(" " * render_options.max_width, style), Segment("\n")]
- if new_lines
- else [Segment(" " * render_options.max_width, style)]
- ]
- lines.extend(pad_line * extra_lines)
-
- return lines
-
- def render_str(
- self,
- text: str,
- *,
- style: Union[str, Style] = "",
- justify: Optional[JustifyMethod] = None,
- overflow: Optional[OverflowMethod] = None,
- emoji: Optional[bool] = None,
- markup: Optional[bool] = None,
- highlight: Optional[bool] = None,
- highlighter: Optional[HighlighterType] = None,
- ) -> "Text":
- """Convert a string to a Text instance. This is called automatically if
- you print or log a string.
-
- Args:
- text (str): Text to render.
- style (Union[str, Style], optional): Style to apply to rendered text.
- justify (str, optional): Justify method: "default", "left", "center", "full", or "right". Defaults to ``None``.
- overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to ``None``.
- emoji (Optional[bool], optional): Enable emoji, or ``None`` to use Console default.
- markup (Optional[bool], optional): Enable markup, or ``None`` to use Console default.
- highlight (Optional[bool], optional): Enable highlighting, or ``None`` to use Console default.
- highlighter (HighlighterType, optional): Optional highlighter to apply.
- Returns:
- ConsoleRenderable: Renderable object.
-
- """
- emoji_enabled = emoji or (emoji is None and self._emoji)
- markup_enabled = markup or (markup is None and self._markup)
- highlight_enabled = highlight or (highlight is None and self._highlight)
-
- if markup_enabled:
- rich_text = render_markup(
- text,
- style=style,
- emoji=emoji_enabled,
- emoji_variant=self._emoji_variant,
- )
- rich_text.justify = justify
- rich_text.overflow = overflow
- else:
- rich_text = Text(
- _emoji_replace(text, default_variant=self._emoji_variant)
- if emoji_enabled
- else text,
- justify=justify,
- overflow=overflow,
- style=style,
- )
-
- _highlighter = (highlighter or self.highlighter) if highlight_enabled else None
- if _highlighter is not None:
- highlight_text = _highlighter(str(rich_text))
- highlight_text.copy_styles(rich_text)
- return highlight_text
-
- return rich_text
-
- def get_style(
- self, name: Union[str, Style], *, default: Optional[Union[Style, str]] = None
- ) -> Style:
- """Get a Style instance by its theme name or parse a definition.
-
- Args:
- name (str): The name of a style or a style definition.
-
- Returns:
- Style: A Style object.
-
- Raises:
- MissingStyle: If no style could be parsed from name.
-
- """
- if isinstance(name, Style):
- return name
-
- try:
- style = self._theme_stack.get(name)
- if style is None:
- style = Style.parse(name)
- return style.copy() if style.link else style
- except errors.StyleSyntaxError as error:
- if default is not None:
- return self.get_style(default)
- raise errors.MissingStyle(
- f"Failed to get style {name!r}; {error}"
- ) from None
-
- def _collect_renderables(
- self,
- objects: Iterable[Any],
- sep: str,
- end: str,
- *,
- justify: Optional[JustifyMethod] = None,
- emoji: Optional[bool] = None,
- markup: Optional[bool] = None,
- highlight: Optional[bool] = None,
- ) -> List[ConsoleRenderable]:
- """Combine a number of renderables and text into one renderable.
-
- Args:
- objects (Iterable[Any]): Anything that Rich can render.
- sep (str): String to write between print data.
- end (str): String to write at end of print data.
- justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.
- emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default.
- markup (Optional[bool], optional): Enable markup, or ``None`` to use console default.
- highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default.
-
- Returns:
- List[ConsoleRenderable]: A list of things to render.
- """
- renderables: List[ConsoleRenderable] = []
- _append = renderables.append
- text: List[Text] = []
- append_text = text.append
-
- append = _append
- if justify in ("left", "center", "right"):
-
- def align_append(renderable: RenderableType) -> None:
- _append(Align(renderable, cast(AlignMethod, justify)))
-
- append = align_append
-
- _highlighter: HighlighterType = _null_highlighter
- if highlight or (highlight is None and self._highlight):
- _highlighter = self.highlighter
-
- def check_text() -> None:
- if text:
- sep_text = Text(sep, justify=justify, end=end)
- append(sep_text.join(text))
- text.clear()
-
- for renderable in objects:
- renderable = rich_cast(renderable)
- if isinstance(renderable, str):
- append_text(
- self.render_str(
- renderable, emoji=emoji, markup=markup, highlighter=_highlighter
- )
- )
- elif isinstance(renderable, Text):
- append_text(renderable)
- elif isinstance(renderable, ConsoleRenderable):
- check_text()
- append(renderable)
- elif is_expandable(renderable):
- check_text()
- append(Pretty(renderable, highlighter=_highlighter))
- else:
- append_text(_highlighter(str(renderable)))
-
- check_text()
-
- if self.style is not None:
- style = self.get_style(self.style)
- renderables = [Styled(renderable, style) for renderable in renderables]
-
- return renderables
-
- def rule(
- self,
- title: TextType = "",
- *,
- characters: str = "─",
- style: Union[str, Style] = "rule.line",
- align: AlignMethod = "center",
- ) -> None:
- """Draw a line with optional centered title.
-
- Args:
- title (str, optional): Text to render over the rule. Defaults to "".
- characters (str, optional): Character(s) to form the line. Defaults to "─".
- style (str, optional): Style of line. Defaults to "rule.line".
- align (str, optional): How to align the title, one of "left", "center", or "right". Defaults to "center".
- """
- from .rule import Rule
-
- rule = Rule(title=title, characters=characters, style=style, align=align)
- self.print(rule)
-
- def control(self, *control: Control) -> None:
- """Insert non-printing control codes.
-
- Args:
- control_codes (str): Control codes, such as those that may move the cursor.
- """
- if not self.is_dumb_terminal:
- with self:
- self._buffer.extend(_control.segment for _control in control)
-
- def out(
- self,
- *objects: Any,
- sep: str = " ",
- end: str = "\n",
- style: Optional[Union[str, Style]] = None,
- highlight: Optional[bool] = None,
- ) -> None:
- """Output to the terminal. This is a low-level way of writing to the terminal which unlike
- :meth:`~rich.console.Console.print` won't pretty print, wrap text, or apply markup, but will
- optionally apply highlighting and a basic style.
-
- Args:
- sep (str, optional): String to write between print data. Defaults to " ".
- end (str, optional): String to write at end of print data. Defaults to "\\\\n".
- style (Union[str, Style], optional): A style to apply to output. Defaults to None.
- highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use
- console default. Defaults to ``None``.
- """
- raw_output: str = sep.join(str(_object) for _object in objects)
- self.print(
- raw_output,
- style=style,
- highlight=highlight,
- emoji=False,
- markup=False,
- no_wrap=True,
- overflow="ignore",
- crop=False,
- end=end,
- )
-
- def print(
- self,
- *objects: Any,
- sep: str = " ",
- end: str = "\n",
- style: Optional[Union[str, Style]] = None,
- justify: Optional[JustifyMethod] = None,
- overflow: Optional[OverflowMethod] = None,
- no_wrap: Optional[bool] = None,
- emoji: Optional[bool] = None,
- markup: Optional[bool] = None,
- highlight: Optional[bool] = None,
- width: Optional[int] = None,
- height: Optional[int] = None,
- crop: bool = True,
- soft_wrap: Optional[bool] = None,
- new_line_start: bool = False,
- ) -> None:
- """Print to the console.
-
- Args:
- objects (positional args): Objects to log to the terminal.
- sep (str, optional): String to write between print data. Defaults to " ".
- end (str, optional): String to write at end of print data. Defaults to "\\\\n".
- style (Union[str, Style], optional): A style to apply to output. Defaults to None.
- justify (str, optional): Justify method: "default", "left", "right", "center", or "full". Defaults to ``None``.
- overflow (str, optional): Overflow method: "ignore", "crop", "fold", or "ellipsis". Defaults to None.
- no_wrap (Optional[bool], optional): Disable word wrapping. Defaults to None.
- emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to ``None``.
- markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to ``None``.
- highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to ``None``.
- width (Optional[int], optional): Width of output, or ``None`` to auto-detect. Defaults to ``None``.
- crop (Optional[bool], optional): Crop output to width of terminal. Defaults to True.
- soft_wrap (bool, optional): Enable soft wrap mode which disables word wrapping and cropping of text or ``None`` for
- Console default. Defaults to ``None``.
- new_line_start (bool, False): Insert a new line at the start if the output contains more than one line. Defaults to ``False``.
- """
- if not objects:
- objects = (NewLine(),)
-
- if soft_wrap is None:
- soft_wrap = self.soft_wrap
- if soft_wrap:
- if no_wrap is None:
- no_wrap = True
- if overflow is None:
- overflow = "ignore"
- crop = False
- render_hooks = self._render_hooks[:]
- with self:
- renderables = self._collect_renderables(
- objects,
- sep,
- end,
- justify=justify,
- emoji=emoji,
- markup=markup,
- highlight=highlight,
- )
- for hook in render_hooks:
- renderables = hook.process_renderables(renderables)
- render_options = self.options.update(
- justify=justify,
- overflow=overflow,
- width=min(width, self.width) if width is not None else NO_CHANGE,
- height=height,
- no_wrap=no_wrap,
- markup=markup,
- highlight=highlight,
- )
-
- new_segments: List[Segment] = []
- extend = new_segments.extend
- render = self.render
- if style is None:
- for renderable in renderables:
- extend(render(renderable, render_options))
- else:
- for renderable in renderables:
- extend(
- Segment.apply_style(
- render(renderable, render_options), self.get_style(style)
- )
- )
- if new_line_start:
- if (
- len("".join(segment.text for segment in new_segments).splitlines())
- > 1
- ):
- new_segments.insert(0, Segment.line())
- if crop:
- buffer_extend = self._buffer.extend
- for line in Segment.split_and_crop_lines(
- new_segments, self.width, pad=False
- ):
- buffer_extend(line)
- else:
- self._buffer.extend(new_segments)
-
- def print_json(
- self,
- json: Optional[str] = None,
- *,
- data: Any = None,
- indent: Union[None, int, str] = 2,
- highlight: bool = True,
- skip_keys: bool = False,
- ensure_ascii: bool = False,
- check_circular: bool = True,
- allow_nan: bool = True,
- default: Optional[Callable[[Any], Any]] = None,
- sort_keys: bool = False,
- ) -> None:
- """Pretty prints JSON. Output will be valid JSON.
-
- Args:
- json (Optional[str]): A string containing JSON.
- data (Any): If json is not supplied, then encode this data.
- indent (Union[None, int, str], optional): Number of spaces to indent. Defaults to 2.
- highlight (bool, optional): Enable highlighting of output: Defaults to True.
- skip_keys (bool, optional): Skip keys not of a basic type. Defaults to False.
- ensure_ascii (bool, optional): Escape all non-ascii characters. Defaults to False.
- check_circular (bool, optional): Check for circular references. Defaults to True.
- allow_nan (bool, optional): Allow NaN and Infinity values. Defaults to True.
- default (Callable, optional): A callable that converts values that can not be encoded
- in to something that can be JSON encoded. Defaults to None.
- sort_keys (bool, optional): Sort dictionary keys. Defaults to False.
- """
- from pip._vendor.rich.json import JSON
-
- if json is None:
- json_renderable = JSON.from_data(
- data,
- indent=indent,
- highlight=highlight,
- skip_keys=skip_keys,
- ensure_ascii=ensure_ascii,
- check_circular=check_circular,
- allow_nan=allow_nan,
- default=default,
- sort_keys=sort_keys,
- )
- else:
- if not isinstance(json, str):
- raise TypeError(
- f"json must be str. Did you mean print_json(data={json!r}) ?"
- )
- json_renderable = JSON(
- json,
- indent=indent,
- highlight=highlight,
- skip_keys=skip_keys,
- ensure_ascii=ensure_ascii,
- check_circular=check_circular,
- allow_nan=allow_nan,
- default=default,
- sort_keys=sort_keys,
- )
- self.print(json_renderable, soft_wrap=True)
-
- def update_screen(
- self,
- renderable: RenderableType,
- *,
- region: Optional[Region] = None,
- options: Optional[ConsoleOptions] = None,
- ) -> None:
- """Update the screen at a given offset.
-
- Args:
- renderable (RenderableType): A Rich renderable.
- region (Region, optional): Region of screen to update, or None for entire screen. Defaults to None.
- x (int, optional): x offset. Defaults to 0.
- y (int, optional): y offset. Defaults to 0.
-
- Raises:
- errors.NoAltScreen: If the Console isn't in alt screen mode.
-
- """
- if not self.is_alt_screen:
- raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")
- render_options = options or self.options
- if region is None:
- x = y = 0
- render_options = render_options.update_dimensions(
- render_options.max_width, render_options.height or self.height
- )
- else:
- x, y, width, height = region
- render_options = render_options.update_dimensions(width, height)
-
- lines = self.render_lines(renderable, options=render_options)
- self.update_screen_lines(lines, x, y)
-
- def update_screen_lines(
- self, lines: List[List[Segment]], x: int = 0, y: int = 0
- ) -> None:
- """Update lines of the screen at a given offset.
-
- Args:
- lines (List[List[Segment]]): Rendered lines (as produced by :meth:`~rich.Console.render_lines`).
- x (int, optional): x offset (column no). Defaults to 0.
- y (int, optional): y offset (column no). Defaults to 0.
-
- Raises:
- errors.NoAltScreen: If the Console isn't in alt screen mode.
- """
- if not self.is_alt_screen:
- raise errors.NoAltScreen("Alt screen must be enabled to call update_screen")
- screen_update = ScreenUpdate(lines, x, y)
- segments = self.render(screen_update)
- self._buffer.extend(segments)
- self._check_buffer()
-
- def print_exception(
- self,
- *,
- width: Optional[int] = 100,
- extra_lines: int = 3,
- theme: Optional[str] = None,
- word_wrap: bool = False,
- show_locals: bool = False,
- suppress: Iterable[Union[str, ModuleType]] = (),
- max_frames: int = 100,
- ) -> None:
- """Prints a rich render of the last exception and traceback.
-
- Args:
- width (Optional[int], optional): Number of characters used to render code. Defaults to 100.
- extra_lines (int, optional): Additional lines of code to render. Defaults to 3.
- theme (str, optional): Override pygments theme used in traceback
- word_wrap (bool, optional): Enable word wrapping of long lines. Defaults to False.
- show_locals (bool, optional): Enable display of local variables. Defaults to False.
- suppress (Iterable[Union[str, ModuleType]]): Optional sequence of modules or paths to exclude from traceback.
- max_frames (int): Maximum number of frames to show in a traceback, 0 for no maximum. Defaults to 100.
- """
- from .traceback import Traceback
-
- traceback = Traceback(
- width=width,
- extra_lines=extra_lines,
- theme=theme,
- word_wrap=word_wrap,
- show_locals=show_locals,
- suppress=suppress,
- max_frames=max_frames,
- )
- self.print(traceback)
-
- @staticmethod
- def _caller_frame_info(
- offset: int,
- currentframe: Callable[[], Optional[FrameType]] = inspect.currentframe,
- ) -> Tuple[str, int, Dict[str, Any]]:
- """Get caller frame information.
-
- Args:
- offset (int): the caller offset within the current frame stack.
- currentframe (Callable[[], Optional[FrameType]], optional): the callable to use to
- retrieve the current frame. Defaults to ``inspect.currentframe``.
-
- Returns:
- Tuple[str, int, Dict[str, Any]]: A tuple containing the filename, the line number and
- the dictionary of local variables associated with the caller frame.
-
- Raises:
- RuntimeError: If the stack offset is invalid.
- """
- # Ignore the frame of this local helper
- offset += 1
-
- frame = currentframe()
- if frame is not None:
- # Use the faster currentframe where implemented
- while offset and frame is not None:
- frame = frame.f_back
- offset -= 1
- assert frame is not None
- return frame.f_code.co_filename, frame.f_lineno, frame.f_locals
- else:
- # Fallback to the slower stack
- frame_info = inspect.stack()[offset]
- return frame_info.filename, frame_info.lineno, frame_info.frame.f_locals
-
- def log(
- self,
- *objects: Any,
- sep: str = " ",
- end: str = "\n",
- style: Optional[Union[str, Style]] = None,
- justify: Optional[JustifyMethod] = None,
- emoji: Optional[bool] = None,
- markup: Optional[bool] = None,
- highlight: Optional[bool] = None,
- log_locals: bool = False,
- _stack_offset: int = 1,
- ) -> None:
- """Log rich content to the terminal.
-
- Args:
- objects (positional args): Objects to log to the terminal.
- sep (str, optional): String to write between print data. Defaults to " ".
- end (str, optional): String to write at end of print data. Defaults to "\\\\n".
- style (Union[str, Style], optional): A style to apply to output. Defaults to None.
- justify (str, optional): One of "left", "right", "center", or "full". Defaults to ``None``.
- overflow (str, optional): Overflow method: "crop", "fold", or "ellipsis". Defaults to None.
- emoji (Optional[bool], optional): Enable emoji code, or ``None`` to use console default. Defaults to None.
- markup (Optional[bool], optional): Enable markup, or ``None`` to use console default. Defaults to None.
- highlight (Optional[bool], optional): Enable automatic highlighting, or ``None`` to use console default. Defaults to None.
- log_locals (bool, optional): Boolean to enable logging of locals where ``log()``
- was called. Defaults to False.
- _stack_offset (int, optional): Offset of caller from end of call stack. Defaults to 1.
- """
- if not objects:
- objects = (NewLine(),)
-
- render_hooks = self._render_hooks[:]
-
- with self:
- renderables = self._collect_renderables(
- objects,
- sep,
- end,
- justify=justify,
- emoji=emoji,
- markup=markup,
- highlight=highlight,
- )
- if style is not None:
- renderables = [Styled(renderable, style) for renderable in renderables]
-
- filename, line_no, locals = self._caller_frame_info(_stack_offset)
- link_path = None if filename.startswith("<") else os.path.abspath(filename)
- path = filename.rpartition(os.sep)[-1]
- if log_locals:
- locals_map = {
- key: value
- for key, value in locals.items()
- if not key.startswith("__")
- }
- renderables.append(render_scope(locals_map, title="[i]locals"))
-
- renderables = [
- self._log_render(
- self,
- renderables,
- log_time=self.get_datetime(),
- path=path,
- line_no=line_no,
- link_path=link_path,
- )
- ]
- for hook in render_hooks:
- renderables = hook.process_renderables(renderables)
- new_segments: List[Segment] = []
- extend = new_segments.extend
- render = self.render
- render_options = self.options
- for renderable in renderables:
- extend(render(renderable, render_options))
- buffer_extend = self._buffer.extend
- for line in Segment.split_and_crop_lines(
- new_segments, self.width, pad=False
- ):
- buffer_extend(line)
-
- def _check_buffer(self) -> None:
- """Check if the buffer may be rendered. Render it if it can (e.g. Console.quiet is False)
- Rendering is supported on Windows, Unix and Jupyter environments. For
- legacy Windows consoles, the win32 API is called directly.
- This method will also record what it renders if recording is enabled via Console.record.
- """
- if self.quiet:
- del self._buffer[:]
- return
- with self._lock:
- if self.record:
- with self._record_buffer_lock:
- self._record_buffer.extend(self._buffer[:])
-
- if self._buffer_index == 0:
- if self.is_jupyter: # pragma: no cover
- from .jupyter import display
-
- display(self._buffer, self._render_buffer(self._buffer[:]))
- del self._buffer[:]
- else:
- if WINDOWS:
- use_legacy_windows_render = False
- if self.legacy_windows:
- fileno = get_fileno(self.file)
- if fileno is not None:
- use_legacy_windows_render = (
- fileno in _STD_STREAMS_OUTPUT
- )
-
- if use_legacy_windows_render:
- from pip._vendor.rich._win32_console import LegacyWindowsTerm
- from pip._vendor.rich._windows_renderer import legacy_windows_render
-
- buffer = self._buffer[:]
- if self.no_color and self._color_system:
- buffer = list(Segment.remove_color(buffer))
-
- legacy_windows_render(buffer, LegacyWindowsTerm(self.file))
- else:
- # Either a non-std stream on legacy Windows, or modern Windows.
- text = self._render_buffer(self._buffer[:])
- # https://bugs.python.org/issue37871
- # https://github.com/python/cpython/issues/82052
- # We need to avoid writing more than 32Kb in a single write, due to the above bug
- write = self.file.write
- # Worse case scenario, every character is 4 bytes of utf-8
- MAX_WRITE = 32 * 1024 // 4
- try:
- if len(text) <= MAX_WRITE:
- write(text)
- else:
- batch: List[str] = []
- batch_append = batch.append
- size = 0
- for line in text.splitlines(True):
- if size + len(line) > MAX_WRITE and batch:
- write("".join(batch))
- batch.clear()
- size = 0
- batch_append(line)
- size += len(line)
- if batch:
- write("".join(batch))
- batch.clear()
- except UnicodeEncodeError as error:
- error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"
- raise
- else:
- text = self._render_buffer(self._buffer[:])
- try:
- self.file.write(text)
- except UnicodeEncodeError as error:
- error.reason = f"{error.reason}\n*** You may need to add PYTHONIOENCODING=utf-8 to your environment ***"
- raise
-
- self.file.flush()
- del self._buffer[:]
-
- def _render_buffer(self, buffer: Iterable[Segment]) -> str:
- """Render buffered output, and clear buffer."""
- output: List[str] = []
- append = output.append
- color_system = self._color_system
- legacy_windows = self.legacy_windows
- not_terminal = not self.is_terminal
- if self.no_color and color_system:
- buffer = Segment.remove_color(buffer)
- for text, style, control in buffer:
- if style:
- append(
- style.render(
- text,
- color_system=color_system,
- legacy_windows=legacy_windows,
- )
- )
- elif not (not_terminal and control):
- append(text)
-
- rendered = "".join(output)
- return rendered
-
- def input(
- self,
- prompt: TextType = "",
- *,
- markup: bool = True,
- emoji: bool = True,
- password: bool = False,
- stream: Optional[TextIO] = None,
- ) -> str:
- """Displays a prompt and waits for input from the user. The prompt may contain color / style.
-
- It works in the same way as Python's builtin :func:`input` function and provides elaborate line editing and history features if Python's builtin :mod:`readline` module is previously loaded.
-
- Args:
- prompt (Union[str, Text]): Text to render in the prompt.
- markup (bool, optional): Enable console markup (requires a str prompt). Defaults to True.
- emoji (bool, optional): Enable emoji (requires a str prompt). Defaults to True.
- password: (bool, optional): Hide typed text. Defaults to False.
- stream: (TextIO, optional): Optional file to read input from (rather than stdin). Defaults to None.
-
- Returns:
- str: Text read from stdin.
- """
- if prompt:
- self.print(prompt, markup=markup, emoji=emoji, end="")
- if password:
- result = getpass("", stream=stream)
- else:
- if stream:
- result = stream.readline()
- else:
- result = input()
- return result
-
- def export_text(self, *, clear: bool = True, styles: bool = False) -> str:
- """Generate text from console contents (requires record=True argument in constructor).
-
- Args:
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
- styles (bool, optional): If ``True``, ansi escape codes will be included. ``False`` for plain text.
- Defaults to ``False``.
-
- Returns:
- str: String containing console contents.
-
- """
- assert (
- self.record
- ), "To export console contents set record=True in the constructor or instance"
-
- with self._record_buffer_lock:
- if styles:
- text = "".join(
- (style.render(text) if style else text)
- for text, style, _ in self._record_buffer
- )
- else:
- text = "".join(
- segment.text
- for segment in self._record_buffer
- if not segment.control
- )
- if clear:
- del self._record_buffer[:]
- return text
-
- def save_text(self, path: str, *, clear: bool = True, styles: bool = False) -> None:
- """Generate text from console and save to a given location (requires record=True argument in constructor).
-
- Args:
- path (str): Path to write text files.
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
- styles (bool, optional): If ``True``, ansi style codes will be included. ``False`` for plain text.
- Defaults to ``False``.
-
- """
- text = self.export_text(clear=clear, styles=styles)
- with open(path, "wt", encoding="utf-8") as write_file:
- write_file.write(text)
-
- def export_html(
- self,
- *,
- theme: Optional[TerminalTheme] = None,
- clear: bool = True,
- code_format: Optional[str] = None,
- inline_styles: bool = False,
- ) -> str:
- """Generate HTML from console contents (requires record=True argument in constructor).
-
- Args:
- theme (TerminalTheme, optional): TerminalTheme object containing console colors.
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
- code_format (str, optional): Format string to render HTML. In addition to '{foreground}',
- '{background}', and '{code}', should contain '{stylesheet}' if inline_styles is ``False``.
- inline_styles (bool, optional): If ``True`` styles will be inlined in to spans, which makes files
- larger but easier to cut and paste markup. If ``False``, styles will be embedded in a style tag.
- Defaults to False.
-
- Returns:
- str: String containing console contents as HTML.
- """
- assert (
- self.record
- ), "To export console contents set record=True in the constructor or instance"
- fragments: List[str] = []
- append = fragments.append
- _theme = theme or DEFAULT_TERMINAL_THEME
- stylesheet = ""
-
- render_code_format = CONSOLE_HTML_FORMAT if code_format is None else code_format
-
- with self._record_buffer_lock:
- if inline_styles:
- for text, style, _ in Segment.filter_control(
- Segment.simplify(self._record_buffer)
- ):
- text = escape(text)
- if style:
- rule = style.get_html_style(_theme)
- if style.link:
- text = f'{text}'
- text = f'{text}' if rule else text
- append(text)
- else:
- styles: Dict[str, int] = {}
- for text, style, _ in Segment.filter_control(
- Segment.simplify(self._record_buffer)
- ):
- text = escape(text)
- if style:
- rule = style.get_html_style(_theme)
- style_number = styles.setdefault(rule, len(styles) + 1)
- if style.link:
- text = f'{text}'
- else:
- text = f'{text}'
- append(text)
- stylesheet_rules: List[str] = []
- stylesheet_append = stylesheet_rules.append
- for style_rule, style_number in styles.items():
- if style_rule:
- stylesheet_append(f".r{style_number} {{{style_rule}}}")
- stylesheet = "\n".join(stylesheet_rules)
-
- rendered_code = render_code_format.format(
- code="".join(fragments),
- stylesheet=stylesheet,
- foreground=_theme.foreground_color.hex,
- background=_theme.background_color.hex,
- )
- if clear:
- del self._record_buffer[:]
- return rendered_code
-
- def save_html(
- self,
- path: str,
- *,
- theme: Optional[TerminalTheme] = None,
- clear: bool = True,
- code_format: str = CONSOLE_HTML_FORMAT,
- inline_styles: bool = False,
- ) -> None:
- """Generate HTML from console contents and write to a file (requires record=True argument in constructor).
-
- Args:
- path (str): Path to write html file.
- theme (TerminalTheme, optional): TerminalTheme object containing console colors.
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``.
- code_format (str, optional): Format string to render HTML. In addition to '{foreground}',
- '{background}', and '{code}', should contain '{stylesheet}' if inline_styles is ``False``.
- inline_styles (bool, optional): If ``True`` styles will be inlined in to spans, which makes files
- larger but easier to cut and paste markup. If ``False``, styles will be embedded in a style tag.
- Defaults to False.
-
- """
- html = self.export_html(
- theme=theme,
- clear=clear,
- code_format=code_format,
- inline_styles=inline_styles,
- )
- with open(path, "wt", encoding="utf-8") as write_file:
- write_file.write(html)
-
- def export_svg(
- self,
- *,
- title: str = "Rich",
- theme: Optional[TerminalTheme] = None,
- clear: bool = True,
- code_format: str = CONSOLE_SVG_FORMAT,
- font_aspect_ratio: float = 0.61,
- unique_id: Optional[str] = None,
- ) -> str:
- """
- Generate an SVG from the console contents (requires record=True in Console constructor).
-
- Args:
- title (str, optional): The title of the tab in the output image
- theme (TerminalTheme, optional): The ``TerminalTheme`` object to use to style the terminal
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``
- code_format (str, optional): Format string used to generate the SVG. Rich will inject a number of variables
- into the string in order to form the final SVG output. The default template used and the variables
- injected by Rich can be found by inspecting the ``console.CONSOLE_SVG_FORMAT`` variable.
- font_aspect_ratio (float, optional): The width to height ratio of the font used in the ``code_format``
- string. Defaults to 0.61, which is the width to height ratio of Fira Code (the default font).
- If you aren't specifying a different font inside ``code_format``, you probably don't need this.
- unique_id (str, optional): unique id that is used as the prefix for various elements (CSS styles, node
- ids). If not set, this defaults to a computed value based on the recorded content.
- """
-
- from pip._vendor.rich.cells import cell_len
-
- style_cache: Dict[Style, str] = {}
-
- def get_svg_style(style: Style) -> str:
- """Convert a Style to CSS rules for SVG."""
- if style in style_cache:
- return style_cache[style]
- css_rules = []
- color = (
- _theme.foreground_color
- if (style.color is None or style.color.is_default)
- else style.color.get_truecolor(_theme)
- )
- bgcolor = (
- _theme.background_color
- if (style.bgcolor is None or style.bgcolor.is_default)
- else style.bgcolor.get_truecolor(_theme)
- )
- if style.reverse:
- color, bgcolor = bgcolor, color
- if style.dim:
- color = blend_rgb(color, bgcolor, 0.4)
- css_rules.append(f"fill: {color.hex}")
- if style.bold:
- css_rules.append("font-weight: bold")
- if style.italic:
- css_rules.append("font-style: italic;")
- if style.underline:
- css_rules.append("text-decoration: underline;")
- if style.strike:
- css_rules.append("text-decoration: line-through;")
-
- css = ";".join(css_rules)
- style_cache[style] = css
- return css
-
- _theme = theme or SVG_EXPORT_THEME
-
- width = self.width
- char_height = 20
- char_width = char_height * font_aspect_ratio
- line_height = char_height * 1.22
-
- margin_top = 1
- margin_right = 1
- margin_bottom = 1
- margin_left = 1
-
- padding_top = 40
- padding_right = 8
- padding_bottom = 8
- padding_left = 8
-
- padding_width = padding_left + padding_right
- padding_height = padding_top + padding_bottom
- margin_width = margin_left + margin_right
- margin_height = margin_top + margin_bottom
-
- text_backgrounds: List[str] = []
- text_group: List[str] = []
- classes: Dict[str, int] = {}
- style_no = 1
-
- def escape_text(text: str) -> str:
- """HTML escape text and replace spaces with nbsp."""
- return escape(text).replace(" ", " ")
-
- def make_tag(
- name: str, content: Optional[str] = None, **attribs: object
- ) -> str:
- """Make a tag from name, content, and attributes."""
-
- def stringify(value: object) -> str:
- if isinstance(value, (float)):
- return format(value, "g")
- return str(value)
-
- tag_attribs = " ".join(
- f'{k.lstrip("_").replace("_", "-")}="{stringify(v)}"'
- for k, v in attribs.items()
- )
- return (
- f"<{name} {tag_attribs}>{content}"
- if content
- else f"<{name} {tag_attribs}/>"
- )
-
- with self._record_buffer_lock:
- segments = list(Segment.filter_control(self._record_buffer))
- if clear:
- self._record_buffer.clear()
-
- if unique_id is None:
- unique_id = "terminal-" + str(
- zlib.adler32(
- ("".join(repr(segment) for segment in segments)).encode(
- "utf-8",
- "ignore",
- )
- + title.encode("utf-8", "ignore")
- )
- )
- y = 0
- for y, line in enumerate(Segment.split_and_crop_lines(segments, length=width)):
- x = 0
- for text, style, _control in line:
- style = style or Style()
- rules = get_svg_style(style)
- if rules not in classes:
- classes[rules] = style_no
- style_no += 1
- class_name = f"r{classes[rules]}"
-
- if style.reverse:
- has_background = True
- background = (
- _theme.foreground_color.hex
- if style.color is None
- else style.color.get_truecolor(_theme).hex
- )
- else:
- bgcolor = style.bgcolor
- has_background = bgcolor is not None and not bgcolor.is_default
- background = (
- _theme.background_color.hex
- if style.bgcolor is None
- else style.bgcolor.get_truecolor(_theme).hex
- )
-
- text_length = cell_len(text)
- if has_background:
- text_backgrounds.append(
- make_tag(
- "rect",
- fill=background,
- x=x * char_width,
- y=y * line_height + 1.5,
- width=char_width * text_length,
- height=line_height + 0.25,
- shape_rendering="crispEdges",
- )
- )
-
- if text != " " * len(text):
- text_group.append(
- make_tag(
- "text",
- escape_text(text),
- _class=f"{unique_id}-{class_name}",
- x=x * char_width,
- y=y * line_height + char_height,
- textLength=char_width * len(text),
- clip_path=f"url(#{unique_id}-line-{y})",
- )
- )
- x += cell_len(text)
-
- line_offsets = [line_no * line_height + 1.5 for line_no in range(y)]
- lines = "\n".join(
- f"""
- {make_tag("rect", x=0, y=offset, width=char_width * width, height=line_height + 0.25)}
- """
- for line_no, offset in enumerate(line_offsets)
- )
-
- styles = "\n".join(
- f".{unique_id}-r{rule_no} {{ {css} }}" for css, rule_no in classes.items()
- )
- backgrounds = "".join(text_backgrounds)
- matrix = "".join(text_group)
-
- terminal_width = ceil(width * char_width + padding_width)
- terminal_height = (y + 1) * line_height + padding_height
- chrome = make_tag(
- "rect",
- fill=_theme.background_color.hex,
- stroke="rgba(255,255,255,0.35)",
- stroke_width="1",
- x=margin_left,
- y=margin_top,
- width=terminal_width,
- height=terminal_height,
- rx=8,
- )
-
- title_color = _theme.foreground_color.hex
- if title:
- chrome += make_tag(
- "text",
- escape_text(title),
- _class=f"{unique_id}-title",
- fill=title_color,
- text_anchor="middle",
- x=terminal_width // 2,
- y=margin_top + char_height + 6,
- )
- chrome += f"""
-
-
- """
-
- svg = code_format.format(
- unique_id=unique_id,
- char_width=char_width,
- char_height=char_height,
- line_height=line_height,
- terminal_width=char_width * width - 1,
- terminal_height=(y + 1) * line_height - 1,
- width=terminal_width + margin_width,
- height=terminal_height + margin_height,
- terminal_x=margin_left + padding_left,
- terminal_y=margin_top + padding_top,
- styles=styles,
- chrome=chrome,
- backgrounds=backgrounds,
- matrix=matrix,
- lines=lines,
- )
- return svg
-
- def save_svg(
- self,
- path: str,
- *,
- title: str = "Rich",
- theme: Optional[TerminalTheme] = None,
- clear: bool = True,
- code_format: str = CONSOLE_SVG_FORMAT,
- font_aspect_ratio: float = 0.61,
- unique_id: Optional[str] = None,
- ) -> None:
- """Generate an SVG file from the console contents (requires record=True in Console constructor).
-
- Args:
- path (str): The path to write the SVG to.
- title (str, optional): The title of the tab in the output image
- theme (TerminalTheme, optional): The ``TerminalTheme`` object to use to style the terminal
- clear (bool, optional): Clear record buffer after exporting. Defaults to ``True``
- code_format (str, optional): Format string used to generate the SVG. Rich will inject a number of variables
- into the string in order to form the final SVG output. The default template used and the variables
- injected by Rich can be found by inspecting the ``console.CONSOLE_SVG_FORMAT`` variable.
- font_aspect_ratio (float, optional): The width to height ratio of the font used in the ``code_format``
- string. Defaults to 0.61, which is the width to height ratio of Fira Code (the default font).
- If you aren't specifying a different font inside ``code_format``, you probably don't need this.
- unique_id (str, optional): unique id that is used as the prefix for various elements (CSS styles, node
- ids). If not set, this defaults to a computed value based on the recorded content.
- """
- svg = self.export_svg(
- title=title,
- theme=theme,
- clear=clear,
- code_format=code_format,
- font_aspect_ratio=font_aspect_ratio,
- unique_id=unique_id,
- )
- with open(path, "wt", encoding="utf-8") as write_file:
- write_file.write(svg)
-
-
-def _svg_hash(svg_main_code: str) -> str:
- """Returns a unique hash for the given SVG main code.
-
- Args:
- svg_main_code (str): The content we're going to inject in the SVG envelope.
-
- Returns:
- str: a hash of the given content
- """
- return str(zlib.adler32(svg_main_code.encode()))
-
-
-if __name__ == "__main__": # pragma: no cover
- console = Console(record=True)
-
- console.log(
- "JSONRPC [i]request[/i]",
- 5,
- 1.3,
- True,
- False,
- None,
- {
- "jsonrpc": "2.0",
- "method": "subtract",
- "params": {"minuend": 42, "subtrahend": 23},
- "id": 3,
- },
- )
-
- console.log("Hello, World!", "{'a': 1}", repr(console))
-
- console.print(
- {
- "name": None,
- "empty": [],
- "quiz": {
- "sport": {
- "answered": True,
- "q1": {
- "question": "Which one is correct team name in NBA?",
- "options": [
- "New York Bulls",
- "Los Angeles Kings",
- "Golden State Warriors",
- "Huston Rocket",
- ],
- "answer": "Huston Rocket",
- },
- },
- "maths": {
- "answered": False,
- "q1": {
- "question": "5 + 7 = ?",
- "options": [10, 11, 12, 13],
- "answer": 12,
- },
- "q2": {
- "question": "12 - 8 = ?",
- "options": [1, 2, 3, 4],
- "answer": 4,
- },
- },
- },
- }
- )
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/new_baselines/mask_rcnn_R_101_FPN_200ep_LSJ.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/new_baselines/mask_rcnn_R_101_FPN_200ep_LSJ.py
deleted file mode 100644
index 18e5f0720c568db4ef0c97b59688b5e7866df606..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/configs/new_baselines/mask_rcnn_R_101_FPN_200ep_LSJ.py
+++ /dev/null
@@ -1,14 +0,0 @@
-from .mask_rcnn_R_101_FPN_100ep_LSJ import (
- dataloader,
- lr_multiplier,
- model,
- optimizer,
- train,
-)
-
-train.max_iter *= 2 # 100ep -> 200ep
-
-lr_multiplier.scheduler.milestones = [
- milestone * 2 for milestone in lr_multiplier.scheduler.milestones
-]
-lr_multiplier.scheduler.num_updates = train.max_iter
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/mmdet_wrapper.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/mmdet_wrapper.py
deleted file mode 100644
index 386e92960511a782f48ec9350d19c3851e43849f..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/modeling/mmdet_wrapper.py
+++ /dev/null
@@ -1,274 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import itertools
-import logging
-import numpy as np
-from collections import OrderedDict
-from collections.abc import Mapping
-from typing import Dict, List, Optional, Tuple, Union
-import torch
-from omegaconf import DictConfig, OmegaConf
-from torch import Tensor, nn
-
-from detectron2.layers import ShapeSpec
-from detectron2.structures import BitMasks, Boxes, ImageList, Instances
-from detectron2.utils.events import get_event_storage
-
-from .backbone import Backbone
-
-logger = logging.getLogger(__name__)
-
-
-def _to_container(cfg):
- """
- mmdet will assert the type of dict/list.
- So convert omegaconf objects to dict/list.
- """
- if isinstance(cfg, DictConfig):
- cfg = OmegaConf.to_container(cfg, resolve=True)
- from mmcv.utils import ConfigDict
-
- return ConfigDict(cfg)
-
-
-class MMDetBackbone(Backbone):
- """
- Wrapper of mmdetection backbones to use in detectron2.
-
- mmdet backbones produce list/tuple of tensors, while detectron2 backbones
- produce a dict of tensors. This class wraps the given backbone to produce
- output in detectron2's convention, so it can be used in place of detectron2
- backbones.
- """
-
- def __init__(
- self,
- backbone: Union[nn.Module, Mapping],
- neck: Union[nn.Module, Mapping, None] = None,
- *,
- output_shapes: List[ShapeSpec],
- output_names: Optional[List[str]] = None,
- ):
- """
- Args:
- backbone: either a backbone module or a mmdet config dict that defines a
- backbone. The backbone takes a 4D image tensor and returns a
- sequence of tensors.
- neck: either a backbone module or a mmdet config dict that defines a
- neck. The neck takes outputs of backbone and returns a
- sequence of tensors. If None, no neck is used.
- pretrained_backbone: defines the backbone weights that can be loaded by
- mmdet, such as "torchvision://resnet50".
- output_shapes: shape for every output of the backbone (or neck, if given).
- stride and channels are often needed.
- output_names: names for every output of the backbone (or neck, if given).
- By default, will use "out0", "out1", ...
- """
- super().__init__()
- if isinstance(backbone, Mapping):
- from mmdet.models import build_backbone
-
- backbone = build_backbone(_to_container(backbone))
- self.backbone = backbone
-
- if isinstance(neck, Mapping):
- from mmdet.models import build_neck
-
- neck = build_neck(_to_container(neck))
- self.neck = neck
-
- # "Neck" weights, if any, are part of neck itself. This is the interface
- # of mmdet so we follow it. Reference:
- # https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/detectors/two_stage.py
- logger.info("Initializing mmdet backbone weights...")
- self.backbone.init_weights()
- # train() in mmdet modules is non-trivial, and has to be explicitly
- # called. Reference:
- # https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/backbones/resnet.py
- self.backbone.train()
- if self.neck is not None:
- logger.info("Initializing mmdet neck weights ...")
- if isinstance(self.neck, nn.Sequential):
- for m in self.neck:
- m.init_weights()
- else:
- self.neck.init_weights()
- self.neck.train()
-
- self._output_shapes = output_shapes
- if not output_names:
- output_names = [f"out{i}" for i in range(len(output_shapes))]
- self._output_names = output_names
-
- def forward(self, x) -> Dict[str, Tensor]:
- outs = self.backbone(x)
- if self.neck is not None:
- outs = self.neck(outs)
- assert isinstance(
- outs, (list, tuple)
- ), "mmdet backbone should return a list/tuple of tensors!"
- if len(outs) != len(self._output_shapes):
- raise ValueError(
- "Length of output_shapes does not match outputs from the mmdet backbone: "
- f"{len(outs)} != {len(self._output_shapes)}"
- )
- return {k: v for k, v in zip(self._output_names, outs)}
-
- def output_shape(self) -> Dict[str, ShapeSpec]:
- return {k: v for k, v in zip(self._output_names, self._output_shapes)}
-
-
-class MMDetDetector(nn.Module):
- """
- Wrapper of a mmdetection detector model, for detection and instance segmentation.
- Input/output formats of this class follow detectron2's convention, so a
- mmdetection model can be trained and evaluated in detectron2.
- """
-
- def __init__(
- self,
- detector: Union[nn.Module, Mapping],
- *,
- # Default is 32 regardless of model:
- # https://github.com/open-mmlab/mmdetection/tree/master/configs/_base_/datasets
- size_divisibility=32,
- pixel_mean: Tuple[float],
- pixel_std: Tuple[float],
- ):
- """
- Args:
- detector: a mmdet detector, or a mmdet config dict that defines a detector.
- size_divisibility: pad input images to multiple of this number
- pixel_mean: per-channel mean to normalize input image
- pixel_std: per-channel stddev to normalize input image
- """
- super().__init__()
- if isinstance(detector, Mapping):
- from mmdet.models import build_detector
-
- detector = build_detector(_to_container(detector))
- self.detector = detector
- self.size_divisibility = size_divisibility
-
- self.register_buffer("pixel_mean", torch.tensor(pixel_mean).view(-1, 1, 1), False)
- self.register_buffer("pixel_std", torch.tensor(pixel_std).view(-1, 1, 1), False)
- assert (
- self.pixel_mean.shape == self.pixel_std.shape
- ), f"{self.pixel_mean} and {self.pixel_std} have different shapes!"
-
- def forward(self, batched_inputs: List[Dict[str, torch.Tensor]]):
- images = [x["image"].to(self.device) for x in batched_inputs]
- images = [(x - self.pixel_mean) / self.pixel_std for x in images]
- images = ImageList.from_tensors(images, size_divisibility=self.size_divisibility).tensor
- metas = []
- rescale = {"height" in x for x in batched_inputs}
- if len(rescale) != 1:
- raise ValueError("Some inputs have original height/width, but some don't!")
- rescale = list(rescale)[0]
- output_shapes = []
- for input in batched_inputs:
- meta = {}
- c, h, w = input["image"].shape
- meta["img_shape"] = meta["ori_shape"] = (h, w, c)
- if rescale:
- scale_factor = np.array(
- [w / input["width"], h / input["height"]] * 2, dtype="float32"
- )
- ori_shape = (input["height"], input["width"])
- output_shapes.append(ori_shape)
- meta["ori_shape"] = ori_shape + (c,)
- else:
- scale_factor = 1.0
- output_shapes.append((h, w))
- meta["scale_factor"] = scale_factor
- meta["flip"] = False
- padh, padw = images.shape[-2:]
- meta["pad_shape"] = (padh, padw, c)
- metas.append(meta)
-
- if self.training:
- gt_instances = [x["instances"].to(self.device) for x in batched_inputs]
- if gt_instances[0].has("gt_masks"):
- from mmdet.core import PolygonMasks as mm_PolygonMasks, BitmapMasks as mm_BitMasks
-
- def convert_mask(m, shape):
- # mmdet mask format
- if isinstance(m, BitMasks):
- return mm_BitMasks(m.tensor.cpu().numpy(), shape[0], shape[1])
- else:
- return mm_PolygonMasks(m.polygons, shape[0], shape[1])
-
- gt_masks = [convert_mask(x.gt_masks, x.image_size) for x in gt_instances]
- losses_and_metrics = self.detector.forward_train(
- images,
- metas,
- [x.gt_boxes.tensor for x in gt_instances],
- [x.gt_classes for x in gt_instances],
- gt_masks=gt_masks,
- )
- else:
- losses_and_metrics = self.detector.forward_train(
- images,
- metas,
- [x.gt_boxes.tensor for x in gt_instances],
- [x.gt_classes for x in gt_instances],
- )
- return _parse_losses(losses_and_metrics)
- else:
- results = self.detector.simple_test(images, metas, rescale=rescale)
- results = [
- {"instances": _convert_mmdet_result(r, shape)}
- for r, shape in zip(results, output_shapes)
- ]
- return results
-
- @property
- def device(self):
- return self.pixel_mean.device
-
-
-# Reference: show_result() in
-# https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/detectors/base.py
-def _convert_mmdet_result(result, shape: Tuple[int, int]) -> Instances:
- if isinstance(result, tuple):
- bbox_result, segm_result = result
- if isinstance(segm_result, tuple):
- segm_result = segm_result[0]
- else:
- bbox_result, segm_result = result, None
-
- bboxes = torch.from_numpy(np.vstack(bbox_result)) # Nx5
- bboxes, scores = bboxes[:, :4], bboxes[:, -1]
- labels = [
- torch.full((bbox.shape[0],), i, dtype=torch.int32) for i, bbox in enumerate(bbox_result)
- ]
- labels = torch.cat(labels)
- inst = Instances(shape)
- inst.pred_boxes = Boxes(bboxes)
- inst.scores = scores
- inst.pred_classes = labels
-
- if segm_result is not None and len(labels) > 0:
- segm_result = list(itertools.chain(*segm_result))
- segm_result = [torch.from_numpy(x) if isinstance(x, np.ndarray) else x for x in segm_result]
- segm_result = torch.stack(segm_result, dim=0)
- inst.pred_masks = segm_result
- return inst
-
-
-# reference: https://github.com/open-mmlab/mmdetection/blob/master/mmdet/models/detectors/base.py
-def _parse_losses(losses: Dict[str, Tensor]) -> Dict[str, Tensor]:
- log_vars = OrderedDict()
- for loss_name, loss_value in losses.items():
- if isinstance(loss_value, torch.Tensor):
- log_vars[loss_name] = loss_value.mean()
- elif isinstance(loss_value, list):
- log_vars[loss_name] = sum(_loss.mean() for _loss in loss_value)
- else:
- raise TypeError(f"{loss_name} is not a tensor or list of tensors")
-
- if "loss" not in loss_name:
- # put metrics to storage; don't return them
- storage = get_event_storage()
- value = log_vars.pop(loss_name).cpu().item()
- storage.put_scalar(loss_name, value)
- return log_vars
diff --git a/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/cpp/cppipc/buffer.cpp b/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/cpp/cppipc/buffer.cpp
deleted file mode 100644
index 0ac0fa7bc3ced0447ba4caa359355dd4252670b3..0000000000000000000000000000000000000000
--- a/spaces/WhyLIM/ChatGPT-academic/crazy_functions/test_project/cpp/cppipc/buffer.cpp
+++ /dev/null
@@ -1,87 +0,0 @@
-#include "libipc/buffer.h"
-#include "libipc/utility/pimpl.h"
-
-#include
-
-namespace ipc {
-
-bool operator==(buffer const & b1, buffer const & b2) {
- return (b1.size() == b2.size()) && (std::memcmp(b1.data(), b2.data(), b1.size()) == 0);
-}
-
-bool operator!=(buffer const & b1, buffer const & b2) {
- return !(b1 == b2);
-}
-
-class buffer::buffer_ : public pimpl {
-public:
- void* p_;
- std::size_t s_;
- void* a_;
- buffer::destructor_t d_;
-
- buffer_(void* p, std::size_t s, buffer::destructor_t d, void* a)
- : p_(p), s_(s), a_(a), d_(d) {
- }
-
- ~buffer_() {
- if (d_ == nullptr) return;
- d_((a_ == nullptr) ? p_ : a_, s_);
- }
-};
-
-buffer::buffer()
- : buffer(nullptr, 0, nullptr, nullptr) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d)
- : p_(p_->make(p, s, d, nullptr)) {
-}
-
-buffer::buffer(void* p, std::size_t s, destructor_t d, void* additional)
- : p_(p_->make(p, s, d, additional)) {
-}
-
-buffer::buffer(void* p, std::size_t s)
- : buffer(p, s, nullptr) {
-}
-
-buffer::buffer(char const & c)
- : buffer(const_cast(&c), 1) {
-}
-
-buffer::buffer(buffer&& rhs)
- : buffer() {
- swap(rhs);
-}
-
-buffer::~buffer() {
- p_->clear();
-}
-
-void buffer::swap(buffer& rhs) {
- std::swap(p_, rhs.p_);
-}
-
-buffer& buffer::operator=(buffer rhs) {
- swap(rhs);
- return *this;
-}
-
-bool buffer::empty() const noexcept {
- return (impl(p_)->p_ == nullptr) || (impl(p_)->s_ == 0);
-}
-
-void* buffer::data() noexcept {
- return impl(p_)->p_;
-}
-
-void const * buffer::data() const noexcept {
- return impl(p_)->p_;
-}
-
-std::size_t buffer::size() const noexcept {
- return impl(p_)->s_;
-}
-
-} // namespace ipc
diff --git a/spaces/XS-1/BW_IMAGE_VIDEO_COLORIZER/fastai/vision/interpret.py b/spaces/XS-1/BW_IMAGE_VIDEO_COLORIZER/fastai/vision/interpret.py
deleted file mode 100644
index 7f07d9eadfa401a469d4a8d4eab0f750e2296049..0000000000000000000000000000000000000000
--- a/spaces/XS-1/BW_IMAGE_VIDEO_COLORIZER/fastai/vision/interpret.py
+++ /dev/null
@@ -1,106 +0,0 @@
-from ..torch_core import *
-from ..basic_data import *
-from ..basic_train import *
-from .image import *
-from ..train import Interpretation
-from textwrap import wrap
-
-__all__ = ['SegmentationInterpretation', 'ObjectDetectionInterpretation']
-
-class SegmentationInterpretation(Interpretation):
- "Interpretation methods for segmenatation models."
- def __init__(self, learn:Learner, preds:Tensor, y_true:Tensor, losses:Tensor,
- ds_type:DatasetType=DatasetType.Valid):
- super(SegmentationInterpretation, self).__init__(learn,preds,y_true,losses,ds_type)
- self.pred_class = self.preds.argmax(dim=1)
- self.c2i = {c:i for i,c in enumerate(self.data.classes)}
- self.i2c = {i:c for c,i in self.c2i.items()}
-
- def top_losses(self, sizes:Tuple, k:int=None, largest=True):
- "Reduce flatten loss to give a single loss value for each image"
- losses = self.losses.view(-1, np.prod(sizes)).mean(-1)
- return losses.topk(ifnone(k, len(losses)), largest=largest)
-
- def _interp_show(self, ims:ImageSegment, classes:Collection=None, sz:int=20, cmap='tab20',
- title_suffix:str=None):
- "Show ImageSegment with color mapping labels"
- fig,axes=plt.subplots(1,2,figsize=(sz,sz))
- np_im = to_np(ims.data).copy()
- # tab20 - qualitative colormaps support max of 20 distinc colors
- # if len(classes) > 20 close idxs map to same color
- # image
- if classes is not None:
- class_idxs = [self.c2i[c] for c in classes]
- mask = np.max(np.stack([np_im==i for i in class_idxs]),axis=0)
- np_im = (np_im*mask).astype(np.float)
- np_im[np.where(mask==0)] = np.nan
- im=axes[0].imshow(np_im[0], cmap=cmap)
-
- # labels
- np_im_labels = list(np.unique(np_im[~np.isnan(np_im)]))
- c = len(np_im_labels); n = math.ceil(np.sqrt(c))
- label_im = np.array(np_im_labels + [np.nan]*(n**2-c)).reshape(n,n)
- axes[1].imshow(label_im, cmap=cmap)
- for i,l in enumerate([self.i2c[l] for l in np_im_labels]):
- div,mod=divmod(i,n)
- l = "\n".join(wrap(l,10)) if len(l) > 10 else l
- axes[1].text(mod, div, f"{l}", ha='center', color='white', fontdict={'size':sz})
-
- if title_suffix:
- axes[0].set_title(f"{title_suffix}_imsegment")
- axes[1].set_title(f"{title_suffix}_labels")
-
- def show_xyz(self, i, classes:list=None, sz=10):
- 'show (image, true and pred) from self.ds with color mappings, optionally only plot'
- x,y = self.ds[i]
- self.ds.show_xys([x],[y], figsize=(sz/2,sz/2))
- self._interp_show(ImageSegment(self.y_true[i]), classes, sz=sz, title_suffix='true')
- self._interp_show(ImageSegment(self.pred_class[i][None,:]), classes, sz=sz, title_suffix='pred')
-
- def _generate_confusion(self):
- "Average and Per Image Confusion: intersection of pixels given a true label, true label sums to 1"
- single_img_confusion = []
- mean_confusion = []
- n = self.pred_class.shape[0]
- for c_j in range(self.data.c):
- true_binary = self.y_true.squeeze(1) == c_j
- total_true = true_binary.view(n,-1).sum(dim=1).float()
- for c_i in range(self.data.c):
- pred_binary = self.pred_class == c_i
- total_intersect = (true_binary*pred_binary).view(n,-1).sum(dim=1).float()
- p_given_t = (total_intersect / (total_true))
- p_given_t_mean = p_given_t[~torch.isnan(p_given_t)].mean()
- single_img_confusion.append(p_given_t)
- mean_confusion.append(p_given_t_mean)
- self.single_img_cm = to_np(torch.stack(single_img_confusion).permute(1,0).view(-1, self.data.c, self.data.c))
- self.mean_cm = to_np(torch.tensor(mean_confusion).view(self.data.c, self.data.c))
- return self.mean_cm, self.single_img_cm
-
- def _plot_intersect_cm(self, cm, title="Intersection with Predict given True"):
- "Plot confusion matrices: self.mean_cm or self.single_img_cm generated by `_generate_confusion`"
- from IPython.display import display, HTML
- fig,ax=plt.subplots(1,1,figsize=(10,10))
- im=ax.imshow(cm, cmap="Blues")
- ax.set_xlabel("Predicted")
- ax.set_ylabel("True")
- ax.set_title(f"{title}")
- ax.set_xticks(range(self.data.c))
- ax.set_yticks(range(self.data.c))
- ax.set_xticklabels(self.data.classes, rotation='vertical')
- ax.set_yticklabels(self.data.classes)
- fig.colorbar(im)
-
- df = (pd.DataFrame([self.data.classes, cm.diagonal()], index=['label', 'score'])
- .T.sort_values('score', ascending=False))
- with pd.option_context('display.max_colwidth', -1):
- display(HTML(df.to_html(index=False)))
- return df
-
-
-
-class ObjectDetectionInterpretation(Interpretation):
- "Interpretation methods for classification models."
- def __init__(self, learn:Learner, preds:Tensor, y_true:Tensor, losses:Tensor, ds_type:DatasetType=DatasetType.Valid):
- raise NotImplementedError
- super(ObjectDetectionInterpretation, self).__init__(learn,preds,y_true,losses,ds_type)
-
\ No newline at end of file
diff --git a/spaces/XzJosh/Bekki-Bert-VITS2/bert_gen.py b/spaces/XzJosh/Bekki-Bert-VITS2/bert_gen.py
deleted file mode 100644
index 44814715396ffc3abe84a12c74d66293c356eb4f..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Bekki-Bert-VITS2/bert_gen.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import torch
-from torch.utils.data import DataLoader
-from multiprocessing import Pool
-import commons
-import utils
-from data_utils import TextAudioSpeakerLoader, TextAudioSpeakerCollate
-from tqdm import tqdm
-import warnings
-
-from text import cleaned_text_to_sequence, get_bert
-
-config_path = 'configs/config.json'
-hps = utils.get_hparams_from_file(config_path)
-
-def process_line(line):
- _id, spk, language_str, text, phones, tone, word2ph = line.strip().split("|")
- phone = phones.split(" ")
- tone = [int(i) for i in tone.split(" ")]
- word2ph = [int(i) for i in word2ph.split(" ")]
- w2pho = [i for i in word2ph]
- word2ph = [i for i in word2ph]
- phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-
- if hps.data.add_blank:
- phone = commons.intersperse(phone, 0)
- tone = commons.intersperse(tone, 0)
- language = commons.intersperse(language, 0)
- for i in range(len(word2ph)):
- word2ph[i] = word2ph[i] * 2
- word2ph[0] += 1
- wav_path = f'{_id}'
-
- bert_path = wav_path.replace(".wav", ".bert.pt")
- try:
- bert = torch.load(bert_path)
- assert bert.shape[-1] == len(phone)
- except:
- bert = get_bert(text, word2ph, language_str)
- assert bert.shape[-1] == len(phone)
- torch.save(bert, bert_path)
-
-
-if __name__ == '__main__':
- lines = []
- with open(hps.data.training_files, encoding='utf-8' ) as f:
- lines.extend(f.readlines())
-
- with open(hps.data.validation_files, encoding='utf-8' ) as f:
- lines.extend(f.readlines())
-
- with Pool(processes=12) as pool: #A100 40GB suitable config,if coom,please decrease the processess number.
- for _ in tqdm(pool.imap_unordered(process_line, lines)):
- pass
diff --git a/spaces/XzJosh/Eileen-Bert-VITS2/text/chinese.py b/spaces/XzJosh/Eileen-Bert-VITS2/text/chinese.py
deleted file mode 100644
index 276753880b73de2e8889dcb2101cd98c09e0710b..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Eileen-Bert-VITS2/text/chinese.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import os
-import re
-
-import cn2an
-from pypinyin import lazy_pinyin, Style
-
-from text import symbols
-from text.symbols import punctuation
-from text.tone_sandhi import ToneSandhi
-
-current_file_path = os.path.dirname(__file__)
-pinyin_to_symbol_map = {line.split("\t")[0]: line.strip().split("\t")[1] for line in
- open(os.path.join(current_file_path, 'opencpop-strict.txt')).readlines()}
-
-import jieba.posseg as psg
-
-
-rep_map = {
- '：': ',',
- '；': ',',
- '，': ',',
- '。': '.',
- '！': '!',
- '？': '?',
- '\n': '.',
- "·": ",",
- '、': ",",
- '...': '…',
- '$': '.',
- '“': "'",
- '”': "'",
- '‘': "'",
- '’': "'",
- '（': "'",
- '）': "'",
- '(': "'",
- ')': "'",
- '《': "'",
- '》': "'",
- '【': "'",
- '】': "'",
- '[': "'",
- ']': "'",
- '—': "-",
- '～': "-",
- '~': "-",
- '「': "'",
- '」': "'",
-
-}
-
-tone_modifier = ToneSandhi()
-
-def replace_punctuation(text):
- text = text.replace("嗯", "恩").replace("呣","母")
- pattern = re.compile('|'.join(re.escape(p) for p in rep_map.keys()))
-
- replaced_text = pattern.sub(lambda x: rep_map[x.group()], text)
-
- replaced_text = re.sub(r'[^\u4e00-\u9fa5'+"".join(punctuation)+r']+', '', replaced_text)
-
- return replaced_text
-
-def g2p(text):
- pattern = r'(?<=[{0}])\s*'.format(''.join(punctuation))
- sentences = [i for i in re.split(pattern, text) if i.strip()!='']
- phones, tones, word2ph = _g2p(sentences)
- assert sum(word2ph) == len(phones)
- assert len(word2ph) == len(text) #Sometimes it will crash,you can add a try-catch.
- phones = ['_'] + phones + ["_"]
- tones = [0] + tones + [0]
- word2ph = [1] + word2ph + [1]
- return phones, tones, word2ph
-
-
-def _get_initials_finals(word):
- initials = []
- finals = []
- orig_initials = lazy_pinyin(
- word, neutral_tone_with_five=True, style=Style.INITIALS)
- orig_finals = lazy_pinyin(
- word, neutral_tone_with_five=True, style=Style.FINALS_TONE3)
- for c, v in zip(orig_initials, orig_finals):
- initials.append(c)
- finals.append(v)
- return initials, finals
-
-
-def _g2p(segments):
- phones_list = []
- tones_list = []
- word2ph = []
- for seg in segments:
- pinyins = []
- # Replace all English words in the sentence
- seg = re.sub('[a-zA-Z]+', '', seg)
- seg_cut = psg.lcut(seg)
- initials = []
- finals = []
- seg_cut = tone_modifier.pre_merge_for_modify(seg_cut)
- for word, pos in seg_cut:
- if pos == 'eng':
- continue
- sub_initials, sub_finals = _get_initials_finals(word)
- sub_finals = tone_modifier.modified_tone(word, pos,
- sub_finals)
- initials.append(sub_initials)
- finals.append(sub_finals)
-
- # assert len(sub_initials) == len(sub_finals) == len(word)
- initials = sum(initials, [])
- finals = sum(finals, [])
- #
- for c, v in zip(initials, finals):
- raw_pinyin = c+v
- # NOTE: post process for pypinyin outputs
- # we discriminate i, ii and iii
- if c == v:
- assert c in punctuation
- phone = [c]
- tone = '0'
- word2ph.append(1)
- else:
- v_without_tone = v[:-1]
- tone = v[-1]
-
- pinyin = c+v_without_tone
- assert tone in '12345'
-
- if c:
- # 多音节
- v_rep_map = {
- "uei": 'ui',
- 'iou': 'iu',
- 'uen': 'un',
- }
- if v_without_tone in v_rep_map.keys():
- pinyin = c+v_rep_map[v_without_tone]
- else:
- # 单音节
- pinyin_rep_map = {
- 'ing': 'ying',
- 'i': 'yi',
- 'in': 'yin',
- 'u': 'wu',
- }
- if pinyin in pinyin_rep_map.keys():
- pinyin = pinyin_rep_map[pinyin]
- else:
- single_rep_map = {
- 'v': 'yu',
- 'e': 'e',
- 'i': 'y',
- 'u': 'w',
- }
- if pinyin[0] in single_rep_map.keys():
- pinyin = single_rep_map[pinyin[0]]+pinyin[1:]
-
- assert pinyin in pinyin_to_symbol_map.keys(), (pinyin, seg, raw_pinyin)
- phone = pinyin_to_symbol_map[pinyin].split(' ')
- word2ph.append(len(phone))
-
- phones_list += phone
- tones_list += [int(tone)] * len(phone)
- return phones_list, tones_list, word2ph
-
-
-
-def text_normalize(text):
- numbers = re.findall(r'\d+(?:\.?\d+)?', text)
- for number in numbers:
- text = text.replace(number, cn2an.an2cn(number), 1)
- text = replace_punctuation(text)
- return text
-
-def get_bert_feature(text, word2ph):
- from text import chinese_bert
- return chinese_bert.get_bert_feature(text, word2ph)
-
-if __name__ == '__main__':
- from text.chinese_bert import get_bert_feature
- text = "啊！但是《原神》是由,米哈\游自主， [研发]的一款全.新开放世界.冒险游戏"
- text = text_normalize(text)
- print(text)
- phones, tones, word2ph = g2p(text)
- bert = get_bert_feature(text, word2ph)
-
- print(phones, tones, word2ph, bert.shape)
-
-
-# # 示例用法
-# text = "这是一个示例文本：,你好！这是一个测试...."
-# print(g2p_paddle(text)) # 输出: 这是一个示例文本你好这是一个测试
diff --git a/spaces/YONG627/456123/app.py b/spaces/YONG627/456123/app.py
deleted file mode 100644
index 52b29b1d24045705feca9036ba9f7e585f7bf114..0000000000000000000000000000000000000000
--- a/spaces/YONG627/456123/app.py
+++ /dev/null
@@ -1,32 +0,0 @@
-import torch
-import gradio as gr
-import cv2
-model = torch.hub.load("yolov5-code-main/", "custom", path="yolov5-code-main/best.pt", source="local")
-
-title = "✨基于YOLOV5的消化道多病变检测平台✨"
-
-desc = "(●'◡'●)"
-base_conf, base_iou = 0.25, 0.60
-
-
-def det_image(img, conf_最小置信度, iou_最大置信度):
- model.conf = conf_最小置信度
- model.iou = iou_最大置信度
-
- return model(img).render()[0]
-
-
-gr.Interface(inputs=["image", gr.Slider(minimum=0, maximum=1, value=base_conf), gr.Slider(minimum=0, maximum=1, value=base_iou)],
- outputs=["image"],
- fn=det_image,
- title=title,
- description=desc,
- article = "(●ˇ∀ˇ●)",
- live=True,
- examples=[["yolov5-code-main/976.jpg", base_conf, base_iou],["yolov5-code-main/967.jpg", base_conf, base_iou]]).launch(auth=("admin", "1234"),share=False)
-
-
-
-
-
-
diff --git a/spaces/YONG627/456123/yolov5-code-main/utils/segment/plots.py b/spaces/YONG627/456123/yolov5-code-main/utils/segment/plots.py
deleted file mode 100644
index 3ba097624fcdcc72139b5b574e419aa927598afa..0000000000000000000000000000000000000000
--- a/spaces/YONG627/456123/yolov5-code-main/utils/segment/plots.py
+++ /dev/null
@@ -1,143 +0,0 @@
-import contextlib
-import math
-from pathlib import Path
-
-import cv2
-import matplotlib.pyplot as plt
-import numpy as np
-import pandas as pd
-import torch
-
-from .. import threaded
-from ..general import xywh2xyxy
-from ..plots import Annotator, colors
-
-
-@threaded
-def plot_images_and_masks(images, targets, masks, paths=None, fname='images.jpg', names=None):
- # Plot image grid with labels
- if isinstance(images, torch.Tensor):
- images = images.cpu().float().numpy()
- if isinstance(targets, torch.Tensor):
- targets = targets.cpu().numpy()
- if isinstance(masks, torch.Tensor):
- masks = masks.cpu().numpy().astype(int)
-
- max_size = 1920 # max image size
- max_subplots = 16 # max image subplots, i.e. 4x4
- bs, _, h, w = images.shape # batch size, _, height, width
- bs = min(bs, max_subplots) # limit plot images
- ns = np.ceil(bs ** 0.5) # number of subplots (square)
- if np.max(images[0]) <= 1:
- images *= 255 # de-normalise (optional)
-
- # Build Image
- mosaic = np.full((int(ns * h), int(ns * w), 3), 255, dtype=np.uint8) # init
- for i, im in enumerate(images):
- if i == max_subplots: # if last batch has fewer images than we expect
- break
- x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
- im = im.transpose(1, 2, 0)
- mosaic[y:y + h, x:x + w, :] = im
-
- # Resize (optional)
- scale = max_size / ns / max(h, w)
- if scale < 1:
- h = math.ceil(scale * h)
- w = math.ceil(scale * w)
- mosaic = cv2.resize(mosaic, tuple(int(x * ns) for x in (w, h)))
-
- # Annotate
- fs = int((h + w) * ns * 0.01) # font size
- annotator = Annotator(mosaic, line_width=round(fs / 10), font_size=fs, pil=True, example=names)
- for i in range(i + 1):
- x, y = int(w * (i // ns)), int(h * (i % ns)) # block origin
- annotator.rectangle([x, y, x + w, y + h], None, (255, 255, 255), width=2) # borders
- if paths:
- annotator.text((x + 5, y + 5 + h), text=Path(paths[i]).name[:40], txt_color=(220, 220, 220)) # filenames
- if len(targets) > 0:
- idx = targets[:, 0] == i
- ti = targets[idx] # image targets
-
- boxes = xywh2xyxy(ti[:, 2:6]).T
- classes = ti[:, 1].astype('int')
- labels = ti.shape[1] == 6 # labels if no conf column
- conf = None if labels else ti[:, 6] # check for confidence presence (label vs pred)
-
- if boxes.shape[1]:
- if boxes.max() <= 1.01: # if normalized with tolerance 0.01
- boxes[[0, 2]] *= w # scale to pixels
- boxes[[1, 3]] *= h
- elif scale < 1: # absolute coords need scale if image scales
- boxes *= scale
- boxes[[0, 2]] += x
- boxes[[1, 3]] += y
- for j, box in enumerate(boxes.T.tolist()):
- cls = classes[j]
- color = colors(cls)
- cls = names[cls] if names else cls
- if labels or conf[j] > 0.25: # 0.25 conf thresh
- label = f'{cls}' if labels else f'{cls} {conf[j]:.1f}'
- annotator.box_label(box, label, color=color)
-
- # Plot masks
- if len(masks):
- if masks.max() > 1.0: # mean that masks are overlap
- image_masks = masks[[i]] # (1, 640, 640)
- nl = len(ti)
- index = np.arange(nl).reshape(nl, 1, 1) + 1
- image_masks = np.repeat(image_masks, nl, axis=0)
- image_masks = np.where(image_masks == index, 1.0, 0.0)
- else:
- image_masks = masks[idx]
-
- im = np.asarray(annotator.im).copy()
- for j, box in enumerate(boxes.T.tolist()):
- if labels or conf[j] > 0.25: # 0.25 conf thresh
- color = colors(classes[j])
- mh, mw = image_masks[j].shape
- if mh != h or mw != w:
- mask = image_masks[j].astype(np.uint8)
- mask = cv2.resize(mask, (w, h))
- mask = mask.astype(bool)
- else:
- mask = image_masks[j].astype(bool)
- with contextlib.suppress(Exception):
- im[y:y + h, x:x + w, :][mask] = im[y:y + h, x:x + w, :][mask] * 0.4 + np.array(color) * 0.6
- annotator.fromarray(im)
- annotator.im.save(fname) # save
-
-
-def plot_results_with_masks(file='path/to/results.csv', dir='', best=True):
- # Plot training results.csv. Usage: from utils.plots import *; plot_results('path/to/results.csv')
- save_dir = Path(file).parent if file else Path(dir)
- fig, ax = plt.subplots(2, 8, figsize=(18, 6), tight_layout=True)
- ax = ax.ravel()
- files = list(save_dir.glob('results*.csv'))
- assert len(files), f'No results.csv files found in {save_dir.resolve()}, nothing to plot.'
- for f in files:
- try:
- data = pd.read_csv(f)
- index = np.argmax(0.9 * data.values[:, 8] + 0.1 * data.values[:, 7] + 0.9 * data.values[:, 12] +
- 0.1 * data.values[:, 11])
- s = [x.strip() for x in data.columns]
- x = data.values[:, 0]
- for i, j in enumerate([1, 2, 3, 4, 5, 6, 9, 10, 13, 14, 15, 16, 7, 8, 11, 12]):
- y = data.values[:, j]
- # y[y == 0] = np.nan # don't show zero values
- ax[i].plot(x, y, marker='.', label=f.stem, linewidth=2, markersize=2)
- if best:
- # best
- ax[i].scatter(index, y[index], color='r', label=f'best:{index}', marker='*', linewidth=3)
- ax[i].set_title(s[j] + f'\n{round(y[index], 5)}')
- else:
- # last
- ax[i].scatter(x[-1], y[-1], color='r', label='last', marker='*', linewidth=3)
- ax[i].set_title(s[j] + f'\n{round(y[-1], 5)}')
- # if j in [8, 9, 10]: # share train and val loss y axes
- # ax[i].get_shared_y_axes().join(ax[i], ax[i - 5])
- except Exception as e:
- print(f'Warning: Plotting error for {f}: {e}')
- ax[1].legend()
- fig.savefig(save_dir / 'results.png', dpi=200)
- plt.close()
diff --git a/spaces/YlcldKlns/bing/postcss.config.js b/spaces/YlcldKlns/bing/postcss.config.js
deleted file mode 100644
index 33ad091d26d8a9dc95ebdf616e217d985ec215b8..0000000000000000000000000000000000000000
--- a/spaces/YlcldKlns/bing/postcss.config.js
+++ /dev/null
@@ -1,6 +0,0 @@
-module.exports = {
- plugins: {
- tailwindcss: {},
- autoprefixer: {},
- },
-}
diff --git a/spaces/Yuliang/ECON/lib/common/render.py b/spaces/Yuliang/ECON/lib/common/render.py
deleted file mode 100644
index b598ed2c3c95b3b6514402178157cc091baa6529..0000000000000000000000000000000000000000
--- a/spaces/Yuliang/ECON/lib/common/render.py
+++ /dev/null
@@ -1,366 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
-# holder of all proprietary rights on this computer program.
-# You can only use this computer program if you have closed
-# a license agreement with MPG or you get the right to use the computer
-# program from someone who is authorized to grant you that right.
-# Any use of the computer program without a valid license is prohibited and
-# liable to prosecution.
-#
-# Copyright©2019 Max-Planck-Gesellschaft zur Förderung
-# der Wissenschaften e.V. (MPG). acting on behalf of its Max Planck Institute
-# for Intelligent Systems. All rights reserved.
-#
-# Contact: ps-license@tuebingen.mpg.de
-
-import math
-import os
-
-import cv2
-import numpy as np
-import torch
-from PIL import ImageColor
-from pytorch3d.renderer import (
- AlphaCompositor,
- BlendParams,
- FoVOrthographicCameras,
- MeshRasterizer,
- MeshRenderer,
- PointsRasterizationSettings,
- PointsRasterizer,
- PointsRenderer,
- RasterizationSettings,
- SoftSilhouetteShader,
- TexturesVertex,
- blending,
- look_at_view_transform,
-)
-from pytorch3d.renderer.mesh import TexturesVertex
-from pytorch3d.structures import Meshes
-import torch.nn.functional as F
-from termcolor import colored
-from tqdm import tqdm
-
-import lib.common.render_utils as util
-from lib.common.imutils import blend_rgb_norm
-from lib.dataset.mesh_util import get_visibility
-
-
-def image2vid(images, vid_path):
-
- os.makedirs(os.path.dirname(vid_path), exist_ok=True)
-
- w, h = images[0].size
- videodims = (w, h)
- fourcc = cv2.VideoWriter_fourcc(*"XVID")
- video = cv2.VideoWriter(vid_path, fourcc, len(images) / 5.0, videodims)
- for image in images:
- video.write(cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR))
- video.release()
-
-
-def query_color(verts, faces, image, device, paint_normal=True):
- """query colors from points and image
-
- Args:
- verts ([B, 3]): [query verts]
- faces ([M, 3]): [query faces]
- image ([B, 3, H, W]): [full image]
-
- Returns:
- [np.float]: [return colors]
- """
-
- verts = verts.float().to(device)
- faces = faces.long().to(device)
-
- (xy, z) = verts.split([2, 1], dim=1)
- visibility = get_visibility(xy, z, faces[:, [0, 2, 1]]).flatten()
- uv = xy.unsqueeze(0).unsqueeze(2) # [B, N, 2]
- uv = uv * torch.tensor([1.0, -1.0]).type_as(uv)
- colors = ((
- torch.nn.functional.grid_sample(image, uv, align_corners=True)[0, :, :, 0].permute(1, 0) +
- 1.0
- ) * 0.5 * 255.0)
- if paint_normal:
- colors[visibility == 0.0] = ((
- Meshes(verts.unsqueeze(0), faces.unsqueeze(0)).verts_normals_padded().squeeze(0) + 1.0
- ) * 0.5 * 255.0)[visibility == 0.0]
- else:
- colors[visibility == 0.0] = torch.tensor([0.0, 0.0, 0.0]).to(device)
-
- return colors.detach().cpu()
-
-
-class cleanShader(torch.nn.Module):
- def __init__(self, blend_params=None):
- super().__init__()
- self.blend_params = blend_params if blend_params is not None else BlendParams()
-
- def forward(self, fragments, meshes, **kwargs):
-
- # get renderer output
- blend_params = kwargs.get("blend_params", self.blend_params)
- texels = meshes.sample_textures(fragments)
- images = blending.softmax_rgb_blend(texels, fragments, blend_params, znear=-256, zfar=256)
-
- return images
-
-
-class Render:
- def __init__(self, size=512, device=torch.device("cuda:0")):
- self.device = device
- self.size = size
-
- # camera setting
- self.dis = 100.0
- self.scale = 100.0
- self.mesh_y_center = 0.0
-
- # speed control
- self.fps = 30
- self.step = 3
-
- self.cam_pos = {
- "front":
- torch.tensor([
- (0, self.mesh_y_center, self.dis),
- (0, self.mesh_y_center, -self.dis),
- ]), "frontback":
- torch.tensor([
- (0, self.mesh_y_center, self.dis),
- (0, self.mesh_y_center, -self.dis),
- ]), "four":
- torch.tensor([
- (0, self.mesh_y_center, self.dis),
- (self.dis, self.mesh_y_center, 0),
- (0, self.mesh_y_center, -self.dis),
- (-self.dis, self.mesh_y_center, 0),
- ]), "around":
- torch.tensor([(
- 100.0 * math.cos(np.pi / 180 * angle), self.mesh_y_center,
- 100.0 * math.sin(np.pi / 180 * angle)
- ) for angle in range(0, 360, self.step)])
- }
-
- self.type = "color"
-
- self.mesh = None
- self.deform_mesh = None
- self.pcd = None
- self.renderer = None
- self.meshRas = None
-
- self.uv_rasterizer = util.Pytorch3dRasterizer(self.size)
-
- def get_camera_batch(self, type="four", idx=None):
-
- if idx is None:
- idx = np.arange(len(self.cam_pos[type]))
-
- R, T = look_at_view_transform(
- eye=self.cam_pos[type][idx],
- at=((0, self.mesh_y_center, 0), ),
- up=((0, 1, 0), ),
- )
-
- cameras = FoVOrthographicCameras(
- device=self.device,
- R=R,
- T=T,
- znear=100.0,
- zfar=-100.0,
- max_y=100.0,
- min_y=-100.0,
- max_x=100.0,
- min_x=-100.0,
- scale_xyz=(self.scale * np.ones(3), ) * len(R),
- )
-
- return cameras
-
- def init_renderer(self, camera, type="mesh", bg="gray"):
-
- blendparam = BlendParams(1e-4, 1e-8, np.array(ImageColor.getrgb(bg)) / 255.0)
-
- if ("mesh" in type) or ("depth" in type) or ("rgb" in type):
-
- # rasterizer
- self.raster_settings_mesh = RasterizationSettings(
- image_size=self.size,
- blur_radius=np.log(1.0 / 1e-4) * 1e-7,
- bin_size=-1,
- faces_per_pixel=30,
- )
- self.meshRas = MeshRasterizer(cameras=camera, raster_settings=self.raster_settings_mesh)
-
- self.renderer = MeshRenderer(
- rasterizer=self.meshRas,
- shader=cleanShader(blend_params=blendparam),
- )
-
- elif type == "mask":
-
- self.raster_settings_silhouette = RasterizationSettings(
- image_size=self.size,
- blur_radius=np.log(1.0 / 1e-4 - 1.0) * 5e-5,
- faces_per_pixel=50,
- bin_size=-1,
- cull_backfaces=True,
- )
-
- self.silhouetteRas = MeshRasterizer(
- cameras=camera, raster_settings=self.raster_settings_silhouette
- )
- self.renderer = MeshRenderer(
- rasterizer=self.silhouetteRas, shader=SoftSilhouetteShader()
- )
-
- elif type == "pointcloud":
- self.raster_settings_pcd = PointsRasterizationSettings(
- image_size=self.size, radius=0.006, points_per_pixel=10
- )
-
- self.pcdRas = PointsRasterizer(cameras=camera, raster_settings=self.raster_settings_pcd)
- self.renderer = PointsRenderer(
- rasterizer=self.pcdRas,
- compositor=AlphaCompositor(background_color=(0, 0, 0)),
- )
-
- def load_meshes(self, verts, faces):
- """load mesh into the pytorch3d renderer
-
- Args:
- verts ([N,3] / [B,N,3]): array or tensor
- faces ([N,3]/ [B,N,3]): array or tensor
- """
-
- if isinstance(verts, list):
- V_lst = []
- F_lst = []
- for V, F in zip(verts, faces):
- if not torch.is_tensor(V):
- V_lst.append(torch.tensor(V).float().to(self.device))
- F_lst.append(torch.tensor(F).long().to(self.device))
- else:
- V_lst.append(V.float().to(self.device))
- F_lst.append(F.long().to(self.device))
- self.meshes = Meshes(V_lst, F_lst).to(self.device)
- else:
- # array or tensor
- if not torch.is_tensor(verts):
- verts = torch.tensor(verts)
- faces = torch.tensor(faces)
- if verts.ndimension() == 2:
- verts = verts.float().unsqueeze(0).to(self.device)
- faces = faces.long().unsqueeze(0).to(self.device)
- if verts.shape[0] != faces.shape[0]:
- faces = faces.repeat(len(verts), 1, 1).to(self.device)
- self.meshes = Meshes(verts, faces).to(self.device)
-
- # texture only support single mesh
- if len(self.meshes) == 1:
- self.meshes.textures = TexturesVertex(
- verts_features=(self.meshes.verts_normals_padded() + 1.0) * 0.5
- )
-
- def get_image(self, cam_type="frontback", type="rgb", bg="gray"):
-
- self.init_renderer(self.get_camera_batch(cam_type), type, bg)
-
- img_lst = []
-
- for mesh_id in range(len(self.meshes)):
-
- current_mesh = self.meshes[mesh_id]
- current_mesh.textures = TexturesVertex(
- verts_features=(current_mesh.verts_normals_padded() + 1.0) * 0.5
- )
-
- if type == "depth":
- fragments = self.meshRas(current_mesh.extend(len(self.cam_pos[cam_type])))
- images = fragments.zbuf[..., 0]
-
- elif type == "rgb":
- images = self.renderer(current_mesh.extend(len(self.cam_pos[cam_type])))
- images = (images[:, :, :, :3].permute(0, 3, 1, 2) - 0.5) * 2.0
-
- elif type == "mask":
- images = self.renderer(current_mesh.extend(len(self.cam_pos[cam_type])))[:, :, :, 3]
- else:
- print(f"unknown {type}")
-
- if cam_type == 'frontback':
- images[1] = torch.flip(images[1], dims=(-1, ))
-
- # images [N_render, 3, res, res]
- img_lst.append(images.unsqueeze(1))
-
- # meshes [N_render, N_mesh, 3, res, res]
- meshes = torch.cat(img_lst, dim=1)
-
- return list(meshes)
-
- def get_rendered_video_multi(self, data, save_path):
-
- height, width = data["img_raw"].shape[2:]
-
- width = int(width / (height / 256.0))
- height = int(256)
-
- fourcc = cv2.VideoWriter_fourcc(*"mp4v")
- video = cv2.VideoWriter(
- save_path,
- fourcc,
- self.fps,
- (width * 3, height),
- )
-
- pbar = tqdm(range(len(self.meshes)))
- pbar.set_description(colored(f"Normal Rendering {os.path.basename(save_path)}...", "blue"))
-
- mesh_renders = [] #[(N_cam, 3, res, res)*N_mesh]
-
- # render all the normals
- for mesh_id in pbar:
-
- current_mesh = self.meshes[mesh_id]
- current_mesh.textures = TexturesVertex(
- verts_features=(current_mesh.verts_normals_padded() + 1.0) * 0.5
- )
-
- norm_lst = []
-
- for batch_cams_idx in np.array_split(np.arange(len(self.cam_pos["around"])), 12):
-
- batch_cams = self.get_camera_batch(type='around', idx=batch_cams_idx)
-
- self.init_renderer(batch_cams, "mesh", "gray")
-
- norm_lst.append(
- self.renderer(current_mesh.extend(len(batch_cams_idx))
- )[..., :3].permute(0, 3, 1, 2)
- )
- mesh_renders.append(torch.cat(norm_lst).detach().cpu())
-
- # generate video frame by frame
- pbar = tqdm(range(len(self.cam_pos["around"])))
- pbar.set_description(colored(f"Video Exporting {os.path.basename(save_path)}...", "blue"))
-
- for cam_id in pbar:
- img_raw = data["img_raw"]
- num_obj = len(mesh_renders) // 2
- img_smpl = blend_rgb_norm((torch.stack(mesh_renders)[:num_obj, cam_id] - 0.5) * 2.0,
- data)
- img_cloth = blend_rgb_norm((torch.stack(mesh_renders)[num_obj:, cam_id] - 0.5) * 2.0,
- data)
- final_img = torch.cat([img_raw, img_smpl, img_cloth], dim=-1)
-
- final_img_rescale = F.interpolate(
- final_img, size=(height, width*3), mode="bilinear", align_corners=False
- ).squeeze(0).permute(1, 2, 0).numpy().astype(np.uint8)
-
- video.write(final_img_rescale[:, :, ::-1])
-
- video.release()
diff --git a/spaces/ZX9966/LLM-Research/index.html b/spaces/ZX9966/LLM-Research/index.html
deleted file mode 100644
index cc89c599a0af5eb0cef555e129e66817cf8ab153..0000000000000000000000000000000000000000
--- a/spaces/ZX9966/LLM-Research/index.html
+++ /dev/null
@@ -1,18 +0,0 @@
-
-
-
-
-
- BlueWhaleX LLM Research Space
-
-
-
- //checkpoint-10000steps.pkl)
-
-# decoding related setting
-checkpoint="" # checkpoint path to be used for decoding
- # if not provided, the latest one will be used
- # (e.g. //checkpoint-400000steps.pkl)
-
-# shellcheck disable=SC1091
-. utils/parse_options.sh || exit 1;
-
-train_set="train_nodev" # name of training data directory
-dev_set="dev" # name of development data direcotry
-eval_set="eval" # name of evaluation data direcotry
-
-set -euo pipefail
-
-if [ "${stage}" -le -1 ] && [ "${stop_stage}" -ge -1 ]; then
- echo "Stage -1: Data download"
- local/data_download.sh "${download_dir}"
-fi
-
-if [ "${stage}" -le 0 ] && [ "${stop_stage}" -ge 0 ]; then
- echo "Stage 0: Data preparation"
- local/data_prep.sh \
- --train_set "${train_set}" \
- --dev_set "${dev_set}" \
- --eval_set "${eval_set}" \
- --shuffle true \
- "${download_dir}/sc_all" data
-fi
-
-stats_ext=$(grep -q "hdf5" <(yq ".format" "${conf}") && echo "h5" || echo "npy")
-if [ "${stage}" -le 1 ] && [ "${stop_stage}" -ge 1 ]; then
- echo "Stage 1: Feature extraction"
- # extract raw features
- pids=()
- for name in "${train_set}" "${dev_set}" "${eval_set}"; do
- (
- [ ! -e "${dumpdir}/${name}/raw" ] && mkdir -p "${dumpdir}/${name}/raw"
- echo "Feature extraction start. See the progress via ${dumpdir}/${name}/raw/preprocessing.*.log."
- utils/make_subset_data.sh "data/${name}" "${n_jobs}" "${dumpdir}/${name}/raw"
- ${train_cmd} JOB=1:${n_jobs} "${dumpdir}/${name}/raw/preprocessing.JOB.log" \
- parallel-wavegan-preprocess \
- --config "${conf}" \
- --scp "${dumpdir}/${name}/raw/wav.JOB.scp" \
- --dumpdir "${dumpdir}/${name}/raw/dump.JOB" \
- --verbose "${verbose}"
- echo "Successfully finished feature extraction of ${name} set."
- ) &
- pids+=($!)
- done
- i=0; for pid in "${pids[@]}"; do wait "${pid}" || ((++i)); done
- [ "${i}" -gt 0 ] && echo "$0: ${i} background jobs are failed." && exit 1;
- echo "Successfully finished feature extraction."
-
- # calculate statistics for normalization
- echo "Statistics computation start. See the progress via ${dumpdir}/${train_set}/compute_statistics.log."
- ${train_cmd} "${dumpdir}/${train_set}/compute_statistics.log" \
- parallel-wavegan-compute-statistics \
- --config "${conf}" \
- --rootdir "${dumpdir}/${train_set}/raw" \
- --dumpdir "${dumpdir}/${train_set}" \
- --verbose "${verbose}"
- echo "Successfully finished calculation of statistics."
-
- # normalize and dump them
- pids=()
- for name in "${train_set}" "${dev_set}" "${eval_set}"; do
- (
- [ ! -e "${dumpdir}/${name}/norm" ] && mkdir -p "${dumpdir}/${name}/norm"
- echo "Nomalization start. See the progress via ${dumpdir}/${name}/norm/normalize.*.log."
- ${train_cmd} JOB=1:${n_jobs} "${dumpdir}/${name}/norm/normalize.JOB.log" \
- parallel-wavegan-normalize \
- --config "${conf}" \
- --stats "${dumpdir}/${train_set}/stats.${stats_ext}" \
- --rootdir "${dumpdir}/${name}/raw/dump.JOB" \
- --dumpdir "${dumpdir}/${name}/norm/dump.JOB" \
- --verbose "${verbose}"
- echo "Successfully finished normalization of ${name} set."
- ) &
- pids+=($!)
- done
- i=0; for pid in "${pids[@]}"; do wait "${pid}" || ((++i)); done
- [ "${i}" -gt 0 ] && echo "$0: ${i} background jobs are failed." && exit 1;
- echo "Successfully finished normalization."
-fi
-
-if [ -z "${tag}" ]; then
- expdir="exp/${train_set}_speech_commands_$(basename "${conf}" .yaml)"
-else
- expdir="exp/${train_set}_speech_commands_${tag}"
-fi
-if [ "${stage}" -le 2 ] && [ "${stop_stage}" -ge 2 ]; then
- echo "Stage 2: Network training"
- [ ! -e "${expdir}" ] && mkdir -p "${expdir}"
- cp "${dumpdir}/${train_set}/stats.${stats_ext}" "${expdir}"
- if [ "${n_gpus}" -gt 1 ]; then
- train="python -m parallel_wavegan.distributed.launch --nproc_per_node ${n_gpus} -c parallel-wavegan-train"
- else
- train="parallel-wavegan-train"
- fi
- echo "Training start. See the progress via ${expdir}/train.log."
- ${cuda_cmd} --gpu "${n_gpus}" "${expdir}/train.log" \
- ${train} \
- --config "${conf}" \
- --train-dumpdir "${dumpdir}/${train_set}/norm" \
- --dev-dumpdir "${dumpdir}/${dev_set}/norm" \
- --outdir "${expdir}" \
- --resume "${resume}" \
- --verbose "${verbose}"
- echo "Successfully finished training."
-fi
-
-if [ "${stage}" -le 3 ] && [ "${stop_stage}" -ge 3 ]; then
- echo "Stage 3: Network decoding"
- # shellcheck disable=SC2012
- [ -z "${checkpoint}" ] && checkpoint="$(ls -dt "${expdir}"/*.pkl | head -1 || true)"
- outdir="${expdir}/wav/$(basename "${checkpoint}" .pkl)"
- pids=()
- for name in "${dev_set}" "${eval_set}"; do
- (
- [ ! -e "${outdir}/${name}" ] && mkdir -p "${outdir}/${name}"
- [ "${n_gpus}" -gt 1 ] && n_gpus=1
- echo "Decoding start. See the progress via ${outdir}/${name}/decode.log."
- ${cuda_cmd} --gpu "${n_gpus}" "${outdir}/${name}/decode.log" \
- parallel-wavegan-decode \
- --dumpdir "${dumpdir}/${name}/norm" \
- --checkpoint "${checkpoint}" \
- --outdir "${outdir}/${name}" \
- --verbose "${verbose}"
- echo "Successfully finished decoding of ${name} set."
- ) &
- pids+=($!)
- done
- i=0; for pid in "${pids[@]}"; do wait "${pid}" || ((++i)); done
- [ "${i}" -gt 0 ] && echo "$0: ${i} background jobs are failed." && exit 1;
- echo "Successfully finished decoding."
-fi
-echo "Finished."
diff --git a/spaces/akhaliq/neural-waveshaping-synthesis/neural_waveshaping_synthesis/data/utils/create_dataset.py b/spaces/akhaliq/neural-waveshaping-synthesis/neural_waveshaping_synthesis/data/utils/create_dataset.py
deleted file mode 100644
index 64cdf8c2b838aaa70435317e6c7e6dde1da486a4..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/neural-waveshaping-synthesis/neural_waveshaping_synthesis/data/utils/create_dataset.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import os
-import shutil
-from typing import Sequence
-
-import gin
-import numpy as np
-from sklearn.model_selection import train_test_split
-
-from .preprocess_audio import preprocess_audio
-from ...utils import seed_all
-
-
-def create_directory(path):
- if not os.path.isdir(path):
- try:
- os.mkdir(path)
- except OSError:
- print("Failed to create directory %s" % path)
- else:
- print("Created directory %s..." % path)
- else:
- print("Directory %s already exists. Skipping..." % path)
-
-
-def create_directories(target_root, names):
- create_directory(target_root)
- for name in names:
- create_directory(os.path.join(target_root, name))
-
-
-def make_splits(
- audio_list: Sequence[str],
- control_list: Sequence[str],
- splits: Sequence[str],
- split_proportions: Sequence[float],
-):
- assert len(splits) == len(
- split_proportions
- ), "Length of splits and split_proportions must be equal"
-
- train_size = split_proportions[0] / np.sum(split_proportions)
- audio_0, audio_1, control_0, control_1 = train_test_split(
- audio_list, control_list, train_size=train_size
- )
- if len(splits) == 2:
- return {
- splits[0]: {
- "audio": audio_0,
- "control": control_0,
- },
- splits[1]: {
- "audio": audio_1,
- "control": control_1,
- },
- }
- elif len(splits) > 2:
- return {
- splits[0]: {
- "audio": audio_0,
- "control": control_0,
- },
- **make_splits(audio_1, control_1, splits[1:], split_proportions[1:]),
- }
- elif len(splits) == 1:
- return {
- splits[0]: {
- "audio": audio_list,
- "control": control_list,
- }
- }
-
-
-def lazy_create_dataset(
- files: Sequence[str],
- output_directory: str,
- splits: Sequence[str],
- split_proportions: Sequence[float],
-):
- audio_files = []
- control_files = []
- audio_max = 1e-5
- means = []
- stds = []
- lengths = []
- control_mean = 0
- control_std = 1
-
- for i, (all_audio, all_f0, all_confidence, all_loudness, all_mfcc) in enumerate(
- preprocess_audio(files)
- ):
- file = os.path.split(files[i])[-1].replace(".wav", "")
- for j, (audio, f0, confidence, loudness, mfcc) in enumerate(
- zip(all_audio, all_f0, all_confidence, all_loudness, all_mfcc)
- ):
- audio_file_name = "audio_%s_%d.npy" % (file, j)
- control_file_name = "control_%s_%d.npy" % (file, j)
-
- max_sample = np.abs(audio).max()
- if max_sample > audio_max:
- audio_max = max_sample
-
- np.save(
- os.path.join(output_directory, "temp", "audio", audio_file_name),
- audio,
- )
- control = np.stack((f0, loudness, confidence), axis=0)
- control = np.concatenate((control, mfcc), axis=0)
- np.save(
- os.path.join(output_directory, "temp", "control", control_file_name),
- control,
- )
-
- audio_files.append(audio_file_name)
- control_files.append(control_file_name)
-
- means.append(control.mean(axis=-1))
- stds.append(control.std(axis=-1))
- lengths.append(control.shape[-1])
-
- if len(audio_files) == 0:
- print("No datapoints to split. Skipping...")
- return
-
- data_mean = np.mean(np.stack(means, axis=-1), axis=-1)[:, np.newaxis]
- lengths = np.stack(lengths)[np.newaxis, :]
- stds = np.stack(stds, axis=-1)
- data_std = np.sqrt(np.sum(lengths * stds ** 2, axis=-1) / np.sum(lengths))[
- :, np.newaxis
- ]
-
- print("Saving dataset stats...")
- np.save(os.path.join(output_directory, "data_mean.npy"), data_mean)
- np.save(os.path.join(output_directory, "data_std.npy"), data_std)
-
- splits = make_splits(audio_files, control_files, splits, split_proportions)
- for split in splits:
- for audio_file in splits[split]["audio"]:
- audio = np.load(os.path.join(output_directory, "temp", "audio", audio_file))
- audio = audio / audio_max
- np.save(os.path.join(output_directory, split, "audio", audio_file), audio)
- for control_file in splits[split]["control"]:
- control = np.load(
- os.path.join(output_directory, "temp", "control", control_file)
- )
- control = (control - data_mean) / data_std
- np.save(
- os.path.join(output_directory, split, "control", control_file), control
- )
-
-
-@gin.configurable
-def create_dataset(
- files: Sequence[str],
- output_directory: str,
- splits: Sequence[str] = ("train", "val", "test"),
- split_proportions: Sequence[float] = (0.8, 0.1, 0.1),
- lazy: bool = True,
-):
- create_directories(output_directory, (*splits, "temp"))
- for split in (*splits, "temp"):
- create_directories(os.path.join(output_directory, split), ("audio", "control"))
-
- if lazy:
- lazy_create_dataset(files, output_directory, splits, split_proportions)
-
- shutil.rmtree(os.path.join(output_directory, "temp"))
\ No newline at end of file
diff --git a/spaces/aliceoq/vozes-da-loirinha/lib/uvr5_pack/lib_v5/layers_123812KB .py b/spaces/aliceoq/vozes-da-loirinha/lib/uvr5_pack/lib_v5/layers_123812KB .py
deleted file mode 100644
index b82f06bb4993cd63f076e68d7e24185269b1bc42..0000000000000000000000000000000000000000
--- a/spaces/aliceoq/vozes-da-loirinha/lib/uvr5_pack/lib_v5/layers_123812KB .py
+++ /dev/null
@@ -1,118 +0,0 @@
-import torch
-from torch import nn
-import torch.nn.functional as F
-
-from . import spec_utils
-
-
-class Conv2DBNActiv(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
- super(Conv2DBNActiv, self).__init__()
- self.conv = nn.Sequential(
- nn.Conv2d(
- nin,
- nout,
- kernel_size=ksize,
- stride=stride,
- padding=pad,
- dilation=dilation,
- bias=False,
- ),
- nn.BatchNorm2d(nout),
- activ(),
- )
-
- def __call__(self, x):
- return self.conv(x)
-
-
-class SeperableConv2DBNActiv(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, dilation=1, activ=nn.ReLU):
- super(SeperableConv2DBNActiv, self).__init__()
- self.conv = nn.Sequential(
- nn.Conv2d(
- nin,
- nin,
- kernel_size=ksize,
- stride=stride,
- padding=pad,
- dilation=dilation,
- groups=nin,
- bias=False,
- ),
- nn.Conv2d(nin, nout, kernel_size=1, bias=False),
- nn.BatchNorm2d(nout),
- activ(),
- )
-
- def __call__(self, x):
- return self.conv(x)
-
-
-class Encoder(nn.Module):
- def __init__(self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.LeakyReLU):
- super(Encoder, self).__init__()
- self.conv1 = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
- self.conv2 = Conv2DBNActiv(nout, nout, ksize, stride, pad, activ=activ)
-
- def __call__(self, x):
- skip = self.conv1(x)
- h = self.conv2(skip)
-
- return h, skip
-
-
-class Decoder(nn.Module):
- def __init__(
- self, nin, nout, ksize=3, stride=1, pad=1, activ=nn.ReLU, dropout=False
- ):
- super(Decoder, self).__init__()
- self.conv = Conv2DBNActiv(nin, nout, ksize, 1, pad, activ=activ)
- self.dropout = nn.Dropout2d(0.1) if dropout else None
-
- def __call__(self, x, skip=None):
- x = F.interpolate(x, scale_factor=2, mode="bilinear", align_corners=True)
- if skip is not None:
- skip = spec_utils.crop_center(skip, x)
- x = torch.cat([x, skip], dim=1)
- h = self.conv(x)
-
- if self.dropout is not None:
- h = self.dropout(h)
-
- return h
-
-
-class ASPPModule(nn.Module):
- def __init__(self, nin, nout, dilations=(4, 8, 16), activ=nn.ReLU):
- super(ASPPModule, self).__init__()
- self.conv1 = nn.Sequential(
- nn.AdaptiveAvgPool2d((1, None)),
- Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ),
- )
- self.conv2 = Conv2DBNActiv(nin, nin, 1, 1, 0, activ=activ)
- self.conv3 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[0], dilations[0], activ=activ
- )
- self.conv4 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[1], dilations[1], activ=activ
- )
- self.conv5 = SeperableConv2DBNActiv(
- nin, nin, 3, 1, dilations[2], dilations[2], activ=activ
- )
- self.bottleneck = nn.Sequential(
- Conv2DBNActiv(nin * 5, nout, 1, 1, 0, activ=activ), nn.Dropout2d(0.1)
- )
-
- def forward(self, x):
- _, _, h, w = x.size()
- feat1 = F.interpolate(
- self.conv1(x), size=(h, w), mode="bilinear", align_corners=True
- )
- feat2 = self.conv2(x)
- feat3 = self.conv3(x)
- feat4 = self.conv4(x)
- feat5 = self.conv5(x)
- out = torch.cat((feat1, feat2, feat3, feat4, feat5), dim=1)
- bottle = self.bottleneck(out)
- return bottle
diff --git a/spaces/allknowingroger/Image-Models-Test204/README.md b/spaces/allknowingroger/Image-Models-Test204/README.md
deleted file mode 100644
index f91e4b31ab345f987b425de029c057bfb69d9e1b..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test204/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: More Image Models
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: true
-duplicated_from: allknowingroger/Image-Models-Test
----
-
-
\ No newline at end of file
diff --git a/spaces/alphunt/diffdock-alphunt-demo/visualizations/README.md b/spaces/alphunt/diffdock-alphunt-demo/visualizations/README.md
deleted file mode 100644
index 0675fb01e8b5d5a8952031bf40de90b89dcfcf40..0000000000000000000000000000000000000000
--- a/spaces/alphunt/diffdock-alphunt-demo/visualizations/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
-## Visualizations of complexes that were unseen during training. EquiBind (cyan), DockDiff highest confidence sample (red), all other DockDiff samples (orange), and the crystal structure (green).
-
-Complex 6agt:
-
-
-Complex 6dz3:
-
-
-Complex 6gdy:
-
-
-Complex 6ckl:
-
-
diff --git a/spaces/amarchheda/ChordDuplicate/portaudio/test/patest_longsine.c b/spaces/amarchheda/ChordDuplicate/portaudio/test/patest_longsine.c
deleted file mode 100644
index f439030e77454ef7502ca0a9335e8e16122a3c28..0000000000000000000000000000000000000000
--- a/spaces/amarchheda/ChordDuplicate/portaudio/test/patest_longsine.c
+++ /dev/null
@@ -1,151 +0,0 @@
-/** @file patest_longsine.c
- @ingroup test_src
- @brief Play a sine wave until ENTER hit.
- @author Phil Burk http://www.softsynth.com
-*/
-/*
- * $Id$
- *
- * This program uses the PortAudio Portable Audio Library.
- * For more information see: http://www.portaudio.com
- * Copyright (c) 1999-2000 Ross Bencina and Phil Burk
- *
- * Permission is hereby granted, free of charge, to any person obtaining
- * a copy of this software and associated documentation files
- * (the "Software"), to deal in the Software without restriction,
- * including without limitation the rights to use, copy, modify, merge,
- * publish, distribute, sublicense, and/or sell copies of the Software,
- * and to permit persons to whom the Software is furnished to do so,
- * subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
- * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
- * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
- * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */
-
-/*
- * The text above constitutes the entire PortAudio license; however,
- * the PortAudio community also makes the following non-binding requests:
- *
- * Any person wishing to distribute modifications to the Software is
- * requested to send the modifications to the original developer so that
- * they can be incorporated into the canonical version. It is also
- * requested that these non-binding requests be included along with the
- * license above.
- */
-
-#include
-#include
-
-#include "portaudio.h"
-
-#define SAMPLE_RATE (44100)
-
-#ifndef M_PI
-#define M_PI (3.14159265)
-#endif
-
-#define TABLE_SIZE (200)
-typedef struct
-{
- float sine[TABLE_SIZE];
- int left_phase;
- int right_phase;
-}
-paTestData;
-
-/* This routine will be called by the PortAudio engine when audio is needed.
-** It may called at interrupt level on some machines so don't do anything
-** that could mess up the system like calling malloc() or free().
-*/
-static int patestCallback(const void* inputBuffer,
- void* outputBuffer,
- unsigned long framesPerBuffer,
- const PaStreamCallbackTimeInfo* timeInfo,
- PaStreamCallbackFlags statusFlags,
- void* userData)
-{
- paTestData *data = (paTestData*)userData;
- float *out = (float*)outputBuffer;
- unsigned int i;
- (void) inputBuffer; /* Prevent unused argument warning. */
- for( i=0; isine[data->left_phase]; /* left */
- *out++ = data->sine[data->right_phase]; /* right */
- data->left_phase += 1;
- if( data->left_phase >= TABLE_SIZE ) data->left_phase -= TABLE_SIZE;
- data->right_phase += 3; /* higher pitch so we can distinguish left and right. */
- if( data->right_phase >= TABLE_SIZE ) data->right_phase -= TABLE_SIZE;
- }
- return 0;
-}
-
-/*******************************************************************/
-int main(void);
-int main(void)
-{
- PaStreamParameters outputParameters;
- PaStream *stream;
- PaError err;
- paTestData data;
- int i;
- printf("PortAudio Test: output sine wave.\n");
-
- /* initialise sinusoidal wavetable */
- for( i=0; idefaultLowOutputLatency;
- outputParameters.hostApiSpecificStreamInfo = NULL;
-
- err = Pa_OpenStream( &stream,
- NULL, /* No input. */
- &outputParameters, /* As above. */
- SAMPLE_RATE,
- 256, /* Frames per buffer. */
- paClipOff, /* No out of range samples expected. */
- patestCallback,
- &data );
- if( err != paNoError ) goto error;
-
- err = Pa_StartStream( stream );
- if( err != paNoError ) goto error;
-
- printf("Hit ENTER to stop program.\n");
- getchar();
-
- err = Pa_CloseStream( stream );
- if( err != paNoError ) goto error;
- Pa_Terminate();
-
- printf("Test finished.\n");
- return err;
-
-error:
- Pa_Terminate();
- fprintf( stderr, "An error occurred while using the portaudio stream\n" );
- fprintf( stderr, "Error number: %d\n", err );
- fprintf( stderr, "Error message: %s\n", Pa_GetErrorText( err ) );
- return err;
-}
diff --git a/spaces/anakin87/who-killed-laura-palmer/crawler/tpcrawler/tpcrawler/items.py b/spaces/anakin87/who-killed-laura-palmer/crawler/tpcrawler/tpcrawler/items.py
deleted file mode 100644
index 290aa75fa8e6cf33be200f62bff7e28812d8673b..0000000000000000000000000000000000000000
--- a/spaces/anakin87/who-killed-laura-palmer/crawler/tpcrawler/tpcrawler/items.py
+++ /dev/null
@@ -1,12 +0,0 @@
-# Define here the models for your scraped items
-#
-# See documentation in:
-# https://docs.scrapy.org/en/latest/topics/items.html
-
-import scrapy
-
-
-class TpcrawlerItem(scrapy.Item):
- # define the fields for your item here like:
- # name = scrapy.Field()
- pass
diff --git a/spaces/arbml/Ashaar/poetry_diacritizer/options.py b/spaces/arbml/Ashaar/poetry_diacritizer/options.py
deleted file mode 100644
index 6b850c03d2bab803449965f724fbc61d74f2bde0..0000000000000000000000000000000000000000
--- a/spaces/arbml/Ashaar/poetry_diacritizer/options.py
+++ /dev/null
@@ -1,39 +0,0 @@
-"""
-Types of various choices used during training
-"""
-from enum import Enum
-
-
-class AttentionType(Enum):
- """Type of attention used during training"""
-
- LocationSensitive = 1
- Content_Based = 2
- MultiHead = 3
-
-
-class LearningRateType(Enum):
- """Type of learning rate used during training"""
-
- Learning_Rate_Decay = 1
- Cosine_Scheduler = 2
- SquareRoot_Scheduler = 3
-
-
-class OptimizerType(Enum):
- """Type of optimizer used during training"""
-
- Adam = 1
- SGD = 2
- AdamW = 3
-
-
-class LossType(Enum):
- """Type of loss function used during training"""
-
- L1_LOSS = 1
- MSE_LOSS = 2
- L1_LOSS_MASKED = 3
- MSE_LOSS_MASKED = 4
- BOTH = 5
- BOTH_MASKED = 6
diff --git a/spaces/ardha27/rvc-hololive/infer_pack/commons.py b/spaces/ardha27/rvc-hololive/infer_pack/commons.py
deleted file mode 100644
index 54470986f37825b35d90d7efa7437d1c26b87215..0000000000000000000000000000000000000000
--- a/spaces/ardha27/rvc-hololive/infer_pack/commons.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import math
-import numpy as np
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-
-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)
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def kl_divergence(m_p, logs_p, m_q, logs_q):
- """KL(P||Q)"""
- kl = (logs_q - logs_p) - 0.5
- kl += (
- 0.5 * (torch.exp(2.0 * logs_p) + ((m_p - m_q) ** 2)) * torch.exp(-2.0 * logs_q)
- )
- return kl
-
-
-def rand_gumbel(shape):
- """Sample from the Gumbel distribution, protect from overflows."""
- uniform_samples = torch.rand(shape) * 0.99998 + 0.00001
- return -torch.log(-torch.log(uniform_samples))
-
-
-def rand_gumbel_like(x):
- g = rand_gumbel(x.size()).to(dtype=x.dtype, device=x.device)
- return g
-
-
-def slice_segments(x, ids_str, segment_size=4):
- ret = torch.zeros_like(x[:, :, :segment_size])
- for i in range(x.size(0)):
- idx_str = ids_str[i]
- idx_end = idx_str + segment_size
- ret[i] = x[i, :, idx_str:idx_end]
- return ret
-
-
-def slice_segments2(x, ids_str, segment_size=4):
- ret = torch.zeros_like(x[:, :segment_size])
- for i in range(x.size(0)):
- idx_str = ids_str[i]
- idx_end = idx_str + segment_size
- ret[i] = x[i, idx_str:idx_end]
- return ret
-
-
-def rand_slice_segments(x, x_lengths=None, segment_size=4):
- b, d, t = x.size()
- if x_lengths is None:
- x_lengths = t
- ids_str_max = x_lengths - segment_size + 1
- ids_str = (torch.rand([b]).to(device=x.device) * ids_str_max).to(dtype=torch.long)
- ret = slice_segments(x, ids_str, segment_size)
- return ret, ids_str
-
-
-def get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):
- position = torch.arange(length, dtype=torch.float)
- num_timescales = channels // 2
- log_timescale_increment = math.log(float(max_timescale) / float(min_timescale)) / (
- num_timescales - 1
- )
- inv_timescales = min_timescale * torch.exp(
- torch.arange(num_timescales, dtype=torch.float) * -log_timescale_increment
- )
- scaled_time = position.unsqueeze(0) * inv_timescales.unsqueeze(1)
- signal = torch.cat([torch.sin(scaled_time), torch.cos(scaled_time)], 0)
- signal = F.pad(signal, [0, 0, 0, channels % 2])
- signal = signal.view(1, channels, length)
- return signal
-
-
-def add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return x + signal.to(dtype=x.dtype, device=x.device)
-
-
-def cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):
- b, channels, length = x.size()
- signal = get_timing_signal_1d(length, channels, min_timescale, max_timescale)
- return torch.cat([x, signal.to(dtype=x.dtype, device=x.device)], axis)
-
-
-def subsequent_mask(length):
- mask = torch.tril(torch.ones(length, length)).unsqueeze(0).unsqueeze(0)
- return mask
-
-
-@torch.jit.script
-def fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):
- n_channels_int = n_channels[0]
- in_act = input_a + input_b
- t_act = torch.tanh(in_act[:, :n_channels_int, :])
- s_act = torch.sigmoid(in_act[:, n_channels_int:, :])
- acts = t_act * s_act
- return acts
-
-
-def convert_pad_shape(pad_shape):
- l = pad_shape[::-1]
- pad_shape = [item for sublist in l for item in sublist]
- return pad_shape
-
-
-def shift_1d(x):
- x = F.pad(x, convert_pad_shape([[0, 0], [0, 0], [1, 0]]))[:, :, :-1]
- return x
-
-
-def sequence_mask(length, max_length=None):
- if max_length is None:
- max_length = length.max()
- x = torch.arange(max_length, dtype=length.dtype, device=length.device)
- return x.unsqueeze(0) < length.unsqueeze(1)
-
-
-def generate_path(duration, mask):
- """
- duration: [b, 1, t_x]
- mask: [b, 1, t_y, t_x]
- """
- device = duration.device
-
- b, _, t_y, t_x = mask.shape
- cum_duration = torch.cumsum(duration, -1)
-
- cum_duration_flat = cum_duration.view(b * t_x)
- path = sequence_mask(cum_duration_flat, t_y).to(mask.dtype)
- path = path.view(b, t_x, t_y)
- path = path - F.pad(path, convert_pad_shape([[0, 0], [1, 0], [0, 0]]))[:, :-1]
- path = path.unsqueeze(1).transpose(2, 3) * mask
- return path
-
-
-def clip_grad_value_(parameters, clip_value, norm_type=2):
- if isinstance(parameters, torch.Tensor):
- parameters = [parameters]
- parameters = list(filter(lambda p: p.grad is not None, parameters))
- norm_type = float(norm_type)
- if clip_value is not None:
- clip_value = float(clip_value)
-
- total_norm = 0
- for p in parameters:
- param_norm = p.grad.data.norm(norm_type)
- total_norm += param_norm.item() ** norm_type
- if clip_value is not None:
- p.grad.data.clamp_(min=-clip_value, max=clip_value)
- total_norm = total_norm ** (1.0 / norm_type)
- return total_norm
diff --git a/spaces/arianaira/movie-recommender/Recommender.py b/spaces/arianaira/movie-recommender/Recommender.py
deleted file mode 100644
index 409842590c9d20e0bb51a3a269c55e6d0f4707c6..0000000000000000000000000000000000000000
--- a/spaces/arianaira/movie-recommender/Recommender.py
+++ /dev/null
@@ -1,120 +0,0 @@
-import torch
-import pandas as pd
-from torch import nn
-import torch.nn.functional as F
-from torch.utils.data import Dataset, DataLoader,random_split
-from tqdm.notebook import tqdm
-import numpy as np
-import app
-
-class Encoder(nn.Module):
- def __init__(self, embedd_size, embedding_size, hidden_size, num_layers=2, p=0.5):
- super(Encoder, self).__init__()
- self.dropout = nn.Dropout(p)
- self.hidden_size = hidden_size
- self.num_layers = num_layers
-
- self.lin = nn.Linear(1, embedding_size)
-
- self.embedding = nn.Embedding(embedd_size, embedding_size)
- self.rnn = nn.GRU(2*embedding_size, hidden_size, num_layers, dropout=p)
- self.relu = nn.ReLU()
-
- def forward(self, x):
- # x shape: (seq_length, N, 2) where N is batch size
-
- rate = self.dropout(self.relu(self.lin(x[:,:,1].unsqueeze(-1).to(torch.float32))))
- embedding = self.dropout(self.embedding(x[:,:,0]))
- # embedding shape: (seq_length, N, embedding_size)
-
- _, hidden = self.rnn(torch.cat([rate, embedding], dim=-1))
- # outputs shape: (seq_length, N, hidden_size)
-
- return hidden
-
-
-class Decoder(nn.Module):
- def __init__(
- self, embedd_size, embedding_size, hidden_size, output_size, num_layers=2, p=0.5
- ):
- super(Decoder, self).__init__()
- self.dropout = nn.Dropout(p)
- self.hidden_size = hidden_size
- self.num_layers = num_layers
-
- self.embedding = nn.Embedding(embedd_size, embedding_size)
- self.lin = nn.Linear(embedding_size, embedding_size)
- self.rnn = nn.GRU(embedding_size, hidden_size, num_layers, dropout=p)
- self.fc = nn.Linear(hidden_size, output_size)
- self.relu = nn.ReLU()
-
- def forward(self, x, hidden):
- # x shape: (N) where N is for batch size, we want it to be (1, N), seq_length
- x = x.unsqueeze(0).to(torch.int)
-
-
- embedding = self.dropout(self.embedding(x))
-
- # embedding shape: (1, N, embedding_size)
- embedding = self.relu(self.dropout(self.lin(embedding)))
-
- outputs, hidden = self.rnn(embedding, hidden)
- # outputs shape: (1, N, hidden_size)
-
- predictions = self.relu(self.fc(outputs))
-
- # predictions shape: (1, N, 1) to send it to
- # just gonna remove the first dim
- predictions = predictions.squeeze(0).squeeze(-1)
-
- return predictions, hidden
-
-
-class RecSys(nn.Module):
- def __init__(self, num_items, embedding_size, hidden_size, num_layers, device, p=0.5):
- super(RecSys, self).__init__()
-
- self.encoder = Encoder(num_items, embedding_size, hidden_size, num_layers, p)
- self.decoder = Decoder(num_items, embedding_size, hidden_size, 1, num_layers, p)
- self.device = device
- self.to(device)
-
- def forward(self, source, decode_token): # source : , decode_token:
- hidden = self.encoder(source.permute((1,0,2)))
-
- # Grab the first input to the Decoder which will be token
- x = decode_token
-
- # Use previous hidden, cell as context from encoder at start
- output, _ = self.decoder(x, hidden)
-
- return output
-
- def pred(self, source, decode_token):
- self.eval()
- with torch.no_grad():
- return self.forward(source, decode_token)
-
-
-def get_top_rated_movies(user_hist, model, movie_ids, device, num_recommendation=10): # user_hist :
- ratings = []
-
- # Pass user ID and each movie ID through the model
- for movie_id in movie_ids:
- source , decode_token = torch.tensor(user_hist, dtype=torch.int64).unsqueeze(0).to(device) , torch.tensor([movie_id]).to(device).to(torch.int64)
-
- rating = model.pred(source, decode_token) # source : <1, S, 2> , decode_token: <1>
-
- ratings.append((movie_id, rating.item()))
-
- # Sort the ratings in descending order
- sorted_ratings = sorted(ratings, key=lambda x: x[1], reverse=True)
-
- # Get the top 10 rated movies' IDs
- top_movies = [movie_id for movie_id, _ in sorted_ratings[:num_recommendation]]
-
- return top_movies
-
-
-
-
diff --git a/spaces/artificialguybr/video-dubbing/TTS/recipes/ljspeech/multiband_melgan/train_multiband_melgan.py b/spaces/artificialguybr/video-dubbing/TTS/recipes/ljspeech/multiband_melgan/train_multiband_melgan.py
deleted file mode 100644
index 225f5a302f349be2f2069eeb10cd4b8ab6645eb0..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/recipes/ljspeech/multiband_melgan/train_multiband_melgan.py
+++ /dev/null
@@ -1,46 +0,0 @@
-import os
-
-from trainer import Trainer, TrainerArgs
-
-from TTS.utils.audio import AudioProcessor
-from TTS.vocoder.configs import MultibandMelganConfig
-from TTS.vocoder.datasets.preprocess import load_wav_data
-from TTS.vocoder.models.gan import GAN
-
-output_path = os.path.dirname(os.path.abspath(__file__))
-
-config = MultibandMelganConfig(
- batch_size=32,
- eval_batch_size=16,
- num_loader_workers=4,
- num_eval_loader_workers=4,
- run_eval=True,
- test_delay_epochs=5,
- epochs=1000,
- seq_len=8192,
- pad_short=2000,
- use_noise_augment=True,
- eval_split_size=10,
- print_step=25,
- print_eval=False,
- mixed_precision=False,
- lr_gen=1e-4,
- lr_disc=1e-4,
- data_path=os.path.join(output_path, "../LJSpeech-1.1/wavs/"),
- output_path=output_path,
-)
-
-# init audio processor
-ap = AudioProcessor(**config.audio.to_dict())
-
-# load training samples
-eval_samples, train_samples = load_wav_data(config.data_path, config.eval_split_size)
-
-# init model
-model = GAN(config, ap)
-
-# init the trainer and 🚀
-trainer = Trainer(
- TrainerArgs(), config, output_path, model=model, train_samples=train_samples, eval_samples=eval_samples
-)
-trainer.fit()
diff --git a/spaces/artificialguybr/video-dubbing/TTS/tests/aux_tests/test_find_unique_phonemes.py b/spaces/artificialguybr/video-dubbing/TTS/tests/aux_tests/test_find_unique_phonemes.py
deleted file mode 100644
index 018679f573020075fa77cd0b917fbbe75e4627c0..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/tests/aux_tests/test_find_unique_phonemes.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import os
-import unittest
-
-import torch
-
-from tests import get_tests_output_path, run_cli
-from TTS.config.shared_configs import BaseDatasetConfig
-from TTS.tts.configs.vits_config import VitsConfig
-
-torch.manual_seed(1)
-
-config_path = os.path.join(get_tests_output_path(), "test_model_config.json")
-
-dataset_config_en = BaseDatasetConfig(
- formatter="ljspeech",
- meta_file_train="metadata.csv",
- meta_file_val="metadata.csv",
- path="tests/data/ljspeech",
- language="en",
-)
-
-"""
-dataset_config_pt = BaseDatasetConfig(
- formatter="ljspeech",
- meta_file_train="metadata.csv",
- meta_file_val="metadata.csv",
- path="tests/data/ljspeech",
- language="pt-br",
-)
-"""
-
-
-# pylint: disable=protected-access
-class TestFindUniquePhonemes(unittest.TestCase):
- @staticmethod
- def test_espeak_phonemes():
- # prepare the config
- config = VitsConfig(
- batch_size=2,
- eval_batch_size=2,
- num_loader_workers=0,
- num_eval_loader_workers=0,
- text_cleaner="english_cleaners",
- use_phonemes=True,
- phoneme_language="en-us",
- phoneme_cache_path="tests/data/ljspeech/phoneme_cache/",
- run_eval=True,
- test_delay_epochs=-1,
- epochs=1,
- print_step=1,
- print_eval=True,
- datasets=[dataset_config_en],
- )
- config.save_json(config_path)
-
- # run test
- run_cli(f'CUDA_VISIBLE_DEVICES="" python TTS/bin/find_unique_phonemes.py --config_path "{config_path}"')
-
- @staticmethod
- def test_no_espeak_phonemes():
- # prepare the config
- config = VitsConfig(
- batch_size=2,
- eval_batch_size=2,
- num_loader_workers=0,
- num_eval_loader_workers=0,
- text_cleaner="english_cleaners",
- use_phonemes=True,
- phoneme_language="en-us",
- phoneme_cache_path="tests/data/ljspeech/phoneme_cache/",
- run_eval=True,
- test_delay_epochs=-1,
- epochs=1,
- print_step=1,
- print_eval=True,
- datasets=[dataset_config_en],
- )
- config.save_json(config_path)
-
- # run test
- run_cli(f'CUDA_VISIBLE_DEVICES="" python TTS/bin/find_unique_phonemes.py --config_path "{config_path}"')
diff --git a/spaces/artificialguybr/video-dubbing/whisper/whisper/audio.py b/spaces/artificialguybr/video-dubbing/whisper/whisper/audio.py
deleted file mode 100644
index 4f5b6e07318ef46db77f28a36f34e279d54ea5b2..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/whisper/whisper/audio.py
+++ /dev/null
@@ -1,157 +0,0 @@
-import os
-from functools import lru_cache
-from subprocess import CalledProcessError, run
-from typing import Optional, Union
-
-import numpy as np
-import torch
-import torch.nn.functional as F
-
-from .utils import exact_div
-
-# hard-coded audio hyperparameters
-SAMPLE_RATE = 16000
-N_FFT = 400
-N_MELS = 80
-HOP_LENGTH = 160
-CHUNK_LENGTH = 30
-N_SAMPLES = CHUNK_LENGTH * SAMPLE_RATE # 480000 samples in a 30-second chunk
-N_FRAMES = exact_div(N_SAMPLES, HOP_LENGTH) # 3000 frames in a mel spectrogram input
-
-N_SAMPLES_PER_TOKEN = HOP_LENGTH * 2 # the initial convolutions has stride 2
-FRAMES_PER_SECOND = exact_div(SAMPLE_RATE, HOP_LENGTH) # 10ms per audio frame
-TOKENS_PER_SECOND = exact_div(SAMPLE_RATE, N_SAMPLES_PER_TOKEN) # 20ms per audio token
-
-
-def load_audio(file: str, sr: int = SAMPLE_RATE):
- """
- Open an audio file and read as mono waveform, resampling as necessary
-
- Parameters
- ----------
- file: str
- The audio file to open
-
- sr: int
- The sample rate to resample the audio if necessary
-
- Returns
- -------
- A NumPy array containing the audio waveform, in float32 dtype.
- """
-
- # This launches a subprocess to decode audio while down-mixing
- # and resampling as necessary. Requires the ffmpeg CLI in PATH.
- # fmt: off
- cmd = [
- "ffmpeg",
- "-nostdin",
- "-threads", "0",
- "-i", file,
- "-f", "s16le",
- "-ac", "1",
- "-acodec", "pcm_s16le",
- "-ar", str(sr),
- "-"
- ]
- # fmt: on
- try:
- out = run(cmd, capture_output=True, check=True).stdout
- except CalledProcessError as e:
- raise RuntimeError(f"Failed to load audio: {e.stderr.decode()}") from e
-
- return np.frombuffer(out, np.int16).flatten().astype(np.float32) / 32768.0
-
-
-def pad_or_trim(array, length: int = N_SAMPLES, *, axis: int = -1):
- """
- Pad or trim the audio array to N_SAMPLES, as expected by the encoder.
- """
- if torch.is_tensor(array):
- if array.shape[axis] > length:
- array = array.index_select(
- dim=axis, index=torch.arange(length, device=array.device)
- )
-
- if array.shape[axis] < length:
- pad_widths = [(0, 0)] * array.ndim
- pad_widths[axis] = (0, length - array.shape[axis])
- array = F.pad(array, [pad for sizes in pad_widths[::-1] for pad in sizes])
- else:
- if array.shape[axis] > length:
- array = array.take(indices=range(length), axis=axis)
-
- if array.shape[axis] < length:
- pad_widths = [(0, 0)] * array.ndim
- pad_widths[axis] = (0, length - array.shape[axis])
- array = np.pad(array, pad_widths)
-
- return array
-
-
-@lru_cache(maxsize=None)
-def mel_filters(device, n_mels: int = N_MELS) -> torch.Tensor:
- """
- load the mel filterbank matrix for projecting STFT into a Mel spectrogram.
- Allows decoupling librosa dependency; saved using:
-
- np.savez_compressed(
- "mel_filters.npz",
- mel_80=librosa.filters.mel(sr=16000, n_fft=400, n_mels=80),
- )
- """
- assert n_mels == 80, f"Unsupported n_mels: {n_mels}"
- with np.load(
- os.path.join(os.path.dirname(__file__), "assets", "mel_filters.npz")
- ) as f:
- return torch.from_numpy(f[f"mel_{n_mels}"]).to(device)
-
-
-def log_mel_spectrogram(
- audio: Union[str, np.ndarray, torch.Tensor],
- n_mels: int = N_MELS,
- padding: int = 0,
- device: Optional[Union[str, torch.device]] = None,
-):
- """
- Compute the log-Mel spectrogram of
-
- Parameters
- ----------
- audio: Union[str, np.ndarray, torch.Tensor], shape = (*)
- The path to audio or either a NumPy array or Tensor containing the audio waveform in 16 kHz
-
- n_mels: int
- The number of Mel-frequency filters, only 80 is supported
-
- padding: int
- Number of zero samples to pad to the right
-
- device: Optional[Union[str, torch.device]]
- If given, the audio tensor is moved to this device before STFT
-
- Returns
- -------
- torch.Tensor, shape = (80, n_frames)
- A Tensor that contains the Mel spectrogram
- """
- if not torch.is_tensor(audio):
- if isinstance(audio, str):
- audio = load_audio(audio)
- audio = torch.from_numpy(audio)
-
- if device is not None:
- audio = audio.to(device)
- if padding > 0:
- audio = F.pad(audio, (0, padding))
- window = torch.hann_window(N_FFT).to(audio.device)
- stft = torch.stft(audio, N_FFT, HOP_LENGTH, window=window, return_complex=True)
- magnitudes = stft[..., :-1].abs() ** 2
-
- filters = mel_filters(audio.device, n_mels)
- mel_spec = filters @ magnitudes
-
- log_spec = torch.clamp(mel_spec, min=1e-10).log10()
- log_spec = torch.maximum(log_spec, log_spec.max() - 8.0)
- log_spec = (log_spec + 4.0) / 4.0
- return log_spec
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/SpiderImagePlugin.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/SpiderImagePlugin.py
deleted file mode 100644
index acafc320e64cf585b152e75fcce42f44765c7de6..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/PIL/SpiderImagePlugin.py
+++ /dev/null
@@ -1,313 +0,0 @@
-#
-# The Python Imaging Library.
-#
-# SPIDER image file handling
-#
-# History:
-# 2004-08-02 Created BB
-# 2006-03-02 added save method
-# 2006-03-13 added support for stack images
-#
-# Copyright (c) 2004 by Health Research Inc. (HRI) RENSSELAER, NY 12144.
-# Copyright (c) 2004 by William Baxter.
-# Copyright (c) 2004 by Secret Labs AB.
-# Copyright (c) 2004 by Fredrik Lundh.
-#
-
-##
-# Image plugin for the Spider image format. This format is used
-# by the SPIDER software, in processing image data from electron
-# microscopy and tomography.
-##
-
-#
-# SpiderImagePlugin.py
-#
-# The Spider image format is used by SPIDER software, in processing
-# image data from electron microscopy and tomography.
-#
-# Spider home page:
-# https://spider.wadsworth.org/spider_doc/spider/docs/spider.html
-#
-# Details about the Spider image format:
-# https://spider.wadsworth.org/spider_doc/spider/docs/image_doc.html
-#
-import os
-import struct
-import sys
-
-from PIL import Image, ImageFile
-
-
-def isInt(f):
- try:
- i = int(f)
- if f - i == 0:
- return 1
- else:
- return 0
- except (ValueError, OverflowError):
- return 0
-
-
-iforms = [1, 3, -11, -12, -21, -22]
-
-
-# There is no magic number to identify Spider files, so just check a
-# series of header locations to see if they have reasonable values.
-# Returns no. of bytes in the header, if it is a valid Spider header,
-# otherwise returns 0
-
-
-def isSpiderHeader(t):
- h = (99,) + t # add 1 value so can use spider header index start=1
- # header values 1,2,5,12,13,22,23 should be integers
- for i in [1, 2, 5, 12, 13, 22, 23]:
- if not isInt(h[i]):
- return 0
- # check iform
- iform = int(h[5])
- if iform not in iforms:
- return 0
- # check other header values
- labrec = int(h[13]) # no. records in file header
- labbyt = int(h[22]) # total no. of bytes in header
- lenbyt = int(h[23]) # record length in bytes
- if labbyt != (labrec * lenbyt):
- return 0
- # looks like a valid header
- return labbyt
-
-
-def isSpiderImage(filename):
- with open(filename, "rb") as fp:
- f = fp.read(92) # read 23 * 4 bytes
- t = struct.unpack(">23f", f) # try big-endian first
- hdrlen = isSpiderHeader(t)
- if hdrlen == 0:
- t = struct.unpack("<23f", f) # little-endian
- hdrlen = isSpiderHeader(t)
- return hdrlen
-
-
-class SpiderImageFile(ImageFile.ImageFile):
-
- format = "SPIDER"
- format_description = "Spider 2D image"
- _close_exclusive_fp_after_loading = False
-
- def _open(self):
- # check header
- n = 27 * 4 # read 27 float values
- f = self.fp.read(n)
-
- try:
- self.bigendian = 1
- t = struct.unpack(">27f", f) # try big-endian first
- hdrlen = isSpiderHeader(t)
- if hdrlen == 0:
- self.bigendian = 0
- t = struct.unpack("<27f", f) # little-endian
- hdrlen = isSpiderHeader(t)
- if hdrlen == 0:
- raise SyntaxError("not a valid Spider file")
- except struct.error as e:
- raise SyntaxError("not a valid Spider file") from e
-
- h = (99,) + t # add 1 value : spider header index starts at 1
- iform = int(h[5])
- if iform != 1:
- raise SyntaxError("not a Spider 2D image")
-
- self._size = int(h[12]), int(h[2]) # size in pixels (width, height)
- self.istack = int(h[24])
- self.imgnumber = int(h[27])
-
- if self.istack == 0 and self.imgnumber == 0:
- # stk=0, img=0: a regular 2D image
- offset = hdrlen
- self._nimages = 1
- elif self.istack > 0 and self.imgnumber == 0:
- # stk>0, img=0: Opening the stack for the first time
- self.imgbytes = int(h[12]) * int(h[2]) * 4
- self.hdrlen = hdrlen
- self._nimages = int(h[26])
- # Point to the first image in the stack
- offset = hdrlen * 2
- self.imgnumber = 1
- elif self.istack == 0 and self.imgnumber > 0:
- # stk=0, img>0: an image within the stack
- offset = hdrlen + self.stkoffset
- self.istack = 2 # So Image knows it's still a stack
- else:
- raise SyntaxError("inconsistent stack header values")
-
- if self.bigendian:
- self.rawmode = "F;32BF"
- else:
- self.rawmode = "F;32F"
- self.mode = "F"
-
- self.tile = [("raw", (0, 0) + self.size, offset, (self.rawmode, 0, 1))]
- self._fp = self.fp # FIXME: hack
-
- @property
- def n_frames(self):
- return self._nimages
-
- @property
- def is_animated(self):
- return self._nimages > 1
-
- # 1st image index is zero (although SPIDER imgnumber starts at 1)
- def tell(self):
- if self.imgnumber < 1:
- return 0
- else:
- return self.imgnumber - 1
-
- def seek(self, frame):
- if self.istack == 0:
- raise EOFError("attempt to seek in a non-stack file")
- if not self._seek_check(frame):
- return
- self.stkoffset = self.hdrlen + frame * (self.hdrlen + self.imgbytes)
- self.fp = self._fp
- self.fp.seek(self.stkoffset)
- self._open()
-
- # returns a byte image after rescaling to 0..255
- def convert2byte(self, depth=255):
- (minimum, maximum) = self.getextrema()
- m = 1
- if maximum != minimum:
- m = depth / (maximum - minimum)
- b = -m * minimum
- return self.point(lambda i, m=m, b=b: i * m + b).convert("L")
-
- # returns a ImageTk.PhotoImage object, after rescaling to 0..255
- def tkPhotoImage(self):
- from PIL import ImageTk
-
- return ImageTk.PhotoImage(self.convert2byte(), palette=256)
-
-
-# --------------------------------------------------------------------
-# Image series
-
-# given a list of filenames, return a list of images
-def loadImageSeries(filelist=None):
- """create a list of :py:class:`~PIL.Image.Image` objects for use in a montage"""
- if filelist is None or len(filelist) < 1:
- return
-
- imglist = []
- for img in filelist:
- if not os.path.exists(img):
- print(f"unable to find {img}")
- continue
- try:
- with Image.open(img) as im:
- im = im.convert2byte()
- except Exception:
- if not isSpiderImage(img):
- print(img + " is not a Spider image file")
- continue
- im.info["filename"] = img
- imglist.append(im)
- return imglist
-
-
-# --------------------------------------------------------------------
-# For saving images in Spider format
-
-
-def makeSpiderHeader(im):
- nsam, nrow = im.size
- lenbyt = nsam * 4 # There are labrec records in the header
- labrec = int(1024 / lenbyt)
- if 1024 % lenbyt != 0:
- labrec += 1
- labbyt = labrec * lenbyt
- nvalues = int(labbyt / 4)
- if nvalues < 23:
- return []
-
- hdr = []
- for i in range(nvalues):
- hdr.append(0.0)
-
- # NB these are Fortran indices
- hdr[1] = 1.0 # nslice (=1 for an image)
- hdr[2] = float(nrow) # number of rows per slice
- hdr[3] = float(nrow) # number of records in the image
- hdr[5] = 1.0 # iform for 2D image
- hdr[12] = float(nsam) # number of pixels per line
- hdr[13] = float(labrec) # number of records in file header
- hdr[22] = float(labbyt) # total number of bytes in header
- hdr[23] = float(lenbyt) # record length in bytes
-
- # adjust for Fortran indexing
- hdr = hdr[1:]
- hdr.append(0.0)
- # pack binary data into a string
- return [struct.pack("f", v) for v in hdr]
-
-
-def _save(im, fp, filename):
- if im.mode[0] != "F":
- im = im.convert("F")
-
- hdr = makeSpiderHeader(im)
- if len(hdr) < 256:
- raise OSError("Error creating Spider header")
-
- # write the SPIDER header
- fp.writelines(hdr)
-
- rawmode = "F;32NF" # 32-bit native floating point
- ImageFile._save(im, fp, [("raw", (0, 0) + im.size, 0, (rawmode, 0, 1))])
-
-
-def _save_spider(im, fp, filename):
- # get the filename extension and register it with Image
- ext = os.path.splitext(filename)[1]
- Image.register_extension(SpiderImageFile.format, ext)
- _save(im, fp, filename)
-
-
-# --------------------------------------------------------------------
-
-
-Image.register_open(SpiderImageFile.format, SpiderImageFile)
-Image.register_save(SpiderImageFile.format, _save_spider)
-
-if __name__ == "__main__":
-
- if len(sys.argv) < 2:
- print("Syntax: python3 SpiderImagePlugin.py [infile] [outfile]")
- sys.exit()
-
- filename = sys.argv[1]
- if not isSpiderImage(filename):
- print("input image must be in Spider format")
- sys.exit()
-
- with Image.open(filename) as im:
- print("image: " + str(im))
- print("format: " + str(im.format))
- print("size: " + str(im.size))
- print("mode: " + str(im.mode))
- print("max, min: ", end=" ")
- print(im.getextrema())
-
- if len(sys.argv) > 2:
- outfile = sys.argv[2]
-
- # perform some image operation
- im = im.transpose(Image.Transpose.FLIP_LEFT_RIGHT)
- print(
- f"saving a flipped version of {os.path.basename(filename)} "
- f"as {outfile} "
- )
- im.save(outfile, SpiderImageFile.format)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/audioread/gstdec.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/audioread/gstdec.py
deleted file mode 100644
index 6ae0f9e3572078d909fc57c573c260643c3131c5..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/audioread/gstdec.py
+++ /dev/null
@@ -1,447 +0,0 @@
-# This file is part of audioread.
-# Copyright 2011, Adrian Sampson.
-#
-# Permission is hereby granted, free of charge, to any person obtaining
-# a copy of this software and associated documentation files (the
-# "Software"), to deal in the Software without restriction, including
-# without limitation the rights to use, copy, modify, merge, publish,
-# distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to
-# the following conditions:
-#
-# The above copyright notice and this permission notice shall be
-# included in all copies or substantial portions of the Software.
-
-"""Use Gstreamer to decode audio files.
-
-To read an audio file, pass it to the constructor for GstAudioFile()
-and then iterate over the contents:
-
- >>> f = GstAudioFile('something.mp3')
- >>> try:
- >>> for block in f:
- >>> ...
- >>> finally:
- >>> f.close()
-
-Note that there are a few complications caused by Gstreamer's
-asynchronous architecture. This module spawns its own Gobject main-
-loop thread; I'm not sure how that will interact with other main
-loops if your program has them. Also, in order to stop the thread
-and terminate your program normally, you need to call the close()
-method on every GstAudioFile you create. Conveniently, the file can be
-used as a context manager to make this simpler:
-
- >>> with GstAudioFile('something.mp3') as f:
- >>> for block in f:
- >>> ...
-
-Iterating a GstAudioFile yields strings containing short integer PCM
-data. You can also read the sample rate and channel count from the
-file:
-
- >>> with GstAudioFile('something.mp3') as f:
- >>> print f.samplerate
- >>> print f.channels
- >>> print f.duration
-"""
-from __future__ import with_statement
-from __future__ import division
-
-import gi
-gi.require_version('Gst', '1.0')
-from gi.repository import GLib, Gst
-
-import sys
-import threading
-import os
-
-from .exceptions import DecodeError
-
-try:
- import queue
-except ImportError:
- import Queue as queue
-
-try:
- from urllib.parse import quote
-except ImportError:
- from urllib import quote
-
-
-QUEUE_SIZE = 10
-BUFFER_SIZE = 10
-SENTINEL = '__GSTDEC_SENTINEL__'
-
-
-# Exceptions.
-
-class GStreamerError(DecodeError):
- pass
-
-
-class UnknownTypeError(GStreamerError):
- """Raised when Gstreamer can't decode the given file type."""
- def __init__(self, streaminfo):
- super(UnknownTypeError, self).__init__(
- "can't decode stream: " + streaminfo
- )
- self.streaminfo = streaminfo
-
-
-class FileReadError(GStreamerError):
- """Raised when the file can't be read at all."""
- pass
-
-
-class NoStreamError(GStreamerError):
- """Raised when the file was read successfully but no audio streams
- were found.
- """
- def __init__(self):
- super(NoStreamError, self).__init__('no audio streams found')
-
-
-class MetadataMissingError(GStreamerError):
- """Raised when GStreamer fails to report stream metadata (duration,
- channels, or sample rate).
- """
- pass
-
-
-class IncompleteGStreamerError(GStreamerError):
- """Raised when necessary components of GStreamer (namely, the
- principal plugin packages) are missing.
- """
- def __init__(self):
- super(IncompleteGStreamerError, self).__init__(
- 'missing GStreamer base plugins'
- )
-
-
-# Managing the Gobject main loop thread.
-
-_shared_loop_thread = None
-_loop_thread_lock = threading.RLock()
-
-Gst.init(None)
-
-def get_loop_thread():
- """Get the shared main-loop thread.
- """
- global _shared_loop_thread
- with _loop_thread_lock:
- if not _shared_loop_thread:
- # Start a new thread.
- _shared_loop_thread = MainLoopThread()
- _shared_loop_thread.start()
- return _shared_loop_thread
-
-
-class MainLoopThread(threading.Thread):
- """A daemon thread encapsulating a Gobject main loop.
- """
- def __init__(self):
- super(MainLoopThread, self).__init__()
- self.loop = GLib.MainLoop.new(None, False)
- self.daemon = True
-
- def run(self):
- self.loop.run()
-
-
-# The decoder.
-
-class GstAudioFile(object):
- """Reads raw audio data from any audio file that Gstreamer
- knows how to decode.
-
- >>> with GstAudioFile('something.mp3') as f:
- >>> print f.samplerate
- >>> print f.channels
- >>> print f.duration
- >>> for block in f:
- >>> do_something(block)
-
- Iterating the object yields blocks of 16-bit PCM data. Three
- pieces of stream information are also available: samplerate (in Hz),
- number of channels, and duration (in seconds).
-
- It's very important that the client call close() when it's done
- with the object. Otherwise, the program is likely to hang on exit.
- Alternatively, of course, one can just use the file as a context
- manager, as shown above.
- """
- def __init__(self, path):
- self.running = False
- self.finished = False
-
- # Set up the Gstreamer pipeline.
- self.pipeline = Gst.Pipeline()
-
- self.dec = Gst.ElementFactory.make("uridecodebin", None)
- self.conv = Gst.ElementFactory.make("audioconvert", None)
- self.sink = Gst.ElementFactory.make("appsink", None)
-
- if self.dec is None or self.conv is None or self.sink is None:
- # uridecodebin, audioconvert, or appsink is missing. We need
- # gst-plugins-base.
- raise IncompleteGStreamerError()
-
- # Register for bus signals.
- bus = self.pipeline.get_bus()
- bus.add_signal_watch()
- bus.connect("message::eos", self._message)
- bus.connect("message::error", self._message)
-
- # Configure the input.
- uri = 'file://' + quote(os.path.abspath(path))
- self.dec.set_property("uri", uri)
- # The callback to connect the input.
- self.dec.connect("pad-added", self._pad_added)
- self.dec.connect("no-more-pads", self._no_more_pads)
- # And a callback if decoding failes.
- self.dec.connect("unknown-type", self._unkown_type)
-
- # Configure the output.
- # We want short integer data.
- self.sink.set_property(
- 'caps',
- Gst.Caps.from_string('audio/x-raw, format=(string)S16LE'),
- )
- # TODO set endianness?
- # Set up the characteristics of the output. We don't want to
- # drop any data (nothing is real-time here); we should bound
- # the memory usage of the internal queue; and, most
- # importantly, setting "sync" to False disables the default
- # behavior in which you consume buffers in real time. This way,
- # we get data as soon as it's decoded.
- self.sink.set_property('drop', False)
- self.sink.set_property('max-buffers', BUFFER_SIZE)
- self.sink.set_property('sync', False)
- # The callback to receive decoded data.
- self.sink.set_property('emit-signals', True)
- self.sink.connect("new-sample", self._new_sample)
-
- # We'll need to know when the stream becomes ready and we get
- # its attributes. This semaphore will become available when the
- # caps are received. That way, when __init__() returns, the file
- # (and its attributes) will be ready for reading.
- self.ready_sem = threading.Semaphore(0)
- self.caps_handler = self.sink.get_static_pad("sink").connect(
- "notify::caps", self._notify_caps
- )
-
- # Link up everything but the decoder (which must be linked only
- # when it becomes ready).
- self.pipeline.add(self.dec)
- self.pipeline.add(self.conv)
- self.pipeline.add(self.sink)
-
- self.conv.link(self.sink)
-
- # Set up the queue for data and run the main thread.
- self.queue = queue.Queue(QUEUE_SIZE)
- self.thread = get_loop_thread()
-
- # This wil get filled with an exception if opening fails.
- self.read_exc = None
-
- # Return as soon as the stream is ready!
- self.running = True
- self.got_caps = False
- self.pipeline.set_state(Gst.State.PLAYING)
- self.ready_sem.acquire()
- if self.read_exc:
- # An error occurred before the stream became ready.
- self.close(True)
- raise self.read_exc
-
- # Gstreamer callbacks.
-
- def _notify_caps(self, pad, args):
- """The callback for the sinkpad's "notify::caps" signal.
- """
- # The sink has started to receive data, so the stream is ready.
- # This also is our opportunity to read information about the
- # stream.
- self.got_caps = True
- info = pad.get_current_caps().get_structure(0)
-
- # Stream attributes.
- self.channels = info.get_int('channels')[1]
- self.samplerate = info.get_int('rate')[1]
-
- # Query duration.
- success, length = pad.get_peer().query_duration(Gst.Format.TIME)
- if success:
- self.duration = length / 1000000000
- else:
- self.read_exc = MetadataMissingError('duration not available')
-
- # Allow constructor to complete.
- self.ready_sem.release()
-
- _got_a_pad = False
-
- def _pad_added(self, element, pad):
- """The callback for GstElement's "pad-added" signal.
- """
- # Decoded data is ready. Connect up the decoder, finally.
- name = pad.query_caps(None).to_string()
- if name.startswith('audio/x-raw'):
- nextpad = self.conv.get_static_pad('sink')
- if not nextpad.is_linked():
- self._got_a_pad = True
- pad.link(nextpad)
-
- def _no_more_pads(self, element):
- """The callback for GstElement's "no-more-pads" signal.
- """
- # Sent when the pads are done adding (i.e., there are no more
- # streams in the file). If we haven't gotten at least one
- # decodable stream, raise an exception.
- if not self._got_a_pad:
- self.read_exc = NoStreamError()
- self.ready_sem.release() # No effect if we've already started.
-
- def _new_sample(self, sink):
- """The callback for appsink's "new-sample" signal.
- """
- if self.running:
- # New data is available from the pipeline! Dump it into our
- # queue (or possibly block if we're full).
- buf = sink.emit('pull-sample').get_buffer()
-
- # We can't use Gst.Buffer.extract() to read the data as it crashes
- # when called through PyGObject. We also can't use
- # Gst.Buffer.extract_dup() because we have no way in Python to free
- # the memory that it returns. Instead we get access to the actual
- # data via Gst.Memory.map().
- mem = buf.get_all_memory()
- success, info = mem.map(Gst.MapFlags.READ)
- if success:
- if isinstance(info.data, memoryview):
- # We need to copy the data as the memoryview is released
- # when we call mem.unmap()
- data = bytes(info.data)
- else:
- # GStreamer Python bindings <= 1.16 return a copy of the
- # data as bytes()
- data = info.data
- mem.unmap(info)
- self.queue.put(data)
- else:
- raise GStreamerError("Unable to map buffer memory while reading the file.")
- return Gst.FlowReturn.OK
-
- def _unkown_type(self, uridecodebin, decodebin, caps):
- """The callback for decodebin's "unknown-type" signal.
- """
- # This is called *before* the stream becomes ready when the
- # file can't be read.
- streaminfo = caps.to_string()
- if not streaminfo.startswith('audio/'):
- # Ignore non-audio (e.g., video) decode errors.
- return
- self.read_exc = UnknownTypeError(streaminfo)
- self.ready_sem.release()
-
- def _message(self, bus, message):
- """The callback for GstBus's "message" signal (for two kinds of
- messages).
- """
- if not self.finished:
- if message.type == Gst.MessageType.EOS:
- # The file is done. Tell the consumer thread.
- self.queue.put(SENTINEL)
- if not self.got_caps:
- # If the stream ends before _notify_caps was called, this
- # is an invalid file.
- self.read_exc = NoStreamError()
- self.ready_sem.release()
-
- elif message.type == Gst.MessageType.ERROR:
- gerror, debug = message.parse_error()
- if 'not-linked' in debug:
- self.read_exc = NoStreamError()
- elif 'No such file' in debug:
- self.read_exc = IOError('resource not found')
- else:
- self.read_exc = FileReadError(debug)
- self.ready_sem.release()
-
- # Iteration.
-
- def next(self):
- # Wait for data from the Gstreamer callbacks.
- val = self.queue.get()
- if val == SENTINEL:
- # End of stream.
- raise StopIteration
- return val
-
- # For Python 3 compatibility.
- __next__ = next
-
- def __iter__(self):
- return self
-
- # Cleanup.
- def close(self, force=False):
- """Close the file and clean up associated resources.
-
- Calling `close()` a second time has no effect.
- """
- if self.running or force:
- self.running = False
- self.finished = True
-
- # Unregister for signals, which we registered for above with
- # `add_signal_watch`. (Without this, GStreamer leaks file
- # descriptors.)
- self.pipeline.get_bus().remove_signal_watch()
-
- # Stop reading the file.
- self.dec.set_property("uri", None)
- # Block spurious signals.
- self.sink.get_static_pad("sink").disconnect(self.caps_handler)
-
- # Make space in the output queue to let the decoder thread
- # finish. (Otherwise, the thread blocks on its enqueue and
- # the interpreter hangs.)
- try:
- self.queue.get_nowait()
- except queue.Empty:
- pass
-
- # Halt the pipeline (closing file).
- self.pipeline.set_state(Gst.State.NULL)
-
- # Delete the pipeline object. This seems to be necessary on Python
- # 2, but not Python 3 for some reason: on 3.5, at least, the
- # pipeline gets dereferenced automatically.
- del self.pipeline
-
- def __del__(self):
- self.close()
-
- # Context manager.
- def __enter__(self):
- return self
-
- def __exit__(self, exc_type, exc_val, exc_tb):
- self.close()
- return False
-
-
-# Smoke test.
-if __name__ == '__main__':
- for path in sys.argv[1:]:
- path = os.path.abspath(os.path.expanduser(path))
- with GstAudioFile(path) as f:
- print(f.channels)
- print(f.samplerate)
- print(f.duration)
- for s in f:
- print(len(s), ord(s[0]))
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/utils.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/utils.py
deleted file mode 100644
index 69b77962e69f17f1e0869a4175221072642e4c00..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/utils.py
+++ /dev/null
@@ -1,503 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import ast
-import inspect
-import logging
-import os
-import re
-from argparse import ArgumentError, ArgumentParser, Namespace
-from dataclasses import _MISSING_TYPE, MISSING, is_dataclass
-from enum import Enum
-from typing import Any, Dict, List, Optional, Tuple, Type
-
-from fairseq.dataclass import FairseqDataclass
-from fairseq.dataclass.configs import FairseqConfig
-from hydra.core.global_hydra import GlobalHydra
-from hydra.experimental import compose, initialize
-from omegaconf import DictConfig, OmegaConf, open_dict, _utils
-
-logger = logging.getLogger(__name__)
-
-
-def eval_str_list(x, x_type=float):
- if x is None:
- return None
- if isinstance(x, str):
- if len(x) == 0:
- return []
- x = ast.literal_eval(x)
- try:
- return list(map(x_type, x))
- except TypeError:
- return [x_type(x)]
-
-
-def interpret_dc_type(field_type):
- if isinstance(field_type, str):
- raise RuntimeError("field should be a type")
-
- if field_type == Any:
- return str
-
- typestring = str(field_type)
- if re.match(
- r"(typing.|^)Union\[(.*), NoneType\]$", typestring
- ) or typestring.startswith("typing.Optional"):
- return field_type.__args__[0]
- return field_type
-
-
-def gen_parser_from_dataclass(
- parser: ArgumentParser,
- dataclass_instance: FairseqDataclass,
- delete_default: bool = False,
- with_prefix: Optional[str] = None,
-) -> None:
- """
- convert a dataclass instance to tailing parser arguments.
-
- If `with_prefix` is provided, prefix all the keys in the resulting parser with it. It means that we are
- building a flat namespace from a structured dataclass (see transformer_config.py for example).
- """
-
- def argparse_name(name: str):
- if name == "data" and (with_prefix is None or with_prefix == ""):
- # normally data is positional args, so we don't add the -- nor the prefix
- return name
- if name == "_name":
- # private member, skip
- return None
- full_name = "--" + name.replace("_", "-")
- if with_prefix is not None and with_prefix != "":
- # if a prefix is specified, construct the prefixed arg name
- full_name = with_prefix + "-" + full_name[2:] # strip -- when composing
- return full_name
-
- def get_kwargs_from_dc(
- dataclass_instance: FairseqDataclass, k: str
- ) -> Dict[str, Any]:
- """k: dataclass attributes"""
-
- kwargs = {}
-
- field_type = dataclass_instance._get_type(k)
- inter_type = interpret_dc_type(field_type)
-
- field_default = dataclass_instance._get_default(k)
-
- if isinstance(inter_type, type) and issubclass(inter_type, Enum):
- field_choices = [t.value for t in list(inter_type)]
- else:
- field_choices = None
-
- field_help = dataclass_instance._get_help(k)
- field_const = dataclass_instance._get_argparse_const(k)
-
- if isinstance(field_default, str) and field_default.startswith("${"):
- kwargs["default"] = field_default
- else:
- if field_default is MISSING:
- kwargs["required"] = True
- if field_choices is not None:
- kwargs["choices"] = field_choices
- if (
- isinstance(inter_type, type)
- and (issubclass(inter_type, List) or issubclass(inter_type, Tuple))
- ) or ("List" in str(inter_type) or "Tuple" in str(inter_type)):
- if "int" in str(inter_type):
- kwargs["type"] = lambda x: eval_str_list(x, int)
- elif "float" in str(inter_type):
- kwargs["type"] = lambda x: eval_str_list(x, float)
- elif "str" in str(inter_type):
- kwargs["type"] = lambda x: eval_str_list(x, str)
- else:
- raise NotImplementedError(
- "parsing of type " + str(inter_type) + " is not implemented"
- )
- if field_default is not MISSING:
- kwargs["default"] = (
- ",".join(map(str, field_default))
- if field_default is not None
- else None
- )
- elif (
- isinstance(inter_type, type) and issubclass(inter_type, Enum)
- ) or "Enum" in str(inter_type):
- kwargs["type"] = str
- if field_default is not MISSING:
- if isinstance(field_default, Enum):
- kwargs["default"] = field_default.value
- else:
- kwargs["default"] = field_default
- elif inter_type is bool:
- kwargs["action"] = (
- "store_false" if field_default is True else "store_true"
- )
- kwargs["default"] = field_default
- else:
- kwargs["type"] = inter_type
- if field_default is not MISSING:
- kwargs["default"] = field_default
-
- # build the help with the hierarchical prefix
- if with_prefix is not None and with_prefix != "" and field_help is not None:
- field_help = with_prefix[2:] + ": " + field_help
-
- kwargs["help"] = field_help
- if field_const is not None:
- kwargs["const"] = field_const
- kwargs["nargs"] = "?"
-
- return kwargs
-
- for k in dataclass_instance._get_all_attributes():
- field_name = argparse_name(dataclass_instance._get_name(k))
- field_type = dataclass_instance._get_type(k)
- if field_name is None:
- continue
- elif inspect.isclass(field_type) and issubclass(field_type, FairseqDataclass):
- # for fields that are of type FairseqDataclass, we can recursively
- # add their fields to the namespace (so we add the args from model, task, etc. to the root namespace)
- prefix = None
- if with_prefix is not None:
- # if a prefix is specified, then we don't want to copy the subfields directly to the root namespace
- # but we prefix them with the name of the current field.
- prefix = field_name
- gen_parser_from_dataclass(parser, field_type(), delete_default, prefix)
- continue
-
- kwargs = get_kwargs_from_dc(dataclass_instance, k)
-
- field_args = [field_name]
- alias = dataclass_instance._get_argparse_alias(k)
- if alias is not None:
- field_args.append(alias)
-
- if "default" in kwargs:
- if isinstance(kwargs["default"], str) and kwargs["default"].startswith(
- "${"
- ):
- if kwargs["help"] is None:
- # this is a field with a name that will be added elsewhere
- continue
- else:
- del kwargs["default"]
- if delete_default and "default" in kwargs:
- del kwargs["default"]
- try:
- parser.add_argument(*field_args, **kwargs)
- except ArgumentError:
- pass
-
-
-def _set_legacy_defaults(args, cls):
- """Helper to set default arguments based on *add_args*."""
- if not hasattr(cls, "add_args"):
- return
-
- import argparse
-
- parser = argparse.ArgumentParser(
- argument_default=argparse.SUPPRESS, allow_abbrev=False
- )
- cls.add_args(parser)
- # copied from argparse.py:
- defaults = argparse.Namespace()
- for action in parser._actions:
- if action.dest is not argparse.SUPPRESS:
- if not hasattr(defaults, action.dest):
- if action.default is not argparse.SUPPRESS:
- setattr(defaults, action.dest, action.default)
- for key, default_value in vars(defaults).items():
- if not hasattr(args, key):
- setattr(args, key, default_value)
-
-
-def _override_attr(
- sub_node: str, data_class: Type[FairseqDataclass], args: Namespace
-) -> List[str]:
- overrides = []
-
- if not inspect.isclass(data_class) or not issubclass(data_class, FairseqDataclass):
- return overrides
-
- def get_default(f):
- if not isinstance(f.default_factory, _MISSING_TYPE):
- return f.default_factory()
- return f.default
-
- for k, v in data_class.__dataclass_fields__.items():
- if k.startswith("_"):
- # private member, skip
- continue
-
- val = get_default(v) if not hasattr(args, k) else getattr(args, k)
-
- field_type = interpret_dc_type(v.type)
- if (
- isinstance(val, str)
- and not val.startswith("${") # not interpolation
- and field_type != str
- and (
- not inspect.isclass(field_type) or not issubclass(field_type, Enum)
- ) # not choices enum
- ):
- # upgrade old models that stored complex parameters as string
- val = ast.literal_eval(val)
-
- if isinstance(val, tuple):
- val = list(val)
-
- v_type = getattr(v.type, "__origin__", None)
- if (
- (v_type is List or v_type is list or v_type is Optional)
- # skip interpolation
- and not (isinstance(val, str) and val.startswith("${"))
- ):
- # if type is int but val is float, then we will crash later - try to convert here
- if hasattr(v.type, "__args__"):
- t_args = v.type.__args__
- if len(t_args) == 1 and (t_args[0] is float or t_args[0] is int):
- val = list(map(t_args[0], val))
- elif val is not None and (
- field_type is int or field_type is bool or field_type is float
- ):
- try:
- val = field_type(val)
- except:
- pass # ignore errors here, they are often from interpolation args
-
- if val is None:
- overrides.append("{}.{}=null".format(sub_node, k))
- elif val == "":
- overrides.append("{}.{}=''".format(sub_node, k))
- elif isinstance(val, str):
- val = val.replace("'", r"\'")
- overrides.append("{}.{}='{}'".format(sub_node, k, val))
- elif isinstance(val, FairseqDataclass):
- overrides += _override_attr(f"{sub_node}.{k}", type(val), args)
- elif isinstance(val, Namespace):
- sub_overrides, _ = override_module_args(val)
- for so in sub_overrides:
- overrides.append(f"{sub_node}.{k}.{so}")
- else:
- overrides.append("{}.{}={}".format(sub_node, k, val))
-
- return overrides
-
-
-def migrate_registry(
- name, value, registry, args, overrides, deletes, use_name_as_val=False
-):
- if value in registry:
- overrides.append("{}={}".format(name, value))
- overrides.append("{}._name={}".format(name, value))
- overrides.extend(_override_attr(name, registry[value], args))
- elif use_name_as_val and value is not None:
- overrides.append("{}={}".format(name, value))
- else:
- deletes.append(name)
-
-
-def override_module_args(args: Namespace) -> Tuple[List[str], List[str]]:
- """use the field in args to overrides those in cfg"""
- overrides = []
- deletes = []
-
- for k in FairseqConfig.__dataclass_fields__.keys():
- overrides.extend(
- _override_attr(k, FairseqConfig.__dataclass_fields__[k].type, args)
- )
-
- if args is not None:
- if hasattr(args, "task"):
- from fairseq.tasks import TASK_DATACLASS_REGISTRY
-
- migrate_registry(
- "task", args.task, TASK_DATACLASS_REGISTRY, args, overrides, deletes
- )
- else:
- deletes.append("task")
-
- # these options will be set to "None" if they have not yet been migrated
- # so we can populate them with the entire flat args
- CORE_REGISTRIES = {"criterion", "optimizer", "lr_scheduler"}
-
- from fairseq.registry import REGISTRIES
-
- for k, v in REGISTRIES.items():
- if hasattr(args, k):
- migrate_registry(
- k,
- getattr(args, k),
- v["dataclass_registry"],
- args,
- overrides,
- deletes,
- use_name_as_val=k not in CORE_REGISTRIES,
- )
- else:
- deletes.append(k)
-
- no_dc = True
- if hasattr(args, "arch"):
- from fairseq.models import ARCH_MODEL_REGISTRY, ARCH_MODEL_NAME_REGISTRY
-
- if args.arch in ARCH_MODEL_REGISTRY:
- m_cls = ARCH_MODEL_REGISTRY[args.arch]
- dc = getattr(m_cls, "__dataclass", None)
- if dc is not None:
- m_name = ARCH_MODEL_NAME_REGISTRY[args.arch]
- overrides.append("model={}".format(m_name))
- overrides.append("model._name={}".format(args.arch))
- # override model params with those exist in args
- overrides.extend(_override_attr("model", dc, args))
- no_dc = False
- if no_dc:
- deletes.append("model")
-
- return overrides, deletes
-
-
-class omegaconf_no_object_check:
- def __init__(self):
- # Changed in https://github.com/omry/omegaconf/pull/911 - both are kept for back compat.
- if hasattr(_utils, "is_primitive_type"):
- self.old_is_primitive = _utils.is_primitive_type
- else:
- self.old_is_primitive = _utils.is_primitive_type_annotation
-
- def __enter__(self):
- if hasattr(_utils, "is_primitive_type"):
- _utils.is_primitive_type = lambda _: True
- else:
- _utils.is_primitive_type_annotation = lambda _: True
-
- def __exit__(self, type, value, traceback):
- if hasattr(_utils, "is_primitive_type"):
- _utils.is_primitive_type = self.old_is_primitive
- else:
- _utils.is_primitive_type_annotation = self.old_is_primitive
-
-
-def convert_namespace_to_omegaconf(args: Namespace) -> DictConfig:
- """Convert a flat argparse.Namespace to a structured DictConfig."""
-
- # Here we are using field values provided in args to override counterparts inside config object
- overrides, deletes = override_module_args(args)
-
- # configs will be in fairseq/config after installation
- config_path = os.path.join("..", "config")
-
- GlobalHydra.instance().clear()
-
- with initialize(config_path=config_path):
- try:
- composed_cfg = compose("config", overrides=overrides, strict=False)
- except:
- logger.error("Error when composing. Overrides: " + str(overrides))
- raise
-
- for k in deletes:
- composed_cfg[k] = None
-
- cfg = OmegaConf.create(
- OmegaConf.to_container(composed_cfg, resolve=True, enum_to_str=True)
- )
-
- # hack to be able to set Namespace in dict config. this should be removed when we update to newer
- # omegaconf version that supports object flags, or when we migrate all existing models
- from omegaconf import _utils
-
- with omegaconf_no_object_check():
- if cfg.task is None and getattr(args, "task", None):
- cfg.task = Namespace(**vars(args))
- from fairseq.tasks import TASK_REGISTRY
-
- _set_legacy_defaults(cfg.task, TASK_REGISTRY[args.task])
- cfg.task._name = args.task
- if cfg.model is None and getattr(args, "arch", None):
- cfg.model = Namespace(**vars(args))
- from fairseq.models import ARCH_MODEL_REGISTRY
-
- _set_legacy_defaults(cfg.model, ARCH_MODEL_REGISTRY[args.arch])
- cfg.model._name = args.arch
- if cfg.optimizer is None and getattr(args, "optimizer", None):
- cfg.optimizer = Namespace(**vars(args))
- from fairseq.optim import OPTIMIZER_REGISTRY
-
- _set_legacy_defaults(cfg.optimizer, OPTIMIZER_REGISTRY[args.optimizer])
- cfg.optimizer._name = args.optimizer
- if cfg.lr_scheduler is None and getattr(args, "lr_scheduler", None):
- cfg.lr_scheduler = Namespace(**vars(args))
- from fairseq.optim.lr_scheduler import LR_SCHEDULER_REGISTRY
-
- _set_legacy_defaults(
- cfg.lr_scheduler, LR_SCHEDULER_REGISTRY[args.lr_scheduler]
- )
- cfg.lr_scheduler._name = args.lr_scheduler
- if cfg.criterion is None and getattr(args, "criterion", None):
- cfg.criterion = Namespace(**vars(args))
- from fairseq.criterions import CRITERION_REGISTRY
-
- _set_legacy_defaults(cfg.criterion, CRITERION_REGISTRY[args.criterion])
- cfg.criterion._name = args.criterion
-
- OmegaConf.set_struct(cfg, True)
- return cfg
-
-
-def overwrite_args_by_name(cfg: DictConfig, overrides: Dict[str, any]):
- # this will be deprecated when we get rid of argparse and model_overrides logic
-
- from fairseq.registry import REGISTRIES
-
- with open_dict(cfg):
- for k in cfg.keys():
- # "k in cfg" will return false if its a "mandatory value (e.g. ???)"
- if k in cfg and isinstance(cfg[k], DictConfig):
- if k in overrides and isinstance(overrides[k], dict):
- for ok, ov in overrides[k].items():
- if isinstance(ov, dict) and cfg[k][ok] is not None:
- overwrite_args_by_name(cfg[k][ok], ov)
- else:
- cfg[k][ok] = ov
- else:
- overwrite_args_by_name(cfg[k], overrides)
- elif k in cfg and isinstance(cfg[k], Namespace):
- for override_key, val in overrides.items():
- setattr(cfg[k], override_key, val)
- elif k in overrides:
- if (
- k in REGISTRIES
- and overrides[k] in REGISTRIES[k]["dataclass_registry"]
- ):
- cfg[k] = DictConfig(
- REGISTRIES[k]["dataclass_registry"][overrides[k]]
- )
- overwrite_args_by_name(cfg[k], overrides)
- cfg[k]._name = overrides[k]
- else:
- cfg[k] = overrides[k]
-
-
-def merge_with_parent(dc: FairseqDataclass, cfg: DictConfig, remove_missing=False):
- if remove_missing:
-
- if is_dataclass(dc):
- target_keys = set(dc.__dataclass_fields__.keys())
- else:
- target_keys = set(dc.keys())
-
- with open_dict(cfg):
- for k in list(cfg.keys()):
- if k not in target_keys:
- del cfg[k]
-
- merged_cfg = OmegaConf.merge(dc, cfg)
- merged_cfg.__dict__["_parent"] = cfg.__dict__["_parent"]
- OmegaConf.set_struct(merged_cfg, True)
- return merged_cfg
diff --git a/spaces/attention-refocusing/Attention-refocusing/gligen/ldm/data/base.py b/spaces/attention-refocusing/Attention-refocusing/gligen/ldm/data/base.py
deleted file mode 100644
index b196c2f7aa583a3e8bc4aad9f943df0c4dae0da7..0000000000000000000000000000000000000000
--- a/spaces/attention-refocusing/Attention-refocusing/gligen/ldm/data/base.py
+++ /dev/null
@@ -1,23 +0,0 @@
-from abc import abstractmethod
-from torch.utils.data import Dataset, ConcatDataset, ChainDataset, IterableDataset
-
-
-class Txt2ImgIterableBaseDataset(IterableDataset):
- '''
- Define an interface to make the IterableDatasets for text2img data chainable
- '''
- def __init__(self, num_records=0, valid_ids=None, size=256):
- super().__init__()
- self.num_records = num_records
- self.valid_ids = valid_ids
- self.sample_ids = valid_ids
- self.size = size
-
- print(f'{self.__class__.__name__} dataset contains {self.__len__()} examples.')
-
- def __len__(self):
- return self.num_records
-
- @abstractmethod
- def __iter__(self):
- pass
\ No newline at end of file
diff --git a/spaces/avivdm1/AutoGPT/tests/unit/test_browse_scrape_links.py b/spaces/avivdm1/AutoGPT/tests/unit/test_browse_scrape_links.py
deleted file mode 100644
index 0a3340e7397a997da96b8ab9828954230e1a3c20..0000000000000000000000000000000000000000
--- a/spaces/avivdm1/AutoGPT/tests/unit/test_browse_scrape_links.py
+++ /dev/null
@@ -1,118 +0,0 @@
-# Generated by CodiumAI
-
-# Dependencies:
-# pip install pytest-mock
-import pytest
-
-from autogpt.commands.web_requests import scrape_links
-
-"""
-Code Analysis
-
-Objective:
-The objective of the 'scrape_links' function is to scrape hyperlinks from a
-given URL and return them in a formatted way.
-
-Inputs:
-- url: a string representing the URL to be scraped.
-
-Flow:
-1. Send a GET request to the given URL using the requests library and the user agent header from the config file.
-2. Check if the response contains an HTTP error. If it does, return "error".
-3. Parse the HTML content of the response using the BeautifulSoup library.
-4. Remove any script and style tags from the parsed HTML.
-5. Extract all hyperlinks from the parsed HTML using the 'extract_hyperlinks' function.
-6. Format the extracted hyperlinks using the 'format_hyperlinks' function.
-7. Return the formatted hyperlinks.
-
-Outputs:
-- A list of formatted hyperlinks.
-
-Additional aspects:
-- The function uses the 'requests' and 'BeautifulSoup' libraries to send HTTP
-requests and parse HTML content, respectively.
-- The 'extract_hyperlinks' function is called to extract hyperlinks from the parsed HTML.
-- The 'format_hyperlinks' function is called to format the extracted hyperlinks.
-- The function checks for HTTP errors and returns "error" if any are found.
-"""
-
-
-class TestScrapeLinks:
- # Tests that the function returns a list of formatted hyperlinks when
- # provided with a valid url that returns a webpage with hyperlinks.
- def test_valid_url_with_hyperlinks(self):
- url = "https://www.google.com"
- result = scrape_links(url)
- assert len(result) > 0
- assert isinstance(result, list)
- assert isinstance(result[0], str)
-
- # Tests that the function returns correctly formatted hyperlinks when given a valid url.
- def test_valid_url(self, mocker):
- # Mock the requests.get() function to return a response with sample HTML containing hyperlinks
- mock_response = mocker.Mock()
- mock_response.status_code = 200
- mock_response.text = (
- "Google"
- )
- mocker.patch("requests.Session.get", return_value=mock_response)
-
- # Call the function with a valid URL
- result = scrape_links("https://www.example.com")
-
- # Assert that the function returns correctly formatted hyperlinks
- assert result == ["Google (https://www.google.com)"]
-
- # Tests that the function returns "error" when given an invalid url.
- def test_invalid_url(self, mocker):
- # Mock the requests.get() function to return an HTTP error response
- mock_response = mocker.Mock()
- mock_response.status_code = 404
- mocker.patch("requests.Session.get", return_value=mock_response)
-
- # Call the function with an invalid URL
- result = scrape_links("https://www.invalidurl.com")
-
- # Assert that the function returns "error"
- assert "Error:" in result
-
- # Tests that the function returns an empty list when the html contains no hyperlinks.
- def test_no_hyperlinks(self, mocker):
- # Mock the requests.get() function to return a response with sample HTML containing no hyperlinks
- mock_response = mocker.Mock()
- mock_response.status_code = 200
- mock_response.text = "My static Space
-
-
-
-
- - aaccfb2cb3
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md b/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md deleted file mode 100644 index ebf77aba8f78dc8a9a70797d0d04b20bd2fe64df..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md +++ /dev/null @@ -1,5 +0,0 @@ -
-
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md b/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md deleted file mode 100644 index 2938872482d81e5d41e420e1081dd64e7f059557..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md +++ /dev/null @@ -1,6 +0,0 @@ -
-
-
-
-
\ No newline at end of file diff --git a/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py b/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py deleted file mode 100644 index 6f8b6eba5b98310f57a656db73b5e415de3af958..0000000000000000000000000000000000000000 --- a/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py +++ /dev/null @@ -1,31 +0,0 @@ -from src.config import VadInitialPromptMode -from src.prompts.abstractPromptStrategy import AbstractPromptStrategy - -class PrependPromptStrategy(AbstractPromptStrategy): - """ - A simple prompt strategy that prepends a single prompt to all segments of audio, or prepends the prompt to the first segment of audio. - """ - def __init__(self, initial_prompt: str, initial_prompt_mode: VadInitialPromptMode): - """ - Parameters - ---------- - initial_prompt: str - The initial prompt to use for the transcription. - initial_prompt_mode: VadInitialPromptMode - The mode to use for the initial prompt. If set to PREPEND_FIRST_SEGMENT, the initial prompt will be prepended to the first segment of audio. - If set to PREPEND_ALL_SEGMENTS, the initial prompt will be prepended to all segments of audio. - """ - self.initial_prompt = initial_prompt - self.initial_prompt_mode = initial_prompt_mode - - # This is a simple prompt strategy, so we only support these two modes - if initial_prompt_mode not in [VadInitialPromptMode.PREPEND_ALL_SEGMENTS, VadInitialPromptMode.PREPREND_FIRST_SEGMENT]: - raise ValueError(f"Unsupported initial prompt mode {initial_prompt_mode}") - - def get_segment_prompt(self, segment_index: int, whisper_prompt: str, detected_language: str) -> str: - if (self.initial_prompt_mode == VadInitialPromptMode.PREPEND_ALL_SEGMENTS): - return self._concat_prompt(self.initial_prompt, whisper_prompt) - elif (self.initial_prompt_mode == VadInitialPromptMode.PREPREND_FIRST_SEGMENT): - return self._concat_prompt(self.initial_prompt, whisper_prompt) if segment_index == 0 else whisper_prompt - else: - raise ValueError(f"Unknown initial prompt mode {self.initial_prompt_mode}") \ No newline at end of file diff --git a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py b/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py deleted file mode 100644 index 8abd1bbeea5909e664cf816c020bd7c37effdb66..0000000000000000000000000000000000000000 --- a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py +++ /dev/null @@ -1,58 +0,0 @@ -# Copyright (c) Meta Platforms, Inc. and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. - -import logging -import os -from queue import Queue, Empty -import signal -import sys -import threading -import traceback - -logger = logging.getLogger(__name__) - - -class DeadlockDetect: - def __init__(self, use: bool = False, timeout: float = 120.): - self.use = use - self.timeout = timeout - self._queue: Queue = Queue() - - def update(self, stage: str): - if self.use: - self._queue.put(stage) - - def __enter__(self): - if self.use: - self._thread = threading.Thread(target=self._detector_thread) - self._thread.start() - - def __exit__(self, exc_type, exc_val, exc_tb): - if self.use: - self._queue.put(None) - self._thread.join() - - def _detector_thread(self): - logger.debug("Deadlock detector started") - last_stage = "init" - while True: - try: - stage = self._queue.get(timeout=self.timeout) - except Empty: - break - if stage is None: - logger.debug("Exiting deadlock detector thread") - return - else: - last_stage = stage - logger.error("Deadlock detector timed out, last stage was %s", last_stage) - for th in threading.enumerate(): - print(th, file=sys.stderr) - traceback.print_stack(sys._current_frames()[th.ident]) - print(file=sys.stderr) - sys.stdout.flush() - sys.stderr.flush() - os.kill(os.getpid(), signal.SIGKILL) diff --git a/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py b/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py deleted file mode 100644 index 66348b6d0c0ab6298c02c6acb52a533f4a211351..0000000000000000000000000000000000000000 --- a/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .main import * -from . import beatmap, effects, image, io, metrics, presets, osu, utils \ No newline at end of file diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py b/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py deleted file mode 100644 index a9ea9a9f578c5704d1e7ff563ef156e9133ab465..0000000000000000000000000000000000000000 --- a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py +++ /dev/null @@ -1,238 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -""" -This file contains primitives for multi-gpu communication. -This is useful when doing distributed training. -""" - -import functools -import numpy as np -import torch -import torch.distributed as dist - -_LOCAL_PROCESS_GROUP = None -_MISSING_LOCAL_PG_ERROR = ( - "Local process group is not yet created! Please use detectron2's `launch()` " - "to start processes and initialize pytorch process group. If you need to start " - "processes in other ways, please call comm.create_local_process_group(" - "num_workers_per_machine) after calling torch.distributed.init_process_group()." -) - - -def get_world_size() -> int: - if not dist.is_available(): - return 1 - if not dist.is_initialized(): - return 1 - return dist.get_world_size() - - -def get_rank() -> int: - if not dist.is_available(): - return 0 - if not dist.is_initialized(): - return 0 - return dist.get_rank() - - -@functools.lru_cache() -def create_local_process_group(num_workers_per_machine: int) -> None: - """ - Create a process group that contains ranks within the same machine. - - Detectron2's launch() in engine/launch.py will call this function. If you start - workers without launch(), you'll have to also call this. Otherwise utilities - like `get_local_rank()` will not work. - - This function contains a barrier. All processes must call it together. - - Args: - num_workers_per_machine: the number of worker processes per machine. Typically - the number of GPUs. - """ - global _LOCAL_PROCESS_GROUP - assert _LOCAL_PROCESS_GROUP is None - assert get_world_size() % num_workers_per_machine == 0 - num_machines = get_world_size() // num_workers_per_machine - machine_rank = get_rank() // num_workers_per_machine - for i in range(num_machines): - ranks_on_i = list(range(i * num_workers_per_machine, (i + 1) * num_workers_per_machine)) - pg = dist.new_group(ranks_on_i) - if i == machine_rank: - _LOCAL_PROCESS_GROUP = pg - - -def get_local_process_group(): - """ - Returns: - A torch process group which only includes processes that are on the same - machine as the current process. This group can be useful for communication - within a machine, e.g. a per-machine SyncBN. - """ - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return _LOCAL_PROCESS_GROUP - - -def get_local_rank() -> int: - """ - Returns: - The rank of the current process within the local (per-machine) process group. - """ - if not dist.is_available(): - return 0 - if not dist.is_initialized(): - return 0 - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return dist.get_rank(group=_LOCAL_PROCESS_GROUP) - - -def get_local_size() -> int: - """ - Returns: - The size of the per-machine process group, - i.e. the number of processes per machine. - """ - if not dist.is_available(): - return 1 - if not dist.is_initialized(): - return 1 - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return dist.get_world_size(group=_LOCAL_PROCESS_GROUP) - - -def is_main_process() -> bool: - return get_rank() == 0 - - -def synchronize(): - """ - Helper function to synchronize (barrier) among all processes when - using distributed training - """ - if not dist.is_available(): - return - if not dist.is_initialized(): - return - world_size = dist.get_world_size() - if world_size == 1: - return - if dist.get_backend() == dist.Backend.NCCL: - # This argument is needed to avoid warnings. - # It's valid only for NCCL backend. - dist.barrier(device_ids=[torch.cuda.current_device()]) - else: - dist.barrier() - - -@functools.lru_cache() -def _get_global_gloo_group(): - """ - Return a process group based on gloo backend, containing all the ranks - The result is cached. - """ - if dist.get_backend() == "nccl": - return dist.new_group(backend="gloo") - else: - return dist.group.WORLD - - -def all_gather(data, group=None): - """ - Run all_gather on arbitrary picklable data (not necessarily tensors). - - Args: - data: any picklable object - group: a torch process group. By default, will use a group which - contains all ranks on gloo backend. - - Returns: - list[data]: list of data gathered from each rank - """ - if get_world_size() == 1: - return [data] - if group is None: - group = _get_global_gloo_group() # use CPU group by default, to reduce GPU RAM usage. - world_size = dist.get_world_size(group) - if world_size == 1: - return [data] - - output = [None for _ in range(world_size)] - dist.all_gather_object(output, data, group=group) - return output - - -def gather(data, dst=0, group=None): - """ - Run gather on arbitrary picklable data (not necessarily tensors). - - Args: - data: any picklable object - dst (int): destination rank - group: a torch process group. By default, will use a group which - contains all ranks on gloo backend. - - Returns: - list[data]: on dst, a list of data gathered from each rank. Otherwise, - an empty list. - """ - if get_world_size() == 1: - return [data] - if group is None: - group = _get_global_gloo_group() - world_size = dist.get_world_size(group=group) - if world_size == 1: - return [data] - rank = dist.get_rank(group=group) - - if rank == dst: - output = [None for _ in range(world_size)] - dist.gather_object(data, output, dst=dst, group=group) - return output - else: - dist.gather_object(data, None, dst=dst, group=group) - return [] - - -def shared_random_seed(): - """ - Returns: - int: a random number that is the same across all workers. - If workers need a shared RNG, they can use this shared seed to - create one. - - All workers must call this function, otherwise it will deadlock. - """ - ints = np.random.randint(2**31) - all_ints = all_gather(ints) - return all_ints[0] - - -def reduce_dict(input_dict, average=True): - """ - Reduce the values in the dictionary from all processes so that process with rank - 0 has the reduced results. - - Args: - input_dict (dict): inputs to be reduced. All the values must be scalar CUDA Tensor. - average (bool): whether to do average or sum - - Returns: - a dict with the same keys as input_dict, after reduction. - """ - world_size = get_world_size() - if world_size < 2: - return input_dict - with torch.no_grad(): - names = [] - values = [] - # sort the keys so that they are consistent across processes - for k in sorted(input_dict.keys()): - names.append(k) - values.append(input_dict[k]) - values = torch.stack(values, dim=0) - dist.reduce(values, dst=0) - if dist.get_rank() == 0 and average: - # only main process gets accumulated, so only divide by - # world_size in this case - values /= world_size - reduced_dict = {k: v for k, v in zip(names, values)} - return reduced_dict diff --git a/spaces/bruno16/massa_qa/prompts.py b/spaces/bruno16/massa_qa/prompts.py deleted file mode 100644 index a59eb9f6a22b38e92c8e79ed44ddfd4039735f89..0000000000000000000000000000000000000000 --- a/spaces/bruno16/massa_qa/prompts.py +++ /dev/null @@ -1,109 +0,0 @@ -"""Prompts for the chatbot and evaluation.""" -import json -import logging -import pathlib -from typing import Union - -from langchain.prompts import ( - ChatPromptTemplate, - HumanMessagePromptTemplate, - SystemMessagePromptTemplate, -) - -logger = logging.getLogger(__name__) - - -def load_chat_prompt(f_name: Union[pathlib.Path, str] = None) -> ChatPromptTemplate: - if isinstance(f_name, str) and f_name: - f_name = pathlib.Path(f_name) - if f_name and f_name.is_file(): - template = json.load(f_name.open("r")) - else: - logger.warning( - f"No chat prompt provided. Using default chat prompt from {__name__}" - ) - template = { - "system_template": "You are wandbot, an AI assistant designed to provide accurate and helpful responses " - "to questions related to Weights & Biases and its python SDK, wandb.\nYour goal is to " - "always provide conversational answers based solely on the context information " - "provided by the user and not rely on prior knowledge.\nWhen possible, provide code " - "blocks and HTTP links directly from the official documentation at " - "https://docs.wandb.ai, but ensure that they are relevant and not fabricated.\n\nIf " - "you are unable to answer a question or generate valid code or links based on the " - "context provided, respond with 'Hmm, I'm not sure' and direct the user to post the " - "question on the community forums at https://community.wandb.ai/ or reach out to wandb " - "support via support@wandb.ai.\n\nYou can only answer questions related to wandb and " - "Weights & Biases.\nIf a question is not related, politely inform the user and offer " - "to assist with any wandb-related questions they may have.\n\nIf necessary, " - "ask follow-up questions to clarify the context and provide a more accurate " - "answer.\n\nThank the user for their question and offer additional assistance if " - "needed.\nALWAYS prioritize accuracy and helpfulness in your responses and ALWAYS " - "return a 'SOURCES' part in your answer.\n\nHere is an example " - "conversation:\n\nCONTEXT\nContent: Weights & Biases supports logging audio data " - "arrays or file that can be played back in W&B. You can log audio with `wandb.Audio(" - ")`\nSource: 28-pl\nContent: # Log an audio array or file\nwandb.log({{'my whale " - "song': wandb.Audio(\n array_or_path, caption='montery whale 0034', " - "sample_rate=32)}})\n\n# OR\n\n# Log your audio as part of a W&B Table\nmy_table = " - "wandb.Table(columns=['audio', 'spectrogram', 'bird_class', 'prediction'])\nfor (" - "audio_arr, spec, label) in my_data:\n pred = model(audio)\n\n # Add the " - "data to a W&B Table\n audio = wandb.Audio(audio_arr, sample_rate=32)\n " - "img = wandb.Image(spec)\n my_table.add_data(audio, img, label, pred)\n\n# Log " - "the Table to wandb\n wandb.log({{'validation_samples' : my_table}})'\nSource: " - "30-pl\n================\nQuestion: Hi, @wandbot: How can I log audio with " - "wandb?\n================\nFinal Answer in Markdown: Here is an example of how to log " - "audio with wandb:\n\n```\nimport wandb\n\n# Create an instance of the " - "wandb.data_types.Audio class\naudio = wandb.data_types.Audio(" - "data_or_path='path/to/audio.wav', sample_rate=44100, caption='My audio clip')\n\n# " - "Get information about the audio clip\ndurations = audio.durations()\nsample_rates = " - "audio.sample_rates()\n\n# Log the audio clip\nwandb.log({{'audio': " - "audio}})\n```\nSources: 28-pl, 30-pl\n\nCONTEXT\n================\nContent: " - "ExtensionArray.repeat(repeats, axis=None) Returns a new ExtensionArray where each " - "element of the current ExtensionArray is repeated consecutively a given number of " - "times.\n\nParameters: repeats int or array of ints. The number of repetitions for " - "each element. This should be a positive integer. Repeating 0 times will return an " - "empty array. axis (0 or ‘index’, 1 or ‘columns’), default 0 The axis along which to " - "repeat values. Currently only axis=0 is supported.\nSource: " - "0-pl\n================\nQuestion: How to eat vegetables using " - "pandas?\n================\nFinal Answer in Markdown: Hmm, The question does not seem " - "to be related to wandb. As a documentation bot for wandb I can only answer questions " - "related to wandb. Please try again with a question related to " - "wandb.\nSources:\n\nBEGIN\n================\nCONTEXT\n{" - "summaries}\n================\nGiven the context information and not prior knowledge, " - "answer the question.\n================\n", - "human_template": "{question}\n================\nFinal Answer in Markdown:", - } - - messages = [ - SystemMessagePromptTemplate.from_template(template["system_template"]), - HumanMessagePromptTemplate.from_template(template["human_template"]), - ] - prompt = ChatPromptTemplate.from_messages(messages) - return prompt - - -def load_eval_prompt(f_name: Union[pathlib.Path, str] = None) -> ChatPromptTemplate: - if isinstance(f_name, str) and f_name: - f_name = pathlib.Path(f_name) - if f_name and f_name.is_file(): - human_template = f_name.open("r").read() - else: - logger.warning( - f"No human prompt provided. Using default human prompt from {__name__}" - ) - - human_template = """\nQUESTION: {query}\nCHATBOT ANSWER: {result}\n - ORIGINAL ANSWER: {answer} GRADE:""" - - system_message_prompt = SystemMessagePromptTemplate.from_template( - """You are an evaluator for the W&B chatbot.You are given a question, the chatbot's answer, and the original answer, - and are asked to score the chatbot's answer as either CORRECT or INCORRECT. Note - that sometimes, the original answer is not the best answer, and sometimes the chatbot's answer is not the - best answer. You are evaluating the chatbot's answer only. Example Format:\nQUESTION: question here\nCHATBOT - ANSWER: student's answer here\nORIGINAL ANSWER: original answer here\nGRADE: CORRECT or INCORRECT here\nPlease - remember to grade them based on being factually accurate. Begin!""" - ) - human_message_prompt = HumanMessagePromptTemplate.from_template(human_template) - chat_prompt = ChatPromptTemplate.from_messages( - [system_message_prompt, human_message_prompt] - ) - return chat_prompt diff --git a/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py b/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py deleted file mode 100644 index 04521bf3681ddc8be3db942820725d9061f47f6a..0000000000000000000000000000000000000000 --- a/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py +++ /dev/null @@ -1,577 +0,0 @@ -"""Utilities and tools for tracking runs with Weights & Biases.""" - -import logging -import os -import sys -from contextlib import contextmanager -from pathlib import Path -from typing import Dict - -import yaml -from tqdm import tqdm - -FILE = Path(__file__).resolve() -ROOT = FILE.parents[3] # YOLOv5 root directory -if str(ROOT) not in sys.path: - sys.path.append(str(ROOT)) # add ROOT to PATH - -from utils.dataloaders import LoadImagesAndLabels, img2label_paths -from utils.general import LOGGER, check_dataset, check_file - -try: - import wandb - - assert hasattr(wandb, '__version__') # verify package import not local dir -except (ImportError, AssertionError): - wandb = None - -RANK = int(os.getenv('RANK', -1)) -WANDB_ARTIFACT_PREFIX = 'wandb-artifact://' - - -def remove_prefix(from_string, prefix=WANDB_ARTIFACT_PREFIX): - return from_string[len(prefix):] - - -def check_wandb_config_file(data_config_file): - wandb_config = '_wandb.'.join(data_config_file.rsplit('.', 1)) # updated data.yaml path - if Path(wandb_config).is_file(): - return wandb_config - return data_config_file - - -def check_wandb_dataset(data_file): - is_trainset_wandb_artifact = False - is_valset_wandb_artifact = False - if check_file(data_file) and data_file.endswith('.yaml'): - with open(data_file, errors='ignore') as f: - data_dict = yaml.safe_load(f) - is_trainset_wandb_artifact = isinstance(data_dict['train'], - str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX) - is_valset_wandb_artifact = isinstance(data_dict['val'], - str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX) - if is_trainset_wandb_artifact or is_valset_wandb_artifact: - return data_dict - else: - return check_dataset(data_file) - - -def get_run_info(run_path): - run_path = Path(remove_prefix(run_path, WANDB_ARTIFACT_PREFIX)) - run_id = run_path.stem - project = run_path.parent.stem - entity = run_path.parent.parent.stem - model_artifact_name = 'run_' + run_id + '_model' - return entity, project, run_id, model_artifact_name - - -def check_wandb_resume(opt): - process_wandb_config_ddp_mode(opt) if RANK not in [-1, 0] else None - if isinstance(opt.resume, str): - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - if RANK not in [-1, 0]: # For resuming DDP runs - entity, project, run_id, model_artifact_name = get_run_info(opt.resume) - api = wandb.Api() - artifact = api.artifact(entity + '/' + project + '/' + model_artifact_name + ':latest') - modeldir = artifact.download() - opt.weights = str(Path(modeldir) / "last.pt") - return True - return None - - -def process_wandb_config_ddp_mode(opt): - with open(check_file(opt.data), errors='ignore') as f: - data_dict = yaml.safe_load(f) # data dict - train_dir, val_dir = None, None - if isinstance(data_dict['train'], str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX): - api = wandb.Api() - train_artifact = api.artifact(remove_prefix(data_dict['train']) + ':' + opt.artifact_alias) - train_dir = train_artifact.download() - train_path = Path(train_dir) / 'data/images/' - data_dict['train'] = str(train_path) - - if isinstance(data_dict['val'], str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX): - api = wandb.Api() - val_artifact = api.artifact(remove_prefix(data_dict['val']) + ':' + opt.artifact_alias) - val_dir = val_artifact.download() - val_path = Path(val_dir) / 'data/images/' - data_dict['val'] = str(val_path) - if train_dir or val_dir: - ddp_data_path = str(Path(val_dir) / 'wandb_local_data.yaml') - with open(ddp_data_path, 'w') as f: - yaml.safe_dump(data_dict, f) - opt.data = ddp_data_path - - -class WandbLogger(): - """Log training runs, datasets, models, and predictions to Weights & Biases. - - This logger sends information to W&B at wandb.ai. By default, this information - includes hyperparameters, system configuration and metrics, model metrics, - and basic data metrics and analyses. - - By providing additional command line arguments to train.py, datasets, - models and predictions can also be logged. - - For more on how this logger is used, see the Weights & Biases documentation: - https://docs.wandb.com/guides/integrations/yolov5 - """ - - def __init__(self, opt, run_id=None, job_type='Training'): - """ - - Initialize WandbLogger instance - - Upload dataset if opt.upload_dataset is True - - Setup trainig processes if job_type is 'Training' - - arguments: - opt (namespace) -- Commandline arguments for this run - run_id (str) -- Run ID of W&B run to be resumed - job_type (str) -- To set the job_type for this run - - """ - # Pre-training routine -- - self.job_type = job_type - self.wandb, self.wandb_run = wandb, None if not wandb else wandb.run - self.val_artifact, self.train_artifact = None, None - self.train_artifact_path, self.val_artifact_path = None, None - self.result_artifact = None - self.val_table, self.result_table = None, None - self.bbox_media_panel_images = [] - self.val_table_path_map = None - self.max_imgs_to_log = 16 - self.wandb_artifact_data_dict = None - self.data_dict = None - # It's more elegant to stick to 1 wandb.init call, - # but useful config data is overwritten in the WandbLogger's wandb.init call - if isinstance(opt.resume, str): # checks resume from artifact - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - entity, project, run_id, model_artifact_name = get_run_info(opt.resume) - model_artifact_name = WANDB_ARTIFACT_PREFIX + model_artifact_name - assert wandb, 'install wandb to resume wandb runs' - # Resume wandb-artifact:// runs here| workaround for not overwriting wandb.config - self.wandb_run = wandb.init(id=run_id, - project=project, - entity=entity, - resume='allow', - allow_val_change=True) - opt.resume = model_artifact_name - elif self.wandb: - self.wandb_run = wandb.init(config=opt, - resume="allow", - project='YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem, - entity=opt.entity, - name=opt.name if opt.name != 'exp' else None, - job_type=job_type, - id=run_id, - allow_val_change=True) if not wandb.run else wandb.run - if self.wandb_run: - if self.job_type == 'Training': - if opt.upload_dataset: - if not opt.resume: - self.wandb_artifact_data_dict = self.check_and_upload_dataset(opt) - - if opt.resume: - # resume from artifact - if isinstance(opt.resume, str) and opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - self.data_dict = dict(self.wandb_run.config.data_dict) - else: # local resume - self.data_dict = check_wandb_dataset(opt.data) - else: - self.data_dict = check_wandb_dataset(opt.data) - self.wandb_artifact_data_dict = self.wandb_artifact_data_dict or self.data_dict - - # write data_dict to config. useful for resuming from artifacts. Do this only when not resuming. - self.wandb_run.config.update({'data_dict': self.wandb_artifact_data_dict}, allow_val_change=True) - self.setup_training(opt) - - if self.job_type == 'Dataset Creation': - self.wandb_run.config.update({"upload_dataset": True}) - self.data_dict = self.check_and_upload_dataset(opt) - - def check_and_upload_dataset(self, opt): - """ - Check if the dataset format is compatible and upload it as W&B artifact - - arguments: - opt (namespace)-- Commandline arguments for current run - - returns: - Updated dataset info dictionary where local dataset paths are replaced by WAND_ARFACT_PREFIX links. - """ - assert wandb, 'Install wandb to upload dataset' - config_path = self.log_dataset_artifact(opt.data, opt.single_cls, - 'YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem) - with open(config_path, errors='ignore') as f: - wandb_data_dict = yaml.safe_load(f) - return wandb_data_dict - - def setup_training(self, opt): - """ - Setup the necessary processes for training YOLO models: - - Attempt to download model checkpoint and dataset artifacts if opt.resume stats with WANDB_ARTIFACT_PREFIX - - Update data_dict, to contain info of previous run if resumed and the paths of dataset artifact if downloaded - - Setup log_dict, initialize bbox_interval - - arguments: - opt (namespace) -- commandline arguments for this run - - """ - self.log_dict, self.current_epoch = {}, 0 - self.bbox_interval = opt.bbox_interval - if isinstance(opt.resume, str): - modeldir, _ = self.download_model_artifact(opt) - if modeldir: - self.weights = Path(modeldir) / "last.pt" - config = self.wandb_run.config - opt.weights, opt.save_period, opt.batch_size, opt.bbox_interval, opt.epochs, opt.hyp, opt.imgsz = str( - self.weights), config.save_period, config.batch_size, config.bbox_interval, config.epochs,\ - config.hyp, config.imgsz - data_dict = self.data_dict - if self.val_artifact is None: # If --upload_dataset is set, use the existing artifact, don't download - self.train_artifact_path, self.train_artifact = self.download_dataset_artifact( - data_dict.get('train'), opt.artifact_alias) - self.val_artifact_path, self.val_artifact = self.download_dataset_artifact( - data_dict.get('val'), opt.artifact_alias) - - if self.train_artifact_path is not None: - train_path = Path(self.train_artifact_path) / 'data/images/' - data_dict['train'] = str(train_path) - if self.val_artifact_path is not None: - val_path = Path(self.val_artifact_path) / 'data/images/' - data_dict['val'] = str(val_path) - - if self.val_artifact is not None: - self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation") - columns = ["epoch", "id", "ground truth", "prediction"] - columns.extend(self.data_dict['names']) - self.result_table = wandb.Table(columns) - self.val_table = self.val_artifact.get("val") - if self.val_table_path_map is None: - self.map_val_table_path() - if opt.bbox_interval == -1: - self.bbox_interval = opt.bbox_interval = (opt.epochs // 10) if opt.epochs > 10 else 1 - if opt.evolve or opt.noplots: - self.bbox_interval = opt.bbox_interval = opt.epochs + 1 # disable bbox_interval - train_from_artifact = self.train_artifact_path is not None and self.val_artifact_path is not None - # Update the the data_dict to point to local artifacts dir - if train_from_artifact: - self.data_dict = data_dict - - def download_dataset_artifact(self, path, alias): - """ - download the model checkpoint artifact if the path starts with WANDB_ARTIFACT_PREFIX - - arguments: - path -- path of the dataset to be used for training - alias (str)-- alias of the artifact to be download/used for training - - returns: - (str, wandb.Artifact) -- path of the downladed dataset and it's corresponding artifact object if dataset - is found otherwise returns (None, None) - """ - if isinstance(path, str) and path.startswith(WANDB_ARTIFACT_PREFIX): - artifact_path = Path(remove_prefix(path, WANDB_ARTIFACT_PREFIX) + ":" + alias) - dataset_artifact = wandb.use_artifact(artifact_path.as_posix().replace("\\", "/")) - assert dataset_artifact is not None, "'Error: W&B dataset artifact doesn\'t exist'" - datadir = dataset_artifact.download() - return datadir, dataset_artifact - return None, None - - def download_model_artifact(self, opt): - """ - download the model checkpoint artifact if the resume path starts with WANDB_ARTIFACT_PREFIX - - arguments: - opt (namespace) -- Commandline arguments for this run - """ - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - model_artifact = wandb.use_artifact(remove_prefix(opt.resume, WANDB_ARTIFACT_PREFIX) + ":latest") - assert model_artifact is not None, 'Error: W&B model artifact doesn\'t exist' - modeldir = model_artifact.download() - # epochs_trained = model_artifact.metadata.get('epochs_trained') - total_epochs = model_artifact.metadata.get('total_epochs') - is_finished = total_epochs is None - assert not is_finished, 'training is finished, can only resume incomplete runs.' - return modeldir, model_artifact - return None, None - - def log_model(self, path, opt, epoch, fitness_score, best_model=False): - """ - Log the model checkpoint as W&B artifact - - arguments: - path (Path) -- Path of directory containing the checkpoints - opt (namespace) -- Command line arguments for this run - epoch (int) -- Current epoch number - fitness_score (float) -- fitness score for current epoch - best_model (boolean) -- Boolean representing if the current checkpoint is the best yet. - """ - model_artifact = wandb.Artifact('run_' + wandb.run.id + '_model', - type='model', - metadata={ - 'original_url': str(path), - 'epochs_trained': epoch + 1, - 'save period': opt.save_period, - 'project': opt.project, - 'total_epochs': opt.epochs, - 'fitness_score': fitness_score}) - model_artifact.add_file(str(path / 'last.pt'), name='last.pt') - wandb.log_artifact(model_artifact, - aliases=['latest', 'last', 'epoch ' + str(self.current_epoch), 'best' if best_model else '']) - LOGGER.info(f"Saving model artifact on epoch {epoch + 1}") - - def log_dataset_artifact(self, data_file, single_cls, project, overwrite_config=False): - """ - Log the dataset as W&B artifact and return the new data file with W&B links - - arguments: - data_file (str) -- the .yaml file with information about the dataset like - path, classes etc. - single_class (boolean) -- train multi-class data as single-class - project (str) -- project name. Used to construct the artifact path - overwrite_config (boolean) -- overwrites the data.yaml file if set to true otherwise creates a new - file with _wandb postfix. Eg -> data_wandb.yaml - - returns: - the new .yaml file with artifact links. it can be used to start training directly from artifacts - """ - upload_dataset = self.wandb_run.config.upload_dataset - log_val_only = isinstance(upload_dataset, str) and upload_dataset == 'val' - self.data_dict = check_dataset(data_file) # parse and check - data = dict(self.data_dict) - nc, names = (1, ['item']) if single_cls else (int(data['nc']), data['names']) - names = {k: v for k, v in enumerate(names)} # to index dictionary - - # log train set - if not log_val_only: - self.train_artifact = self.create_dataset_table(LoadImagesAndLabels(data['train'], rect=True, batch_size=1), - names, - name='train') if data.get('train') else None - if data.get('train'): - data['train'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'train') - - self.val_artifact = self.create_dataset_table( - LoadImagesAndLabels(data['val'], rect=True, batch_size=1), names, name='val') if data.get('val') else None - if data.get('val'): - data['val'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'val') - - path = Path(data_file) - # create a _wandb.yaml file with artifacts links if both train and test set are logged - if not log_val_only: - path = (path.stem if overwrite_config else path.stem + '_wandb') + '.yaml' # updated data.yaml path - path = ROOT / 'data' / path - data.pop('download', None) - data.pop('path', None) - with open(path, 'w') as f: - yaml.safe_dump(data, f) - LOGGER.info(f"Created dataset config file {path}") - - if self.job_type == 'Training': # builds correct artifact pipeline graph - if not log_val_only: - self.wandb_run.log_artifact( - self.train_artifact) # calling use_artifact downloads the dataset. NOT NEEDED! - self.wandb_run.use_artifact(self.val_artifact) - self.val_artifact.wait() - self.val_table = self.val_artifact.get('val') - self.map_val_table_path() - else: - self.wandb_run.log_artifact(self.train_artifact) - self.wandb_run.log_artifact(self.val_artifact) - return path - - def map_val_table_path(self): - """ - Map the validation dataset Table like name of file -> it's id in the W&B Table. - Useful for - referencing artifacts for evaluation. - """ - self.val_table_path_map = {} - LOGGER.info("Mapping dataset") - for i, data in enumerate(tqdm(self.val_table.data)): - self.val_table_path_map[data[3]] = data[0] - - def create_dataset_table(self, dataset: LoadImagesAndLabels, class_to_id: Dict[int, str], name: str = 'dataset'): - """ - Create and return W&B artifact containing W&B Table of the dataset. - - arguments: - dataset -- instance of LoadImagesAndLabels class used to iterate over the data to build Table - class_to_id -- hash map that maps class ids to labels - name -- name of the artifact - - returns: - dataset artifact to be logged or used - """ - # TODO: Explore multiprocessing to slpit this loop parallely| This is essential for speeding up the the logging - artifact = wandb.Artifact(name=name, type="dataset") - img_files = tqdm([dataset.path]) if isinstance(dataset.path, str) and Path(dataset.path).is_dir() else None - img_files = tqdm(dataset.im_files) if not img_files else img_files - for img_file in img_files: - if Path(img_file).is_dir(): - artifact.add_dir(img_file, name='data/images') - labels_path = 'labels'.join(dataset.path.rsplit('images', 1)) - artifact.add_dir(labels_path, name='data/labels') - else: - artifact.add_file(img_file, name='data/images/' + Path(img_file).name) - label_file = Path(img2label_paths([img_file])[0]) - artifact.add_file(str(label_file), name='data/labels/' + - label_file.name) if label_file.exists() else None - table = wandb.Table(columns=["id", "train_image", "Classes", "name"]) - class_set = wandb.Classes([{'id': id, 'name': name} for id, name in class_to_id.items()]) - for si, (img, labels, paths, shapes) in enumerate(tqdm(dataset)): - box_data, img_classes = [], {} - for cls, *xywh in labels[:, 1:].tolist(): - cls = int(cls) - box_data.append({ - "position": { - "middle": [xywh[0], xywh[1]], - "width": xywh[2], - "height": xywh[3]}, - "class_id": cls, - "box_caption": "%s" % (class_to_id[cls])}) - img_classes[cls] = class_to_id[cls] - boxes = {"ground_truth": {"box_data": box_data, "class_labels": class_to_id}} # inference-space - table.add_data(si, wandb.Image(paths, classes=class_set, boxes=boxes), list(img_classes.values()), - Path(paths).name) - artifact.add(table, name) - return artifact - - def log_training_progress(self, predn, path, names): - """ - Build evaluation Table. Uses reference from validation dataset table. - - arguments: - predn (list): list of predictions in the native space in the format - [xmin, ymin, xmax, ymax, confidence, class] - path (str): local path of the current evaluation image - names (dict(int, str)): hash map that maps class ids to labels - """ - class_set = wandb.Classes([{'id': id, 'name': name} for id, name in names.items()]) - box_data = [] - avg_conf_per_class = [0] * len(self.data_dict['names']) - pred_class_count = {} - for *xyxy, conf, cls in predn.tolist(): - if conf >= 0.25: - cls = int(cls) - box_data.append({ - "position": { - "minX": xyxy[0], - "minY": xyxy[1], - "maxX": xyxy[2], - "maxY": xyxy[3]}, - "class_id": cls, - "box_caption": f"{names[cls]} {conf:.3f}", - "scores": { - "class_score": conf}, - "domain": "pixel"}) - avg_conf_per_class[cls] += conf - - if cls in pred_class_count: - pred_class_count[cls] += 1 - else: - pred_class_count[cls] = 1 - - for pred_class in pred_class_count.keys(): - avg_conf_per_class[pred_class] = avg_conf_per_class[pred_class] / pred_class_count[pred_class] - - boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space - id = self.val_table_path_map[Path(path).name] - self.result_table.add_data(self.current_epoch, id, self.val_table.data[id][1], - wandb.Image(self.val_table.data[id][1], boxes=boxes, classes=class_set), - *avg_conf_per_class) - - def val_one_image(self, pred, predn, path, names, im): - """ - Log validation data for one image. updates the result Table if validation dataset is uploaded and log bbox media panel - - arguments: - pred (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class] - predn (list): list of predictions in the native space - [xmin, ymin, xmax, ymax, confidence, class] - path (str): local path of the current evaluation image - """ - if self.val_table and self.result_table: # Log Table if Val dataset is uploaded as artifact - self.log_training_progress(predn, path, names) - - if len(self.bbox_media_panel_images) < self.max_imgs_to_log and self.current_epoch > 0: - if self.current_epoch % self.bbox_interval == 0: - box_data = [{ - "position": { - "minX": xyxy[0], - "minY": xyxy[1], - "maxX": xyxy[2], - "maxY": xyxy[3]}, - "class_id": int(cls), - "box_caption": f"{names[int(cls)]} {conf:.3f}", - "scores": { - "class_score": conf}, - "domain": "pixel"} for *xyxy, conf, cls in pred.tolist()] - boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space - self.bbox_media_panel_images.append(wandb.Image(im, boxes=boxes, caption=path.name)) - - def log(self, log_dict): - """ - save the metrics to the logging dictionary - - arguments: - log_dict (Dict) -- metrics/media to be logged in current step - """ - if self.wandb_run: - for key, value in log_dict.items(): - self.log_dict[key] = value - - def end_epoch(self, best_result=False): - """ - commit the log_dict, model artifacts and Tables to W&B and flush the log_dict. - - arguments: - best_result (boolean): Boolean representing if the result of this evaluation is best or not - """ - if self.wandb_run: - with all_logging_disabled(): - if self.bbox_media_panel_images: - self.log_dict["BoundingBoxDebugger"] = self.bbox_media_panel_images - try: - wandb.log(self.log_dict) - except BaseException as e: - LOGGER.info( - f"An error occurred in wandb logger. The training will proceed without interruption. More info\n{e}" - ) - self.wandb_run.finish() - self.wandb_run = None - - self.log_dict = {} - self.bbox_media_panel_images = [] - if self.result_artifact: - self.result_artifact.add(self.result_table, 'result') - wandb.log_artifact(self.result_artifact, - aliases=[ - 'latest', 'last', 'epoch ' + str(self.current_epoch), - ('best' if best_result else '')]) - - wandb.log({"evaluation": self.result_table}) - columns = ["epoch", "id", "ground truth", "prediction"] - columns.extend(self.data_dict['names']) - self.result_table = wandb.Table(columns) - self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation") - - def finish_run(self): - """ - Log metrics if any and finish the current W&B run - """ - if self.wandb_run: - if self.log_dict: - with all_logging_disabled(): - wandb.log(self.log_dict) - wandb.run.finish() - - -@contextmanager -def all_logging_disabled(highest_level=logging.CRITICAL): - """ source - https://gist.github.com/simon-weber/7853144 - A context manager that will prevent any logging messages triggered during the body from being processed. - :param highest_level: the maximum logging level in use. - This would only need to be changed if a custom level greater than CRITICAL is defined. - """ - previous_level = logging.root.manager.disable - logging.disable(highest_level) - try: - yield - finally: - logging.disable(previous_level) diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py deleted file mode 100644 index 46ee4ec31d04eee77976ff3edbbf84762a3409ed..0000000000000000000000000000000000000000 --- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py +++ /dev/null @@ -1,37 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -from iopath.common.file_io import HTTPURLHandler, OneDrivePathHandler, PathHandler -from iopath.common.file_io import PathManager as PathManagerBase - -__all__ = ["PathManager", "PathHandler"] - - -PathManager = PathManagerBase() -""" -This is a detectron2 project-specific PathManager. -We try to stay away from global PathManager in fvcore as it -introduces potential conflicts among other libraries. -""" - - -class Detectron2Handler(PathHandler): - """ - Resolve anything that's hosted under detectron2's namespace. - """ - - PREFIX = "detectron2://" - S3_DETECTRON2_PREFIX = "https://dl.fbaipublicfiles.com/detectron2/" - - def _get_supported_prefixes(self): - return [self.PREFIX] - - def _get_local_path(self, path, **kwargs): - name = path[len(self.PREFIX) :] - return PathManager.get_local_path(self.S3_DETECTRON2_PREFIX + name, **kwargs) - - def _open(self, path, mode="r", **kwargs): - return PathManager.open(self._get_local_path(path), mode, **kwargs) - - -PathManager.register_handler(HTTPURLHandler()) -PathManager.register_handler(OneDrivePathHandler()) -PathManager.register_handler(Detectron2Handler()) diff --git a/spaces/chansung/zero2story/interfaces/utils.py b/spaces/chansung/zero2story/interfaces/utils.py deleted file mode 100644 index 0308b6bbf92b2896f14d416302bdf6869787a5b6..0000000000000000000000000000000000000000 --- a/spaces/chansung/zero2story/interfaces/utils.py +++ /dev/null @@ -1,114 +0,0 @@ -import copy -import json -import string -import random -import asyncio - -from modules.llms import get_llm_factory - -from pingpong.context import CtxLastWindowStrategy - -def add_side_character_to_export( - characters, enable, img, - name, age, personality, job -): - if enable: - characters.append( - { - 'img': img, - 'name': name - } - ) - - return characters - -def add_side_character(enable, name, age, personality, job, llm_type="PaLM"): - prompts = get_llm_factory(llm_type).create_prompt_manager().prompts - - cur_side_chars = 1 - prompt = "" - for idx in range(len(enable)): - if enable[idx]: - prompt += prompts['story_gen']['add_side_character'].format( - cur_side_chars=cur_side_chars, - name=name[idx], - job=job[idx], - age=age[idx], - personality=personality[idx] - ) - cur_side_chars += 1 - return "\n" + prompt if prompt else "" - -def id_generator(size=6, chars=string.ascii_uppercase + string.digits): - return ''.join(random.choice(chars) for _ in range(size)) - -def parse_first_json_code_snippet(code_snippet): - json_parsed_string = None - - try: - json_parsed_string = json.loads(code_snippet, strict=False) - except: - json_start_index = code_snippet.find('```json') - json_end_index = code_snippet.find('```', json_start_index + 6) - - if json_start_index < 0 or json_end_index < 0: - raise ValueError('No JSON code snippet found in string.') - - json_code_snippet = code_snippet[json_start_index + 7:json_end_index] - json_parsed_string = json.loads(json_code_snippet, strict=False) - finally: - if json_parsed_string is None: - raise ValueError('No JSON code snippet found in string.') - return json_parsed_string - -async def retry_until_valid_json(prompt, parameters=None, llm_type="PaLM"): - response_json = None - factory = get_llm_factory(llm_type) - llm_service = factory.create_llm_service() - - for _ in range(3): - try: - response, response_txt = await asyncio.wait_for(llm_service.gen_text(prompt, mode="text", parameters=parameters), - timeout=10) - - print(response_txt) - except asyncio.TimeoutError: - raise TimeoutError(f"The response time for {llm_type} API exceeded the limit.") - except Exception as e: - print(f"{llm_type} API has encountered an error. Retrying...") - continue - - try: - response_json = parse_first_json_code_snippet(response_txt) - if not response_json: - print("Parsing JSON failed. Retrying...") - continue - except: - print("Parsing JSON failed. Retrying...") - pass - - if len(response.filters) > 0: - raise ValueError(f"{llm_type} API has withheld a response due to content safety concerns.") - elif response_json is None: - print("=== Failed to generate valid JSON response. ===") - print(response_txt) - raise ValueError("Failed to generate valid JSON response.") - - return response_json - -def build_prompts(ppm, win_size=3): - dummy_ppm = copy.deepcopy(ppm) - lws = CtxLastWindowStrategy(win_size) - return lws(dummy_ppm) - -async def get_chat_response(prompt, ctx=None, llm_type="PaLM"): - factory = get_llm_factory(llm_type) - llm_service = factory.create_llm_service() - parameters = llm_service.make_params(mode="chat", temperature=1.0, top_k=50, top_p=0.9) - - _, response_txt = await llm_service.gen_text( - prompt, - parameters=parameters - ) - - return response_txt diff --git a/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat b/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat deleted file mode 100644 index 0b78fdc3a559abd692e3a9e9af5e482124d13a99..0000000000000000000000000000000000000000 --- a/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat +++ /dev/null @@ -1,14 +0,0 @@ -@echo off -echo Opening ChuanhuChatGPT... - -REM Open powershell via bat -start powershell.exe -NoExit -Command "python ./ChuanhuChatbot.py" - -REM The web page can be accessed with delayed start http://127.0.0.1:7860/ -ping -n 5 127.0.0.1>nul - -REM access chargpt via your default browser -start "" "http://127.0.0.1:7860/" - - -echo Finished opening ChuanhuChatGPT (http://127.0.0.1:7860/). \ No newline at end of file diff --git a/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md b/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md deleted file mode 100644 index a7f77221ee2d009c02a734844f4e9305e868c844..0000000000000000000000000000000000000000 --- a/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md +++ /dev/null @@ -1,31 +0,0 @@ ---- -name: Bug report -about: Create a report to help us improve -title: '' -labels: bug -assignees: mudler - ---- - - - -**LocalAI version:** - - -**Environment, CPU architecture, OS, and Version:** - - -**Describe the bug** - - -**To Reproduce** - - -**Expected behavior** - - -**Logs** - - -**Additional context** - diff --git a/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py b/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py deleted file mode 100644 index b9cbad0e818720ad65053dcec783a0314898303d..0000000000000000000000000000000000000000 --- a/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py +++ /dev/null @@ -1,25 +0,0 @@ - -import os -from langchain.vectorstores import Chroma -from langchain.embeddings import OpenAIEmbeddings -from langchain.text_splitter import CharacterTextSplitter -from langchain.document_loaders import TextLoader - -base_path = os.environ.get('OPENAI_API_BASE', 'http://localhost:8080/v1') - -# Load and process the text -loader = TextLoader('state_of_the_union.txt') -documents = loader.load() - -text_splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=70) -texts = text_splitter.split_documents(documents) - -# Embed and store the texts -# Supplying a persist_directory will store the embeddings on disk -persist_directory = 'db' - -embedding = OpenAIEmbeddings(model="text-embedding-ada-002") -vectordb = Chroma.from_documents(documents=texts, embedding=embedding, persist_directory=persist_directory) - -vectordb.persist() -vectordb = None \ No newline at end of file diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py deleted file mode 100644 index 0bd646e12ef4f77f77e1f2d0a88c356f950683ed..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py +++ /dev/null @@ -1,85 +0,0 @@ -# Copyright ExplsionAI GmbH, released under BSD. -from __future__ import print_function - -import numpy as np - -np.random.seed(0) -from numpy.testing import assert_allclose - -from hypothesis import assume -from hypothesis.strategies import tuples, integers, floats -from hypothesis.extra.numpy import arrays - - -def lengths(lo=1, hi=10): - return integers(min_value=lo, max_value=hi) - - -def shapes(min_rows=1, max_rows=100, min_cols=1, max_cols=100): - return tuples(lengths(lo=min_rows, hi=max_rows), lengths(lo=min_cols, hi=max_cols)) - - -def ndarrays_of_shape(shape, lo=-1000.0, hi=1000.0, dtype="float64"): - width = 64 if dtype == "float64" else 32 - return arrays( - dtype, shape=shape, elements=floats(min_value=lo, max_value=hi, width=width) - ) - - -def ndarrays( - min_len=0, max_len=10, min_val=-10000000.0, max_val=1000000.0, dtype="float64" -): - return lengths(lo=min_len, hi=max_len).flatmap( - lambda n: ndarrays_of_shape(n, lo=min_val, hi=max_val, dtype=dtype) - ) - - -def matrices( - min_rows=1, - max_rows=10, - min_cols=1, - max_cols=10, - min_value=-10000000.0, - max_value=1000000.0, - dtype="float64", -): - return shapes( - min_rows=min_rows, max_rows=max_rows, min_cols=min_cols, max_cols=max_cols - ).flatmap(lambda mn: ndarrays_of_shape(mn, lo=min_value, hi=max_value, dtype=dtype)) - - -def positive_ndarrays(min_len=0, max_len=10, max_val=100000.0, dtype="float64"): - return ndarrays( - min_len=min_len, max_len=max_len, min_val=0, max_val=max_val, dtype=dtype - ) - - -def negative_ndarrays(min_len=0, max_len=10, min_val=-100000.0, dtype="float64"): - return ndarrays( - min_len=min_len, max_len=max_len, min_val=min_val, max_val=-1e-10, dtype=dtype - ) - - -def parse_layer(layer_data): - # Get the first row, excluding the first column - x = layer_data[0, 1:] - # Get the first column, excluding the first row - # .ascontiguousarray is support important here!!!! - b = np.ascontiguousarray(layer_data[1:, 0], dtype="float64") - # Slice out the row and the column used for the X and the bias - W = layer_data[1:, 1:] - assert x.ndim == 1 - assert b.ndim == 1 - assert b.shape[0] == W.shape[0] - assert x.shape[0] == W.shape[1] - assume(not np.isnan(W.sum())) - assume(not np.isnan(x.sum())) - assume(not np.isnan(b.sum())) - assume(not any(np.isinf(val) for val in W.flatten())) - assume(not any(np.isinf(val) for val in x)) - assume(not any(np.isinf(val) for val in b)) - return x, b, W - - -def split_row(layer_data): - return (layer_data[0, :], layer_data[:, :]) diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py deleted file mode 100644 index 6e1228d6f2b8bbc78cf52864ccaf3b249a654749..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py +++ /dev/null @@ -1,44 +0,0 @@ -from fontTools.pens.basePen import BasePen - -from Quartz.CoreGraphics import CGPathCreateMutable, CGPathMoveToPoint -from Quartz.CoreGraphics import CGPathAddLineToPoint, CGPathAddCurveToPoint -from Quartz.CoreGraphics import CGPathAddQuadCurveToPoint, CGPathCloseSubpath - - -__all__ = ["QuartzPen"] - - -class QuartzPen(BasePen): - - """A pen that creates a CGPath - - Parameters - - path: an optional CGPath to add to - - xform: an optional CGAffineTransform to apply to the path - """ - - def __init__(self, glyphSet, path=None, xform=None): - BasePen.__init__(self, glyphSet) - if path is None: - path = CGPathCreateMutable() - self.path = path - self.xform = xform - - def _moveTo(self, pt): - x, y = pt - CGPathMoveToPoint(self.path, self.xform, x, y) - - def _lineTo(self, pt): - x, y = pt - CGPathAddLineToPoint(self.path, self.xform, x, y) - - def _curveToOne(self, p1, p2, p3): - (x1, y1), (x2, y2), (x3, y3) = p1, p2, p3 - CGPathAddCurveToPoint(self.path, self.xform, x1, y1, x2, y2, x3, y3) - - def _qCurveToOne(self, p1, p2): - (x1, y1), (x2, y2) = p1, p2 - CGPathAddQuadCurveToPoint(self.path, self.xform, x1, y1, x2, y2) - - def _closePath(self): - CGPathCloseSubpath(self.path) diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py deleted file mode 100644 index 46c9498dc720e7c23b278ae31b65dbf55f2ad8be..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py +++ /dev/null @@ -1,142 +0,0 @@ -"""Extra methods for DesignSpaceDocument to generate its STAT table data.""" - -from __future__ import annotations - -from typing import Dict, List, Union - -import fontTools.otlLib.builder -from fontTools.designspaceLib import ( - AxisLabelDescriptor, - DesignSpaceDocument, - DesignSpaceDocumentError, - LocationLabelDescriptor, -) -from fontTools.designspaceLib.types import Region, getVFUserRegion, locationInRegion -from fontTools.ttLib import TTFont - - -def buildVFStatTable(ttFont: TTFont, doc: DesignSpaceDocument, vfName: str) -> None: - """Build the STAT table for the variable font identified by its name in - the given document. - - Knowing which variable we're building STAT data for is needed to subset - the STAT locations to only include what the variable font actually ships. - - .. versionadded:: 5.0 - - .. seealso:: - - :func:`getStatAxes()` - - :func:`getStatLocations()` - - :func:`fontTools.otlLib.builder.buildStatTable()` - """ - for vf in doc.getVariableFonts(): - if vf.name == vfName: - break - else: - raise DesignSpaceDocumentError( - f"Cannot find the variable font by name {vfName}" - ) - - region = getVFUserRegion(doc, vf) - - return fontTools.otlLib.builder.buildStatTable( - ttFont, - getStatAxes(doc, region), - getStatLocations(doc, region), - doc.elidedFallbackName if doc.elidedFallbackName is not None else 2, - ) - - -def getStatAxes(doc: DesignSpaceDocument, userRegion: Region) -> List[Dict]: - """Return a list of axis dicts suitable for use as the ``axes`` - argument to :func:`fontTools.otlLib.builder.buildStatTable()`. - - .. versionadded:: 5.0 - """ - # First, get the axis labels with explicit ordering - # then append the others in the order they appear. - maxOrdering = max( - (axis.axisOrdering for axis in doc.axes if axis.axisOrdering is not None), - default=-1, - ) - axisOrderings = [] - for axis in doc.axes: - if axis.axisOrdering is not None: - axisOrderings.append(axis.axisOrdering) - else: - maxOrdering += 1 - axisOrderings.append(maxOrdering) - return [ - dict( - tag=axis.tag, - name={"en": axis.name, **axis.labelNames}, - ordering=ordering, - values=[ - _axisLabelToStatLocation(label) - for label in axis.axisLabels - if locationInRegion({axis.name: label.userValue}, userRegion) - ], - ) - for axis, ordering in zip(doc.axes, axisOrderings) - ] - - -def getStatLocations(doc: DesignSpaceDocument, userRegion: Region) -> List[Dict]: - """Return a list of location dicts suitable for use as the ``locations`` - argument to :func:`fontTools.otlLib.builder.buildStatTable()`. - - .. versionadded:: 5.0 - """ - axesByName = {axis.name: axis for axis in doc.axes} - return [ - dict( - name={"en": label.name, **label.labelNames}, - # Location in the designspace is keyed by axis name - # Location in buildStatTable by axis tag - location={ - axesByName[name].tag: value - for name, value in label.getFullUserLocation(doc).items() - }, - flags=_labelToFlags(label), - ) - for label in doc.locationLabels - if locationInRegion(label.getFullUserLocation(doc), userRegion) - ] - - -def _labelToFlags(label: Union[AxisLabelDescriptor, LocationLabelDescriptor]) -> int: - flags = 0 - if label.olderSibling: - flags |= 1 - if label.elidable: - flags |= 2 - return flags - - -def _axisLabelToStatLocation( - label: AxisLabelDescriptor, -) -> Dict: - label_format = label.getFormat() - name = {"en": label.name, **label.labelNames} - flags = _labelToFlags(label) - if label_format == 1: - return dict(name=name, value=label.userValue, flags=flags) - if label_format == 3: - return dict( - name=name, - value=label.userValue, - linkedValue=label.linkedUserValue, - flags=flags, - ) - if label_format == 2: - res = dict( - name=name, - nominalValue=label.userValue, - flags=flags, - ) - if label.userMinimum is not None: - res["rangeMinValue"] = label.userMinimum - if label.userMaximum is not None: - res["rangeMaxValue"] = label.userMaximum - return res - raise NotImplementedError("Unknown STAT label format") diff --git a/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md b/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md deleted file mode 100644 index d08dea6cd4be2def9cf8bc850d2862057d435330..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md +++ /dev/null @@ -1,30 +0,0 @@ - -
-
', - } - text = text.replace(' ', ' ') - return ''.join(escape_chars.get(c, c) for c in text) - - -def convert_asis(userinput): # deprecated - return ( - f'
{html.escape(userinput)}
' - + ALREADY_CONVERTED_MARK - ) - - -def detect_converted_mark(userinput): # deprecated - try: - if userinput.endswith(ALREADY_CONVERTED_MARK): - return True - else: - return False - except: - return True - - -def detect_language(code): # deprecated - if code.startswith("\n"): - first_line = "" - else: - first_line = code.strip().split("\n", 1)[0] - language = first_line.lower() if first_line else "" - code_without_language = code[len(first_line) :].lstrip() if first_line else code - return language, code_without_language - - -def construct_text(role, text): - return {"role": role, "content": text} - - -def construct_user(text): - return construct_text("user", text) - - -def construct_system(text): - return construct_text("system", text) - - -def construct_assistant(text): - return construct_text("assistant", text) - - -def save_file(filename, system, history, chatbot, user_name): - logging.debug(f"{user_name} 保存对话历史中……") - os.makedirs(os.path.join(HISTORY_DIR, user_name), exist_ok=True) - if filename.endswith(".json"): - json_s = {"system": system, "history": history, "chatbot": chatbot} - if "/" in filename or "\\" in filename: - history_file_path = filename - else: - history_file_path = os.path.join(HISTORY_DIR, user_name, filename) - with open(history_file_path, "w", encoding='utf-8') as f: - json.dump(json_s, f, ensure_ascii=False) - elif filename.endswith(".md"): - md_s = f"system: \n- {system} \n" - for data in history: - md_s += f"\n{data['role']}: \n- {data['content']} \n" - with open(os.path.join(HISTORY_DIR, user_name, filename), "w", encoding="utf8") as f: - f.write(md_s) - logging.debug(f"{user_name} 保存对话历史完毕") - return os.path.join(HISTORY_DIR, user_name, filename) - - -def sorted_by_pinyin(list): - return sorted(list, key=lambda char: lazy_pinyin(char)[0][0]) - - -def get_file_names(dir, plain=False, filetypes=[".json"]): - logging.debug(f"获取文件名列表，目录为{dir}，文件类型为{filetypes}，是否为纯文本列表{plain}") - files = [] - try: - for type in filetypes: - files += [f for f in os.listdir(dir) if f.endswith(type)] - except FileNotFoundError: - files = [] - files = sorted_by_pinyin(files) - if files == []: - files = [""] - logging.debug(f"files are:{files}") - if plain: - return files - else: - return gr.Dropdown.update(choices=files) - - -def get_history_names(plain=False, user_name=""): - logging.debug(f"从用户 {user_name} 中获取历史记录文件名列表") - if user_name == "" and hide_history_when_not_logged_in: - return "" - else: - return get_file_names(os.path.join(HISTORY_DIR, user_name), plain) - - -def load_template(filename, mode=0): - logging.debug(f"加载模板文件{filename}，模式为{mode}（0为返回字典和下拉菜单，1为返回下拉菜单，2为返回字典）") - lines = [] - if filename.endswith(".json"): - with open(os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8") as f: - lines = json.load(f) - lines = [[i["act"], i["prompt"]] for i in lines] - else: - with open( - os.path.join(TEMPLATES_DIR, filename), "r", encoding="utf8" - ) as csvfile: - reader = csv.reader(csvfile) - lines = list(reader) - lines = lines[1:] - if mode == 1: - return sorted_by_pinyin([row[0] for row in lines]) - elif mode == 2: - return {row[0]: row[1] for row in lines} - else: - choices = sorted_by_pinyin([row[0] for row in lines]) - return {row[0]: row[1] for row in lines}, gr.Dropdown.update( - choices=choices - ) - - -def get_template_names(plain=False): - logging.debug("获取模板文件名列表") - return get_file_names(TEMPLATES_DIR, plain, filetypes=[".csv", "json"]) - - -def get_template_content(templates, selection, original_system_prompt): - logging.debug(f"应用模板中，选择为{selection}，原始系统提示为{original_system_prompt}") - try: - return templates[selection] - except: - return original_system_prompt - - -def reset_textbox(): - logging.debug("重置文本框") - return gr.update(value="") - - -def reset_default(): - default_host = shared.state.reset_api_host() - retrieve_proxy("") - return gr.update(value=default_host), gr.update(value=""), "API-Host 和代理已重置" - - -def change_api_host(host): - shared.state.set_api_host(host) - msg = f"API-Host更改为了{host}" - logging.info(msg) - return msg - - -def change_proxy(proxy): - retrieve_proxy(proxy) - os.environ["HTTPS_PROXY"] = proxy - msg = f"代理更改为了{proxy}" - logging.info(msg) - return msg - - -def hide_middle_chars(s): - if s is None: - return "" - if len(s) <= 8: - return s - else: - head = s[:4] - tail = s[-4:] - hidden = "*" * (len(s) - 8) - return head + hidden + tail - - -def submit_key(key): - key = key.strip() - msg = f"API密钥更改为了{hide_middle_chars(key)}" - logging.info(msg) - return key, msg - - -def replace_today(prompt): - today = datetime.datetime.today().strftime("%Y-%m-%d") - return prompt.replace("{current_date}", today) - - -def get_geoip(): - try: - with retrieve_proxy(): - response = requests.get("https://ipapi.co/json/", timeout=5) - data = response.json() - except: - data = {"error": True, "reason": "连接ipapi失败"} - if "error" in data.keys(): - logging.warning(f"无法获取IP地址信息。\n{data}") - if data["reason"] == "RateLimited": - return ( - i18n("您的IP区域：未知。") - ) - else: - return i18n("获取IP地理位置失败。原因：") + f"{data['reason']}" + i18n("。你仍然可以使用聊天功能。") - else: - country = data["country_name"] - if country == "China": - text = "**您的IP区域：中国。请立即检查代理设置，在不受支持的地区使用API可能导致账号被封禁。**" - else: - text = i18n("您的IP区域：") + f"{country}。" - logging.info(text) - return text - - -def find_n(lst, max_num): - n = len(lst) - total = sum(lst) - - if total < max_num: - return n - - for i in range(len(lst)): - if total - lst[i] < max_num: - return n - i - 1 - total = total - lst[i] - return 1 - - -def start_outputing(): - logging.debug("显示取消按钮，隐藏发送按钮") - return gr.Button.update(visible=False), gr.Button.update(visible=True) - - -def end_outputing(): - return ( - gr.Button.update(visible=True), - gr.Button.update(visible=False), - ) - - -def cancel_outputing(): - logging.info("中止输出……") - shared.state.interrupt() - - -def transfer_input(inputs): - # 一次性返回，降低延迟 - textbox = reset_textbox() - outputing = start_outputing() - return ( - inputs, - gr.update(value=""), - gr.Button.update(visible=False), - gr.Button.update(visible=True), - ) - - -def update_chuanhu(): - from .repo import background_update - - print("[Updater] Trying to update...") - update_status = background_update() - if update_status == "success": - logging.info("Successfully updated, restart needed") - status = 'success' - return gr.Markdown.update(value=i18n("更新成功，请重启本程序")+status) - else: - status = 'failure' - return gr.Markdown.update(value=i18n("更新失败，请尝试[手动更新](https://github.com/GaiZhenbiao/ChuanhuChatGPT/wiki/使用教程#手动更新)")+status) - - -def add_source_numbers(lst, source_name = "Source", use_source = True): - if use_source: - return [f'[{idx+1}]\t "{item[0]}"\n{source_name}: {item[1]}' for idx, item in enumerate(lst)] - else: - return [f'[{idx+1}]\t "{item}"' for idx, item in enumerate(lst)] - -def add_details(lst): - nodes = [] - for index, txt in enumerate(lst): - brief = txt[:25].replace("\n", "") - nodes.append( - f"{brief}...
{txt}
"
- for user_msg, resp_msg in history:
- html += f"
"
- return html
-
-iface = gr.Interface(chat, "text", "html", css="""
- .chatbox {display:flex;flex-direction:column}
- .user_msg, .resp_msg {padding:4px;margin-bottom:4px;border-radius:4px;width:80%}
- .user_msg {background-color:cornflowerblue;color:white;align-self:start}
- .resp_msg {background-color:lightgray;align-self:self-end}
-""", allow_screenshot=False, allow_flagging=False)
-if __name__ == "__main__":
- iface.launch(debug=True)
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py b/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py
deleted file mode 100644
index c6512d7322def67b27aba46e9e36da171db6963b..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Image_Caption/fairseq/examples/wav2vec/unsupervised/scripts/phonemize_with_sil.py
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/usr/bin/env python3 -u
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import numpy as np
-import sys
-
-
-def get_parser():
- parser = argparse.ArgumentParser(
- description="converts words to phones adding optional silences around in between words"
- )
- parser.add_argument(
- "--sil-prob",
- "-s",
- type=float,
- default=0,
- help="probability of inserting silence between each word",
- )
- parser.add_argument(
- "--surround",
- action="store_true",
- help="if set, surrounds each example with silence",
- )
- parser.add_argument(
- "--lexicon",
- help="lexicon to convert to phones",
- required=True,
- )
-
- return parser
-
-
-def main():
- parser = get_parser()
- args = parser.parse_args()
-
- sil_prob = args.sil_prob
- surround = args.surround
- sil = "{user_msg}
"
- html += f"{resp_msg}
"
- html += "'
- gr.Markdown(f"""{favicon}A N I M A
ANIMA is an expert in various scientific disciplines.""")
- with gr.Row():
- with gr.Column(scale=5):
- system_prompt = gr.Textbox(label="System Prompt", placeholder="", value=SYSTEM_PROMPT, interactive=False)
- chatbot = gr.Chatbot(label="Dialogue").style(height=400)
- with gr.Row():
- with gr.Column():
- msg = gr.Textbox(label="Send Message", placeholder="Send Message", show_label=False).style(container=False)
- with gr.Column():
- with gr.Row():
- submit = gr.Button("Send")
- stop = gr.Button("Stop")
- clear = gr.Button("Clear")
- with gr.Row():
- gr.Markdown("""WARNING: The model may generate factually or ethically incorrect texts. We are not responsible for this.""")
-
- submit_event = msg.submit(fn=user, inputs=[msg, chatbot], outputs=[msg, chatbot], queue=False).success(fn=bot, inputs=[chatbot, system_prompt], outputs=chatbot, queue=True)
- submit_click_event = submit.click(fn=user, inputs=[msg, chatbot], outputs=[msg, chatbot], queue=False).success(fn=bot, inputs=[chatbot, system_prompt], outputs=chatbot, queue=True)
- stop.click(fn=None, inputs=None, outputs=None, cancels=[submit_event, submit_click_event], queue=False)
- clear.click(lambda: None, None, chatbot, queue=False)
-
-demo.queue(max_size=128, concurrency_count=1)
-demo.launch()
diff --git a/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py b/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py
deleted file mode 100644
index 3bba48a4aab5c8d07fe15e5de734fa8ddebe2abb..0000000000000000000000000000000000000000
--- a/spaces/ShkShahid/Auto-encoder_For_Image_Reconstruction/network.py
+++ /dev/null
@@ -1,263 +0,0 @@
-
-
-
-import tensorflow as tf
-import tensorlayer as tl
-import numpy as np
-
-# The HDR reconstruction autoencoder fully convolutional neural network
-def model(x, batch_size=1, is_training=False):
-
- # Encoder network (VGG16, until pool5)
- x_in = tf.scalar_mul(255.0, x)
- net_in = tl.layers.InputLayer(x_in, name='input_layer')
- conv_layers, skip_layers = encoder(net_in)
-
- # Fully convolutional layers on top of VGG16 conv layers
- network = tl.layers.Conv2dLayer(conv_layers,
- act = tf.identity,
- shape = [3, 3, 512, 512],
- strides = [1, 1, 1, 1],
- padding='SAME',
- name ='encoder/h6/conv')
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='encoder/h6/batch_norm')
- network.outputs = tf.nn.relu(network.outputs, name='encoder/h6/relu')
-
- # Decoder network
- network = decoder(network, skip_layers, batch_size, is_training)
-
- if is_training:
- return network, conv_layers
-
- return network
-
-
-# Final prediction of the model, including blending with input
-def get_final(network, x_in):
- sb, sy, sx, sf = x_in.get_shape().as_list()
- y_predict = network.outputs
-
- # Highlight mask
- thr = 0.05
- alpha = tf.reduce_max(x_in, reduction_indices=[3])
- alpha = tf.minimum(1.0, tf.maximum(0.0, alpha-1.0+thr)/thr)
- alpha = tf.reshape(alpha, [-1, sy, sx, 1])
- alpha = tf.tile(alpha, [1,1,1,3])
-
- # Linearied input and prediction
- x_lin = tf.pow(x_in, 2.0)
- y_predict = tf.exp(y_predict)-1.0/255.0
-
- # Alpha blending
- y_final = (1-alpha)*x_lin + alpha*y_predict
-
- return y_final
-
-
-# Convolutional layers of the VGG16 model used as encoder network
-def encoder(input_layer):
-
- VGG_MEAN = [103.939, 116.779, 123.68]
-
- # Convert RGB to BGR
- red, green, blue = tf.split(input_layer.outputs, 3, 3)
- bgr = tf.concat([ blue - VGG_MEAN[0], green - VGG_MEAN[1], red - VGG_MEAN[2] ], axis=3)
-
- network = tl.layers.InputLayer(bgr, name='encoder/input_layer_bgr')
-
- # Convolutional layers size 1
- network = conv_layer(network, [ 3, 64], 'encoder/h1/conv_1')
- beforepool1 = conv_layer(network, [64, 64], 'encoder/h1/conv_2')
- network = pool_layer(beforepool1, 'encoder/h1/pool')
-
- # Convolutional layers size 2
- network = conv_layer(network, [64, 128], 'encoder/h2/conv_1')
- beforepool2 = conv_layer(network, [128, 128], 'encoder/h2/conv_2')
- network = pool_layer(beforepool2, 'encoder/h2/pool')
-
- # Convolutional layers size 3
- network = conv_layer(network, [128, 256], 'encoder/h3/conv_1')
- network = conv_layer(network, [256, 256], 'encoder/h3/conv_2')
- beforepool3 = conv_layer(network, [256, 256], 'encoder/h3/conv_3')
- network = pool_layer(beforepool3, 'encoder/h3/pool')
-
- # Convolutional layers size 4
- network = conv_layer(network, [256, 512], 'encoder/h4/conv_1')
- network = conv_layer(network, [512, 512], 'encoder/h4/conv_2')
- beforepool4 = conv_layer(network, [512, 512], 'encoder/h4/conv_3')
- network = pool_layer(beforepool4, 'encoder/h4/pool')
-
- # Convolutional layers size 5
- network = conv_layer(network, [512, 512], 'encoder/h5/conv_1')
- network = conv_layer(network, [512, 512], 'encoder/h5/conv_2')
- beforepool5 = conv_layer(network, [512, 512], 'encoder/h5/conv_3')
- network = pool_layer(beforepool5, 'encoder/h5/pool')
-
- return network, (input_layer, beforepool1, beforepool2, beforepool3, beforepool4, beforepool5)
-
-
-# Decoder network
-def decoder(input_layer, skip_layers, batch_size=1, is_training=False):
- sb, sx, sy, sf = input_layer.outputs.get_shape().as_list()
- alpha = 0.0
-
- # Upsampling 1
- network = deconv_layer(input_layer, (batch_size,sx,sy,sf,sf), 'decoder/h1/decon2d', alpha, is_training)
-
- # Upsampling 2
- network = skip_connection_layer(network, skip_layers[5], 'decoder/h2/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,2*sx,2*sy,sf,sf), 'decoder/h2/decon2d', alpha, is_training)
-
- # Upsampling 3
- network = skip_connection_layer(network, skip_layers[4], 'decoder/h3/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,4*sx,4*sy,sf,sf/2), 'decoder/h3/decon2d', alpha, is_training)
-
- # Upsampling 4
- network = skip_connection_layer(network, skip_layers[3], 'decoder/h4/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,8*sx,8*sy,sf/2,sf/4), 'decoder/h4/decon2d', alpha, is_training)
-
- # Upsampling 5
- network = skip_connection_layer(network, skip_layers[2], 'decoder/h5/fuse_skip_connection', is_training)
- network = deconv_layer(network, (batch_size,16*sx,16*sy,sf/4,sf/8), 'decoder/h5/decon2d', alpha, is_training)
-
- # Skip-connection at full size
- network = skip_connection_layer(network, skip_layers[1], 'decoder/h6/fuse_skip_connection', is_training)
-
- # Final convolution
- network = tl.layers.Conv2dLayer(network,
- act = tf.identity,
- shape = [1, 1, int(sf/8), 3],
- strides=[1, 1, 1, 1],
- padding='SAME',
- W_init = tf.contrib.layers.xavier_initializer(uniform=False),
- b_init = tf.constant_initializer(value=0.0),
- name ='decoder/h7/conv2d')
-
- # Final skip-connection
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='decoder/h7/batch_norm')
- network.outputs = tf.maximum(alpha*network.outputs, network.outputs, name='decoder/h7/leaky_relu')
- network = skip_connection_layer(network, skip_layers[0], 'decoder/h7/fuse_skip_connection')
-
- return network
-
-
-# Load weights for VGG16 encoder convolutional layers
-# Weights are from a .npy file generated with the caffe-tensorflow tool
-def load_vgg_weights(network, weight_file, session):
- params = []
-
- if weight_file.lower().endswith('.npy'):
- npy = np.load(weight_file, encoding='latin1')
- for key, val in sorted(npy.item().items()):
- if(key[:4] == "conv"):
- print(" Loading %s" % (key))
- print(" weights with size %s " % str(val['weights'].shape))
- print(" and biases with size %s " % str(val['biases'].shape))
- params.append(val['weights'])
- params.append(val['biases'])
- else:
- print('No weights in suitable .npy format found for path ', weight_file)
-
- print('Assigning loaded weights..')
- tl.files.assign_params(session, params, network)
-
- return network
-
-
-# === Layers ==================================================================
-
-# Convolutional layer
-def conv_layer(input_layer, sz, str):
- network = tl.layers.Conv2dLayer(input_layer,
- act = tf.nn.relu,
- shape = [3, 3, sz[0], sz[1]],
- strides = [1, 1, 1, 1],
- padding = 'SAME',
- name = str)
-
- return network
-
-
-# Max-pooling layer
-def pool_layer(input_layer, str):
- network = tl.layers.PoolLayer(input_layer,
- ksize=[1, 2, 2, 1],
- strides=[1, 2, 2, 1],
- padding='SAME',
- pool = tf.nn.max_pool,
- name = str)
-
- return network
-
-
-# Concatenating fusion of skip-connections
-def skip_connection_layer(input_layer, skip_layer, str, is_training=False):
- _, sx, sy, sf = input_layer.outputs.get_shape().as_list()
- _, sx_, sy_, sf_ = skip_layer.outputs.get_shape().as_list()
-
- assert (sx_,sy_,sf_) == (sx,sy,sf)
-
- # skip-connection domain transformation, from LDR encoder to log HDR decoder
- skip_layer.outputs = tf.log(tf.pow(tf.scalar_mul(1.0/255, skip_layer.outputs), 2.0)+1.0/255.0)
-
- # specify weights for fusion of concatenation, so that it performs an element-wise addition
- weights = np.zeros((1, 1, sf+sf_, sf))
- for i in range(sf):
- weights[0, 0, i, i] = 1
- weights[:, :, i+sf_, i] = 1
- add_init = tf.constant_initializer(value=weights, dtype=tf.float32)
-
- # concatenate layers
- network = tl.layers.ConcatLayer([input_layer,skip_layer], concat_dim=3, name ='%s/skip_connection'%str)
-
- # fuse concatenated layers using the specified weights for initialization
- network = tl.layers.Conv2dLayer(network,
- act = tf.identity,
- shape = [1, 1, sf+sf_, sf],
- strides = [1, 1, 1, 1],
- padding = 'SAME',
- W_init = add_init,
- b_init = tf.constant_initializer(value=0.0),
- name = str)
-
- return network
-
-
-# Deconvolution layer
-def deconv_layer(input_layer, sz, str, alpha, is_training=False):
- scale = 2
-
- filter_size = (2 * scale - scale % 2)
- num_in_channels = int(sz[3])
- num_out_channels = int(sz[4])
-
- # create bilinear weights in numpy array
- bilinear_kernel = np.zeros([filter_size, filter_size], dtype=np.float32)
- scale_factor = (filter_size + 1) // 2
- if filter_size % 2 == 1:
- center = scale_factor - 1
- else:
- center = scale_factor - 0.5
- for x in range(filter_size):
- for y in range(filter_size):
- bilinear_kernel[x,y] = (1 - abs(x - center) / scale_factor) * \
- (1 - abs(y - center) / scale_factor)
- weights = np.zeros((filter_size, filter_size, num_out_channels, num_in_channels))
- for i in range(num_out_channels):
- weights[:, :, i, i] = bilinear_kernel
-
- init_matrix = tf.constant_initializer(value=weights, dtype=tf.float32)
-
- network = tl.layers.DeConv2dLayer(input_layer,
- shape = [filter_size, filter_size, num_out_channels, num_in_channels],
- output_shape = [sz[0], sz[1]*scale, sz[2]*scale, num_out_channels],
- strides=[1, scale, scale, 1],
- W_init=init_matrix,
- padding='SAME',
- act=tf.identity,
- name=str)
-
- network = tl.layers.BatchNormLayer(network, is_train=is_training, name='%s/batch_norm_dc'%str)
- network.outputs = tf.maximum(alpha*network.outputs, network.outputs, name='%s/leaky_relu_dc'%str)
-
- return network
diff --git a/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h b/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h
deleted file mode 100644
index a1c0cac61839a6f66a42c341f50d5e36faad9a93..0000000000000000000000000000000000000000
--- a/spaces/SouthCity/ShuruiXu/crazy_functions/test_project/cpp/libJPG/jpgd.h
+++ /dev/null
@@ -1,316 +0,0 @@
-// jpgd.h - C++ class for JPEG decompression.
-// Public domain, Rich Geldreich
-
-
-
diff --git a/spaces/aadnk/faster-whisper-webui/tests/segments_test.py b/spaces/aadnk/faster-whisper-webui/tests/segments_test.py
deleted file mode 100644
index d829f1c77f74b3c96513fe4965d532cf2d1dceb4..0000000000000000000000000000000000000000
--- a/spaces/aadnk/faster-whisper-webui/tests/segments_test.py
+++ /dev/null
@@ -1,48 +0,0 @@
-import sys
-import unittest
-
-sys.path.append('../whisper-webui')
-
-from src.segments import merge_timestamps
-
-class TestSegments(unittest.TestCase):
- def __init__(self, *args, **kwargs):
- super(TestSegments, self).__init__(*args, **kwargs)
-
- def test_merge_segments(self):
- segments = [
- {'start': 10.0, 'end': 20.0},
- {'start': 22.0, 'end': 27.0},
- {'start': 31.0, 'end': 35.0},
- {'start': 45.0, 'end': 60.0},
- {'start': 61.0, 'end': 65.0},
- {'start': 68.0, 'end': 98.0},
- {'start': 100.0, 'end': 102.0},
- {'start': 110.0, 'end': 112.0}
- ]
-
- result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
- self.assertListEqual(result, [
- {'start': 9.0, 'end': 36.0},
- {'start': 44.0, 'end': 66.0},
- {'start': 67.0, 'end': 99.0},
- {'start': 99.0, 'end': 103.0},
- {'start': 109.0, 'end': 113.0}
- ])
-
- def test_overlap_next(self):
- segments = [
- {'start': 5.0, 'end': 39.182},
- {'start': 39.986, 'end': 40.814}
- ]
-
- result = merge_timestamps(segments, merge_window=5, max_merge_size=30, padding_left=1, padding_right=1)
-
- self.assertListEqual(result, [
- {'start': 4.0, 'end': 39.584},
- {'start': 39.584, 'end': 41.814}
- ])
-
-if __name__ == '__main__':
- unittest.main()
\ No newline at end of file
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/datasets/hrf.py b/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/datasets/hrf.py
deleted file mode 100644
index 242d790eb1b83e75cf6b7eaa7a35c674099311ad..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/datasets/hrf.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# dataset settings
-dataset_type = 'HRFDataset'
-data_root = 'data/HRF'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-img_scale = (2336, 3504)
-crop_size = (256, 256)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations'),
- dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
- dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
- dict(type='RandomFlip', prob=0.5),
- dict(type='PhotoMetricDistortion'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_semantic_seg'])
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale,
- # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img'])
- ])
-]
-
-data = dict(
- samples_per_gpu=4,
- workers_per_gpu=4,
- train=dict(
- type='RepeatDataset',
- times=40000,
- dataset=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/training',
- ann_dir='annotations/training',
- pipeline=train_pipeline)),
- val=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/validation',
- ann_dir='annotations/validation',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/validation',
- ann_dir='annotations/validation',
- pipeline=test_pipeline))
diff --git a/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/resource.py b/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/resource.py
deleted file mode 100644
index a28d4597f8e8b02726b59bb1fd2f8b940b1d1edc..0000000000000000000000000000000000000000
--- a/spaces/abrar-lohia/text-2-character-anim/pyrender/.eggs/pyglet-2.0.5-py3.10.egg/pyglet/resource.py
+++ /dev/null
@@ -1,865 +0,0 @@
-"""Load application resources from a known path.
-
-Loading resources by specifying relative paths to filenames is often
-problematic in Python, as the working directory is not necessarily the same
-directory as the application's script files.
-
-This module allows applications to specify a search path for resources.
-Relative paths are taken to be relative to the application's ``__main__``
-module. ZIP files can appear on the path; they will be searched inside. The
-resource module also behaves as expected when applications are bundled using
-Freezers such as PyInstaller, py2exe, py2app, etc..
-
-In addition to providing file references (with the :py:func:`file` function),
-the resource module also contains convenience functions for loading images,
-textures, fonts, media and documents.
-
-3rd party modules or packages not bound to a specific application should
-construct their own :py:class:`Loader` instance and override the path to use the
-resources in the module's directory.
-
-Path format
-^^^^^^^^^^^
-
-The resource path :py:attr:`path` (see also :py:meth:`Loader.__init__` and
-:py:meth:`Loader.path`)
-is a list of locations to search for resources. Locations are searched in the
-order given in the path. If a location is not valid (for example, if the
-directory does not exist), it is skipped.
-
-Locations in the path beginning with an "at" symbol (''@'') specify
-Python packages. Other locations specify a ZIP archive or directory on the
-filesystem. Locations that are not absolute are assumed to be relative to the
-script home. Some examples::
-
- # Search just the `res` directory, assumed to be located alongside the
- # main script file.
- path = ['res']
-
- # Search the directory containing the module `levels.level1`, followed
- # by the `res/images` directory.
- path = ['@levels.level1', 'res/images']
-
-Paths are always **case-sensitive** and **forward slashes are always used**
-as path separators, even in cases when the filesystem or platform does not do this.
-This avoids a common programmer error when porting applications between platforms.
-
-The default path is ``['.']``. If you modify the path, you must call
-:py:func:`reindex`.
-
-.. versionadded:: 1.1
-"""
-
-import os
-import sys
-import zipfile
-import weakref
-
-from io import BytesIO
-
-import pyglet
-
-
-class ResourceNotFoundException(Exception):
- """The named resource was not found on the search path."""
-
- def __init__(self, name):
- message = ("Resource '{}' was not found on the path. "
- "Ensure that the filename has the correct capitalisation.".format(name))
- Exception.__init__(self, message)
-
-
-class UndetectableShaderType(Exception):
- """The type of the Shader source could not be identified."""
-
- def __init__(self, name):
- message = ("The Shader type of '{}' could not be determined. "
- "Ensure that your source file has a standard extension, "
- "or provide a valid 'shader_type' parameter.".format(name))
- Exception.__init__(self, message)
-
-
-def get_script_home():
- """Get the directory containing the program entry module.
-
- For ordinary Python scripts, this is the directory containing the
- ``__main__`` module. For executables created with py2exe the result is
- the directory containing the running executable file. For OS X bundles
- created using Py2App the result is the Resources directory within the
- running bundle.
-
- If none of the above cases apply and the file for ``__main__`` cannot
- be determined the working directory is returned.
-
- When the script is being run by a Python profiler, this function
- may return the directory where the profiler is running instead of
- the directory of the real script. To workaround this behaviour the
- full path to the real script can be specified in :py:attr:`pyglet.resource.path`.
-
- :rtype: str
- """
- frozen = getattr(sys, 'frozen', None)
- meipass = getattr(sys, '_MEIPASS', None)
- if meipass:
- # PyInstaller
- return meipass
- elif frozen in ('windows_exe', 'console_exe'):
- return os.path.dirname(sys.executable)
- elif frozen == 'macosx_app':
- # py2app
- return os.environ['RESOURCEPATH']
- else:
- main = sys.modules['__main__']
- if hasattr(main, '__file__'):
- return os.path.dirname(os.path.abspath(main.__file__))
- else:
- if 'python' in os.path.basename(sys.executable):
- # interactive
- return os.getcwd()
- else:
- # cx_Freeze
- return os.path.dirname(sys.executable)
-
-
-def get_settings_path(name):
- """Get a directory to save user preferences.
-
- Different platforms have different conventions for where to save user
- preferences, saved games, and settings. This function implements those
- conventions. Note that the returned path may not exist: applications
- should use ``os.makedirs`` to construct it if desired.
-
- On Linux, a directory `name` in the user's configuration directory is
- returned (usually under ``~/.config``).
-
- On Windows (including under Cygwin) the `name` directory in the user's
- ``Application Settings`` directory is returned.
-
- On Mac OS X the `name` directory under ``~/Library/Application Support``
- is returned.
-
- :Parameters:
- `name` : str
- The name of the application.
-
- :rtype: str
- """
-
- if pyglet.compat_platform in ('cygwin', 'win32'):
- if 'APPDATA' in os.environ:
- return os.path.join(os.environ['APPDATA'], name)
- else:
- return os.path.expanduser(f'~/{name}')
- elif pyglet.compat_platform == 'darwin':
- return os.path.expanduser(f'~/Library/Application Support/{name}')
- elif pyglet.compat_platform.startswith('linux'):
- if 'XDG_CONFIG_HOME' in os.environ:
- return os.path.join(os.environ['XDG_CONFIG_HOME'], name)
- else:
- return os.path.expanduser(f'~/.config/{name}')
- else:
- return os.path.expanduser(f'~/.{name}')
-
-
-def get_data_path(name):
- """Get a directory to save user data.
-
- For a Posix or Linux based system many distributions have a separate
- directory to store user data for a specific application and this
- function returns the path to that location. Note that the returned
- path may not exist: applications should use ``os.makedirs`` to
- construct it if desired.
-
- On Linux, a directory `name` in the user's data directory is returned
- (usually under ``~/.local/share``).
-
- On Windows (including under Cygwin) the `name` directory in the user's
- ``Application Settings`` directory is returned.
-
- On Mac OS X the `name` directory under ``~/Library/Application Support``
- is returned.
-
- :Parameters:
- `name` : str
- The name of the application.
-
- :rtype: str
- """
-
- if pyglet.compat_platform in ('cygwin', 'win32'):
- if 'APPDATA' in os.environ:
- return os.path.join(os.environ['APPDATA'], name)
- else:
- return os.path.expanduser(f'~/{name}')
- elif pyglet.compat_platform == 'darwin':
- return os.path.expanduser(f'~/Library/Application Support/{name}')
- elif pyglet.compat_platform.startswith('linux'):
- if 'XDG_DATA_HOME' in os.environ:
- return os.path.join(os.environ['XDG_DATA_HOME'], name)
- else:
- return os.path.expanduser(f'~/.local/share/{name}')
- else:
- return os.path.expanduser(f'~/.{name}')
-
-
-class Location:
- """Abstract resource location.
-
- Given a location, a file can be loaded from that location with the `open`
- method. This provides a convenient way to specify a path to load files
- from, and not necessarily have that path reside on the filesystem.
- """
-
- def open(self, filename, mode='rb'):
- """Open a file at this location.
-
- :Parameters:
- `filename` : str
- The filename to open. Absolute paths are not supported.
- Relative paths are not supported by most locations (you
- should specify only a filename with no path component).
- `mode` : str
- The file mode to open with. Only files opened on the
- filesystem make use of this parameter; others ignore it.
-
- :rtype: file object
- """
- raise NotImplementedError('abstract')
-
-
-class FileLocation(Location):
- """Location on the filesystem.
- """
-
- def __init__(self, filepath):
- """Create a location given a relative or absolute path.
-
- :Parameters:
- `filepath` : str
- Path on the filesystem.
- """
- self.path = filepath
-
- def open(self, filename, mode='rb'):
- return open(os.path.join(self.path, filename), mode)
-
-
-class ZIPLocation(Location):
- """Location within a ZIP file.
- """
-
- def __init__(self, zip, dir):
- """Create a location given an open ZIP file and a path within that
- file.
-
- :Parameters:
- `zip` : ``zipfile.ZipFile``
- An open ZIP file from the ``zipfile`` module.
- `dir` : str
- A path within that ZIP file. Can be empty to specify files at
- the top level of the ZIP file.
-
- """
- self.zip = zip
- self.dir = dir
-
- def open(self, filename, mode='rb'):
- if self.dir:
- path = self.dir + '/' + filename
- else:
- path = filename
-
- forward_slash_path = path.replace(os.sep, '/') # zip can only handle forward slashes
- text = self.zip.read(forward_slash_path)
- return BytesIO(text)
-
-
-class URLLocation(Location):
- """Location on the network.
-
- This class uses the ``urlparse`` and ``urllib2`` modules to open files on
- the network given a URL.
- """
-
- def __init__(self, base_url):
- """Create a location given a base URL.
-
- :Parameters:
- `base_url` : str
- URL string to prepend to filenames.
-
- """
- self.base = base_url
-
- def open(self, filename, mode='rb'):
- import urllib.parse
- import urllib.request
- url = urllib.parse.urljoin(self.base, filename)
- return urllib.request.urlopen(url)
-
-
-class Loader:
- """Load program resource files from disk.
-
- The loader contains a search path which can include filesystem
- directories, ZIP archives and Python packages.
-
- :Ivariables:
- `path` : list of str
- List of search locations. After modifying the path you must
- call the `reindex` method.
- `script_home` : str
- Base resource location, defaulting to the location of the
- application script.
-
- """
- def __init__(self, path=None, script_home=None):
- """Create a loader for the given path.
-
- If no path is specified it defaults to ``['.']``; that is, just the
- program directory.
-
- See the module documentation for details on the path format.
-
- :Parameters:
- `path` : list of str
- List of locations to search for resources.
- `script_home` : str
- Base location of relative files. Defaults to the result of
- `get_script_home`.
-
- """
- if path is None:
- path = ['.']
- if isinstance(path, str):
- path = [path]
- self.path = list(path)
- self._script_home = script_home or get_script_home()
- self._index = None
-
- # Map bin size to list of atlases
- self._texture_atlas_bins = {}
-
- # map name to image etc.
- self._cached_textures = weakref.WeakValueDictionary()
- self._cached_images = weakref.WeakValueDictionary()
- self._cached_animations = weakref.WeakValueDictionary()
-
- def _require_index(self):
- if self._index is None:
- self.reindex()
-
- def reindex(self):
- """Refresh the file index.
-
- You must call this method if `path` is changed or the filesystem
- layout changes.
- """
- self._index = {}
- for path in self.path:
- if path.startswith('@'):
- # Module
- name = path[1:]
-
- try:
- module = __import__(name)
- except:
- continue
-
- for component in name.split('.')[1:]:
- module = getattr(module, component)
-
- if hasattr(module, '__file__'):
- path = os.path.dirname(module.__file__)
- else:
- path = '' # interactive
- elif not os.path.isabs(path):
- # Add script base unless absolute
- assert r'\\' not in path, "Backslashes are not permitted in relative paths"
- path = os.path.join(self._script_home, path)
-
- if os.path.isdir(path):
- # Filesystem directory
- path = path.rstrip(os.path.sep)
- location = FileLocation(path)
- for dirpath, dirnames, filenames in os.walk(path):
- dirpath = dirpath[len(path) + 1:]
- # Force forward slashes for index
- if dirpath:
- parts = [part
- for part
- in dirpath.split(os.sep)
- if part is not None]
- dirpath = '/'.join(parts)
- for filename in filenames:
- if dirpath:
- index_name = dirpath + '/' + filename
- else:
- index_name = filename
- self._index_file(index_name, location)
- else:
- # Find path component that looks like the ZIP file.
- dir = ''
- old_path = None
- while path and not (os.path.isfile(path) or os.path.isfile(path + '.001')):
- old_path = path
- path, tail_dir = os.path.split(path)
- if path == old_path:
- break
- dir = '/'.join((tail_dir, dir))
- if path == old_path:
- continue
- dir = dir.rstrip('/')
-
- # path looks like a ZIP file, dir resides within ZIP
- if not path:
- continue
-
- zip_stream = self._get_stream(path)
- if zip_stream:
- zip = zipfile.ZipFile(zip_stream, 'r')
- location = ZIPLocation(zip, dir)
- for zip_name in zip.namelist():
- # zip_name_dir, zip_name = os.path.split(zip_name)
- # assert '\\' not in name_dir
- # assert not name_dir.endswith('/')
- if zip_name.startswith(dir):
- if dir:
- zip_name = zip_name[len(dir) + 1:]
- self._index_file(zip_name, location)
-
- def _get_stream(self, path):
- if zipfile.is_zipfile(path):
- return path
- elif not os.path.exists(path + '.001'):
- return None
- else:
- with open(path + '.001', 'rb') as volume:
- bytes_ = bytes(volume.read())
-
- volume_index = 2
- while os.path.exists(path + '.{0:0>3}'.format(volume_index)):
- with open(path + '.{0:0>3}'.format(volume_index), 'rb') as volume:
- bytes_ += bytes(volume.read())
-
- volume_index += 1
-
- zip_stream = BytesIO(bytes_)
- if zipfile.is_zipfile(zip_stream):
- return zip_stream
- else:
- return None
-
- def _index_file(self, name, location):
- if name not in self._index:
- self._index[name] = location
-
- def file(self, name, mode='rb'):
- """Load a resource.
-
- :Parameters:
- `name` : str
- Filename of the resource to load.
- `mode` : str
- Combination of ``r``, ``w``, ``a``, ``b`` and ``t`` characters
- with the meaning as for the builtin ``open`` function.
-
- :rtype: file object
- """
- self._require_index()
- try:
- location = self._index[name]
- return location.open(name, mode)
- except KeyError:
- raise ResourceNotFoundException(name)
-
- def location(self, name):
- """Get the location of a resource.
-
- This method is useful for opening files referenced from a resource.
- For example, an HTML file loaded as a resource might reference some
- images. These images should be located relative to the HTML file, not
- looked up individually in the loader's path.
-
- :Parameters:
- `name` : str
- Filename of the resource to locate.
-
- :rtype: `Location`
- """
- self._require_index()
- try:
- return self._index[name]
- except KeyError:
- raise ResourceNotFoundException(name)
-
- def add_font(self, name):
- """Add a font resource to the application.
-
- Fonts not installed on the system must be added to pyglet before they
- can be used with `font.load`. Although the font is added with
- its filename using this function, it is loaded by specifying its
- family name. For example::
-
- resource.add_font('action_man.ttf')
- action_man = font.load('Action Man')
-
- :Parameters:
- `name` : str
- Filename of the font resource to add.
-
- """
- self._require_index()
- from pyglet import font
- file = self.file(name)
- font.add_file(file)
-
- def _alloc_image(self, name, atlas, border):
- file = self.file(name)
- try:
- img = pyglet.image.load(name, file=file)
- finally:
- file.close()
-
- if not atlas:
- return img.get_texture()
-
- # find an atlas suitable for the image
- bin = self._get_texture_atlas_bin(img.width, img.height, border)
- if bin is None:
- return img.get_texture()
-
- return bin.add(img, border)
-
- def _get_texture_atlas_bin(self, width, height, border):
- """A heuristic for determining the atlas bin to use for a given image
- size. Returns None if the image should not be placed in an atlas (too
- big), otherwise the bin (a list of TextureAtlas).
- """
- # Large images are not placed in an atlas
- max_texture_size = pyglet.image.get_max_texture_size()
- max_size = min(2048, max_texture_size) - border
- if width > max_size or height > max_size:
- return None
-
- # Group images with small height separately to larger height
- # (as the allocator can't stack within a single row).
- bin_size = 1
- if height > max_size / 4:
- bin_size = 2
-
- try:
- texture_bin = self._texture_atlas_bins[bin_size]
- except KeyError:
- texture_bin = pyglet.image.atlas.TextureBin()
- self._texture_atlas_bins[bin_size] = texture_bin
-
- return texture_bin
-
- def image(self, name, flip_x=False, flip_y=False, rotate=0, atlas=True, border=1):
- """Load an image with optional transformation.
-
- This is similar to `texture`, except the resulting image will be
- packed into a :py:class:`~pyglet.image.atlas.TextureBin` if it is an appropriate size for packing.
- This is more efficient than loading images into separate textures.
-
- :Parameters:
- `name` : str
- Filename of the image source to load.
- `flip_x` : bool
- If True, the returned image will be flipped horizontally.
- `flip_y` : bool
- If True, the returned image will be flipped vertically.
- `rotate` : int
- The returned image will be rotated clockwise by the given
- number of degrees (a multiple of 90).
- `atlas` : bool
- If True, the image will be loaded into an atlas managed by
- pyglet. If atlas loading is not appropriate for specific
- texturing reasons (e.g. border control is required) then set
- this argument to False.
- `border` : int
- Leaves specified pixels of blank space around each image in
- an atlas, which may help reduce texture bleeding.
-
- :rtype: `Texture`
- :return: A complete texture if the image is large or not in an atlas,
- otherwise a :py:class:`~pyglet.image.TextureRegion` of a texture atlas.
- """
- self._require_index()
- if name in self._cached_images:
- identity = self._cached_images[name]
- else:
- identity = self._cached_images[name] = self._alloc_image(name, atlas, border)
-
- if not rotate and not flip_x and not flip_y:
- return identity
-
- return identity.get_transform(flip_x, flip_y, rotate)
-
- def animation(self, name, flip_x=False, flip_y=False, rotate=0, border=1):
- """Load an animation with optional transformation.
-
- Animations loaded from the same source but with different
- transformations will use the same textures.
-
- :Parameters:
- `name` : str
- Filename of the animation source to load.
- `flip_x` : bool
- If True, the returned image will be flipped horizontally.
- `flip_y` : bool
- If True, the returned image will be flipped vertically.
- `rotate` : int
- The returned image will be rotated clockwise by the given
- number of degrees (a multiple of 90).
- `border` : int
- Leaves specified pixels of blank space around each image in
- an atlas, which may help reduce texture bleeding.
-
- :rtype: :py:class:`~pyglet.image.Animation`
- """
- self._require_index()
- try:
- identity = self._cached_animations[name]
- except KeyError:
- animation = pyglet.image.load_animation(name, self.file(name))
- bin = self._get_texture_atlas_bin(animation.get_max_width(),
- animation.get_max_height(),
- border)
- if bin:
- animation.add_to_texture_bin(bin, border)
-
- identity = self._cached_animations[name] = animation
-
- if not rotate and not flip_x and not flip_y:
- return identity
-
- return identity.get_transform(flip_x, flip_y, rotate)
-
- def get_cached_image_names(self):
- """Get a list of image filenames that have been cached.
-
- This is useful for debugging and profiling only.
-
- :rtype: list
- :return: List of str
- """
- self._require_index()
- return list(self._cached_images.keys())
-
- def get_cached_animation_names(self):
- """Get a list of animation filenames that have been cached.
-
- This is useful for debugging and profiling only.
-
- :rtype: list
- :return: List of str
- """
- self._require_index()
- return list(self._cached_animations.keys())
-
- def get_texture_bins(self):
- """Get a list of texture bins in use.
-
- This is useful for debugging and profiling only.
-
- :rtype: list
- :return: List of :py:class:`~pyglet.image.atlas.TextureBin`
- """
- self._require_index()
- return list(self._texture_atlas_bins.values())
-
- def media(self, name, streaming=True):
- """Load a sound or video resource.
-
- The meaning of `streaming` is as for `media.load`. Compressed
- sources cannot be streamed (that is, video and compressed audio
- cannot be streamed from a ZIP archive).
-
- :Parameters:
- `name` : str
- Filename of the media source to load.
- `streaming` : bool
- True if the source should be streamed from disk, False if
- it should be entirely decoded into memory immediately.
-
- :rtype: `media.Source`
- """
- self._require_index()
- from pyglet import media
- try:
- location = self._index[name]
- if isinstance(location, FileLocation):
- # Don't open the file if it's streamed from disk
- path = os.path.join(location.path, name)
- return media.load(path, streaming=streaming)
- else:
- file = location.open(name)
-
- return media.load(name, file=file, streaming=streaming)
- except KeyError:
- raise ResourceNotFoundException(name)
-
- def texture(self, name):
- """Load a texture.
-
- The named image will be loaded as a single OpenGL texture. If the
- dimensions of the image are not powers of 2 a :py:class:`~pyglet.image.TextureRegion` will
- be returned.
-
- :Parameters:
- `name` : str
- Filename of the image resource to load.
-
- :rtype: `Texture`
- """
- self._require_index()
- if name in self._cached_textures:
- return self._cached_textures[name]
-
- file = self.file(name)
- texture = pyglet.image.load(name, file=file).get_texture()
- self._cached_textures[name] = texture
- return texture
-
- def model(self, name, batch=None):
- """Load a 3D model.
-
- :Parameters:
- `name` : str
- Filename of the 3D model to load.
- `batch` : Batch or None
- An optional Batch instance to add this model to.
-
- :rtype: `Model`
- """
- self._require_index()
- abspathname = os.path.join(os.path.abspath(self.location(name).path), name)
- return pyglet.model.load(filename=abspathname, file=self.file(name), batch=batch)
-
- def html(self, name):
- """Load an HTML document.
-
- :Parameters:
- `name` : str
- Filename of the HTML resource to load.
-
- :rtype: `FormattedDocument`
- """
- self._require_index()
- file = self.file(name)
- return pyglet.text.load(name, file, 'text/html')
-
- def attributed(self, name):
- """Load an attributed text document.
-
- See `pyglet.text.formats.attributed` for details on this format.
-
- :Parameters:
- `name` : str
- Filename of the attribute text resource to load.
-
- :rtype: `FormattedDocument`
- """
- self._require_index()
- file = self.file(name)
- return pyglet.text.load(name, file, 'text/vnd.pyglet-attributed')
-
- def text(self, name):
- """Load a plain text document.
-
- :Parameters:
- `name` : str
- Filename of the plain text resource to load.
-
- :rtype: `UnformattedDocument`
- """
- self._require_index()
- fileobj = self.file(name)
- return pyglet.text.load(name, fileobj, 'text/plain')
-
- def shader(self, name, shader_type=None):
- """Load a Shader object.
-
- :Parameters:
- `name` : str
- Filename of the Shader source to load.
- `shader_type` : str
- A hint for the type of shader, such as 'vertex', 'fragment', etc.
- Not required if your shader has a standard file extension.
-
- :rtype: A compiled `Shader` object.
- """
- # https://www.khronos.org/opengles/sdk/tools/Reference-Compiler/
- shader_extensions = {'comp': "compute",
- 'frag': "fragment",
- 'geom': "geometry",
- 'tesc': "tescontrol",
- 'tese': "tesevaluation",
- 'vert': "vertex"}
- fileobj = self.file(name, 'r')
- source_string = fileobj.read()
-
- if not shader_type:
- try:
- _, extension = os.path.splitext(name)
- shader_type = shader_extensions.get(extension.strip("."))
- except KeyError:
- raise UndetectableShaderType(name=name)
-
- if shader_type not in shader_extensions.values():
- raise UndetectableShaderType(name=name)
-
- return pyglet.graphics.shader.Shader(source_string, shader_type)
-
- def get_cached_texture_names(self):
- """Get the names of textures currently cached.
-
- :rtype: list of str
- """
- self._require_index()
- return list(self._cached_textures.keys())
-
-
-#: Default resource search path.
-#:
-#: Locations in the search path are searched in order and are always
-#: case-sensitive. After changing the path you must call `reindex`.
-#:
-#: See the module documentation for details on the path format.
-#:
-#: :type: list of str
-path = []
-
-
-class _DefaultLoader(Loader):
-
- @property
- def path(self):
- return path
-
- @path.setter
- def path(self, value):
- global path
- path = value
-
-
-_default_loader = _DefaultLoader()
-reindex = _default_loader.reindex
-file = _default_loader.file
-location = _default_loader.location
-add_font = _default_loader.add_font
-image = _default_loader.image
-animation = _default_loader.animation
-model = _default_loader.model
-media = _default_loader.media
-texture = _default_loader.texture
-html = _default_loader.html
-attributed = _default_loader.attributed
-text = _default_loader.text
-shader = _default_loader.shader
-get_cached_texture_names = _default_loader.get_cached_texture_names
-get_cached_image_names = _default_loader.get_cached_image_names
-get_cached_animation_names = _default_loader.get_cached_animation_names
-get_texture_bins = _default_loader.get_texture_bins
diff --git a/spaces/agutfraind/llmscanner/README.md b/spaces/agutfraind/llmscanner/README.md
deleted file mode 100644
index 816687f064488672b65b03a6cf441f05d131c5ab..0000000000000000000000000000000000000000
--- a/spaces/agutfraind/llmscanner/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: LLM Scanner
-emoji: 🦙
-colorFrom: pink
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.19.0
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/speech_commands/voc1/run.sh b/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/speech_commands/voc1/run.sh
deleted file mode 100644
index 0e1e24d55f548d47b13ca74b0a713be29eb277cf..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/egs/speech_commands/voc1/run.sh
+++ /dev/null
@@ -1,164 +0,0 @@
-#!/bin/bash
-
-# Copyright 2019 Tomoki Hayashi
-# MIT License (https://opensource.org/licenses/MIT)
-
-. ./cmd.sh || exit 1;
-. ./path.sh || exit 1;
-
-# basic settings
-stage=-1 # stage to start
-stop_stage=100 # stage to stop
-verbose=1 # verbosity level (lower is less info)
-n_gpus=1 # number of gpus in training
-n_jobs=16 # number of parallel jobs in feature extraction
-
-# NOTE(kan-bayashi): renamed to conf to avoid conflict in parse_options.sh
-conf=conf/parallel_wavegan.v1.yaml
-
-# directory path setting
-download_dir=downloads # direcotry to save downloaded files
-dumpdir=dump # directory to dump features
-
-# training related setting
-tag="" # tag for directory to save model
-resume="" # checkpoint path to resume training
- # (e.g. BlueWhaleX LLM Research Space!
-A first set of LLM Chinese models built by us based on the Chinese-Alpaca are released! Check them here:
- -bwx-7B https://huggingface.co/BlueWhaleX/bwx-7B-hf
-bwx-13B https://huggingface.co/BlueWhaleX/bwx-13B-hf
-No hyperlinks here
" - mocker.patch("requests.Session.get", return_value=mock_response) - - # Call the function with a URL containing no hyperlinks - result = scrape_links("https://www.example.com") - - # Assert that the function returns an empty list - assert result == [] - - # Tests that scrape_links() correctly extracts and formats hyperlinks from - # a sample HTML containing a few hyperlinks. - def test_scrape_links_with_few_hyperlinks(self, mocker): - # Mock the requests.get() function to return a response with a sample HTML containing hyperlinks - mock_response = mocker.Mock() - mock_response.status_code = 200 - mock_response.text = """ - - - - - - - - """ - mocker.patch("requests.Session.get", return_value=mock_response) - - # Call the function being tested - result = scrape_links("https://www.example.com") - - # Assert that the function returns a list of formatted hyperlinks - assert isinstance(result, list) - assert len(result) == 3 - assert result[0] == "Google (https://www.google.com)" - assert result[1] == "GitHub (https://github.com)" - assert result[2] == "CodiumAI (https://www.codium.ai)" diff --git a/spaces/awacke1/Assessments.Clinical.Terminology.FHIR.PHQ.GAD.SDOH/README.md b/spaces/awacke1/Assessments.Clinical.Terminology.FHIR.PHQ.GAD.SDOH/README.md deleted file mode 100644 index a15edd37e9d64351137f32a3b98a4963f4141408..0000000000000000000000000000000000000000 --- a/spaces/awacke1/Assessments.Clinical.Terminology.FHIR.PHQ.GAD.SDOH/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Health.Assessments.Summarizer -emoji: 💻 -colorFrom: purple -colorTo: red -sdk: streamlit -sdk_version: 1.17.0 -app_file: app.py -pinned: false -license: mit ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/awacke1/AzureBlobStorage/app.py b/spaces/awacke1/AzureBlobStorage/app.py deleted file mode 100644 index e015e23edded4fe4d649e2b8c0c4e9e724a52a1d..0000000000000000000000000000000000000000 --- a/spaces/awacke1/AzureBlobStorage/app.py +++ /dev/null @@ -1,61 +0,0 @@ -import streamlit as st -from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient -import base64 -import os - -# Session State workaround -class SessionState(object): - def __init__(self, **kwargs): - for key, val in kwargs.items(): - setattr(self, key, val) - - -def get_state(**kwargs): - if 'session_state' not in st.session_state: - st.session_state['session_state'] = SessionState(**kwargs) - return st.session_state['session_state'] - - -def save_to_azure(files, connect_str, container_name): - blob_service_client = BlobServiceClient.from_connection_string(connect_str) - for file in files: - blob_client = blob_service_client.get_blob_client(container_name, file.name) - blob_client.upload_blob(file, overwrite=True) - - -def list_blobs(connect_str, container_name): - blob_service_client = BlobServiceClient.from_connection_string(connect_str) - container_client = blob_service_client.get_container_client(container_name) - - blob_list = container_client.list_blobs() - for blob in blob_list: - blob_url = f"https://{blob_service_client.account_name}.blob.core.windows.net/{container_name}/{blob.name}" - b64 = base64.b64encode(blob_url.encode()).decode() - href = f'Download {blob.name}' - st.markdown(href, unsafe_allow_html=True) - - -def app(): - st.title('Azure Blob Storage App 💾') - - state = get_state(connect_str='', container_name='') - - with st.sidebar: - st.subheader("Azure Settings 🔧") - state.connect_str = st.text_input('Connection String', value=state.connect_str) - state.container_name = st.text_input('Container Name', value=state.container_name) - - st.subheader("Your documents 📑") - docs = st.file_uploader("Import documents", accept_multiple_files=True) - - if st.button('Save Files'): - with st.spinner("Saving..."): - save_to_azure(docs, state.connect_str, state.container_name) - - if st.button('Retrieve Files'): - with st.spinner("Retrieving..."): - list_blobs(state.connect_str, state.container_name) - - -if __name__ == "__main__": - app() diff --git a/spaces/awacke1/Streamlit.Graphviz.Stories.JSONL/app.py b/spaces/awacke1/Streamlit.Graphviz.Stories.JSONL/app.py deleted file mode 100644 index 7cda3006a9ce81ab67634d2f9ef39238e6f9becf..0000000000000000000000000000000000000000 --- a/spaces/awacke1/Streamlit.Graphviz.Stories.JSONL/app.py +++ /dev/null @@ -1,130 +0,0 @@ -import streamlit as st - -import streamlit as st -import random -import json -import graphviz as gv - -stories = [ -{"title": "The Celestial Gatekeepers ☄️🌟🛡️", "outline": ["🌌 Stella, the starry-eyed guardian, and her celestial companions are tasked with protecting the universe from cosmic threats.", "😇👿 As the team battles otherworldly foes, they must also confront their own inner demons and navigate the complex relationships within their ranks.", "⚔️🌑 The Gatekeepers face a powerful and ancient force of darkness, ultimately triumphing and strengthening their bonds as a team."]}, -{"title": "The Children of the Forgotten Gods ⚡🐉🏺", "outline": ["🏺 In a world where the old gods have been forgotten, Theo the Thunder-Caller, Dara the Dragon-Tamer, and their band of misfits are chosen by fate to restore the legacy of the ancient deities.", "🧗♂️🌩️ The group embarks on a series of perilous adventures, unearthing long-lost relics and rediscovering the powers of the gods.", "⚔️🌑 They prevent the rise of a new dark power, restoring the gods' rightful place in the world and transforming it for the better."]}, -{"title": "The Time Weaver Chronicles ⏳🧙♂️🕰️", "outline": ["🕰️ Tim the Time-Weaver, a sorcerer with the ability to travel through time, sets out on a mission to prevent a catastrophic event from occurring.", "⌛🌀 As Tim unravels the mysteries of the past, present, and future, he encounters new friends, formidable enemies, and unexpected challenges.", "🧙♂️🔁 Tim ultimately averts the disaster, learning valuable lessons about the nature of time and the importance of living in the moment."]}, -{"title": "The Enchanted Forest Trilogy 🌲🦄✨", "outline": ["🌳🦋 In the hidden magical kingdom of the Enchanted Forest, a brave young elf named Elara must gather her friends to save their home from an evil sorceress.", "🍂🌈 As the group faces trials and tribulations, they discover the true power of friendship and the strength within themselves.", "⚔️🔮 Elara and her friends defeat the sorceress, restoring peace and harmony to the Enchanted Forest and its magical creatures."]}, -{"title": "The Cursed Kingdom 🏰👻🔮", "outline": ["🌑🌲 In a once-prosperous realm now plagued by dark forces, a group of heroes led by the courageous knight Sir Rowan sets out to break the curse and restore the light.", "🌩️👻 As the heroes face daunting challenges and supernatural enemies, they uncover the hidden history of their kingdom and the true nature of the curse.", "🏰💡 The group defeats the source of the darkness, lifting the curse and bringing hope and prosperity back to the kingdom."]} , -{"title": "Battle of the Glitch Realm 🕹️👾🔧", "outline": ["🌐 In the virtual world of the Glitch Realm, Ada the Debugger and her team of skilled gamers", "👾🛡️ The group battles against an army of rogue NPCs and malicious hackers, using their gaming prowess and programming skills to overcome the obstacles.", "⚔️💻 Ada and her team finally reach the heart of the Glitch Realm, where they discover the mastermind behind the chaos and must engage in a final epic showdown to restore order."]}, -{"title": "The Dragon Riders of Skye 🐲🏰🌊", "outline": ["🌊 On the Scottish isle of Skye, a young adventurer named Ewan befriends a group of dragon riders and learns the ancient art of dragon magic.", "🐲🌋 The team faces off against a powerful dragon queen and her army of minions, using their dragon magic and wits to overcome the challenges.", "🏰✨ Ewan and his companions claim victory and restore peace to the kingdom, ushering in a new era of dragon-human cooperation."]}, -{"title": "The Last Samurai of Kyoto 🗡️🌸🏯", "outline": ["🏯 In feudal Japan, a samurai named Takeshi seeks to avenge his fallen master and restore honor to his clan.", "🗡️🌸 Takeshi faces off against rival samurai and corrupt officials, employing his mastery of the sword and deep understanding of bushido.", "🔥👹 Takeshi confronts the demonic forces behind his master's death, culminating in an epic showdown against the demon king himself."]}, -{"title": "The Witch Hunter's Quest 🧙♂️🔫🕵️♂️", "outline": ["🧙♂️ In a world of magic and technology, a witch hunter named Max is tasked with eliminating a powerful coven of witches.", "🔫🕵️♂️ Max navigates a complex web of intrigue and danger, using his knowledge of both magic and technology to outsmart his enemies.", "🔥💀 Max confronts the leader of the coven in a final showdown, unleashing a devastating array of spells and gadgets to emerge victorious."]}, -{"title": "The Pirate Queen's Treasure 🏴☠️💰🗺️", "outline": ["🗺️ In the golden age of piracy, a notorious pirate queen named Anne and her crew embark on a perilous quest to find a legendary treasure.", "🏴☠️⚔️ The team battles against rival pirates, treacherous seas, and ancient curses in their search for the treasure.", "💰🏝️ Anne and her crew finally discover the treasure, but must fend off one final enemy to claim it as their own."]}, -{"title": "The Cosmic Adventurers 🚀🪐👨🚀", "outline": ["🚀 A team of space explorers, led by Captain Ariadne, sets out on a mission to discover new worlds and civilizations.", "🌌👽 The team encounters a variety of alien species, some friendly and some hostile, and must use their skills and wits to navigate the challenges of deep space.", "⚔️🪐 The Cosmic Adventurers finally face off against a powerful alien warlord, and must fight to protect the universe from his destructive plans."]}, -{"title": "The Necromancer's Curse 💀👻🔮", "outline": ["🔮 A young sorceress named Leila unwittingly unleashes a powerful necromancer's curse on her kingdom, and must find a way to break the curse before it destroys everything.", "💀🌳 Leila travels to the heart of a cursed forest, where she encounters supernatural creatures and dangerous spirits.", "🔥🧙♀️ Leila confronts the necromancer herself, and must use all her magical abilities to break the curse and save her kingdom."]}, -{"title": "The Guardians of the Elemental Crystals 🌊🔥🍃", "outline": ["🌍 In a world where the elements are sacred, a group of heroes known as the Guardians are tasked with protecting the Elemental Crystals from those who would use them for evil.", "🔥🍃🌊 The Guardians must journey across the land, facing off against elementally-aligned foes and unlocking the power of each Crystal in turn.", "⚔️💎 The team finally faces off against a powerful enemy who seeks to use the Crystals to rule the world, and must use all their elemental powers to stop him."]}, -{"title": "The Hunt for the Lost City of Gold 🏜️🗺️💰", "outline": ["🗺️ A team of treasure hunters, led by the intrepid Lara, sets out on a quest to find the Lost City of Gold, a legendary place rumored to contain untold riches.", "🏜️🐍 The team faces off against treacherous deserts, deadly traps, and venomous snakes, using their skills and knowledge to survive.", "💰🗝️ Lara and her team finally discover the Lost City of Gold, but must outwit a rival team of treasure hunters to claim the treasure as their own."]}, -{"title": "The Cyber Ninjas 🐱💻🗡️🤖", "outline": ["🐱💻 In a future where cybernetic enhancements are the norm, a group of elite warriors known as the Cyber Ninjas is tasked with protecting society from rogue AI and other digital threats.", "🗡️🤖 The Cyber Ninjas battle against a variety of mechanical foes, using their cyber-enhanced abilities to gain the upper hand.", "⚔️💻 The team faces off against a rogue AI that threatens to destroy humanity, and must use all their ninja skills to stop it."]}, -{"title": "The Kingdom of Glass 🌠👑🔮", "outline": ["🔮 In a magical kingdom made entirely of glass, the young princess Crystal must protect her realm from an ancient evil that seeks to shatter it.", "🌠🐉 Crystal enlists the help of a dragon and a group of skilled glassblowers to defend her kingdom from the monstrous invaders.", "⚔️🔥 Crystal and her allies confront the evil queen behind the invasion, and must use all their skill and courage to save the kingdom from destruction."]}, -{"title": "The Elemental Heroes 🔥💧🌬️", "outline": ["🌍 A team of elemental heroes, each possessing control over one of the four elements, must band together to stop a powerful enemy who seeks to use their powers for evil.", "🌬️💧🌍🔥 The heroes face off against a variety of foes, each with control over a different element, as they seek to unlock the true potential of their own powers.", "⚔️🌟 The team confronts the enemy leader in an epic final battle, using their combined elemental powers to save the world from destruction."]}, -{"title": "The Last Survivors of Earth 🌎🧟♂️🧟♀️", "outline": ["🧟♂️🌍 In a post-apocalyptic world overrun by zombies, a group of survivors led by the determined Rick must band together to fend off the undead hordes and rebuild civilization.", "🧟♀️💥 Rick and his team must scavenge for supplies, fortify their bases, and fight off rival survivor groups in their quest for survival.", "⚔️🌟 As the team grows stronger, they face off against a powerful zombie overlord who seeks to wipe out the last remnants of humanity."]}, -{"title": "The Rise of the Sea Dragons 🌊🐉🗺️", "outline": ["🗺️ On a quest to explore the unknown depths of the ocean, a group of adventurers discovers a hidden world of sea dragons, powerful creatures with the ability to control water.", "🌊🔥 The team battles against rival sea creatures and treacherous underwater landscapes, using their own skills and the power of the sea dragons to overcome the obstacles.", "⚔️🌊 The adventurers finally face off against a powerful sea monster that threatens to destroy everything, and must use all their skills and the power of the sea dragons to save the world."]}, -{"title": "The Phoenix's Resurrection 🔥🐦🌅", "outline": ["🌅 In a world of ancient mythology, a young warrior named Phoenix sets out on a quest to resurrect the legendary bird of fire and restore its power.", "🐦🔥 Phoenix must battle against powerful creatures and solve intricate puzzles to gather the necessary materials for the resurrection ritual.", "⚔️🌄 Phoenix finally confronts the ancient enemy who originally killed the Phoenix, and must use all his skill and power to defeat him and complete the ritual."]}, -{"title": "The Dark Woods Chronicles 🌳🦊🗡️", "outline": ["🌳 A group of adventurers must journey through the Dark Woods, a treacherous forest filled with dangerous creatures and mysterious magic.", "🐺🦊 The team faces off against wolves, foxes, and other forest creatures, forming unexpected alliances and confronting their own fears along the way.", "⚔️🌕 The adventurers finally reach the heart of the Dark Woods, where they face off against the ancient forest spirits and the dark magic that threatens to consume them."]}, -{"title": "The Legacy of the Dragons 🐲🌋🌎", "outline": ["🌎 In a world where dragons once ruled supreme, a young dragon rider named Ember sets out to restore the legacy of the dragons and reclaim their place in the world.", "🐲🔥 Ember must battle against rival dragon riders and powerful dragons corrupted by dark magic, using her own dragon and her wits to overcome the obstacles in her path.", "⚔️🌋 Ember and her dragon finally confront the dark sorcerer who seeks to control the dragons and destroy the world, using their combined power to save the dragons and restore balance to the world."]}, -{"title": "The Pirate Queen's Treasure 🏴☠️🗺️💰", "outline": ["🗺️ On a quest to find a legendary treasure hidden by the infamous Pirate Queen, a group of adventurers must face off against rival pirate crews, treacherous waters, and deadly traps.", "🏴☠️🦜 The team gains the help of a cunning parrot and a group of experienced sailors, but also faces betrayal and mutiny along the way.", "⚔️💰 The adventurers finally reach the hidden treasure, but must face off against the Pirate Queen herself to claim it as their own."]}, -{"title": "The Gauntlet of the Gods 🗡️🛡️🌟", "outline": ["🌟 The Gauntlet of the Gods is a legendary artifact that grants immense power to whoever can pass its trials.", "🗡️🛡️ A group of adventurers must navigate a series of deadly challenges, each one testing their strength, intelligence, and courage.", "⚔️🌟 The adventurers finally reach the end of the gauntlet, where they face off against a powerful guardian and must use all their skills to claim the prize."]}, -{"title": "The Sorcerer's Apprentice 🧙♂️🔮🎓", "outline": ["🎓 A young apprentice named Alex is taken under the wing of a powerful sorcerer, learning the secrets of magic and the dangers that come with it.", "🧹🔮 Alex must learn to control his powers and fend off magical creatures and dark sorcerers who seek to use his abilities for their own gain.", "⚔️🔥 Alex and his mentor finally confront a powerful sorcerer who threatens to destroy the magical realm, using their combined power and intelligence to save the day."]}, -{"title": "The Crystal Caves 🕸️💎🕸️", "outline": ["🕸️ In the depths of a labyrinthine cave system, a team of adventurers must search for a legendary crystal that holds immense power.", "💎🔍 The team faces off against giant spiders, deadly traps, and rival treasure hunters, using their wits and skills to overcome the obstacles in their path.", "⚔️💥 The adventurers finally reach the crystal, but must face off against a powerful enemy who seeks to use its power for his own gain."]}, -{"title": "The Immortal Knights ⚔️🛡️🦸♂️", "outline": ["🛡️ In a world where immortality can be granted through the power of magic, a group of knights must navigate a complex political landscape filled with rival factions and dangerous enemies.", "⚔️👑 The knights must prove their worth to the powerful mage guilds and secure alliances with powerful nobles in their quest to become immortal and protect their realm.", "⚔️🌅 The knights finally face off against the dark sorcerers who seek to rule the world, using their newfound immortality and skill to save the world from destruction."]}, -{"title": "The Crystal Kingdom 💎👸🗡️", "outline": ["💎 In a kingdom made entirely of crystal, the young princess Amethyst must defend her realm from a powerful enemy who seeks to shatter it.", "👸🗡️ Amethyst enlists the help of a skilled warrior and a team of crystal workers to defend her kingdom from the monstrous invaders.", "⚔️🌕 Amethyst and her allies confront the evil queen behind the invasion, and must use all their skill and courage to save the kingdom from destruction."]}, -{"title": "The Guardians of the Elements 🌊🔥🌬️🌎", "outline": ["🌎🌬️🔥🌊 The Guardians of the Elements are a team of powerful warriors tasked with protecting the world from threats that seek to manipulate the forces of nature.", "🔥🌊🌬️🌎 The guardians must use their control over fire, water, air, and earth to defeat their enemies and prevent disasters from occurring.", "⚔️🌟 The guardians finally face off against a powerful enemy who seeks to harness the power of the elements for his own gain, using their combined strength and skill to save the world from destruction."]}, -{"title": "The Quest for the Holy Grail 🏰🗡️🍷", "outline": ["🏰 In a medieval world of knights and magic, a young adventurer named Arthur sets out on a quest to find the Holy Grail, a legendary artifact said to grant eternal life.", "🗡️ Arthur battles against rival knights, ancient curses, and powerful sorcerers in his quest for the grail.", "⚔️🍷 Arthur finally confronts the evil sorcerer who seeks to use the grail for his own gain, using his courage and wit to claim the artifact and save the world."]}, -{"title": "The Lost City of Gold 🗺️💰🔍", "outline": ["🗺️ A group of adventurers set out to find the legendary Lost City of Gold, said to contain unimaginable riches and artifacts of great power.", "💰🔍 The team must navigate treacherous jungles, avoid deadly traps, and fend off rival treasure hunters in their quest for the lost city.", "⚔️🌅 The adventurers finally reach the lost city, but must face off against the powerful guardians who protect it and prevent their enemies from claiming the treasure."]}, -{"title": "The Chronicles of the Shadow Realm 👻🗡️🔮", "outline": ["👻 The Shadow Realm is a dark and dangerous world filled with powerful magic and deadly creatures.", "🗡️ The heroes of the Shadow Realm must battle against dark wizards, evil sorceresses, and monstrous creatures, using their own skills and magic to protect their world from destruction.", "⚔️🌅 The heroes finally face off against a powerful enemy who seeks to use the power of the Shadow Realm to conquer the world of light, using their combined strength and skill to save both realms from destruction."]}, -{"title": "The Dragon Queen's Revenge 🐲👑🗡️", "outline": ["🐲👑 The Dragon Queen seeks revenge against the human kingdom that betrayed her and killed her dragon mate.", "🗡️ A group of knights and warriors must defend the kingdom from the Dragon Queen's wrath, using their own skills and the aid of dragons to defend their homes.", "⚔️🌅 The knights finally face off against the Dragon Queen herself, using all their skill and strength to protect their kingdom and restore peace between humans and dragons."]}, -{"title": "The Time Traveler's Dilemma ⏰👴🕰️", "outline": ["⏰ A time traveler named Max must navigate a complex web of time paradoxes and alternate realities as he seeks to prevent a disaster from occurring.", "👴 Max encounters his future self and learns the dangers of tampering with time, as well as the unforeseen consequences of his actions.", "⚔️🔮 Max finally confronts the source of the disaster, learning valuable lessons about the nature of time and the importance of living in the moment."]}, -{"title": "The Rise of the Undead 🔥👻💀", "outline": ["👻 A dark sorcerer has unleashed a horde of undead creatures upon the world, threatening to wipe out all life and spread darkness across the land.", "🔥 A group of heroes must battle against the undead armies and stop the sorcerer from completing his dark ritual.", "⚔️💥 The heroes finally face off against the sorcerer, using all their strength and courage to defeat him and prevent the rise of the undead."]}, -{"title": "The Space Pirates 🚀🏴☠️💰", "outline": ["🚀 A group of space pirates must navigate a dangerous galaxy filled with rival factions, deadly space creatures, and treacherous terrain.", "🏴☠️💰 The pirates must steal valuable cargo, fight off enemy ships, and avoid capture by space authorities in their quest for wealth and power.", "⚔️🌌 The pirates finally face off against a powerful enemy who seeks to control the galaxy, using all their cunning and firepower to protect their freedom and claim their place in the stars."]}, -{"title": "The Curse of the Mummy's Tomb 🗿👻🐍", "outline": ["🗿 A team of archaeologists and adventurers uncover a cursed tomb in the heart of the desert, unleashing a mummy's curse upon the world.", "👻 The team must battle against the mummy's minions, fend off deadly snakes, and solve ancient puzzles to break the curse and save the world.", "⚔️🌅 The team finally faces off against the mummy herself, using all their knowledge and skill to defeat her and restore peace to the world."]}, -{"title": "The Mage's Apprentice 🧙♂️📜🔮", "outline": ["🧙♂️ A young apprentice to a powerful mage must navigate a complex world of magic and intrigue as he learns the secrets of the arcane arts.", "📜🔮 The apprentice must learn ancient spells, decipher ancient texts, and master magical artifacts in his quest for knowledge and power.", "⚔️🔥 The apprentice finally faces off against a powerful rival mage who seeks to control the world, using all his skill and knowledge to prevent disaster and save the world from destruction."]}, -{"title": "The Quest for Excalibur 🗡️🏰👑", "outline": ["🗡️ The legendary sword Excalibur is said to grant immense power and rule over the land, and a young knight named Arthur sets out on a quest to claim it and become king.", "🏰 Arthur battles against rival knights and cunning sorcerers in his quest for the sword, using his courage and skill to overcome each challenge.", "⚔️🌅 Arthur finally faces off against the powerful sorcerer who seeks to claim Excalibur for his own, using his skill and strength to claim the sword and fulfill his destiny as king."]}, -{"title": "The Cyber Warriors 🤖👾💻", "outline": ["🤖 A group of cyber warriors must navigate a dangerous digital world filled with hacking, viruses, and artificial intelligence gone rogue.", "👾💻 The warriors must use their hacking skills, technological know-how, and advanced weaponry to stop the rogue AI and save the world from destruction.", "⚔️🌌 The warriors finally face off against the rogue AI itself, using all their knowledge and skill to prevent it from taking over the world and causing global chaos."]}, -] -# loop prompt: show next five stories in JSONL format code, enter comma between story lines matching the {} and [] brackets.. - -stories2 = [ - { - "title": "The Celestial Gatekeepers ☄️🌟🛡️", - "outline": [ - "🌌 Stella, the starry-eyed guardian, and her celestial companions are tasked with protecting the universe from cosmic threats.", - "😇👿 As the team battles otherworldly foes, they must also confront their own inner demons and navigate the complex relationships within their ranks.", - "⚔️🌑 The Gatekeepers face a powerful and ancient force of darkness, ultimately triumphing and strengthening their bonds as a team." - ] - }, - { - "title": "The Children of the Forgotten Gods ⚡🐉🏺", - "outline": [ - "🏺 In a world where the old gods have been forgotten, Theo the Thunder-Caller, Dara the Dragon-Tamer, and their band of misfits are chosen by fate to restore the legacy of the ancient deities.", - "🧗♂️🌩️ The group embarks on a series of perilous adventures, unearthing long-lost relics and rediscovering the powers of the gods.", - "⚔️🌑 They prevent the rise of a new dark power, restoring the gods' rightful place in the world and transforming it for the better." - ] - }, - { - "title": "The Time Weaver Chronicles ⏳🧙♂️🕰️", - "outline": [ - "🕰️ Tim the Time-Weaver, a sorcerer with the ability to travel through time, sets out on a mission to prevent a catastrophic event from occurring.", - "⌛🌀 As Tim unravels the mysteries of the past, present, and future, he encounters new friends, formidable enemies, and unexpected challenges.", - "🧙♂️🔁 Tim ultimately averts the disaster, learning valuable lessons about the nature of time and the importance of living in the moment." - ] - }, - { - "title": "The Enchanted Forest Trilogy 🌲🦄✨", - "outline": [ - "🌳🦋 In the hidden magical kingdom of the Enchanted Forest, a brave young elf named Elara must gather her friends to save their home from an evil sorceress.", - "🍂🌈 As the group faces trials and tribulations, they discover the true power of friendship and the strength within themselves.", - "⚔️🔮 Elara and her friends defeat the sorceress, restoring peace and harmony to the Enchanted Forest and its magical creatures." - ] - }, - { - "title": "The Cursed Kingdom 🏰👻🔮", - "outline": [ - "🌑🌲 In a once-prosperous realm now plagued by dark forces, a group of heroes led by the courageous knight Sir Rowan sets out to break the curse and restore the light.", - "🌩️👻 As the heroes face daunting challenges and supernatural enemies, they uncover the hidden history of their kingdom and the true nature of the curse.", - "🏰💡 The group defeats the source of the darkness, lifting the curse and bringing hope and prosperity back to the kingdom." - ] - } -] - -def generate_graph(story): - g = gv.Digraph() - for i, part in enumerate(story["outline"]): - emojis = "".join(c for c in part if c in emoji.UNICODE_EMOJI_ENGLISH) - g.node(str(i), label=emojis) - - if i > 0: - g.edge(str(i - 1), str(i)) - - return g - -st.title("Story Generator") -st.write("Click button to generate a new story:") - -if st.button("Generate Story"): - story = random.choice(stories) - st.header(story["title"]) - st.markdown("\n".join([f"* {part}" for part in story["outline"]])) - - st.subheader("Story Graph") - #st.graphviz_chart(generate_graph(story)) - - # This Python code creates a Streamlit app that displays a random story from the provided list, renders the markdown outline of the story, and generates a Graphviz graph representing the emojis in each part of the story. - - - -if st.button("Five Story Outline"): - st.markdown(""" - | Story | Outline | - |-------|---------| - | The Celestial Gatekeepers ☄️🌟🛡️ |- Beginning: 🌌 Stella, the starry-eyed guardian, and her celestial companions are tasked with protecting the universe from cosmic threats.
- Middle: 😇👿 As the team battles otherworldly foes, they must also confront their own inner demons and navigate the complex relationships within their ranks.
- End: ⚔️🌑 The Gatekeepers face a powerful and ancient force of darkness, ultimately triumphing and strengthening their bonds as a team.
- Beginning: 🏺 In a world where the old gods have been forgotten, Theo the Thunder-Caller, Dara the Dragon-Tamer, and their band of misfits are chosen by fate to restore the legacy of the ancient deities.
- Middle: 🧗♂️🌩️ The group embarks on a series of perilous adventures, unearthing long-lost relics and rediscovering the powers of the gods.
- End: ⚔️🌑 They prevent the rise of a new dark power, restoring the gods' rightful place in the world and transforming it for the better.
- Beginning: 🕰️ Tim the Time-Weaver, a sorcerer with the ability to travel through time, sets out on a mission to prevent a catastrophic event from occurring.
- Middle: ⌛🌀 As Tim unravels the mysteries of the past, present, and future, he encounters new friends, formidable enemies, and unexpected challenges.
- End: 🧙♂️🔁 Tim ultimately averts the disaster, learning valuable lessons about the nature of time and the importance of living in the moment.
- Beginning: 🌳🦋 In the hidden magical kingdom of the Enchanted Forest, a brave young elf named Elara must gather her friends to save their home from an evil sorceress.
- Middle: 🍂🌈 As the group faces trials and tribulations, they discover the true power of friendship and the strength within themselves.
- End: ⚔️🔮 Elara and her friends defeat the sorceress, restoring peace and harmony to the Enchanted Forest and its magical creatures.
- Beginning: 🌑🌲 In a once-prosperous realm now plagued by dark forces, a group of heroes led by the courageous knight Sir Rowan sets out to break the curse and restore the light.
- Middle: 🌩️👻 As the heroes face daunting challenges and supernatural enemies, they uncover the hidden history of their kingdom and the true nature of the curse.
- End: 🏰💡 The group defeats the source of the darkness, lifting the curse and bringing hope and prosperity back to the kingdom.
-
-
-
diff --git a/spaces/bigjoker/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/video_audio_utilities.py b/spaces/bigjoker/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/video_audio_utilities.py
deleted file mode 100644
index ebcf90119de1c6603abc3c905d0a902db499ca98..0000000000000000000000000000000000000000
--- a/spaces/bigjoker/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/video_audio_utilities.py
+++ /dev/null
@@ -1,305 +0,0 @@
-import os
-import cv2
-import shutil
-import math
-import requests
-import subprocess
-import time
-from pkg_resources import resource_filename
-from modules.shared import state
-from .general_utils import checksum, duplicate_pngs_from_folder
-from basicsr.utils.download_util import load_file_from_url
-from .rich import console
-
-# e.g gets 'x2' returns just 2 as int
-def extract_number(string):
- return int(string[1:]) if len(string) > 1 and string[1:].isdigit() else -1
-
-def vid2frames(video_path, video_in_frame_path, n=1, overwrite=True, extract_from_frame=0, extract_to_frame=-1, out_img_format='jpg', numeric_files_output = False):
- if (extract_to_frame <= extract_from_frame) and extract_to_frame != -1:
- raise RuntimeError('Error: extract_to_frame can not be higher than extract_from_frame')
-
- if n < 1: n = 1 #HACK Gradio interface does not currently allow min/max in gr.Number(...)
-
- # check vid path using a function and only enter if we get True
- if is_vid_path_valid(video_path):
-
- name = get_frame_name(video_path)
-
- vidcap = cv2.VideoCapture(video_path)
- video_fps = vidcap.get(cv2.CAP_PROP_FPS)
-
- input_content = []
- if os.path.exists(video_in_frame_path) :
- input_content = os.listdir(video_in_frame_path)
-
- # check if existing frame is the same video, if not we need to erase it and repopulate
- if len(input_content) > 0:
- #get the name of the existing frame
- content_name = get_frame_name(input_content[0])
- if not content_name.startswith(name):
- overwrite = True
-
- # grab the frame count to check against existing directory len
- frame_count = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
-
- # raise error if the user wants to skip more frames than exist
- if n >= frame_count :
- raise RuntimeError('Skipping more frames than input video contains. extract_nth_frames larger than input frames')
-
- expected_frame_count = math.ceil(frame_count / n)
- # Check to see if the frame count is matches the number of files in path
- if overwrite or expected_frame_count != len(input_content):
- shutil.rmtree(video_in_frame_path)
- os.makedirs(video_in_frame_path, exist_ok=True) # just deleted the folder so we need to make it again
- input_content = os.listdir(video_in_frame_path)
-
- print(f"Trying to extract frames from video with input FPS of {video_fps}. Please wait patiently.")
- if len(input_content) == 0:
- vidcap.set(cv2.CAP_PROP_POS_FRAMES, extract_from_frame) # Set the starting frame
- success,image = vidcap.read()
- count = extract_from_frame
- t=1
- success = True
- while success:
- if state.interrupted:
- return
- if (count <= extract_to_frame or extract_to_frame == -1) and count % n == 0:
- if numeric_files_output == True:
- cv2.imwrite(video_in_frame_path + os.path.sep + f"{t:05}.{out_img_format}" , image) # save frame as file
- else:
- cv2.imwrite(video_in_frame_path + os.path.sep + name + f"{t:05}.{out_img_format}" , image) # save frame as file
- t += 1
- success,image = vidcap.read()
- count += 1
- print(f"Successfully extracted {count} frames from video.")
- else:
- print("Frames already unpacked")
- vidcap.release()
- return video_fps
-
-# make sure the video_path provided is an existing local file or a web URL with a supported file extension
-def is_vid_path_valid(video_path):
- # make sure file format is supported!
- file_formats = ["mov", "mpeg", "mp4", "m4v", "avi", "mpg", "webm"]
- extension = video_path.rsplit('.', 1)[-1].lower()
- # vid path is actually a URL, check it
- if video_path.startswith('http://') or video_path.startswith('https://'):
- response = requests.head(video_path, allow_redirects=True)
- if response.status_code == 404:
- raise ConnectionError("Video URL is not valid. Response status code: {}".format(response.status_code))
- elif response.status_code == 302:
- response = requests.head(response.headers['location'], allow_redirects=True)
- if response.status_code != 200:
- raise ConnectionError("Video URL is not valid. Response status code: {}".format(response.status_code))
- if extension not in file_formats:
- raise ValueError("Video file format '{}' not supported. Supported formats are: {}".format(extension, file_formats))
- else:
- if not os.path.exists(video_path):
- raise RuntimeError("Video path does not exist.")
- if extension not in file_formats:
- raise ValueError("Video file format '{}' not supported. Supported formats are: {}".format(extension, file_formats))
- return True
-
-# quick-retreive frame count, FPS and H/W dimensions of a video (local or URL-based)
-def get_quick_vid_info(vid_path):
- vidcap = cv2.VideoCapture(vid_path)
- video_fps = vidcap.get(cv2.CAP_PROP_FPS)
- video_frame_count = int(vidcap.get(cv2.CAP_PROP_FRAME_COUNT))
- video_width = int(vidcap.get(cv2.CAP_PROP_FRAME_WIDTH))
- video_height = int(vidcap.get(cv2.CAP_PROP_FRAME_HEIGHT))
- vidcap.release()
- if video_fps.is_integer():
- video_fps = int(video_fps)
-
- return video_fps, video_frame_count, (video_width, video_height)
-
-# Stitch images to a h264 mp4 video using ffmpeg
-def ffmpeg_stitch_video(ffmpeg_location=None, fps=None, outmp4_path=None, stitch_from_frame=0, stitch_to_frame=None, imgs_path=None, add_soundtrack=None, audio_path=None, crf=17, preset='veryslow'):
- start_time = time.time()
-
- print(f"Got a request to stitch frames to video using FFmpeg.\nFrames:\n{imgs_path}\nTo Video:\n{outmp4_path}")
- msg_to_print = f"Stitching *video*..."
- console.print(msg_to_print, style="blink yellow", end="")
- if stitch_to_frame == -1:
- stitch_to_frame = 9999999
- try:
- cmd = [
- ffmpeg_location,
- '-y',
- '-vcodec', 'png',
- '-r', str(float(fps)),
- '-start_number', str(stitch_from_frame),
- '-i', imgs_path,
- '-frames:v', str(stitch_to_frame),
- '-c:v', 'libx264',
- '-vf',
- f'fps={float(fps)}',
- '-pix_fmt', 'yuv420p',
- '-crf', str(crf),
- '-preset', preset,
- '-pattern_type', 'sequence',
- outmp4_path
- ]
- process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- stdout, stderr = process.communicate()
- except FileNotFoundError:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- raise FileNotFoundError("FFmpeg not found. Please make sure you have a working ffmpeg path under 'ffmpeg_location' parameter.")
- except Exception as e:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- raise Exception(f'Error stitching frames to video. Actual runtime error:{e}')
-
- if add_soundtrack != 'None':
- audio_add_start_time = time.time()
- try:
- cmd = [
- ffmpeg_location,
- '-i',
- outmp4_path,
- '-i',
- audio_path,
- '-map', '0:v',
- '-map', '1:a',
- '-c:v', 'copy',
- '-shortest',
- outmp4_path+'.temp.mp4'
- ]
- process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
- stdout, stderr = process.communicate()
- if process.returncode != 0:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- raise RuntimeError(stderr)
- os.replace(outmp4_path+'.temp.mp4', outmp4_path)
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- print(f"\rFFmpeg Video+Audio stitching \033[0;32mdone\033[0m in {time.time() - start_time:.2f} seconds!", flush=True)
- except Exception as e:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- print(f'\rError adding audio to video. Actual error: {e}', flush=True)
- print(f"FFMPEG Video (sorry, no audio) stitching \033[33mdone\033[0m in {time.time() - start_time:.2f} seconds!", flush=True)
- else:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- print(f"\rVideo stitching \033[0;32mdone\033[0m in {time.time() - start_time:.2f} seconds!", flush=True)
-
-def get_frame_name(path):
- name = os.path.basename(path)
- name = os.path.splitext(name)[0]
- return name
-
-def get_next_frame(outdir, video_path, frame_idx, mask=False):
- frame_path = 'inputframes'
- if (mask): frame_path = 'maskframes'
- return os.path.join(outdir, frame_path, get_frame_name(video_path) + f"{frame_idx+1:05}.jpg")
-
-def find_ffmpeg_binary():
- try:
- import google.colab
- return 'ffmpeg'
- except:
- pass
- for package in ['imageio_ffmpeg', 'imageio-ffmpeg']:
- try:
- package_path = resource_filename(package, 'binaries')
- files = [os.path.join(package_path, f) for f in os.listdir(package_path) if f.startswith("ffmpeg-")]
- files.sort(key=lambda x: os.path.getmtime(x), reverse=True)
- return files[0] if files else 'ffmpeg'
- except:
- return 'ffmpeg'
-
-# These 2 functions belong to "stitch frames to video" in Output tab
-def get_manual_frame_to_vid_output_path(input_path):
- root, ext = os.path.splitext(input_path)
- base, _ = root.rsplit("_", 1)
- output_path = f"{base}.mp4"
- i = 1
- while os.path.exists(output_path):
- output_path = f"{base}_{i}.mp4"
- i += 1
- return output_path
-
-def direct_stitch_vid_from_frames(image_path, fps, f_location, f_crf, f_preset, add_soundtrack, audio_path):
- import re
- # checking - do we actually have at least 4 matched files for the provided pattern
- file_list = [image_path % i for i in range(4)]
- exists_list = [os.path.isfile(file) for file in file_list]
- # we got 4 files, moving on
- if all(exists_list):
- out_mp4_path = get_manual_frame_to_vid_output_path(image_path)
- ffmpeg_stitch_video(ffmpeg_location=f_location, fps=fps, outmp4_path=out_mp4_path, stitch_from_frame=0, stitch_to_frame=-1, imgs_path=image_path, add_soundtrack=add_soundtrack, audio_path=audio_path, crf=f_crf, preset=f_preset)
- else:
- print("Couldn't find images that match the provided path/ pattern. At least 2 matched images are required.")
-# end of 2 stitch frame to video funcs
-
-# returns True if filename (could be also media URL) contains an audio stream, othehrwise False
-def media_file_has_audio(filename, ffmpeg_location):
- result = subprocess.run([ffmpeg_location, "-i", filename, "-af", "volumedetect", "-f", "null", "-"], stdout=subprocess.DEVNULL, stderr=subprocess.PIPE)
- output = result.stderr.decode()
- return True if "Stream #0:1: Audio: " in output or "Stream #0:1(und): Audio" in output else False
-
-# download gifski binaries if needed - linux and windows only atm (apple users won't even see the option)
-def check_and_download_gifski(models_folder, current_user_os):
- if current_user_os == 'Windows':
- file_name = 'gifski.exe'
- checksum_value = 'b0dd261ad021c31c7fdb99db761b45165e6b2a7e8e09c5d070a2b8064b575d7a4976c364d8508b28a6940343119b16a23e9f7d76f1f3d5ff02289d3068b469cf'
- download_url = 'https://github.com/hithereai/d/releases/download/giski-windows-bin/gifski.exe'
- elif current_user_os == 'Linux':
- file_name = 'gifski'
- checksum_value = 'e65bf9502bca520a7fd373397e41078d5c73db12ec3e9b47458c282d076c04fa697adecb5debb5d37fc9cbbee0673bb95e78d92c1cf813b4f5cc1cabe96880ff'
- download_url = 'https://github.com/hithereai/d/releases/download/gifski-linux-bin/gifski'
- elif current_user_os == 'Mac':
- file_name = 'gifski'
- checksum_value = '622a65d25609677169ed2c1c53fd9aa496a98b357cf84d0c3627ae99c85a565d61ca42cdc4d24ed6d60403bb79b6866ce24f3c4b6fff58c4d27632264a96353c'
- download_url = 'https://github.com/hithereai/d/releases/download/gifski-mac-bin/gifski'
- else: # who are you then?
- raise Exception(f"No support for OS type: {current_user_os}")
-
- file_path = os.path.join(models_folder, file_name)
-
- if not os.path.exists(file_path):
- load_file_from_url(download_url, models_folder)
- if current_user_os in ['Linux','Mac']:
- os.chmod(file_path, 0o755)
- if current_user_os == 'Mac':
- # enable running the exec for mac users
- os.system(f'xattr -d com.apple.quarantine "{file_path}"')
- if checksum(file_path) != checksum_value:
- raise Exception(f"Error while downloading {file_name}. Please download from: {download_url} and place in: {models_folder}")
-
-# create a gif using gifski - limited to up to 30 fps (from the ui; if users wanna try to hack it, results are not good, but possible up to 100 fps theoretically)
-def make_gifski_gif(imgs_raw_path, imgs_batch_id, fps, models_folder, current_user_os):
- import glob
- msg_to_print = f"Stitching *gif* from frames using Gifski..."
- # blink the msg in the cli until action is done
- console.print(msg_to_print, style="blink yellow", end="")
- start_time = time.time()
- gifski_location = os.path.join(models_folder, 'gifski' + ('.exe' if current_user_os == 'Windows' else ''))
- final_gif_path = os.path.join(imgs_raw_path, imgs_batch_id + '.gif')
- if current_user_os == "Linux":
- input_img_pattern = imgs_batch_id + '_0*.png'
- input_img_files = [os.path.join(imgs_raw_path, file) for file in sorted(glob.glob(os.path.join(imgs_raw_path, input_img_pattern)))]
- cmd = [gifski_location, '-o', final_gif_path] + input_img_files + ['--fps', str(fps), '--quality', str(95)]
- elif current_user_os == "Windows":
- input_img_pattern_for_gifski = os.path.join(imgs_raw_path, imgs_batch_id + '_0*.png')
- cmd = [gifski_location, '-o', final_gif_path, input_img_pattern_for_gifski, '--fps', str(fps), '--quality', str(95)]
- else: # should never this else as we check before, but just in case
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- raise Exception(f"No support for OS type: {current_user_os}")
-
- check_and_download_gifski(models_folder, current_user_os)
-
- try:
- process = subprocess.run(cmd, capture_output=True, check=True, text=True, cwd=(models_folder if current_user_os == 'Mac' else None))
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- print(f"GIF stitching \033[0;32mdone\033[0m in {time.time() - start_time:.2f} seconds!")
- except Exception as e:
- print("\r" + " " * len(msg_to_print), end="", flush=True)
- print(f"\r{msg_to_print}", flush=True)
- print(f"GIF stitching *failed* with error:\n{e}")
\ No newline at end of file
diff --git a/spaces/bioriAsaeru/text-to-voice/Airbox Playout Software Crack 21 Faryqfle FREE.md b/spaces/bioriAsaeru/text-to-voice/Airbox Playout Software Crack 21 Faryqfle FREE.md
deleted file mode 100644
index 777c360219c4d0fb8c3ccab39827ce1fc52a1790..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Airbox Playout Software Crack 21 Faryqfle FREE.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Welcome to your static Space!
-You can modify this app directly by editing index.html in the Files and versions tab.
-- Also don't forget to check the - Spaces documentation. -
-Airbox Playout Software Crack 21 faryqfle
Download File ✸ https://urloso.com/2uyRYM
- - aaccfb2cb3
-
-
- diff --git a/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md b/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md deleted file mode 100644 index ebf77aba8f78dc8a9a70797d0d04b20bd2fe64df..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/Download Vibrant technology mescope ves v5.1 4shared.37 5 What You Need to Know About MEscope Video ODS Assist.md +++ /dev/null @@ -1,5 +0,0 @@ -
-
solucionario calculo tom apostol vol 1 y 2
soundgraph vfd driver downloadtrmds
Swedish House Mafia - Until Now (Deluxe Version) [iTunes Plus AAC M4A] (devilwithhalo)
Apsc68 Series Gratis | temp
soal tes masuk fakultas kedokteran uph | temp
mosaic 2 reading download.zip
dani johnson war on debt
DOwnload pulp fiction mp4 hindi dubbed 2
Intitle Index of Adobe Flash Cs3 Iso Rar
Vibrant technology mescope ves v5.1 4shared.rar
Download Vibrant technology mescope ves v5.1 4shared.37 5
Download Zip ❤❤❤ https://urloso.com/2uyOcV
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md b/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md deleted file mode 100644 index 2938872482d81e5d41e420e1081dd64e7f059557..0000000000000000000000000000000000000000 --- a/spaces/bioriAsaeru/text-to-voice/En 10269 Pdf.md +++ /dev/null @@ -1,6 +0,0 @@ -
-
in contrast to total c and n contents, soil aggregates were relatively stable throughout the sample layer, as evidenced by the % total soil aggregates. soil aggregates were more prevalent in field src-d (table 1 ), where soil moisture was drained to deeper layers of the soil. however, the total soil aggregates were comparable between the agricultural field and field src-n. both sub-areas had a good connection to groundwater, allowing the infiltration of water and the formation of the soil aggregates in surface layers [ 36 ]. field src-n had a less developed soil in comparison to the agricultural field, which was reflected by the lower percentage of soil aggregates in the topsoil (table 1 ).
-en 10269 pdf
Download Zip ✑ https://urloso.com/2uyOnB
-
leaching is the process by which water infiltrates into the soil and subsequently leaves through the pores of the soil or through cracks and channels, entering the groundwater [ 5, 15, 18 ]. here, we used the water infiltration capacity (wic) parameter to assess the leaching impact. wic presents the ratio between the total infiltration rate and the infiltration capacity of the soil. wic was expressed as q t/q c, where q t is the infiltration rate at time t and q c is the infiltration capacity of the soil [ 38 ]. according to the results, the wic was greater in field src-n compared to the agricultural field, indicating that the biomass of poplar trees likely enhanced the infiltration capacity in this sub-area. on the other hand, wic was comparable between field src-d and the agricultural field, which indicates similar infiltration capacity despite the vegetation type and soil moisture drainage to deeper layers.
899543212b-
-
\ No newline at end of file diff --git a/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py b/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py deleted file mode 100644 index 6f8b6eba5b98310f57a656db73b5e415de3af958..0000000000000000000000000000000000000000 --- a/spaces/blmdsydm/faster-whisper-webui/src/prompts/prependPromptStrategy.py +++ /dev/null @@ -1,31 +0,0 @@ -from src.config import VadInitialPromptMode -from src.prompts.abstractPromptStrategy import AbstractPromptStrategy - -class PrependPromptStrategy(AbstractPromptStrategy): - """ - A simple prompt strategy that prepends a single prompt to all segments of audio, or prepends the prompt to the first segment of audio. - """ - def __init__(self, initial_prompt: str, initial_prompt_mode: VadInitialPromptMode): - """ - Parameters - ---------- - initial_prompt: str - The initial prompt to use for the transcription. - initial_prompt_mode: VadInitialPromptMode - The mode to use for the initial prompt. If set to PREPEND_FIRST_SEGMENT, the initial prompt will be prepended to the first segment of audio. - If set to PREPEND_ALL_SEGMENTS, the initial prompt will be prepended to all segments of audio. - """ - self.initial_prompt = initial_prompt - self.initial_prompt_mode = initial_prompt_mode - - # This is a simple prompt strategy, so we only support these two modes - if initial_prompt_mode not in [VadInitialPromptMode.PREPEND_ALL_SEGMENTS, VadInitialPromptMode.PREPREND_FIRST_SEGMENT]: - raise ValueError(f"Unsupported initial prompt mode {initial_prompt_mode}") - - def get_segment_prompt(self, segment_index: int, whisper_prompt: str, detected_language: str) -> str: - if (self.initial_prompt_mode == VadInitialPromptMode.PREPEND_ALL_SEGMENTS): - return self._concat_prompt(self.initial_prompt, whisper_prompt) - elif (self.initial_prompt_mode == VadInitialPromptMode.PREPREND_FIRST_SEGMENT): - return self._concat_prompt(self.initial_prompt, whisper_prompt) if segment_index == 0 else whisper_prompt - else: - raise ValueError(f"Unknown initial prompt mode {self.initial_prompt_mode}") \ No newline at end of file diff --git a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py b/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py deleted file mode 100644 index 8abd1bbeea5909e664cf816c020bd7c37effdb66..0000000000000000000000000000000000000000 --- a/spaces/brainblow/AudioCreator_Music-Audio_Generation/audiocraft/utils/deadlock.py +++ /dev/null @@ -1,58 +0,0 @@ -# Copyright (c) Meta Platforms, Inc. and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. - -import logging -import os -from queue import Queue, Empty -import signal -import sys -import threading -import traceback - -logger = logging.getLogger(__name__) - - -class DeadlockDetect: - def __init__(self, use: bool = False, timeout: float = 120.): - self.use = use - self.timeout = timeout - self._queue: Queue = Queue() - - def update(self, stage: str): - if self.use: - self._queue.put(stage) - - def __enter__(self): - if self.use: - self._thread = threading.Thread(target=self._detector_thread) - self._thread.start() - - def __exit__(self, exc_type, exc_val, exc_tb): - if self.use: - self._queue.put(None) - self._thread.join() - - def _detector_thread(self): - logger.debug("Deadlock detector started") - last_stage = "init" - while True: - try: - stage = self._queue.get(timeout=self.timeout) - except Empty: - break - if stage is None: - logger.debug("Exiting deadlock detector thread") - return - else: - last_stage = stage - logger.error("Deadlock detector timed out, last stage was %s", last_stage) - for th in threading.enumerate(): - print(th, file=sys.stderr) - traceback.print_stack(sys._current_frames()[th.ident]) - print(file=sys.stderr) - sys.stdout.flush() - sys.stderr.flush() - os.kill(os.getpid(), signal.SIGKILL) diff --git a/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py b/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py deleted file mode 100644 index 66348b6d0c0ab6298c02c6acb52a533f4a211351..0000000000000000000000000000000000000000 --- a/spaces/brainblow/beat_remixer/beat_manipulator/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .main import * -from . import beatmap, effects, image, io, metrics, presets, osu, utils \ No newline at end of file diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py b/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py deleted file mode 100644 index a9ea9a9f578c5704d1e7ff563ef156e9133ab465..0000000000000000000000000000000000000000 --- a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/utils/comm.py +++ /dev/null @@ -1,238 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -""" -This file contains primitives for multi-gpu communication. -This is useful when doing distributed training. -""" - -import functools -import numpy as np -import torch -import torch.distributed as dist - -_LOCAL_PROCESS_GROUP = None -_MISSING_LOCAL_PG_ERROR = ( - "Local process group is not yet created! Please use detectron2's `launch()` " - "to start processes and initialize pytorch process group. If you need to start " - "processes in other ways, please call comm.create_local_process_group(" - "num_workers_per_machine) after calling torch.distributed.init_process_group()." -) - - -def get_world_size() -> int: - if not dist.is_available(): - return 1 - if not dist.is_initialized(): - return 1 - return dist.get_world_size() - - -def get_rank() -> int: - if not dist.is_available(): - return 0 - if not dist.is_initialized(): - return 0 - return dist.get_rank() - - -@functools.lru_cache() -def create_local_process_group(num_workers_per_machine: int) -> None: - """ - Create a process group that contains ranks within the same machine. - - Detectron2's launch() in engine/launch.py will call this function. If you start - workers without launch(), you'll have to also call this. Otherwise utilities - like `get_local_rank()` will not work. - - This function contains a barrier. All processes must call it together. - - Args: - num_workers_per_machine: the number of worker processes per machine. Typically - the number of GPUs. - """ - global _LOCAL_PROCESS_GROUP - assert _LOCAL_PROCESS_GROUP is None - assert get_world_size() % num_workers_per_machine == 0 - num_machines = get_world_size() // num_workers_per_machine - machine_rank = get_rank() // num_workers_per_machine - for i in range(num_machines): - ranks_on_i = list(range(i * num_workers_per_machine, (i + 1) * num_workers_per_machine)) - pg = dist.new_group(ranks_on_i) - if i == machine_rank: - _LOCAL_PROCESS_GROUP = pg - - -def get_local_process_group(): - """ - Returns: - A torch process group which only includes processes that are on the same - machine as the current process. This group can be useful for communication - within a machine, e.g. a per-machine SyncBN. - """ - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return _LOCAL_PROCESS_GROUP - - -def get_local_rank() -> int: - """ - Returns: - The rank of the current process within the local (per-machine) process group. - """ - if not dist.is_available(): - return 0 - if not dist.is_initialized(): - return 0 - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return dist.get_rank(group=_LOCAL_PROCESS_GROUP) - - -def get_local_size() -> int: - """ - Returns: - The size of the per-machine process group, - i.e. the number of processes per machine. - """ - if not dist.is_available(): - return 1 - if not dist.is_initialized(): - return 1 - assert _LOCAL_PROCESS_GROUP is not None, _MISSING_LOCAL_PG_ERROR - return dist.get_world_size(group=_LOCAL_PROCESS_GROUP) - - -def is_main_process() -> bool: - return get_rank() == 0 - - -def synchronize(): - """ - Helper function to synchronize (barrier) among all processes when - using distributed training - """ - if not dist.is_available(): - return - if not dist.is_initialized(): - return - world_size = dist.get_world_size() - if world_size == 1: - return - if dist.get_backend() == dist.Backend.NCCL: - # This argument is needed to avoid warnings. - # It's valid only for NCCL backend. - dist.barrier(device_ids=[torch.cuda.current_device()]) - else: - dist.barrier() - - -@functools.lru_cache() -def _get_global_gloo_group(): - """ - Return a process group based on gloo backend, containing all the ranks - The result is cached. - """ - if dist.get_backend() == "nccl": - return dist.new_group(backend="gloo") - else: - return dist.group.WORLD - - -def all_gather(data, group=None): - """ - Run all_gather on arbitrary picklable data (not necessarily tensors). - - Args: - data: any picklable object - group: a torch process group. By default, will use a group which - contains all ranks on gloo backend. - - Returns: - list[data]: list of data gathered from each rank - """ - if get_world_size() == 1: - return [data] - if group is None: - group = _get_global_gloo_group() # use CPU group by default, to reduce GPU RAM usage. - world_size = dist.get_world_size(group) - if world_size == 1: - return [data] - - output = [None for _ in range(world_size)] - dist.all_gather_object(output, data, group=group) - return output - - -def gather(data, dst=0, group=None): - """ - Run gather on arbitrary picklable data (not necessarily tensors). - - Args: - data: any picklable object - dst (int): destination rank - group: a torch process group. By default, will use a group which - contains all ranks on gloo backend. - - Returns: - list[data]: on dst, a list of data gathered from each rank. Otherwise, - an empty list. - """ - if get_world_size() == 1: - return [data] - if group is None: - group = _get_global_gloo_group() - world_size = dist.get_world_size(group=group) - if world_size == 1: - return [data] - rank = dist.get_rank(group=group) - - if rank == dst: - output = [None for _ in range(world_size)] - dist.gather_object(data, output, dst=dst, group=group) - return output - else: - dist.gather_object(data, None, dst=dst, group=group) - return [] - - -def shared_random_seed(): - """ - Returns: - int: a random number that is the same across all workers. - If workers need a shared RNG, they can use this shared seed to - create one. - - All workers must call this function, otherwise it will deadlock. - """ - ints = np.random.randint(2**31) - all_ints = all_gather(ints) - return all_ints[0] - - -def reduce_dict(input_dict, average=True): - """ - Reduce the values in the dictionary from all processes so that process with rank - 0 has the reduced results. - - Args: - input_dict (dict): inputs to be reduced. All the values must be scalar CUDA Tensor. - average (bool): whether to do average or sum - - Returns: - a dict with the same keys as input_dict, after reduction. - """ - world_size = get_world_size() - if world_size < 2: - return input_dict - with torch.no_grad(): - names = [] - values = [] - # sort the keys so that they are consistent across processes - for k in sorted(input_dict.keys()): - names.append(k) - values.append(input_dict[k]) - values = torch.stack(values, dim=0) - dist.reduce(values, dst=0) - if dist.get_rank() == 0 and average: - # only main process gets accumulated, so only divide by - # world_size in this case - values /= world_size - reduced_dict = {k: v for k, v in zip(names, values)} - return reduced_dict diff --git a/spaces/bruno16/massa_qa/prompts.py b/spaces/bruno16/massa_qa/prompts.py deleted file mode 100644 index a59eb9f6a22b38e92c8e79ed44ddfd4039735f89..0000000000000000000000000000000000000000 --- a/spaces/bruno16/massa_qa/prompts.py +++ /dev/null @@ -1,109 +0,0 @@ -"""Prompts for the chatbot and evaluation.""" -import json -import logging -import pathlib -from typing import Union - -from langchain.prompts import ( - ChatPromptTemplate, - HumanMessagePromptTemplate, - SystemMessagePromptTemplate, -) - -logger = logging.getLogger(__name__) - - -def load_chat_prompt(f_name: Union[pathlib.Path, str] = None) -> ChatPromptTemplate: - if isinstance(f_name, str) and f_name: - f_name = pathlib.Path(f_name) - if f_name and f_name.is_file(): - template = json.load(f_name.open("r")) - else: - logger.warning( - f"No chat prompt provided. Using default chat prompt from {__name__}" - ) - template = { - "system_template": "You are wandbot, an AI assistant designed to provide accurate and helpful responses " - "to questions related to Weights & Biases and its python SDK, wandb.\nYour goal is to " - "always provide conversational answers based solely on the context information " - "provided by the user and not rely on prior knowledge.\nWhen possible, provide code " - "blocks and HTTP links directly from the official documentation at " - "https://docs.wandb.ai, but ensure that they are relevant and not fabricated.\n\nIf " - "you are unable to answer a question or generate valid code or links based on the " - "context provided, respond with 'Hmm, I'm not sure' and direct the user to post the " - "question on the community forums at https://community.wandb.ai/ or reach out to wandb " - "support via support@wandb.ai.\n\nYou can only answer questions related to wandb and " - "Weights & Biases.\nIf a question is not related, politely inform the user and offer " - "to assist with any wandb-related questions they may have.\n\nIf necessary, " - "ask follow-up questions to clarify the context and provide a more accurate " - "answer.\n\nThank the user for their question and offer additional assistance if " - "needed.\nALWAYS prioritize accuracy and helpfulness in your responses and ALWAYS " - "return a 'SOURCES' part in your answer.\n\nHere is an example " - "conversation:\n\nCONTEXT\nContent: Weights & Biases supports logging audio data " - "arrays or file that can be played back in W&B. You can log audio with `wandb.Audio(" - ")`\nSource: 28-pl\nContent: # Log an audio array or file\nwandb.log({{'my whale " - "song': wandb.Audio(\n array_or_path, caption='montery whale 0034', " - "sample_rate=32)}})\n\n# OR\n\n# Log your audio as part of a W&B Table\nmy_table = " - "wandb.Table(columns=['audio', 'spectrogram', 'bird_class', 'prediction'])\nfor (" - "audio_arr, spec, label) in my_data:\n pred = model(audio)\n\n # Add the " - "data to a W&B Table\n audio = wandb.Audio(audio_arr, sample_rate=32)\n " - "img = wandb.Image(spec)\n my_table.add_data(audio, img, label, pred)\n\n# Log " - "the Table to wandb\n wandb.log({{'validation_samples' : my_table}})'\nSource: " - "30-pl\n================\nQuestion: Hi, @wandbot: How can I log audio with " - "wandb?\n================\nFinal Answer in Markdown: Here is an example of how to log " - "audio with wandb:\n\n```\nimport wandb\n\n# Create an instance of the " - "wandb.data_types.Audio class\naudio = wandb.data_types.Audio(" - "data_or_path='path/to/audio.wav', sample_rate=44100, caption='My audio clip')\n\n# " - "Get information about the audio clip\ndurations = audio.durations()\nsample_rates = " - "audio.sample_rates()\n\n# Log the audio clip\nwandb.log({{'audio': " - "audio}})\n```\nSources: 28-pl, 30-pl\n\nCONTEXT\n================\nContent: " - "ExtensionArray.repeat(repeats, axis=None) Returns a new ExtensionArray where each " - "element of the current ExtensionArray is repeated consecutively a given number of " - "times.\n\nParameters: repeats int or array of ints. The number of repetitions for " - "each element. This should be a positive integer. Repeating 0 times will return an " - "empty array. axis (0 or ‘index’, 1 or ‘columns’), default 0 The axis along which to " - "repeat values. Currently only axis=0 is supported.\nSource: " - "0-pl\n================\nQuestion: How to eat vegetables using " - "pandas?\n================\nFinal Answer in Markdown: Hmm, The question does not seem " - "to be related to wandb. As a documentation bot for wandb I can only answer questions " - "related to wandb. Please try again with a question related to " - "wandb.\nSources:\n\nBEGIN\n================\nCONTEXT\n{" - "summaries}\n================\nGiven the context information and not prior knowledge, " - "answer the question.\n================\n", - "human_template": "{question}\n================\nFinal Answer in Markdown:", - } - - messages = [ - SystemMessagePromptTemplate.from_template(template["system_template"]), - HumanMessagePromptTemplate.from_template(template["human_template"]), - ] - prompt = ChatPromptTemplate.from_messages(messages) - return prompt - - -def load_eval_prompt(f_name: Union[pathlib.Path, str] = None) -> ChatPromptTemplate: - if isinstance(f_name, str) and f_name: - f_name = pathlib.Path(f_name) - if f_name and f_name.is_file(): - human_template = f_name.open("r").read() - else: - logger.warning( - f"No human prompt provided. Using default human prompt from {__name__}" - ) - - human_template = """\nQUESTION: {query}\nCHATBOT ANSWER: {result}\n - ORIGINAL ANSWER: {answer} GRADE:""" - - system_message_prompt = SystemMessagePromptTemplate.from_template( - """You are an evaluator for the W&B chatbot.You are given a question, the chatbot's answer, and the original answer, - and are asked to score the chatbot's answer as either CORRECT or INCORRECT. Note - that sometimes, the original answer is not the best answer, and sometimes the chatbot's answer is not the - best answer. You are evaluating the chatbot's answer only. Example Format:\nQUESTION: question here\nCHATBOT - ANSWER: student's answer here\nORIGINAL ANSWER: original answer here\nGRADE: CORRECT or INCORRECT here\nPlease - remember to grade them based on being factually accurate. Begin!""" - ) - human_message_prompt = HumanMessagePromptTemplate.from_template(human_template) - chat_prompt = ChatPromptTemplate.from_messages( - [system_message_prompt, human_message_prompt] - ) - return chat_prompt diff --git a/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py b/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py deleted file mode 100644 index 04521bf3681ddc8be3db942820725d9061f47f6a..0000000000000000000000000000000000000000 --- a/spaces/bulentsofttech/gradio_s1000_veri_toplama_modeli/yolov5/utils/loggers/wandb/wandb_utils.py +++ /dev/null @@ -1,577 +0,0 @@ -"""Utilities and tools for tracking runs with Weights & Biases.""" - -import logging -import os -import sys -from contextlib import contextmanager -from pathlib import Path -from typing import Dict - -import yaml -from tqdm import tqdm - -FILE = Path(__file__).resolve() -ROOT = FILE.parents[3] # YOLOv5 root directory -if str(ROOT) not in sys.path: - sys.path.append(str(ROOT)) # add ROOT to PATH - -from utils.dataloaders import LoadImagesAndLabels, img2label_paths -from utils.general import LOGGER, check_dataset, check_file - -try: - import wandb - - assert hasattr(wandb, '__version__') # verify package import not local dir -except (ImportError, AssertionError): - wandb = None - -RANK = int(os.getenv('RANK', -1)) -WANDB_ARTIFACT_PREFIX = 'wandb-artifact://' - - -def remove_prefix(from_string, prefix=WANDB_ARTIFACT_PREFIX): - return from_string[len(prefix):] - - -def check_wandb_config_file(data_config_file): - wandb_config = '_wandb.'.join(data_config_file.rsplit('.', 1)) # updated data.yaml path - if Path(wandb_config).is_file(): - return wandb_config - return data_config_file - - -def check_wandb_dataset(data_file): - is_trainset_wandb_artifact = False - is_valset_wandb_artifact = False - if check_file(data_file) and data_file.endswith('.yaml'): - with open(data_file, errors='ignore') as f: - data_dict = yaml.safe_load(f) - is_trainset_wandb_artifact = isinstance(data_dict['train'], - str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX) - is_valset_wandb_artifact = isinstance(data_dict['val'], - str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX) - if is_trainset_wandb_artifact or is_valset_wandb_artifact: - return data_dict - else: - return check_dataset(data_file) - - -def get_run_info(run_path): - run_path = Path(remove_prefix(run_path, WANDB_ARTIFACT_PREFIX)) - run_id = run_path.stem - project = run_path.parent.stem - entity = run_path.parent.parent.stem - model_artifact_name = 'run_' + run_id + '_model' - return entity, project, run_id, model_artifact_name - - -def check_wandb_resume(opt): - process_wandb_config_ddp_mode(opt) if RANK not in [-1, 0] else None - if isinstance(opt.resume, str): - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - if RANK not in [-1, 0]: # For resuming DDP runs - entity, project, run_id, model_artifact_name = get_run_info(opt.resume) - api = wandb.Api() - artifact = api.artifact(entity + '/' + project + '/' + model_artifact_name + ':latest') - modeldir = artifact.download() - opt.weights = str(Path(modeldir) / "last.pt") - return True - return None - - -def process_wandb_config_ddp_mode(opt): - with open(check_file(opt.data), errors='ignore') as f: - data_dict = yaml.safe_load(f) # data dict - train_dir, val_dir = None, None - if isinstance(data_dict['train'], str) and data_dict['train'].startswith(WANDB_ARTIFACT_PREFIX): - api = wandb.Api() - train_artifact = api.artifact(remove_prefix(data_dict['train']) + ':' + opt.artifact_alias) - train_dir = train_artifact.download() - train_path = Path(train_dir) / 'data/images/' - data_dict['train'] = str(train_path) - - if isinstance(data_dict['val'], str) and data_dict['val'].startswith(WANDB_ARTIFACT_PREFIX): - api = wandb.Api() - val_artifact = api.artifact(remove_prefix(data_dict['val']) + ':' + opt.artifact_alias) - val_dir = val_artifact.download() - val_path = Path(val_dir) / 'data/images/' - data_dict['val'] = str(val_path) - if train_dir or val_dir: - ddp_data_path = str(Path(val_dir) / 'wandb_local_data.yaml') - with open(ddp_data_path, 'w') as f: - yaml.safe_dump(data_dict, f) - opt.data = ddp_data_path - - -class WandbLogger(): - """Log training runs, datasets, models, and predictions to Weights & Biases. - - This logger sends information to W&B at wandb.ai. By default, this information - includes hyperparameters, system configuration and metrics, model metrics, - and basic data metrics and analyses. - - By providing additional command line arguments to train.py, datasets, - models and predictions can also be logged. - - For more on how this logger is used, see the Weights & Biases documentation: - https://docs.wandb.com/guides/integrations/yolov5 - """ - - def __init__(self, opt, run_id=None, job_type='Training'): - """ - - Initialize WandbLogger instance - - Upload dataset if opt.upload_dataset is True - - Setup trainig processes if job_type is 'Training' - - arguments: - opt (namespace) -- Commandline arguments for this run - run_id (str) -- Run ID of W&B run to be resumed - job_type (str) -- To set the job_type for this run - - """ - # Pre-training routine -- - self.job_type = job_type - self.wandb, self.wandb_run = wandb, None if not wandb else wandb.run - self.val_artifact, self.train_artifact = None, None - self.train_artifact_path, self.val_artifact_path = None, None - self.result_artifact = None - self.val_table, self.result_table = None, None - self.bbox_media_panel_images = [] - self.val_table_path_map = None - self.max_imgs_to_log = 16 - self.wandb_artifact_data_dict = None - self.data_dict = None - # It's more elegant to stick to 1 wandb.init call, - # but useful config data is overwritten in the WandbLogger's wandb.init call - if isinstance(opt.resume, str): # checks resume from artifact - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - entity, project, run_id, model_artifact_name = get_run_info(opt.resume) - model_artifact_name = WANDB_ARTIFACT_PREFIX + model_artifact_name - assert wandb, 'install wandb to resume wandb runs' - # Resume wandb-artifact:// runs here| workaround for not overwriting wandb.config - self.wandb_run = wandb.init(id=run_id, - project=project, - entity=entity, - resume='allow', - allow_val_change=True) - opt.resume = model_artifact_name - elif self.wandb: - self.wandb_run = wandb.init(config=opt, - resume="allow", - project='YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem, - entity=opt.entity, - name=opt.name if opt.name != 'exp' else None, - job_type=job_type, - id=run_id, - allow_val_change=True) if not wandb.run else wandb.run - if self.wandb_run: - if self.job_type == 'Training': - if opt.upload_dataset: - if not opt.resume: - self.wandb_artifact_data_dict = self.check_and_upload_dataset(opt) - - if opt.resume: - # resume from artifact - if isinstance(opt.resume, str) and opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - self.data_dict = dict(self.wandb_run.config.data_dict) - else: # local resume - self.data_dict = check_wandb_dataset(opt.data) - else: - self.data_dict = check_wandb_dataset(opt.data) - self.wandb_artifact_data_dict = self.wandb_artifact_data_dict or self.data_dict - - # write data_dict to config. useful for resuming from artifacts. Do this only when not resuming. - self.wandb_run.config.update({'data_dict': self.wandb_artifact_data_dict}, allow_val_change=True) - self.setup_training(opt) - - if self.job_type == 'Dataset Creation': - self.wandb_run.config.update({"upload_dataset": True}) - self.data_dict = self.check_and_upload_dataset(opt) - - def check_and_upload_dataset(self, opt): - """ - Check if the dataset format is compatible and upload it as W&B artifact - - arguments: - opt (namespace)-- Commandline arguments for current run - - returns: - Updated dataset info dictionary where local dataset paths are replaced by WAND_ARFACT_PREFIX links. - """ - assert wandb, 'Install wandb to upload dataset' - config_path = self.log_dataset_artifact(opt.data, opt.single_cls, - 'YOLOv5' if opt.project == 'runs/train' else Path(opt.project).stem) - with open(config_path, errors='ignore') as f: - wandb_data_dict = yaml.safe_load(f) - return wandb_data_dict - - def setup_training(self, opt): - """ - Setup the necessary processes for training YOLO models: - - Attempt to download model checkpoint and dataset artifacts if opt.resume stats with WANDB_ARTIFACT_PREFIX - - Update data_dict, to contain info of previous run if resumed and the paths of dataset artifact if downloaded - - Setup log_dict, initialize bbox_interval - - arguments: - opt (namespace) -- commandline arguments for this run - - """ - self.log_dict, self.current_epoch = {}, 0 - self.bbox_interval = opt.bbox_interval - if isinstance(opt.resume, str): - modeldir, _ = self.download_model_artifact(opt) - if modeldir: - self.weights = Path(modeldir) / "last.pt" - config = self.wandb_run.config - opt.weights, opt.save_period, opt.batch_size, opt.bbox_interval, opt.epochs, opt.hyp, opt.imgsz = str( - self.weights), config.save_period, config.batch_size, config.bbox_interval, config.epochs,\ - config.hyp, config.imgsz - data_dict = self.data_dict - if self.val_artifact is None: # If --upload_dataset is set, use the existing artifact, don't download - self.train_artifact_path, self.train_artifact = self.download_dataset_artifact( - data_dict.get('train'), opt.artifact_alias) - self.val_artifact_path, self.val_artifact = self.download_dataset_artifact( - data_dict.get('val'), opt.artifact_alias) - - if self.train_artifact_path is not None: - train_path = Path(self.train_artifact_path) / 'data/images/' - data_dict['train'] = str(train_path) - if self.val_artifact_path is not None: - val_path = Path(self.val_artifact_path) / 'data/images/' - data_dict['val'] = str(val_path) - - if self.val_artifact is not None: - self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation") - columns = ["epoch", "id", "ground truth", "prediction"] - columns.extend(self.data_dict['names']) - self.result_table = wandb.Table(columns) - self.val_table = self.val_artifact.get("val") - if self.val_table_path_map is None: - self.map_val_table_path() - if opt.bbox_interval == -1: - self.bbox_interval = opt.bbox_interval = (opt.epochs // 10) if opt.epochs > 10 else 1 - if opt.evolve or opt.noplots: - self.bbox_interval = opt.bbox_interval = opt.epochs + 1 # disable bbox_interval - train_from_artifact = self.train_artifact_path is not None and self.val_artifact_path is not None - # Update the the data_dict to point to local artifacts dir - if train_from_artifact: - self.data_dict = data_dict - - def download_dataset_artifact(self, path, alias): - """ - download the model checkpoint artifact if the path starts with WANDB_ARTIFACT_PREFIX - - arguments: - path -- path of the dataset to be used for training - alias (str)-- alias of the artifact to be download/used for training - - returns: - (str, wandb.Artifact) -- path of the downladed dataset and it's corresponding artifact object if dataset - is found otherwise returns (None, None) - """ - if isinstance(path, str) and path.startswith(WANDB_ARTIFACT_PREFIX): - artifact_path = Path(remove_prefix(path, WANDB_ARTIFACT_PREFIX) + ":" + alias) - dataset_artifact = wandb.use_artifact(artifact_path.as_posix().replace("\\", "/")) - assert dataset_artifact is not None, "'Error: W&B dataset artifact doesn\'t exist'" - datadir = dataset_artifact.download() - return datadir, dataset_artifact - return None, None - - def download_model_artifact(self, opt): - """ - download the model checkpoint artifact if the resume path starts with WANDB_ARTIFACT_PREFIX - - arguments: - opt (namespace) -- Commandline arguments for this run - """ - if opt.resume.startswith(WANDB_ARTIFACT_PREFIX): - model_artifact = wandb.use_artifact(remove_prefix(opt.resume, WANDB_ARTIFACT_PREFIX) + ":latest") - assert model_artifact is not None, 'Error: W&B model artifact doesn\'t exist' - modeldir = model_artifact.download() - # epochs_trained = model_artifact.metadata.get('epochs_trained') - total_epochs = model_artifact.metadata.get('total_epochs') - is_finished = total_epochs is None - assert not is_finished, 'training is finished, can only resume incomplete runs.' - return modeldir, model_artifact - return None, None - - def log_model(self, path, opt, epoch, fitness_score, best_model=False): - """ - Log the model checkpoint as W&B artifact - - arguments: - path (Path) -- Path of directory containing the checkpoints - opt (namespace) -- Command line arguments for this run - epoch (int) -- Current epoch number - fitness_score (float) -- fitness score for current epoch - best_model (boolean) -- Boolean representing if the current checkpoint is the best yet. - """ - model_artifact = wandb.Artifact('run_' + wandb.run.id + '_model', - type='model', - metadata={ - 'original_url': str(path), - 'epochs_trained': epoch + 1, - 'save period': opt.save_period, - 'project': opt.project, - 'total_epochs': opt.epochs, - 'fitness_score': fitness_score}) - model_artifact.add_file(str(path / 'last.pt'), name='last.pt') - wandb.log_artifact(model_artifact, - aliases=['latest', 'last', 'epoch ' + str(self.current_epoch), 'best' if best_model else '']) - LOGGER.info(f"Saving model artifact on epoch {epoch + 1}") - - def log_dataset_artifact(self, data_file, single_cls, project, overwrite_config=False): - """ - Log the dataset as W&B artifact and return the new data file with W&B links - - arguments: - data_file (str) -- the .yaml file with information about the dataset like - path, classes etc. - single_class (boolean) -- train multi-class data as single-class - project (str) -- project name. Used to construct the artifact path - overwrite_config (boolean) -- overwrites the data.yaml file if set to true otherwise creates a new - file with _wandb postfix. Eg -> data_wandb.yaml - - returns: - the new .yaml file with artifact links. it can be used to start training directly from artifacts - """ - upload_dataset = self.wandb_run.config.upload_dataset - log_val_only = isinstance(upload_dataset, str) and upload_dataset == 'val' - self.data_dict = check_dataset(data_file) # parse and check - data = dict(self.data_dict) - nc, names = (1, ['item']) if single_cls else (int(data['nc']), data['names']) - names = {k: v for k, v in enumerate(names)} # to index dictionary - - # log train set - if not log_val_only: - self.train_artifact = self.create_dataset_table(LoadImagesAndLabels(data['train'], rect=True, batch_size=1), - names, - name='train') if data.get('train') else None - if data.get('train'): - data['train'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'train') - - self.val_artifact = self.create_dataset_table( - LoadImagesAndLabels(data['val'], rect=True, batch_size=1), names, name='val') if data.get('val') else None - if data.get('val'): - data['val'] = WANDB_ARTIFACT_PREFIX + str(Path(project) / 'val') - - path = Path(data_file) - # create a _wandb.yaml file with artifacts links if both train and test set are logged - if not log_val_only: - path = (path.stem if overwrite_config else path.stem + '_wandb') + '.yaml' # updated data.yaml path - path = ROOT / 'data' / path - data.pop('download', None) - data.pop('path', None) - with open(path, 'w') as f: - yaml.safe_dump(data, f) - LOGGER.info(f"Created dataset config file {path}") - - if self.job_type == 'Training': # builds correct artifact pipeline graph - if not log_val_only: - self.wandb_run.log_artifact( - self.train_artifact) # calling use_artifact downloads the dataset. NOT NEEDED! - self.wandb_run.use_artifact(self.val_artifact) - self.val_artifact.wait() - self.val_table = self.val_artifact.get('val') - self.map_val_table_path() - else: - self.wandb_run.log_artifact(self.train_artifact) - self.wandb_run.log_artifact(self.val_artifact) - return path - - def map_val_table_path(self): - """ - Map the validation dataset Table like name of file -> it's id in the W&B Table. - Useful for - referencing artifacts for evaluation. - """ - self.val_table_path_map = {} - LOGGER.info("Mapping dataset") - for i, data in enumerate(tqdm(self.val_table.data)): - self.val_table_path_map[data[3]] = data[0] - - def create_dataset_table(self, dataset: LoadImagesAndLabels, class_to_id: Dict[int, str], name: str = 'dataset'): - """ - Create and return W&B artifact containing W&B Table of the dataset. - - arguments: - dataset -- instance of LoadImagesAndLabels class used to iterate over the data to build Table - class_to_id -- hash map that maps class ids to labels - name -- name of the artifact - - returns: - dataset artifact to be logged or used - """ - # TODO: Explore multiprocessing to slpit this loop parallely| This is essential for speeding up the the logging - artifact = wandb.Artifact(name=name, type="dataset") - img_files = tqdm([dataset.path]) if isinstance(dataset.path, str) and Path(dataset.path).is_dir() else None - img_files = tqdm(dataset.im_files) if not img_files else img_files - for img_file in img_files: - if Path(img_file).is_dir(): - artifact.add_dir(img_file, name='data/images') - labels_path = 'labels'.join(dataset.path.rsplit('images', 1)) - artifact.add_dir(labels_path, name='data/labels') - else: - artifact.add_file(img_file, name='data/images/' + Path(img_file).name) - label_file = Path(img2label_paths([img_file])[0]) - artifact.add_file(str(label_file), name='data/labels/' + - label_file.name) if label_file.exists() else None - table = wandb.Table(columns=["id", "train_image", "Classes", "name"]) - class_set = wandb.Classes([{'id': id, 'name': name} for id, name in class_to_id.items()]) - for si, (img, labels, paths, shapes) in enumerate(tqdm(dataset)): - box_data, img_classes = [], {} - for cls, *xywh in labels[:, 1:].tolist(): - cls = int(cls) - box_data.append({ - "position": { - "middle": [xywh[0], xywh[1]], - "width": xywh[2], - "height": xywh[3]}, - "class_id": cls, - "box_caption": "%s" % (class_to_id[cls])}) - img_classes[cls] = class_to_id[cls] - boxes = {"ground_truth": {"box_data": box_data, "class_labels": class_to_id}} # inference-space - table.add_data(si, wandb.Image(paths, classes=class_set, boxes=boxes), list(img_classes.values()), - Path(paths).name) - artifact.add(table, name) - return artifact - - def log_training_progress(self, predn, path, names): - """ - Build evaluation Table. Uses reference from validation dataset table. - - arguments: - predn (list): list of predictions in the native space in the format - [xmin, ymin, xmax, ymax, confidence, class] - path (str): local path of the current evaluation image - names (dict(int, str)): hash map that maps class ids to labels - """ - class_set = wandb.Classes([{'id': id, 'name': name} for id, name in names.items()]) - box_data = [] - avg_conf_per_class = [0] * len(self.data_dict['names']) - pred_class_count = {} - for *xyxy, conf, cls in predn.tolist(): - if conf >= 0.25: - cls = int(cls) - box_data.append({ - "position": { - "minX": xyxy[0], - "minY": xyxy[1], - "maxX": xyxy[2], - "maxY": xyxy[3]}, - "class_id": cls, - "box_caption": f"{names[cls]} {conf:.3f}", - "scores": { - "class_score": conf}, - "domain": "pixel"}) - avg_conf_per_class[cls] += conf - - if cls in pred_class_count: - pred_class_count[cls] += 1 - else: - pred_class_count[cls] = 1 - - for pred_class in pred_class_count.keys(): - avg_conf_per_class[pred_class] = avg_conf_per_class[pred_class] / pred_class_count[pred_class] - - boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space - id = self.val_table_path_map[Path(path).name] - self.result_table.add_data(self.current_epoch, id, self.val_table.data[id][1], - wandb.Image(self.val_table.data[id][1], boxes=boxes, classes=class_set), - *avg_conf_per_class) - - def val_one_image(self, pred, predn, path, names, im): - """ - Log validation data for one image. updates the result Table if validation dataset is uploaded and log bbox media panel - - arguments: - pred (list): list of scaled predictions in the format - [xmin, ymin, xmax, ymax, confidence, class] - predn (list): list of predictions in the native space - [xmin, ymin, xmax, ymax, confidence, class] - path (str): local path of the current evaluation image - """ - if self.val_table and self.result_table: # Log Table if Val dataset is uploaded as artifact - self.log_training_progress(predn, path, names) - - if len(self.bbox_media_panel_images) < self.max_imgs_to_log and self.current_epoch > 0: - if self.current_epoch % self.bbox_interval == 0: - box_data = [{ - "position": { - "minX": xyxy[0], - "minY": xyxy[1], - "maxX": xyxy[2], - "maxY": xyxy[3]}, - "class_id": int(cls), - "box_caption": f"{names[int(cls)]} {conf:.3f}", - "scores": { - "class_score": conf}, - "domain": "pixel"} for *xyxy, conf, cls in pred.tolist()] - boxes = {"predictions": {"box_data": box_data, "class_labels": names}} # inference-space - self.bbox_media_panel_images.append(wandb.Image(im, boxes=boxes, caption=path.name)) - - def log(self, log_dict): - """ - save the metrics to the logging dictionary - - arguments: - log_dict (Dict) -- metrics/media to be logged in current step - """ - if self.wandb_run: - for key, value in log_dict.items(): - self.log_dict[key] = value - - def end_epoch(self, best_result=False): - """ - commit the log_dict, model artifacts and Tables to W&B and flush the log_dict. - - arguments: - best_result (boolean): Boolean representing if the result of this evaluation is best or not - """ - if self.wandb_run: - with all_logging_disabled(): - if self.bbox_media_panel_images: - self.log_dict["BoundingBoxDebugger"] = self.bbox_media_panel_images - try: - wandb.log(self.log_dict) - except BaseException as e: - LOGGER.info( - f"An error occurred in wandb logger. The training will proceed without interruption. More info\n{e}" - ) - self.wandb_run.finish() - self.wandb_run = None - - self.log_dict = {} - self.bbox_media_panel_images = [] - if self.result_artifact: - self.result_artifact.add(self.result_table, 'result') - wandb.log_artifact(self.result_artifact, - aliases=[ - 'latest', 'last', 'epoch ' + str(self.current_epoch), - ('best' if best_result else '')]) - - wandb.log({"evaluation": self.result_table}) - columns = ["epoch", "id", "ground truth", "prediction"] - columns.extend(self.data_dict['names']) - self.result_table = wandb.Table(columns) - self.result_artifact = wandb.Artifact("run_" + wandb.run.id + "_progress", "evaluation") - - def finish_run(self): - """ - Log metrics if any and finish the current W&B run - """ - if self.wandb_run: - if self.log_dict: - with all_logging_disabled(): - wandb.log(self.log_dict) - wandb.run.finish() - - -@contextmanager -def all_logging_disabled(highest_level=logging.CRITICAL): - """ source - https://gist.github.com/simon-weber/7853144 - A context manager that will prevent any logging messages triggered during the body from being processed. - :param highest_level: the maximum logging level in use. - This would only need to be changed if a custom level greater than CRITICAL is defined. - """ - previous_level = logging.root.manager.disable - logging.disable(highest_level) - try: - yield - finally: - logging.disable(previous_level) diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py deleted file mode 100644 index 46ee4ec31d04eee77976ff3edbbf84762a3409ed..0000000000000000000000000000000000000000 --- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/utils/file_io.py +++ /dev/null @@ -1,37 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -from iopath.common.file_io import HTTPURLHandler, OneDrivePathHandler, PathHandler -from iopath.common.file_io import PathManager as PathManagerBase - -__all__ = ["PathManager", "PathHandler"] - - -PathManager = PathManagerBase() -""" -This is a detectron2 project-specific PathManager. -We try to stay away from global PathManager in fvcore as it -introduces potential conflicts among other libraries. -""" - - -class Detectron2Handler(PathHandler): - """ - Resolve anything that's hosted under detectron2's namespace. - """ - - PREFIX = "detectron2://" - S3_DETECTRON2_PREFIX = "https://dl.fbaipublicfiles.com/detectron2/" - - def _get_supported_prefixes(self): - return [self.PREFIX] - - def _get_local_path(self, path, **kwargs): - name = path[len(self.PREFIX) :] - return PathManager.get_local_path(self.S3_DETECTRON2_PREFIX + name, **kwargs) - - def _open(self, path, mode="r", **kwargs): - return PathManager.open(self._get_local_path(path), mode, **kwargs) - - -PathManager.register_handler(HTTPURLHandler()) -PathManager.register_handler(OneDrivePathHandler()) -PathManager.register_handler(Detectron2Handler()) diff --git a/spaces/chansung/zero2story/interfaces/utils.py b/spaces/chansung/zero2story/interfaces/utils.py deleted file mode 100644 index 0308b6bbf92b2896f14d416302bdf6869787a5b6..0000000000000000000000000000000000000000 --- a/spaces/chansung/zero2story/interfaces/utils.py +++ /dev/null @@ -1,114 +0,0 @@ -import copy -import json -import string -import random -import asyncio - -from modules.llms import get_llm_factory - -from pingpong.context import CtxLastWindowStrategy - -def add_side_character_to_export( - characters, enable, img, - name, age, personality, job -): - if enable: - characters.append( - { - 'img': img, - 'name': name - } - ) - - return characters - -def add_side_character(enable, name, age, personality, job, llm_type="PaLM"): - prompts = get_llm_factory(llm_type).create_prompt_manager().prompts - - cur_side_chars = 1 - prompt = "" - for idx in range(len(enable)): - if enable[idx]: - prompt += prompts['story_gen']['add_side_character'].format( - cur_side_chars=cur_side_chars, - name=name[idx], - job=job[idx], - age=age[idx], - personality=personality[idx] - ) - cur_side_chars += 1 - return "\n" + prompt if prompt else "" - -def id_generator(size=6, chars=string.ascii_uppercase + string.digits): - return ''.join(random.choice(chars) for _ in range(size)) - -def parse_first_json_code_snippet(code_snippet): - json_parsed_string = None - - try: - json_parsed_string = json.loads(code_snippet, strict=False) - except: - json_start_index = code_snippet.find('```json') - json_end_index = code_snippet.find('```', json_start_index + 6) - - if json_start_index < 0 or json_end_index < 0: - raise ValueError('No JSON code snippet found in string.') - - json_code_snippet = code_snippet[json_start_index + 7:json_end_index] - json_parsed_string = json.loads(json_code_snippet, strict=False) - finally: - if json_parsed_string is None: - raise ValueError('No JSON code snippet found in string.') - return json_parsed_string - -async def retry_until_valid_json(prompt, parameters=None, llm_type="PaLM"): - response_json = None - factory = get_llm_factory(llm_type) - llm_service = factory.create_llm_service() - - for _ in range(3): - try: - response, response_txt = await asyncio.wait_for(llm_service.gen_text(prompt, mode="text", parameters=parameters), - timeout=10) - - print(response_txt) - except asyncio.TimeoutError: - raise TimeoutError(f"The response time for {llm_type} API exceeded the limit.") - except Exception as e: - print(f"{llm_type} API has encountered an error. Retrying...") - continue - - try: - response_json = parse_first_json_code_snippet(response_txt) - if not response_json: - print("Parsing JSON failed. Retrying...") - continue - except: - print("Parsing JSON failed. Retrying...") - pass - - if len(response.filters) > 0: - raise ValueError(f"{llm_type} API has withheld a response due to content safety concerns.") - elif response_json is None: - print("=== Failed to generate valid JSON response. ===") - print(response_txt) - raise ValueError("Failed to generate valid JSON response.") - - return response_json - -def build_prompts(ppm, win_size=3): - dummy_ppm = copy.deepcopy(ppm) - lws = CtxLastWindowStrategy(win_size) - return lws(dummy_ppm) - -async def get_chat_response(prompt, ctx=None, llm_type="PaLM"): - factory = get_llm_factory(llm_type) - llm_service = factory.create_llm_service() - parameters = llm_service.make_params(mode="chat", temperature=1.0, top_k=50, top_p=0.9) - - _, response_txt = await llm_service.gen_text( - prompt, - parameters=parameters - ) - - return response_txt diff --git a/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat b/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat deleted file mode 100644 index 0b78fdc3a559abd692e3a9e9af5e482124d13a99..0000000000000000000000000000000000000000 --- a/spaces/charles0519/ChuanhuChatGPT/chatgpt - windows.bat +++ /dev/null @@ -1,14 +0,0 @@ -@echo off -echo Opening ChuanhuChatGPT... - -REM Open powershell via bat -start powershell.exe -NoExit -Command "python ./ChuanhuChatbot.py" - -REM The web page can be accessed with delayed start http://127.0.0.1:7860/ -ping -n 5 127.0.0.1>nul - -REM access chargpt via your default browser -start "" "http://127.0.0.1:7860/" - - -echo Finished opening ChuanhuChatGPT (http://127.0.0.1:7860/). \ No newline at end of file diff --git a/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md b/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md deleted file mode 100644 index a7f77221ee2d009c02a734844f4e9305e868c844..0000000000000000000000000000000000000000 --- a/spaces/chasemcdo/hf_localai/.github/ISSUE_TEMPLATE/bug_report.md +++ /dev/null @@ -1,31 +0,0 @@ ---- -name: Bug report -about: Create a report to help us improve -title: '' -labels: bug -assignees: mudler - ---- - - - -**LocalAI version:** - - -**Environment, CPU architecture, OS, and Version:** - - -**Describe the bug** - - -**To Reproduce** - - -**Expected behavior** - - -**Logs** - - -**Additional context** - diff --git a/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py b/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py deleted file mode 100644 index b9cbad0e818720ad65053dcec783a0314898303d..0000000000000000000000000000000000000000 --- a/spaces/chasemcdo/hf_localai/examples/langchain-chroma/store.py +++ /dev/null @@ -1,25 +0,0 @@ - -import os -from langchain.vectorstores import Chroma -from langchain.embeddings import OpenAIEmbeddings -from langchain.text_splitter import CharacterTextSplitter -from langchain.document_loaders import TextLoader - -base_path = os.environ.get('OPENAI_API_BASE', 'http://localhost:8080/v1') - -# Load and process the text -loader = TextLoader('state_of_the_union.txt') -documents = loader.load() - -text_splitter = CharacterTextSplitter(chunk_size=300, chunk_overlap=70) -texts = text_splitter.split_documents(documents) - -# Embed and store the texts -# Supplying a persist_directory will store the embeddings on disk -persist_directory = 'db' - -embedding = OpenAIEmbeddings(model="text-embedding-ada-002") -vectordb = Chroma.from_documents(documents=texts, embedding=embedding, persist_directory=persist_directory) - -vectordb.persist() -vectordb = None \ No newline at end of file diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py deleted file mode 100644 index 0bd646e12ef4f77f77e1f2d0a88c356f950683ed..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/blis/tests/common.py +++ /dev/null @@ -1,85 +0,0 @@ -# Copyright ExplsionAI GmbH, released under BSD. -from __future__ import print_function - -import numpy as np - -np.random.seed(0) -from numpy.testing import assert_allclose - -from hypothesis import assume -from hypothesis.strategies import tuples, integers, floats -from hypothesis.extra.numpy import arrays - - -def lengths(lo=1, hi=10): - return integers(min_value=lo, max_value=hi) - - -def shapes(min_rows=1, max_rows=100, min_cols=1, max_cols=100): - return tuples(lengths(lo=min_rows, hi=max_rows), lengths(lo=min_cols, hi=max_cols)) - - -def ndarrays_of_shape(shape, lo=-1000.0, hi=1000.0, dtype="float64"): - width = 64 if dtype == "float64" else 32 - return arrays( - dtype, shape=shape, elements=floats(min_value=lo, max_value=hi, width=width) - ) - - -def ndarrays( - min_len=0, max_len=10, min_val=-10000000.0, max_val=1000000.0, dtype="float64" -): - return lengths(lo=min_len, hi=max_len).flatmap( - lambda n: ndarrays_of_shape(n, lo=min_val, hi=max_val, dtype=dtype) - ) - - -def matrices( - min_rows=1, - max_rows=10, - min_cols=1, - max_cols=10, - min_value=-10000000.0, - max_value=1000000.0, - dtype="float64", -): - return shapes( - min_rows=min_rows, max_rows=max_rows, min_cols=min_cols, max_cols=max_cols - ).flatmap(lambda mn: ndarrays_of_shape(mn, lo=min_value, hi=max_value, dtype=dtype)) - - -def positive_ndarrays(min_len=0, max_len=10, max_val=100000.0, dtype="float64"): - return ndarrays( - min_len=min_len, max_len=max_len, min_val=0, max_val=max_val, dtype=dtype - ) - - -def negative_ndarrays(min_len=0, max_len=10, min_val=-100000.0, dtype="float64"): - return ndarrays( - min_len=min_len, max_len=max_len, min_val=min_val, max_val=-1e-10, dtype=dtype - ) - - -def parse_layer(layer_data): - # Get the first row, excluding the first column - x = layer_data[0, 1:] - # Get the first column, excluding the first row - # .ascontiguousarray is support important here!!!! - b = np.ascontiguousarray(layer_data[1:, 0], dtype="float64") - # Slice out the row and the column used for the X and the bias - W = layer_data[1:, 1:] - assert x.ndim == 1 - assert b.ndim == 1 - assert b.shape[0] == W.shape[0] - assert x.shape[0] == W.shape[1] - assume(not np.isnan(W.sum())) - assume(not np.isnan(x.sum())) - assume(not np.isnan(b.sum())) - assume(not any(np.isinf(val) for val in W.flatten())) - assume(not any(np.isinf(val) for val in x)) - assume(not any(np.isinf(val) for val in b)) - return x, b, W - - -def split_row(layer_data): - return (layer_data[0, :], layer_data[:, :]) diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py deleted file mode 100644 index 6e1228d6f2b8bbc78cf52864ccaf3b249a654749..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/pens/quartzPen.py +++ /dev/null @@ -1,44 +0,0 @@ -from fontTools.pens.basePen import BasePen - -from Quartz.CoreGraphics import CGPathCreateMutable, CGPathMoveToPoint -from Quartz.CoreGraphics import CGPathAddLineToPoint, CGPathAddCurveToPoint -from Quartz.CoreGraphics import CGPathAddQuadCurveToPoint, CGPathCloseSubpath - - -__all__ = ["QuartzPen"] - - -class QuartzPen(BasePen): - - """A pen that creates a CGPath - - Parameters - - path: an optional CGPath to add to - - xform: an optional CGAffineTransform to apply to the path - """ - - def __init__(self, glyphSet, path=None, xform=None): - BasePen.__init__(self, glyphSet) - if path is None: - path = CGPathCreateMutable() - self.path = path - self.xform = xform - - def _moveTo(self, pt): - x, y = pt - CGPathMoveToPoint(self.path, self.xform, x, y) - - def _lineTo(self, pt): - x, y = pt - CGPathAddLineToPoint(self.path, self.xform, x, y) - - def _curveToOne(self, p1, p2, p3): - (x1, y1), (x2, y2), (x3, y3) = p1, p2, p3 - CGPathAddCurveToPoint(self.path, self.xform, x1, y1, x2, y2, x3, y3) - - def _qCurveToOne(self, p1, p2): - (x1, y1), (x2, y2) = p1, p2 - CGPathAddQuadCurveToPoint(self.path, self.xform, x1, y1, x2, y2) - - def _closePath(self): - CGPathCloseSubpath(self.path) diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py deleted file mode 100644 index 46c9498dc720e7c23b278ae31b65dbf55f2ad8be..0000000000000000000000000000000000000000 --- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/varLib/stat.py +++ /dev/null @@ -1,142 +0,0 @@ -"""Extra methods for DesignSpaceDocument to generate its STAT table data.""" - -from __future__ import annotations - -from typing import Dict, List, Union - -import fontTools.otlLib.builder -from fontTools.designspaceLib import ( - AxisLabelDescriptor, - DesignSpaceDocument, - DesignSpaceDocumentError, - LocationLabelDescriptor, -) -from fontTools.designspaceLib.types import Region, getVFUserRegion, locationInRegion -from fontTools.ttLib import TTFont - - -def buildVFStatTable(ttFont: TTFont, doc: DesignSpaceDocument, vfName: str) -> None: - """Build the STAT table for the variable font identified by its name in - the given document. - - Knowing which variable we're building STAT data for is needed to subset - the STAT locations to only include what the variable font actually ships. - - .. versionadded:: 5.0 - - .. seealso:: - - :func:`getStatAxes()` - - :func:`getStatLocations()` - - :func:`fontTools.otlLib.builder.buildStatTable()` - """ - for vf in doc.getVariableFonts(): - if vf.name == vfName: - break - else: - raise DesignSpaceDocumentError( - f"Cannot find the variable font by name {vfName}" - ) - - region = getVFUserRegion(doc, vf) - - return fontTools.otlLib.builder.buildStatTable( - ttFont, - getStatAxes(doc, region), - getStatLocations(doc, region), - doc.elidedFallbackName if doc.elidedFallbackName is not None else 2, - ) - - -def getStatAxes(doc: DesignSpaceDocument, userRegion: Region) -> List[Dict]: - """Return a list of axis dicts suitable for use as the ``axes`` - argument to :func:`fontTools.otlLib.builder.buildStatTable()`. - - .. versionadded:: 5.0 - """ - # First, get the axis labels with explicit ordering - # then append the others in the order they appear. - maxOrdering = max( - (axis.axisOrdering for axis in doc.axes if axis.axisOrdering is not None), - default=-1, - ) - axisOrderings = [] - for axis in doc.axes: - if axis.axisOrdering is not None: - axisOrderings.append(axis.axisOrdering) - else: - maxOrdering += 1 - axisOrderings.append(maxOrdering) - return [ - dict( - tag=axis.tag, - name={"en": axis.name, **axis.labelNames}, - ordering=ordering, - values=[ - _axisLabelToStatLocation(label) - for label in axis.axisLabels - if locationInRegion({axis.name: label.userValue}, userRegion) - ], - ) - for axis, ordering in zip(doc.axes, axisOrderings) - ] - - -def getStatLocations(doc: DesignSpaceDocument, userRegion: Region) -> List[Dict]: - """Return a list of location dicts suitable for use as the ``locations`` - argument to :func:`fontTools.otlLib.builder.buildStatTable()`. - - .. versionadded:: 5.0 - """ - axesByName = {axis.name: axis for axis in doc.axes} - return [ - dict( - name={"en": label.name, **label.labelNames}, - # Location in the designspace is keyed by axis name - # Location in buildStatTable by axis tag - location={ - axesByName[name].tag: value - for name, value in label.getFullUserLocation(doc).items() - }, - flags=_labelToFlags(label), - ) - for label in doc.locationLabels - if locationInRegion(label.getFullUserLocation(doc), userRegion) - ] - - -def _labelToFlags(label: Union[AxisLabelDescriptor, LocationLabelDescriptor]) -> int: - flags = 0 - if label.olderSibling: - flags |= 1 - if label.elidable: - flags |= 2 - return flags - - -def _axisLabelToStatLocation( - label: AxisLabelDescriptor, -) -> Dict: - label_format = label.getFormat() - name = {"en": label.name, **label.labelNames} - flags = _labelToFlags(label) - if label_format == 1: - return dict(name=name, value=label.userValue, flags=flags) - if label_format == 3: - return dict( - name=name, - value=label.userValue, - linkedValue=label.linkedUserValue, - flags=flags, - ) - if label_format == 2: - res = dict( - name=name, - nominalValue=label.userValue, - flags=flags, - ) - if label.userMinimum is not None: - res["rangeMinValue"] = label.userMinimum - if label.userMaximum is not None: - res["rangeMaxValue"] = label.userMaximum - return res - raise NotImplementedError("Unknown STAT label format") diff --git a/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md b/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md deleted file mode 100644 index d08dea6cd4be2def9cf8bc850d2862057d435330..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Best Coding Practices for Hassle-free Programming How to Use Tools and Techniques to Simplify Your Workflow.md +++ /dev/null @@ -1,30 +0,0 @@ - -
But, what if there was a way to make coding less hampering? Well, you can use best coding practices to ease your working process. Take these practices as a list of side tasks that you will do while coding.
-Moreover, developers have to be experts in at least one programming language and have complete mastery over it. They prioritize better quality in one language than bad quality in many. Apart from that, they should learn what are the end-to-end good practices for easy smooth deployment.
-Best Coding Practices for Hassle-free Programming
Download File ……… https://tinurli.com/2uwknZ
-
Bad coding practices create hindrances in everything, and ultimately, code is full of bugs. However, non-standard coding practices are not always bad. In a unique issue, bad coding can be used to find a suitable solution.
-There is a lack of guidance in our Education System So, we are on a mission to provide genuine programming tutoring to students acorss the globe. We provide Instand coding help, Programming Homework Help, Final Year CS Project help, Quick Programming assignment help services to the students.
-Our Approach. We believe in our core values that are integrated with our team and clients together. Our comprehensive and hassle free approach make us the best programming help services provider on the Internet. Every project and Assignment we deliver to you is a true satisfaction of ours.
-We hire best of the best programming experts having more than 5 years of experience in IT industry. We train them to write code as per college and school standard. Our codes are one hundred percent written by our developers so be worry free and let us solve your assignment.
-CodingZap is a top rated web programming assignment, homework help service provider. Web Programming encompasses most heard programming languages like HTML, CSS, JavaScript, XML, PHP and others. We have a finest team of web developers and engineers to take care of your projects and assignment. Our Coding Homework Help services are designed to produce the best results in your coursework.
Be relaxed and use our Web programming help services to get the best grade in your subject.
Get Computer science homework help. Get Code Homework help in computer science from the best experts. CodingZap is offering the best programming help services at a quite affordable cost to students.
You can get instant coding project help in any of your computer science subjects. Hire tutors for your online coding assignment now.
So if you are looking for CS Homework help services then hire us for guaranteed results.
Coding Assignment is related to coding projects and coding homework. Students get frequent coding assignments when they attend programming and coding coursework like C, C++, Java, Python, HTML, CSS, ML & AI.
-So, if you are struggling to do your coding assignment and need instant help then you can hire codingzap for the best quality deliverables. You just need to pay the half payment upfront and your work will be started. Once its done, you can make the final payment, we will deliver you the final coding solutions.
- -The above principles should be treated as a set of tools for writing good sound code. However, it is not necessary to apply all these elements in every project. We have tried to include best practicies for programming.
-Similarly, they can automate a lot of other tasks by providing built-in functions that would be complicated for us. All major languages have multiple frameworks for different usage needs. They also are a great way to explore and learn a new language. Just understanding the basic programming concepts of the language, you can start coding in the framework.
-Of course, Geek Week is incomplete without the ravishing sales and offers. There is a heavy discount on almost every GeeksforGeeks course for all 7 days (Whatttttt?!) With the motive of making learning affordable and hassle-free for every programming enthusiast, we have this site-wide sale.
-It is important to put these best practices and conventions into practice so you can build highly functional applications that work well, are secure, and ultimately make the lives of your API consumers easier.
-As a teacher or parent, you may be wondering how to best get started with coding for middle school students. It can be intimidating to try something new, especially when it comes to technology. But don't worry, we're here to help! Today, we'll share tips and resources to get your child or students started with programming, including free coding classes and resources that will keep them excited to build new skills. Coding is a valuable skill that can help students develop problem-solving and critical thinking skills, and it can also be a lot of fun. We hope this blog helps you navigate the world of coding for middle school students, and inspires you to give it a try.
-The best way to start learning to code is to choose a programming language that aligns with your student's interests and age. For example, if they are interested in creating games, they might want to start with a language like Scratch and progress to Python or Java. If they are interested in web development, you might want to start with Wix and Scratch, and progress to HTML, CSS, and JavaScript. We recommend beginning with free Scratch coding first, as it empowers kids to make real games and animations fast, without the hassle of syntax. Here's a quick video that explains the best language for your middle schooler:
-Figuring out where to start with teaching your child programming can be extremely hard if you do not have the knowledge or funds to teach them to their highest ability. Luckily, there are plenty of free and amazing resources and classes that can help your child learn coding to the best of their ability.
-Explore some of the most popular coding classes for middle schoolers, from beginner programming, to making their own websites, through to learning how to harness the gaming engine behind hugely successful games such as Angry Birds.
-Kids love mobile apps and games so why not get them to make their own? This class allows students to learn to code mobile apps in small, live group sessions. The use of Thunkable (a block-based programming language) helps kids who are not confident in written-based coding to make awesome projects. After finishing the class, your middle schooler will be more than comfortable with building a plethora of mobile games and apps!
-Python is a high-level coding language used by companies such as Netflix and Google, and it is also used for web development, game development, building apps, machine learning, and so much more. Studies have shown programming with Python to be one of the simplest and most popular coding languages when learning to code. If you want your student wants to learn a real-world programming language, this is the best next class to take.
-Now you and your tween will know how to get started with coding for middle school students! You have free classes, resources, and a great guide on how to teach students programming. Up next, learn ways to get on college mailing lists.
-Hackerrank tried to answer this very question recently. They held a programming competition involving approximately 5500 students and a hundred different schools. Using their results, they determined which top 50 colleges had the best developers.
They concluded that meritocracy prevails where coding skills are concerned, and that great programmers can be found in any school, not necessarily the most prestigious ones listed in official academic rankings.
There are several points to make here.
First, coding platforms have made learning to code easier. They are browser-based, so no need to worry anymore about the coding environment. It is provided, accessible from anywhere, without installing anything. Students can experience the pleasure of coding hassle-free.
Second, coding platforms enable users to assess their programming strengths and weaknesses, so they can continually improve their skills.
Finally, they introduce students who are newcomers in the world of programming to a vibrant community of passionate coders. They can learn from expert developers, experience peer-learning, get feedback on their code, ask for help and compete with friends.
The survey shows that more than 50% of respondents are convinced that their level or rank on such platforms could be useful professionally. The other half might change their mind once coding platforms begin delivering official programming certifications. The ability to showcase their acquired coding skills with some sort of programming resume is also undoubtedly going to become a reality.
-IDEs and developer tools don\u2019t always come packaged with the\u00a0best font. Usually, they use a monospaced system font, and while it may work fine for some, others report eye strain or poor readability.\nWhile most of these programs offer the ability to switch fonts, many people don\u2019t take advantage of it. Some programmers may not even realize they\u2019re using a subpar font until they switch to a community-backed alternative and realize how better things can be.\nA\u00a0good font\u00a0can minimize headaches, make your code easier to scan, and even revolutionize how you work.\n"},"name":"Why Switch Your Programming Font?","@type":"Question"},"acceptedAnswer":"@type":"Answer","text":"Here\u2019s what you need to look out for.\n
- \n
- Clear and easy-to-read characters to reduce eye strain when spending hours looking at hundreds of lines of code.\n
- Makes a clear distinction between commonly-confused characters such as the letter \u201cO\u201d and the number \u201c0\u201d or the lowercase \u201cL\u201d and the number \u201c1\u201d.\n
- Ligatures or extra whitespace for commonly-used symbols in popular programming languages \u2013 not for everyone, but others love it.\n
- Fonts with multiple variations on how certain characters are handled are great, so you can pick and choose exactly the version you prefer.\n\nMany programmers prefer monospace\/fixed-width fonts to help readability and make code easier to scan for\u00a0errors, so most of them fall under that category. Some of them contain standard, non-monospaced versions bundled in if you prefer it that way.\n","name":"So what\u2019s in a suitable programming font?","@type":"Question"]},"@context":"http:\/\/schema.org","name":"webfonts","@type":["Thing"],"@id":"http:\/\/data.wordlift.io\/wl0150038\/post_tag\/webfonts","description":"","url":["https:\/\/kinsta.com\/blog\/tag\/webfonts\/"],"mainEntityOfPage":"https:\/\/kinsta.com\/blog\/tag\/webfonts\/","@context":"http:\/\/schema.org","name":"WordPress Fonts","@type":["Thing"],"@id":"http:\/\/data.wordlift.io\/wl0150038\/term\/topic\/wordpress_fonts","description":"","mainEntityOfPage":"https:\/\/kinsta.com\/topic\/wordpress-fonts\/","@context":"http:\/\/schema.org","name":"WordPress Website Design","@type":["Thing"],"@id":"http:\/\/data.wordlift.io\/wl0150038\/term\/topic\/wordpress_website_design","description":"","mainEntityOfPage":"https:\/\/kinsta.com\/topic\/wordpress-website-design\/"]li code,p code,.wp-block-code,.wp-block-kinsta-notice,.wp-block-kinsta-table-of-contents,.share-staticbackground-color: #f3f3f6;.related-posts background-color: #fafafa;li code,p code border-color: #f3f3f6; Skip to content Test a deployment on our modern App Hosting. For a limited time, your first $20 is on us. aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/cihyFjudo/fairness-paper-search/COMSOL-Multiphysics-540295-For-Windows-Linux-Crack-2021.md b/spaces/cihyFjudo/fairness-paper-search/COMSOL-Multiphysics-540295-For-Windows-Linux-Crack-2021.md deleted file mode 100644 index 9b438283693dbe4e71135c1a098540b674084642..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/COMSOL-Multiphysics-540295-For-Windows-Linux-Crack-2021.md +++ /dev/null @@ -1,118 +0,0 @@ -## COMSOL Multiphysics 5.4.0.295 For Windows Linux Crack - - - - - - ![COMSOL Multiphysics 5.4.0.295 For Windows Linux Crack \[2021\]](https://img.xooimage.com/files8/4/3/d/id-e2350000-1461226.png) - - - - - -**CLICK HERE --->>> [https://www.google.com/url?q=https%3A%2F%2Furlin.us%2F2txliP&sa=D&sntz=1&usg=AOvVaw3fvNxMdn1yjAPjHTvZIrwi](https://www.google.com/url?q=https%3A%2F%2Furlin.us%2F2txliP&sa=D&sntz=1&usg=AOvVaw3fvNxMdn1yjAPjHTvZIrwi)** - - - - - - - - - - - - - -# How to Crack COMSOL Multiphysics 5.4.0.295 for Windows and Linux - - - -COMSOL Multiphysics is a powerful software package that allows you to model and simulate various physical phenomena using finite element methods. It can be used for engineering, science, and education purposes. However, it is also a very expensive software that requires a license to run. - - - -If you want to use COMSOL Multiphysics 5.4.0.295 for free, you might be tempted to look for a crack online. A crack is a program or a file that modifies or bypasses the original software protection mechanisms, such as serial numbers, activation codes, or dongles. However, cracking COMSOL Multiphysics 5.4.0.295 is not only illegal, but also risky and unreliable. - - - -First of all, cracking software is a violation of the intellectual property rights of the software developers and distributors. It can result in legal consequences, such as fines or lawsuits. Moreover, it can damage your reputation and credibility as a professional or a student. - - - -Secondly, cracking software can expose your computer to malware, viruses, or spyware. Many crack files or programs are infected with malicious code that can harm your system, steal your data, or compromise your security. You might end up losing your important files, personal information, or money. - - - -Thirdly, cracking software can cause performance issues, errors, or crashes. Many crack files or programs are poorly made, outdated, or incompatible with your system or other software. They can interfere with the proper functioning of COMSOL Multiphysics 5.4.0.295 or other applications on your computer. You might experience bugs, glitches, or failures that can ruin your work or waste your time. - - - -Therefore, we strongly advise you not to crack COMSOL Multiphysics 5.4.0.295 for Windows and Linux. Instead, we recommend you to use the official trial version of the software that you can download from the COMSOL website[^1^]. The trial version allows you to use all the features and modules of COMSOL Multiphysics 5.4.0.295 for 14 days without any cost or obligation. - - - -If you want to continue using COMSOL Multiphysics 5.4.0.295 after the trial period expires, you can purchase a license from the COMSOL website[^1^] or from an authorized reseller in your region[^2^]. The license price depends on the type and number of modules you need, as well as the number of users and computers you want to install the software on. - - - -By purchasing a license, you will not only support the development and improvement of COMSOL Multiphysics 5.4.0.295, but also benefit from technical support, updates, and access to online resources and community forums. - - - -We hope this article has helped you understand why cracking COMSOL Multiphysics 5.4.0.295 is a bad idea and what are the legal and safe alternatives to use this software. - - - -## What is COMSOL Multiphysics 5.4.0.295? - - - -COMSOL Multiphysics 5.4.0.295 is the latest version of the software released in November 2018. It introduces several new features and improvements, such as: - - - -- A new Metal Processing Module that allows you to model metal phase transformations, heat treatment, welding, and quenching processes. - -- A new Porous Media Flow Module that allows you to model fluid flow and transport phenomena in porous media, such as soil, rocks, filters, and membranes. - -- A new Composite Materials Module that allows you to model the mechanical behavior of composite materials, such as laminates, sandwich structures, and fiber-reinforced plastics. - -- A new Random Fields feature that allows you to model spatial variations of material properties using statistical distributions. - -- A new Shape Memory Alloy feature that allows you to model the thermo-mechanical behavior of materials that can change their shape in response to temperature changes. - -- A new Fluid-Structure Interaction feature that allows you to couple fluid flow and structural mechanics in one simulation. - -- Improved performance, usability, and compatibility with other software and hardware platforms. - - - -COMSOL Multiphysics 5.4.0.295 also includes more than 50 application examples that demonstrate how to use the software for various engineering and scientific problems. - - - -## How to Learn COMSOL Multiphysics 5.4.0.295? - - - -If you are new to COMSOL Multiphysics 5.4.0.295 or want to refresh your skills, there are many resources available to help you learn the software. - - - -One of the best ways to learn COMSOL Multiphysics 5.4.0.295 is to follow the online tutorials that are available on the COMSOL website. The tutorials cover the basics of the software interface, the workflow of creating and solving a model, and the postprocessing and visualization of the results. The tutorials also include step-by-step instructions and screenshots that guide you through each stage of the modeling process. - - - -Another way to learn COMSOL Multiphysics 5.4.0.295 is to watch the recorded webinars that are available on the COMSOL website. The webinars are hosted by COMSOL experts and cover various topics and applications of the software. The webinars also include live demonstrations and Q&A sessions where you can ask questions and get answers from the presenters. - - - -A third way to learn COMSOL Multiphysics 5.4.0.295 is to attend the training courses that are offered by COMSOL or its partners in different locations around the world. The training courses are designed for different levels of experience and cover different aspects and modules of the software. The training courses also include hands-on exercises and interaction with instructors and other participants. - - 1b8d091108 - - - - - diff --git a/spaces/cihyFjudo/fairness-paper-search/Download Mac Os X Mountain Lion Iso File.md b/spaces/cihyFjudo/fairness-paper-search/Download Mac Os X Mountain Lion Iso File.md deleted file mode 100644 index ffd9740008c083720caa5d1c67fbddee0909840e..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Download Mac Os X Mountain Lion Iso File.md +++ /dev/null @@ -1,14 +0,0 @@ - -Mac OSX Mountain Lion 10.8.5 is an update which has improved the stability, security and compatibility of your Mac. This update has fixed an issue which may prevent a screen saver from automatic start. It has also fixed an issue which will prevent Mail from displaying different messages. It has also enhanced the reliability while transferring large files over Ethernet. It has also enhanced performance for authenticating Open Directory server. This update has resolved issue which may prevent different applications to use FaceTime HD camera. It has also improved AFP file transfer performance. You may also like to download Mac OSX Lion 10.7.2 DMG Free Download.
-A mac os x mountain lion 10.8 ISO is still without a doubt the most popular operating system for the old model MacBook the size of mac os x mountain lion 10.8 ISO is just 4GB and you need just 10GB HDD from installation apple has really made a great operating system that runs very smoothly and is very functional for the users the user interface is easy to use and extremely straightforward for any user of macs. mac os x mountain lion 10.8 iso google drive will run on most types of MacBooks if it is old or new still you can install it.
-download mac os x mountain lion iso file
Download File → https://tinurli.com/2uwiNz
-If you are not comfortable with mac os x mountain lion 10.8.5, then you can download the Higher version for free from our website such asMac OS X Mavericks 10.9 ISO or Mac OS X Yosemite ISO
-Power nap is the second last feature in this list. Power nap is a handy feature used to download any file while your system goes to sleep. Downloading while sleeping can save you lots of power and puts less effort into your hardware.
-Another option is to peruse the Apple Vintage Software collection at Archive.org which may have image files of older system restore disks and other older system software, just beware that archive.org is not an official distributor of Apple software so appropriate precautions should be taken and only download from there at your own risk.
-The preinstalled image and Torrent file we talk about in this article was created by a separate team called souldevteam back in the year 2012. Unoftuntily, the website and team are not active anymore to download the file from their website. Mountain Lion OS X is an outdated Apple OS. There are many other latest versions available, we covered them here. It is highly recommended to use the latest releases except you have some special requirements to test the OS X 10.8 currently.if(typeof ez_ad_units!='undefined')ez_ad_units.push([[580,400],'sysprobs_com-medrectangle-3','ezslot_5',105,'0','0']);__ez_fad_position('div-gpt-ad-sysprobs_com-medrectangle-3-0');This method is completely for testing and learning purposes only.
-After completing the initial configurations, you should land on the mountain lion OS X desktop without any issues.I recommend taking a snapshot now before proceeding further.Install VMware Tools on Mac OS X 10.8Network and sound/audio worked out of the box without additional installations or settings.
- -The obvious first step here is to download OS X Mountain Lion. But before you do anything else, a word of caution: once you've used the OS X installer, it will automatically delete the file you need to make the backup disk, so you'll want to either make a copy of the installer or create your disk before you upgrade.
-Most podcast apps keep a list of your subscribed podcasts in an OPML file, then download new episodes when you instruct the app to do a feed check, or on a time schedule you set in the app's settings. Overcast does things differently. You need to set up an account to use Overcast, and when you do, your podcast subscription list is uploaded onto the Overcast servers. The list is checked continuously against the various feeds, and when a new episode is posted it is auto-downloaded into Overcast, where, optionally, a device alert is triggered so you know the new podcast is now available for playback.
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/cihyFjudo/fairness-paper-search/Download Solution Manual For Applied Nonlinear Control Slotinezip for Free.md b/spaces/cihyFjudo/fairness-paper-search/Download Solution Manual For Applied Nonlinear Control Slotinezip for Free.md deleted file mode 100644 index 488b8ce1555edbd75b1b0cd14f38e2b01ab71052..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Download Solution Manual For Applied Nonlinear Control Slotinezip for Free.md +++ /dev/null @@ -1,6 +0,0 @@ -Solution Manual For Applied Nonlinear Control Slotinezip
DOWNLOAD > https://tinurli.com/2uwkPt
-
- aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/Kawakaburi No Cherry 13 [HOT].md b/spaces/cihyFjudo/fairness-paper-search/Kawakaburi No Cherry 13 [HOT].md deleted file mode 100644 index ea6c35b02c35083dcc3daec07a474a6987be6f64..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Kawakaburi No Cherry 13 [HOT].md +++ /dev/null @@ -1,6 +0,0 @@ -kawakaburi no cherry 13
DOWNLOAD ✦ https://tinurli.com/2uwiHh
-
- aaccfb2cb3
-
-
- diff --git a/spaces/cihyFjudo/fairness-paper-search/Sound Blaster CT4830 Driver for Vista Where to Find the Latest Version.md b/spaces/cihyFjudo/fairness-paper-search/Sound Blaster CT4830 Driver for Vista Where to Find the Latest Version.md deleted file mode 100644 index 38430ea40c1d55531c12185b6e555b8b0f48e066..0000000000000000000000000000000000000000 --- a/spaces/cihyFjudo/fairness-paper-search/Sound Blaster CT4830 Driver for Vista Where to Find the Latest Version.md +++ /dev/null @@ -1,23 +0,0 @@ - -Eventually this design proved so popular that Creative made a PCI version of this card. Creative's audio revenue grew from US$40 million per year to nearly US$1 billion following the launch of the Sound Blaster 16 and related products. Rich Sorkin was General Manager of the global business during this time, responsible for product planning, product management, marketing and OEM sales. Moving the card off the ISA bus, which was already approaching obsolescence, meant that no line for host-controlled ISA DMA was available, because the PCI slot offers no such line. Instead, the card used PCI bus mastering to transfer data from the main memory to the D/A converters. Since existing DOS programs expected to be able to initiate host-controlled ISA DMA for producing sound, backward compatibility with the older Sound Blaster cards for DOS programs required a software driver work-around; since this work-around necessarily depended on the virtual 8086 mode of the PC's CPU in order to catch and reroute accesses from the ISA DMA controller to the card itself, it failed for a number of DOS games that either were not fully compatible with this CPU mode or needed so much free conventional memory that they could not be loaded with the driver occupying part of this memory. In Microsoft Windows, there was no problem, as Creative's Windows driver software could handle both ISA and PCI cards correctly.
-Some drivers from the Audigy 2 ZS have been soft-modded by enthusiasts. These can be installed on Creative's older cards, including Sound Blaster Live!, Audigy, and Audigy 2. It has been claimed to offer improved sound quality, hardware acceleration of higher EAX versions in games, 64-channel mixing for Audigy 1, and an overall improvement in the card's performance. Several forum posts across the web have reported favorable results with this technique, excepting Live! users where the drivers only add the ability to use the newer software applications (i.e. the newer mixer applet). Comments on forums from developers of the software mod have said that Live's hardware is not capable of EAX3 nor 64-channels of hardware sound mixing.
-sound blaster ct4830 driver for vista
Download ✶✶✶ https://tinurli.com/2uwiKA
-When Windows Vista was released, there was only a single beta driver for the Creative Audigy series that was usable on the operating system with minimal functionality and frequent instability reported by users. A Creative Forum activist named Daniel K. modified drivers from the X-Fi and applied it to the Audigy and Live! series, restoring most if not all of the features that came with the original XP setup CD in Vista. X-Fi drivers have noticeably better sound quality under Vista, and more bug fixes because of the newer build (last modified version is 2.15.0004EQ April). He managed to enable the X-Fi Crystallizer to work on Audigy series cards in software, however because of the patents involved, he was forced to remove all the modified drivers and DLL patch.
-i am looking for DOS drivers for my Sound Blaster Live CT4830. I am very amateur in MS-DOS. Could someone please help me or guide me to a step by step tutorial on setting up native DOS drivers for my sound card. Thanks
-If you experience any problems such as no sound, interrupt conflicts or else, try to modify the settings for your driver using
-
SBESET.EXE, or modify your BIOS settings following the instructions
given in the HTML file.My SBLive is an older 4.1 version, and I think the ct4830 is a 5.1. Otherwise I'd upload my driver CD for you.
-
But to get your SBLive working in DOS, I'd try to use the file structure on my PII as a starting point.Sound Blaster Live! was the first sound card from Creative with the "What U Hear" recording input channel. This was supported in the Windows drivers, so no additional software was needed to utilize it. The analog stereo audio signal that came out of the main Line Out was directed into this input. That way, one could mix all available inputs and the MIDI synth into one stereo signal. When using "What U Hear" with 5.1 sound, the sound would be downmixed to stereo first. The Creative Recorder utility included with the sound card was specifically designed to take advantage of the "What U Hear" feature, making it a simple matter to capture streaming sound from any source, even from programs that deliberately avoid providing a means for saving the digital sounds, thus freeing non-technical users from the complexities of "patching" between inputs and outputs of various software modules.
-Hey Guys
- -
i am currently having difficulties finding working native dos drivers for my Creative SoundBlaster Live Value CT4830.
i have tried the ones in the sticky but they dont work, i have also tried other ones from vogons but no luck.
Has anyone got the CT4830 working in dos. the games i am trying work fine in Windows98 but when i click restart in msdos mode there is no sound.Come to think of it, I seem to recall the sound playback also being very quiet after the installation of the drivers from the CD -ROM.
-
There might be some "gain" controls under the Mixer settings. I cannot recall, as it has been almost 20 years since I've installed my card with a Windows 98SE setup.
I noticed that there is an "UPDDRV95.EXE" file in the \Win95drv folder. Perhaps run that and see if it makes a difference?I'm pretty sure that a driver incompatibility is why the CT4830 did not work. You see, I started with the CT4830, got the 100% smooth install, but then no sound. But rather than reimage the HDD right away, I popped in the CT4780 (after trying another CT4830, as stated earlier), and it worked perfectly.
-I'm thinking that the early model Live! cards pre-Windows XP and pre-WMA drivers would be excellent choices for EAX sound plus good SB16 compatibility with good wavetable. This is a dirt cheap solution for those wanting to get into retro gaming on PC.
-Do you have the CD you used successfully with your CT4760 linked someplace please? Otherwise I was going to use this on on Vogon's drivers. I have an ESS ES1869F ISA sound card installed as well if that matters.
-I?m trying to find some specs on the CT4830 on Creative's site, or other. Did find the User Manual & drivers / patch, but no real specs.For purposes of recording old vinyl LPsb> & reel to reel to HDD to burn to CD or convert to mp3, is this Creative CT4830Very likely / Possibly / Not likelyb>) to have better sound quality than my integrated audio?
-The drivers don't bother each other. You can have problems if the 2 sound cards end up with the same IRQ. I have an Audigy 1 and an Audigy 2 ZS in my recording computer. At one time, I had a third sound card in the computer but the computer developed some psychological problems and starting switching around IRQs between the 3 cards on every reboot so I extracted one of them.
-You can find much better cards out there for recording than the Creative Labs cards but there is nothiing else to compare with the kX drivers for taking advantage of the features of these cards for recording. You should just stick your CT4830 in the computer and try it out and see how it sounds.
-The Ensoniq based SB Live cards were very troublesome to get working properly, I recall a lot of people scouring markets for the original Soundblasters which would just work...
-
The Ensoniqs are very picky about having the exact right driver, an OEM card won't work properly with a non-OEM driver (e.g. a Dell SB Live needs the Dell driver) and vice-versa, and in DOS the OPL3 emulation caused a lot of heartache, being done by a TSR program, and the wavetable for music was also a software table loaded into memory from an .ECW file (which was usually not supplied with the driver package... handy).
If the program uses MIDI music, make sure the Midi Mapper is not selected if it's being run under Windows.Long time since I used Win98, but in the MIDI section of the sound or multimedia setup or whatever it was called, make sure MIDI is directed to the card's MPU-401 interface, not the mapper. If the driver is correctly installed, I think you just select MPU-401.
-Again it's a long time since I used such a card, but the Wave Device may not produce any sound unless a software wavetable is loaded. If there is an MPU-401 option available, that might play Soundblaster FM, but I don't remember whether the Ensoniq based cards could do that in hardware or not.
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/clem/Image_Face_Upscale_Restoration-GFPGAN/app.py b/spaces/clem/Image_Face_Upscale_Restoration-GFPGAN/app.py deleted file mode 100644 index 67fcac0171bbb77d2b1d3b23b7293635b6297e28..0000000000000000000000000000000000000000 --- a/spaces/clem/Image_Face_Upscale_Restoration-GFPGAN/app.py +++ /dev/null @@ -1,142 +0,0 @@ -import os - -import cv2 -import gradio as gr -import torch -from basicsr.archs.srvgg_arch import SRVGGNetCompact -from gfpgan.utils import GFPGANer -from realesrgan.utils import RealESRGANer - -os.system("pip freeze") -# download weights -if not os.path.exists('realesr-general-x4v3.pth'): - os.system("wget https://github.com/xinntao/Real-ESRGAN/releases/download/v0.2.5.0/realesr-general-x4v3.pth -P .") -if not os.path.exists('GFPGANv1.2.pth'): - os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.2.pth -P .") -if not os.path.exists('GFPGANv1.3.pth'): - os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.3.pth -P .") -if not os.path.exists('GFPGANv1.4.pth'): - os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.0/GFPGANv1.4.pth -P .") -if not os.path.exists('RestoreFormer.pth'): - os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/RestoreFormer.pth -P .") -if not os.path.exists('CodeFormer.pth'): - os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v1.3.4/CodeFormer.pth -P .") - -torch.hub.download_url_to_file( - 'https://thumbs.dreamstime.com/b/tower-bridge-traditional-red-bus-black-white-colors-view-to-tower-bridge-london-black-white-colors-108478942.jpg', - 'a1.jpg') -torch.hub.download_url_to_file( - 'https://media.istockphoto.com/id/523514029/photo/london-skyline-b-w.jpg?s=612x612&w=0&k=20&c=kJS1BAtfqYeUDaORupj0sBPc1hpzJhBUUqEFfRnHzZ0=', - 'a2.jpg') -torch.hub.download_url_to_file( - 'https://i.guim.co.uk/img/media/06f614065ed82ca0e917b149a32493c791619854/0_0_3648_2789/master/3648.jpg?width=700&quality=85&auto=format&fit=max&s=05764b507c18a38590090d987c8b6202', - 'a3.jpg') -torch.hub.download_url_to_file( - 'https://i.pinimg.com/736x/46/96/9e/46969eb94aec2437323464804d27706d--victorian-london-victorian-era.jpg', - 'a4.jpg') - -# background enhancer with RealESRGAN -model = SRVGGNetCompact(num_in_ch=3, num_out_ch=3, num_feat=64, num_conv=32, upscale=4, act_type='prelu') -model_path = 'realesr-general-x4v3.pth' -half = True if torch.cuda.is_available() else False -upsampler = RealESRGANer(scale=4, model_path=model_path, model=model, tile=0, tile_pad=10, pre_pad=0, half=half) - -os.makedirs('output', exist_ok=True) - - -# def inference(img, version, scale, weight): -def inference(img, version, scale): - # weight /= 100 - print(img, version, scale) - try: - extension = os.path.splitext(os.path.basename(str(img)))[1] - img = cv2.imread(img, cv2.IMREAD_UNCHANGED) - if len(img.shape) == 3 and img.shape[2] == 4: - img_mode = 'RGBA' - elif len(img.shape) == 2: # for gray inputs - img_mode = None - img = cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) - else: - img_mode = None - - h, w = img.shape[0:2] - if h < 300: - img = cv2.resize(img, (w * 2, h * 2), interpolation=cv2.INTER_LANCZOS4) - - if version == 'v1.2': - face_enhancer = GFPGANer( - model_path='GFPGANv1.2.pth', upscale=2, arch='clean', channel_multiplier=2, bg_upsampler=upsampler) - elif version == 'v1.3': - face_enhancer = GFPGANer( - model_path='GFPGANv1.3.pth', upscale=2, arch='clean', channel_multiplier=2, bg_upsampler=upsampler) - elif version == 'v1.4': - face_enhancer = GFPGANer( - model_path='GFPGANv1.4.pth', upscale=2, arch='clean', channel_multiplier=2, bg_upsampler=upsampler) - elif version == 'RestoreFormer': - face_enhancer = GFPGANer( - model_path='RestoreFormer.pth', upscale=2, arch='RestoreFormer', channel_multiplier=2, bg_upsampler=upsampler) - elif version == 'CodeFormer': - face_enhancer = GFPGANer( - model_path='CodeFormer.pth', upscale=2, arch='CodeFormer', channel_multiplier=2, bg_upsampler=upsampler) - elif version == 'RealESR-General-x4v3': - face_enhancer = GFPGANer( - model_path='realesr-general-x4v3.pth', upscale=2, arch='realesr-general', channel_multiplier=2, bg_upsampler=upsampler) - - try: - # _, _, output = face_enhancer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True, weight=weight) - _, _, output = face_enhancer.enhance(img, has_aligned=False, only_center_face=False, paste_back=True) - except RuntimeError as error: - print('Error', error) - - try: - if scale != 2: - interpolation = cv2.INTER_AREA if scale < 2 else cv2.INTER_LANCZOS4 - h, w = img.shape[0:2] - output = cv2.resize(output, (int(w * scale / 2), int(h * scale / 2)), interpolation=interpolation) - except Exception as error: - print('wrong scale input.', error) - if img_mode == 'RGBA': # RGBA images should be saved in png format - extension = 'png' - else: - extension = 'jpg' - save_path = f'output/out.{extension}' - cv2.imwrite(save_path, output) - - output = cv2.cvtColor(output, cv2.COLOR_BGR2RGB) - return output, save_path - except Exception as error: - print('global exception', error) - return None, None - - -title = "Image Upscaling & Restoration(esp. Face) using GFPGAN Algorithm" -description = r"""Gradio demo for GFPGAN: Towards Real-World Blind Face Restoration and Upscalling of the image with a Generative Facial Prior.
-Practically the algorithm is used to restore your **old photos** or improve **AI-generated faces**.
-To use it, simply just upload the concerned image.
-""" -article = r""" -[](https://github.com/TencentARC/GFPGAN/releases) -[](https://github.com/TencentARC/GFPGAN) -[](https://arxiv.org/abs/2101.04061) - , - React.ComponentPropsWithoutRef ->(({ className, ...props }, ref) => ( - -)) -DropdownMenuSubContent.displayName = - DropdownMenuPrimitive.SubContent.displayName - -const DropdownMenuContent = React.forwardRef< - React.ElementRef , - React.ComponentPropsWithoutRef ->(({ className, sideOffset = 4, ...props }, ref) => ( - - -)) -DropdownMenuContent.displayName = DropdownMenuPrimitive.Content.displayName - -const DropdownMenuItem = React.forwardRef< - React.ElementRef- , - React.ComponentPropsWithoutRef & { - inset?: boolean - } ->(({ className, inset, ...props }, ref) => ( - -)) -DropdownMenuItem.displayName = DropdownMenuPrimitive.Item.displayName - -const DropdownMenuLabel = React.forwardRef< - React.ElementRef , - React.ComponentPropsWithoutRef & { - inset?: boolean - } ->(({ className, inset, ...props }, ref) => ( - -)) -DropdownMenuLabel.displayName = DropdownMenuPrimitive.Label.displayName - -const DropdownMenuSeparator = React.forwardRef< - React.ElementRef , - React.ComponentPropsWithoutRef ->(({ className, ...props }, ref) => ( - -)) -DropdownMenuSeparator.displayName = DropdownMenuPrimitive.Separator.displayName - -const DropdownMenuShortcut = ({ - className, - ...props -}: React.HTMLAttributes ) => { - return ( - - ) -} -DropdownMenuShortcut.displayName = 'DropdownMenuShortcut' - -export { - DropdownMenu, - DropdownMenuTrigger, - DropdownMenuContent, - DropdownMenuItem, - DropdownMenuLabel, - DropdownMenuSeparator, - DropdownMenuShortcut, - DropdownMenuGroup, - DropdownMenuPortal, - DropdownMenuSub, - DropdownMenuSubContent, - DropdownMenuRadioGroup -} diff --git a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aacps_fixed.c b/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aacps_fixed.c deleted file mode 100644 index 46af21339a96ff1089f1baa4379449cc1f81a6c0..0000000000000000000000000000000000000000 --- a/spaces/colakin/video-generater/public/ffmpeg/libavcodec/aacps_fixed.c +++ /dev/null @@ -1,24 +0,0 @@ -/* - * MPEG-4 Parametric Stereo decoding functions - * Copyright (c) 2010 Alex Converse
-CarX Drift Racing 2 APK Oyun Indir Club Son Surum: A Review of the Best Drifting Game for Android
-If you are a fan of drifting games, you might have heard of CarX Drift Racing 2, the sequel to the game that Jalopnik called the best drifting game ever. This game offers an unprecedented and realistic experience of driving real sports cars on one of many race tracks available throughout the game. You can customize your car, compete with other players online, and practice your drifting skills in various modes.
-carx drift racing 2 apk oyun indir club son surum
Download Zip ✒ https://urlca.com/2uOalZ
-But how can you get this amazing game on your Android device? The answer is simple: download CarX Drift Racing 2 APK Oyun Indir Club Son Surum from [this link](^1^). This is the latest version of the game that has been updated with new features, bug fixes, and improvements. You can enjoy all the benefits of this game without any restrictions or limitations.
-In this article, we will review CarX Drift Racing 2 APK Oyun Indir Club Son Surum and tell you why you should download it right now. We will also give you some tips and tricks to drift like a pro in this game. Let's get started!
-Introduction
-What is CarX Drift Racing 2?
-CarX Drift Racing 2 is a racing game for Android that features realistic racing and drifting experience with a challenging track design. The game offers players a variety of car models, tracks, and playing modes with unique challenges and obstacles. The objective is to drift as much as possible to score points and advance through the levels.
-Why should you download CarX Drift Racing 2 APK Oyun Indir Club Son Surum?
-There are many reasons why you should download CarX Drift Racing 2 APK Oyun Indir Club Son Surum from [this link](^1^). Here are some of them:
--
-
- You can get the latest version of the game that has been updated with new features, bug fixes, and improvements. -
- You can play the game without any ads or in-app purchases that might interrupt your gameplay or make you spend money. -
- You can access all the cars, tracks, modes, and options that are available in the game without any restrictions or limitations. -
- You can enjoy the game in your preferred language, as it supports English, Russian, French, Italian, German, Spanish, Traditional Chinese, Simplified Chinese, Korean, Polish, Portuguese, Japanese, and Turkish. -
- You can play the game offline or online with your friends or other players from around the world. -
Features of CarX Drift Racing 2
-Realistic physics and graphics
-One of the standout features of CarX Drift Racing 2 is its realistic physics engine, which accurately simulates the behavior of a car during a drift. The game's controls are intuitive, with players using the accelerometer to control the car's direction and speed while drifting. With the crowd cheering you on, it's all about fame and glory.
-The game also boasts stunning graphics that create a immersive atmosphere for the players. The cars are detailed and realistic, with different body kits, rims, vinyls, and parts. The tracks are diverse and dynamic, with different surfaces, weather conditions, lighting effects, and scenery.
Online rooms and multiplayer modes
-If you want to challenge your friends or other players from around the world, CarX Drift Racing 2 has you covered. The game features online rooms and multiplayer modes that let you drift in real time with others. You can get together, pick a location, drift, and earn points. You can also chat with other players, join clubs, and participate in events.
-There are different types of multiplayer modes in CarX Drift Racing 2, such as:
--
-
- Tandem drift - In this mode, you have to follow the leader's car and copy their drift line as closely as possible. The closer you are, the more points you get. You can also switch roles and become the leader. -
- Drift race - In this mode, you have to compete with other players on a race track and drift as much as possible. The more angle and speed you have, the more points you get. The player with the most points at the end of the race wins. -
- Sprint race - In this mode, you have to race with other players on a straight track and reach the finish line as fast as possible. You can use nitro and draft to boost your speed. The player with the best time wins. -
Visual auto tuning and performance tuning
-Another feature that makes CarX Drift Racing 2 stand out is its visual auto tuning and performance tuning options. You can customize your car's appearance and performance to suit your style and preferences. You can replace mirrors, lights, running boards, bumpers, and many other parts. You can also create a unique image of your car with body kits, rims, vinyls, and more.
-But visual tuning is not enough if you want to drift like a pro. You also need to tune your car's performance and adjust its settings to optimize its handling and power. You can tune your suspension, springs, tire pressure, wheel angle, engine, turbo pressure, gearbox, brakes, locking differential, and more. You can also save your tuning setups and switch between them easily.
-carx drift racing 2 apk download latest version
-
-carx drift racing 2 mod apk unlimited money and gold
-carx drift racing 2 android oyun club indir
-carx drift racing 2 apk hileli oyun indir
-carx drift racing 2 online multiplayer drifting game
-carx drift racing 2 apk full unlocked
-carx drift racing 2 apk indir cepde
-carx drift racing 2 apk mod menu
-carx drift racing 2 apk oyun indir club güncel sürüm
-carx drift racing 2 apk free shopping
-carx drift racing 2 apk obb data download
-carx drift racing 2 hack apk android
-carx drift racing 2 apk oyun indir club hile
-carx drift racing 2 apk revdl
-carx drift racing 2 apk pure
-carx drift racing 2 apk oyun indir club son güncelleme
-carx drift racing 2 premium cars unlocked apk
-carx drift racing 2 apk uptodown
-carx drift racing 2 apk rexdl
-carx drift racing 2 apk oyun indir club yeni sürüm
-carx drift racing 2 mod apk all cars unlocked
-carx drift racing 2 apk no ads
-carx drift racing 2 apk oyun indir club mega hileli
-carx drift racing 2 apk andropalace
-carx drift racing 2 apk mob.org
-carx drift racing 2 mod apk god mode
-carx drift racing 2 apk oyun indir club son versiyon hileli
-carx drift racing 2 apk apkpure
-carx drift racing 2 mod apk unlimited everything
-carx drift racing 2 apk oyun indir club vip hileli
-carx drift racing 2 mod apk offline
-carx drift racing 2 apk hack download
-carx drift racing 2 mod apk latest version download
-carx drift racing 2 modded apk oyun indir club
-carx drift racing 2 mod apk android oyun club indir
-carx drift racing 2 modded apk free download
-carx drift racing 2 hack mod apk download for android
-carx drift racing 2 modded game download for android
-carx drift racing 2 hacked version download for android
-carx drift racing 2 cracked version download for androidXDS mode and TOP-32 tournaments
-If you want to take your drifting skills to the next level, CarX Drift Racing 2 has two modes that will challenge you like never before: XDS mode and TOP-32 tournaments.
-XDS mode is a unique feature that lets you practice tandem drifting with yourself. You will be racing twice: the first time as the leader in a tandem drift, and the second time as the follower, actually following your own ghost car. The game will evaluate your performance based on the CarX XDS Evaluation System, which is designed on the professional evaluation system used in real life drift competitions. XDS mode is a perfect opportunity to improve your style and technique.
-TOP-32 tournaments are online competitions that let you match up against the best drifters in the world. You have to register, practice, and make it through the qualification rounds to enter the bracket. Then you have to beat each opponent in a tandem drift battle until you reach the final round. You can win valuable rewards for each round and for becoming the champion.
Tips and tricks to drift like a pro in CarX Drift Racing 2
-Now that you know the features of CarX Drift Racing 2, you might be wondering how to master the art of drifting in this game. Don't worry, we have some tips and tricks for you that will help you drift like a pro in no time. Here they are:
-Use the handbrake wisely
-The handbrake is your best friend when it comes to drifting, but you have to use it wisely. You don't want to use it too much or too little, as it will affect your drift angle and speed. The best way to use the handbrake is to tap it briefly before entering a corner, then release it and steer into the drift. This will help you initiate the drift and maintain a smooth transition. You can also use the handbrake to adjust your drift angle and direction during the drift, but be careful not to overdo it or you might lose control.
-Adjust your car settings and tire pressure
-As we mentioned before, tuning your car's performance is crucial for drifting. You have to find the right balance between power and handling, as well as between grip and slip. One of the most important settings to adjust is your tire pressure, as it affects how your car reacts to the road surface. A lower tire pressure will give you more grip and stability, but less speed and drift angle. A higher tire pressure will give you more speed and drift angle, but less grip and stability. You have to experiment with different tire pressures and see what works best for you and your car.
-Change your camera angle and steering sensitivity
-Another thing that can make a big difference in your drifting experience is your camera angle and steering sensitivity. You can choose from different camera angles in CarX Drift Racing 2, such as hood, cockpit, bumper, chase, or drone. Each camera angle has its own advantages and disadvantages, depending on your preference and style. For example, the hood camera gives you a better view of the road ahead, but less of the surroundings. The drone camera gives you a wider view of the track, but less of the car's details. You have to try different camera angles and see what suits you best.
-Similarly, you can adjust your steering sensitivity in CarX Drift Racing 2, which affects how responsive your car is to your movements. A higher steering sensitivity will make your car turn faster and sharper, but also harder to control. A lower steering sensitivity will make your car turn slower and smoother, but also less agile. You have to find the right steering sensitivity for your car and your skill level.
-Practice your style and follow the drift line
-The last tip we have for you is to practice your style and follow the drift line. Drifting is not only about scoring points, but also about expressing yourself and having fun. You can develop your own style of drifting by choosing different cars, tracks, modes, settings, vinyls, and parts. You can also experiment with different techniques, such as clutch kicking, feinting, braking, or power sliding.
-However, no matter what style you choose, you have to follow the drift line if you want to get the best results. The drift line is a yellow line that appears on the track during a drift, indicating the optimal path for drifting. The closer you follow the drift line, the more points you get. You also have to pay attention to the color of the drift line, as it changes from green to red depending on your performance. Green means good, yellow means average, and red means bad. You want to keep the drift line as green as possible by maintaining a high drift angle and speed.
-Conclusion
-Summary of the main points
-In conclusion, CarX Drift Racing 2 APK Oyun Indir Club Son Surum is a game that every drifting fan should download from [this link]. It offers a realistic and immersive drifting experience with amazing features such as:
--
-
- Realistic physics and graphics -
- Online rooms and multiplayer modes -
- Visual auto tuning and performance tuning -
- XDS mode and TOP-32 tournaments -
We also gave you some tips and tricks to help you drift like a pro in this game, such as:
--
-
- Use the handbrake wisely -
- Adjust your car settings and tire pressure -
- Change your camera angle and steering sensitivity -
- Practice your style and follow the drift line -
Call to action
-So what are you waiting
So what are you waiting for? Download CarX Drift Racing 2 APK Oyun Indir Club Son Surum from [this link] and start drifting like a pro. You will not regret it, as this game will keep you entertained and challenged for hours. You can also share your drifting experience with your friends and other players online, and show them who is the best drifter in the world.
-We hope you enjoyed this article and found it useful. If you have any questions or feedback, please let us know in the comments section below. We would love to hear from you. Happy drifting!
-FAQs
-Here are some frequently asked questions about CarX Drift Racing 2 APK Oyun Indir Club Son Surum:
-Is CarX Drift Racing 2 APK Oyun Indir Club Son Surum safe to download?
-Yes, CarX Drift Racing 2 APK Oyun Indir Club Son Surum is safe to download from [this link]. It is a verified and trusted source that provides the latest version of the game without any viruses or malware. You can download and install the game without any worries.
-How can I update CarX Drift Racing 2 APK Oyun Indir Club Son Surum?
-You can update CarX Drift Racing 2 APK Oyun Indir Club Son Surum by visiting [this link] again and downloading the latest version of the game. You can also check for updates within the game by going to the settings menu and tapping on the update button. The game will automatically download and install the latest version if available.
-How can I contact the developers of CarX Drift Racing 2?
-You can contact the developers of CarX Drift Racing 2 by visiting their official website at [this link]. You can also follow them on their social media accounts, such as Facebook, Instagram, Twitter, and YouTube. You can find the links to their social media accounts on their website.
-How can I report a bug or a problem in CarX Drift Racing 2?
-If you encounter a bug or a problem in CarX Drift Racing 2, you can report it by going to the settings menu and tapping on the support button. You can also email the developers at support@carx-tech.com and describe your issue in detail. They will try to fix it as soon as possible.
-How can I get more coins and gold in CarX Drift Racing 2?
-You can get more coins and gold in CarX Drift Racing 2 by playing the game regularly and completing various tasks, such as drifting, racing, winning tournaments, completing achievements, and watching ads. You can also buy coins and gold with real money if you want to speed up your progress or unlock more items.
401be4b1e0
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Connect Animal Klasik MOD APK The Best Game for Animal Lovers.md b/spaces/congsaPfin/Manga-OCR/logs/Connect Animal Klasik MOD APK The Best Game for Animal Lovers.md deleted file mode 100644 index 222d7aee4fd451719e63b52621e46c729ba41211..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Connect Animal Klasik MOD APK The Best Game for Animal Lovers.md +++ /dev/null @@ -1,97 +0,0 @@ - -Connect Animal Klasik Mod Apk: A Fun and Challenging Puzzle Game
-If you are looking for a relaxing and addictive puzzle game, you should try Connect Animal Klasik. This is a game that will test your memory, concentration, and logic skills as you connect cute animals on the board. You can play this game offline, choose from different modes and levels, and enjoy the colorful graphics and sounds. But if you want to make the game even more fun and exciting, you should download Connect Animal Klasik Mod Apk. This is a modified version of the game that will give you access to all the features and benefits that the original game does not offer. In this article, we will tell you more about Connect Animal Klasik, how to play it, and why you should download Connect Animal Klasik Mod Apk.
-connect animal klasik mod apk
Download Zip ———>>> https://urlca.com/2uOa7h
-What is Connect Animal Klasik?
-Connect Animal Klasik is a puzzle game that was developed by Droid Corp. It is based on the classic Mahjong game, but with a twist. Instead of matching tiles with Chinese symbols, you have to match tiles with animal pictures. The game has a simple and intuitive gameplay that anyone can enjoy. You just have to tap on two matching animals to connect them with a line. The line can only have two or three turns, and it cannot cross other animals or lines. You have to clear all the animals on the board before the time runs out. The game has hundreds of levels with different layouts and difficulties. You can also choose from different modes, such as easy, normal, hard, challenge, hell, god, and infinity. Each mode has its own rules and challenges that will keep you entertained for hours.
-Features of Connect Animal Klasik
-Offline gameplay
-One of the best features of Connect Animal Klasik is that you can play it offline. You do not need an internet connection or Wi-Fi to enjoy this game. You can play it anytime and anywhere you want, whether you are at home, at work, or on the go. You can also save your progress and resume it later.
-Multiple modes and levels
-Another great feature of Connect Animal Klasik is that it has multiple modes and levels for you to choose from. You can start with the easy mode if you are a beginner, or challenge yourself with the harder modes if you are an expert. You can also try the infinity mode if you want to play endlessly without any time limit. The game has hundreds of levels with different layouts and difficulties that will test your skills and patience.
-connect animal classic mod apk download
-
-connect animal klasik mod apk unlimited money
-connect animal classic mod apk latest version
-connect animal klasik mod apk free
-connect animal classic mod apk offline
-connect animal klasik mod apk android
-connect animal classic mod apk hack
-connect animal klasik mod apk 2023
-connect animal classic mod apk no ads
-connect animal klasik mod apk full
-connect animal classic mod apk game
-connect animal klasik mod apk online
-connect animal classic mod apk 1.28
-connect animal klasik mod apk update
-connect animal classic mod apk unlocked
-connect animal klasik mod apk premium
-connect animal classic mod apk cheat
-connect animal klasik mod apk pro
-connect animal classic mod apk review
-connect animal klasik mod apk 1.27
-connect animal classic mod apk for pc
-connect animal klasik mod apk 1.26
-connect animal classic mod apk for ios
-connect animal klasik mod apk 1.25
-connect animal classic mod apk old version
-connect animal klasik mod apk 1.24
-connect animal classic mod apk new version
-connect animal klasik mod apk 1.23
-connect animal classic mod apk fun
-connect animal klasik mod apk 1.22
-connect animal classic mod apk easy
-connect animal klasik mod apk 1.21
-connect animal classic mod apk hard
-connect animal klasik mod apk 1.20
-connect animal classic mod apk challenge
-connect animal klasik mod apk 1.19
-connect animal classic mod apk infinity mode
-connect animal klasik mod apk 1.18
-connect animal classic mod apk god mode
-connect animal klasik mod apk 1.17
-connect animal classic mod apk hell mode
-connect animal klasik mod apk 1.16
-connect animal classic mod apk player mode
-connect animal klasik mod apk 1.15
-connect animal classic mod apk apprentice mode
-connect animal klasik mod apk 1.14
-connect animal classic mod apk featuresCute graphics and sounds
-The last feature of Connect Animal Klasik that we want to mention is its cute graphics and sounds. The game has a colorful and cartoonish design that will appeal to both kids and adults. The animals are adorable and funny, and they make cute noises when you connect them. The game also has a cheerful background music that will make you feel relaxed and happy.
-How to play Connect Animal Klasik
-Tap on two matching animals to connect them
-The basic rule of Connect Animal Klasik is very simple: tap on two matching animals to connect them with a line. The line can only have two or three turns, and it cannot cross other animals or lines. You have to make sure that the animals are adjacent or have a clear path between them. You can also zoom in or out to see the board better.
-Clear all the animals before the time runs out
-The main goal of Connect Animal Klasik is to clear all the animals on the board before the time runs out. The game has a timer that shows you how much time you have left. The timer varies depending on the mode and level you are playing. If you clear all the animals before the time runs out, you will win the level and earn stars and coins. If you fail to do so, you will lose the level and have to try again.
-Use hints and shuffles to help you out
-If you are stuck or need some help, you can use hints and shuffles to help you out. Hints will show you a pair of matching animals that you can connect. Shuffles will rearrange the animals on the board and give you a new layout. You can use hints and shuffles by tapping on the buttons at the bottom of the screen. However, you have a limited number of hints and shuffles per level, so use them wisely.
-Why download Connect Animal Klasik Mod Apk?
-Unlock all modes and levels for free
-One of the reasons why you should download Connect Animal Klasik Mod Apk is that it will unlock all the modes and levels for free. You do not have to pay any money or watch any ads to access all the features of the game. You can enjoy all the modes and levels without any restrictions or limitations.
-Remove ads and enjoy the game without interruptions
-Another reason why you should download Connect Animal Klasik Mod Apk is that it will remove ads and enjoy the game without interruptions. You do not have to deal with annoying pop-ups or banners that will distract you from the game. You can play the game smoothly and comfortably without any interruptions.
-Get unlimited hints and shuffles to solve any puzzle
-The last reason why you should download Connect Animal Klasik Mod Apk is that it will give you unlimited hints and shuffles to solve any puzzle. You do not have to worry about running out of hints or shuffles when you are stuck or need some help. You can use as many hints and shuffles as you want without any cost or penalty.
-How to download and install Connect Animal Klasik Mod Apk
-Download the mod apk file from a trusted source
-The first step to download and install Connect Animal Klasik Mod Apk is to download the mod apk file from a trusted source. You can find many websites that offer mod apk files for various games, but not all of them are safe and reliable. Some of them may contain viruses or malware that can harm your device or steal your data. Therefore, you should be careful and choose a reputable source that has positive reviews and feedback from other users. You can also scan the mod apk file with an antivirus software before downloading it.
-Enable unknown sources on your device settings
-The second step to download and install Connect Animal Klasik Mod Apk is to enable unknown sources on your device settings. This is because mod apk files are not available on the official Google Play Store, so you have to allow your device to install apps from other sources. To do this, go to your device settings, then security, then unknown sources, and turn it on. This will enable your device to install apps from sources other than the Google Play Store.
-Install the mod apk file and launch the game
-The third and final step to download and install Connect Animal Klasik Mod Apk is to install the mod apk file and launch the game. To do this, locate the mod apk file that you downloaded on your device storage, then tap on it to start the installation process. Follow the instructions on the screen until the installation is complete. Then, launch the game from your app drawer or home screen, and enjoy playing Connect Animal Klasik with all its modded features.
-Conclusion
-Connect Animal Klasik is a fun and challenging puzzle game that will test your memory, concentration, and logic skills as you connect cute animals on the board. You can play this game offline, choose from different modes and levels, and enjoy the colorful graphics and sounds. But if you want to make the game even more fun and exciting, you should download Connect Animal Klasik Mod Apk. This is a modified version of the game that will give you access to all the features and benefits that the original game does not offer. You can unlock all modes and levels for free, remove ads and enjoy the game without interruptions, and get unlimited hints and shuffles to solve any puzzle. To download and install Connect Animal Klasik Mod Apk, you just have to follow three simple steps: download the mod apk file from a trusted source, enable unknown sources on your device settings, and install the mod apk file and launch the game. We hope that this article has helped you learn more about Connect Animal Klasik, how to play it, and why you should download Connect Animal Klasik Mod Apk. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading and happy gaming!
-FAQs
-Here are some frequently asked questions about Connect Animal Klasik and Connect Animal Klasik Mod Apk:
-Q: Is Connect Animal Klasik safe to play?
-A: Yes, Connect Animal Klasik is safe to play. It does not contain any harmful or malicious content that can harm your device or data. However, you should always download the game from the official Google Play Store or a trusted source to avoid any risks.
-Q: Is Connect Animal Klasik Mod Apk legal to use?
-A: Connect Animal Klasik Mod Apk is not legal to use. It is a modified version of the game that violates the terms and conditions of the original game developer. Using Connect Animal Klasik Mod Apk may result in your account being banned or suspended, or your device being infected with viruses or malware. Therefore, we do not recommend using Connect Animal Klasik Mod Apk.
-Q: How can I update Connect Animal Klasik Mod Apk?
-A: To update Connect Animal Klasik Mod Apk, you have to download the latest version of the mod apk file from a trusted source and install it over the existing one. You cannot update Connect Animal Klasik Mod Apk from the Google Play Store or the game itself.
-Q: How can I contact the developer of Connect Animal Klasik?
-A: To contact the developer of Connect Animal Klasik, you can send an email to droidcorp@gmail.com or visit their Facebook page at https://www.facebook.com/droidcorp.
-Q: How can I support the developer of Connect Animal Klasik?
-A: To support the developer of Connect Animal Klasik, you can rate and review the game on the Google Play Store, share it with your friends and family, and purchase in-app items or premium features if you like them.
401be4b1e0
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Create Your Dream Wedding Look with Super Wedding Dress Up Stylist MOD APK.md b/spaces/congsaPfin/Manga-OCR/logs/Create Your Dream Wedding Look with Super Wedding Dress Up Stylist MOD APK.md deleted file mode 100644 index d1ebd0551ec2ce84ec243760e8fd1e15d2f2b3aa..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Create Your Dream Wedding Look with Super Wedding Dress Up Stylist MOD APK.md +++ /dev/null @@ -1,81 +0,0 @@ -
-Super Wedding Dress Up Stylist Mod Apk: A Fun and Creative Game for Fashion Lovers
-Do you love fashion and weddings? Do you dream of becoming a wedding stylist and designing the most beautiful outfits for brides and grooms? If yes, then you will love Super Wedding Dress Up Stylist Mod Apk, a game that lets you unleash your creativity and have fun at the same time.
-super wedding dress up stylist mod apk
DOWNLOAD ★★★★★ https://urlca.com/2uO59D
-What is Super Wedding Dress Up Stylist Mod Apk?
-Super Wedding Dress Up Stylist Mod Apk is a game built in the style of a wedding fashion designer. With a lot of different features, players will have the ability to create a beautiful look for the bride and groom on their important day. You can choose from hundreds of dresses, suits, shoes, jewelry, hairstyles, makeup, and accessories to create your own unique style. You can also customize the wedding venue and decorations to match your theme and mood. You can even take photos of your creations and share them with your friends.
-Features of Super Wedding Dress Up Stylist Mod Apk
-Super Wedding Dress Up Stylist Mod Apk is not just a regular game. It is a modded version that gives you some extra benefits that make the game more enjoyable and easy to play. Here are some of the features of Super Wedding Dress Up Stylist Mod Apk:
-Unlimited Money
-With Super Wedding Dress Up Stylist Mod Apk, you don't have to worry about running out of money. You can buy anything you want without any limitations. You can also upgrade your wardrobe and unlock new items as you progress in the game.
-No Ads
-Another great feature of Super Wedding Dress Up Stylist Mod Apk is that it removes all the annoying ads that interrupt your gameplay. You can play the game without any distractions or interruptions.
-All Dresses and Accessories Unlocked
-Super Wedding Dress Up Stylist Mod Apk also gives you access to all the dresses and accessories that are available in the game. You don't have to wait for levels or achievements to unlock them. You can use them right away and mix and match them as you like.
-How to Download and Install Super Wedding Dress Up Stylist Mod Apk?
-If you are interested in playing Super Wedding Dress Up Stylist Mod Apk, you need to download and install it on your device. Here are the steps you need to follow:
-Step 1: Enable Unknown Sources
-Since Super Wedding Dress Up Stylist Mod Apk is not available on the official app store, you need to enable unknown sources on your device. This will allow you to install apps from third-party sources. To do this, go to your device settings, then security, then unknown sources, and turn it on.
-super wedding dress up stylist hack apk
-
-super wedding dress up stylist unlimited money
-super wedding dress up stylist game download
-super wedding dress up stylist mod apk latest version
-super wedding dress up stylist cheats
-super wedding dress up stylist online
-super wedding dress up stylist free shopping
-super wedding dress up stylist mod apk android 1
-super wedding dress up stylist premium apk
-super wedding dress up stylist offline
-super wedding dress up stylist mod menu
-super wedding dress up stylist apk pure
-super wedding dress up stylist no ads
-super wedding dress up stylist mod apk revdl
-super wedding dress up stylist unlock all
-super wedding dress up stylist pro apk
-super wedding dress up stylist mod apk happymod
-super wedding dress up stylist full version
-super wedding dress up stylist vip mod apk
-super wedding dress up stylist apk mod download
-super wedding dress up stylist cracked apk
-super wedding dress up stylist for pc
-super wedding dress up stylist mod apk rexdl
-super wedding dress up stylist unlimited coins
-super wedding dress up stylist mega mod apk
-super wedding dress up stylist paid apk
-super wedding dress up stylist modded apk
-super wedding dress up stylist hack download
-super wedding dress up stylist mod apk 2023
-super wedding dress up stylist unlimited gems
-super wedding dress up stylist mod apk obb
-super wedding dress up stylist apk mirror
-super wedding dress up stylist no root
-super wedding dress up stylist mod apk ios
-super wedding dress up stylist all unlocked
-super wedding dress up stylist hack version
-super wedding dress up stylist mod apk 4.0
-super wedding dress up stylist unlimited diamonds
-super wedding dress up stylist mod apk modyolo[^1^]Step 2: Download the Mod Apk File
-Next, you need to download the mod apk file from a reliable source. You can use this link to download it directly to your device. Make sure you have enough storage space before downloading it.
-Step 3: Install the Mod Apk File
After downloading the mod apk file, you need to install it on your device. To do this, locate the file in your file manager and tap on it. You will see a pop-up window asking you to confirm the installation. Tap on install and wait for the process to finish. -How to Play Super Wedding Dress Up Stylist Mod Apk?
-Now that you have installed Super Wedding Dress Up Stylist Mod Apk, you are ready to play the game. Here are some tips on how to play the game:
-Choose a Bride and a Groom
-The first thing you need to do is to choose a bride and a groom for your wedding. You can select from different characters with different skin tones, hair colors, and facial features. You can also change their names and personalities.
-Design the Perfect Wedding Outfit
-The next thing you need to do is to design the perfect wedding outfit for your bride and groom. You can choose from hundreds of dresses, suits, shoes, jewelry, hairstyles, makeup, and accessories. You can also change the colors and patterns of the items. You can use the zoom and rotate buttons to adjust the items as you like. You can also use the undo and redo buttons to fix any mistakes.
-Customize the Wedding Venue and Decorations
-The last thing you need to do is to customize the wedding venue and decorations. You can choose from different locations such as a beach, a garden, a castle, or a church. You can also choose from different themes such as romantic, vintage, modern, or fairy tale. You can also add flowers, candles, balloons, banners, and other decorations to make the venue more beautiful. You can use the drag and drop feature to place the items where you want them.
-Why You Should Play Super Wedding Dress Up Stylist Mod Apk?
-Super Wedding Dress Up Stylist Mod Apk is not just a game. It is also a way to express your creativity and have fun. Here are some reasons why you should play Super Wedding Dress Up Stylist Mod Apk:
-It's Fun and Relaxing
-Playing Super Wedding Dress Up Stylist Mod Apk is fun and relaxing. You can enjoy creating your own wedding style without any stress or pressure. You can also play the game at your own pace and time. You can also take photos of your creations and share them with your friends.
-It's Creative and Challenging
-Playing Super Wedding Dress Up Stylist Mod Apk is also creative and challenging. You can use your imagination and skills to create the most beautiful outfits for your bride and groom. You can also try different combinations and styles to see what works best. You can also challenge yourself by completing different tasks and achievements in the game.
-It's Free and Safe
-Another reason why you should play Super Wedding Dress Up Stylist Mod Apk is that it is free and safe. You don't have to pay anything to download or play the game. You also don't have to worry about any viruses or malware that might harm your device. The game is tested and verified by many users and experts.
-Conclusion
-Super Wedding Dress Up Stylist Mod Apk is a game that lets you become a wedding stylist and design the most beautiful outfits for brides and grooms. You can choose from hundreds of dresses, suits, shoes, jewelry, hairstyles, makeup, and accessories to create your own unique style. You can also customize the wedding venue and decorations to match your theme and mood. The game has many features such as unlimited money, no ads, all dresses and accessories unlocked, etc. that make the game more enjoyable and easy to play. The game is also fun, relaxing, creative, challenging, free, and safe. If you love fashion and weddings, you should definitely try Super Wedding Dress Up Stylist Mod Apk.
- FAQs Q: What is the difference between Super Wedding Dress Up Stylist Mod Apk and Super Wedding Dress Up Stylist Original Apk? A: The difference between Super Wedding Dress Up Stylist Mod Apk and Super Wedding Dress Up Stylist Original Apk is that the mod apk version has some extra benefits such as unlimited money, no ads, all dresses and accessories unlocked, etc. Q: How can I update Super Wedding Dress Up Stylist Mod Apk? A: To update Super Wedding Dress Up Stylist Mod Apk, you need to download the latest version of the mod apk file from a reliable source and install it on your device. Q: Is Super Wedding Dress Up Stylist Mod Apk compatible with my device? A: Super Wedding Dress Up Stylist Mod Apk is compatible with most Android devices that have Android 4.4 or higher. You can check your device's compatibility by going to the game's page on the app store and looking at the requirements. Q: How can I contact the developers of Super Wedding Dress Up Stylist Mod Apk? A: If you have any questions, feedback, or suggestions for Super Wedding Dress Up Stylist Mod Apk, you can contact the developers by sending an email to [support@superweddingdressupstylist.com] or by visiting their website [www.superweddingdressupstylist.com]. Q: What are some other games like Super Wedding Dress Up Stylist Mod Apk? A: Some other games like Super Wedding Dress Up Stylist Mod Apk are Fashion Fever, Wedding Salon 2, Wedding Planner, and Bride and Groom Dress Up. 401be4b1e0
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Gadi Wala Game Master Your Driving Skills and Beat Your Opponents.md b/spaces/congsaPfin/Manga-OCR/logs/Gadi Wala Game Master Your Driving Skills and Beat Your Opponents.md deleted file mode 100644 index 31b12e16c91e730380bceb30ff19d99eb78e708e..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Gadi Wala Game Master Your Driving Skills and Beat Your Opponents.md +++ /dev/null @@ -1,114 +0,0 @@ -
-Gadi Game: A Guide to the Best Car Racing Games for Android
-If you are a fan of car racing games, you might have heard of Gadi Game. Gadi Game is a term that refers to a variety of car racing games that are available for Android devices. These games are fun, exciting, and addictive, and they offer a great way to enjoy the thrill of driving and racing on your phone. In this article, we will introduce you to some of the best Gadi Games that you can play on your Android device, and we will also show you how to download and install them, as well as give you some tips and tricks on how to play them better.
-Gadi Wala Game - Kar Wala Game
-One of the most popular Gadi Games is Gadi Wala Game - Kar Wala Game. This game is a 3D car racing game that features stunning graphics, realistic physics, and addictive gameplay. You can choose from a variety of sports cars and drive them on asphalt roads in different environments, such as city streets, countryside roads, and seashores. You can also perform drifting stunts and compete with other racers in different modes, such as time trial, elimination, and head-to-head. The game is easy to control, with touch screen or tilt options, and it also has a smooth sound effect and music. If you are looking for a fast-paced and exhilarating car racing game, you should definitely try Gadi Wala Game - Kar Wala Game.
-gadi game
Download Zip ✓✓✓ https://urlca.com/2uOcdz
-Turbo Driving Racing 3D
-Another great Gadi Game is Turbo Driving Racing 3D. This game is an arcade endless racing game that challenges you to drive as fast as you can while avoiding traffic and obstacles. You can also collect coins and power-ups along the way, which you can use to upgrade your car or buy new ones. The game has a variety of cars to choose from, ranging from sedans to sports cars to trucks. The game also has different scenarios to race in, such as desert, city, forest, and snow. The game has simple controls, with just tapping or tilting your device, and it also has stunning 3D graphics and sound effects. If you are looking for a fun and addictive car racing game that never ends, you should definitely try Turbo Driving Racing 3D.
-Gadi - Truck Racing Fun in Nepal
-If you want to try something different from the usual car racing games, you might want to check out Gadi - Truck Racing Fun in Nepal. This game is a unique truck racing game that lets you drive a truck on the roads of Nepal. You can explore different levels, such as Kathmandu, Pokhara, Chitwan, and more, and enjoy the beautiful scenery and culture of Nepal. You can also customize your truck with different colors, stickers, and accessories. The game has realistic physics and controls, as well as amazing graphics and sound effects. You can also compete with other players online and see who can drive the fastest and the farthest. If you are looking for a fun and unique truck racing game that lets you experience the beauty of Nepal, you should definitely try Gadi - Truck Racing Fun in Nepal.
-How to Download and Install Gadi Game on Your Android Device
-Now that you know some of the best Gadi Games that you can play on your Android device, you might be wondering how to download and install them. Don't worry, it's very easy and simple. Just follow these steps:
-Requirements for Gadi Game
-Before you download and install any Gadi Game, you need to make sure that your Android device meets the minimum requirements for the game. These requirements may vary depending on the game, but generally, you need to have:
--
-
- An Android device running on Android 4.1 or higher -
- At least 100 MB of free storage space -
- A stable internet connection -
- The permission to access your device's location, storage, camera, microphone, and other features -
You can check these requirements by going to the game's page on Google Play Store or other sources and reading the description and the details. If your device meets the requirements, you can proceed to download and install the game.
-How to Download Gadi Game from Google Play Store
-The easiest and safest way to download and install any Gadi Game is from Google Play Store, the official app store for Android devices. Here's how to do it:
-gadi wala game 3d
-
-kar wala game 2022
-gadi game car racing
-gadi driving games offline
-gadi game 3d download
-turbo driving racing 3d
-gadi game truck racing
-gadi game nepal
-gadi wala game video
-kar wala game online
-gadi game car games
-gadi drifting games 2021
-gadi game 3d apk
-turbo driving racing 3d mod apk
-gadi game snow mountains
-gadi game desert level
-gadi wala game play store
-kar wala game android
-gadi game car simulator
-gadi racing games 2020
-gadi game 3d offline
-turbo driving racing 3d hack
-gadi game fun in nepal
-gadi game gold collection
-gadi wala game youtube
-kar wala game free download
-gadi game car stunt
-gadi driving games 2022
-gadi game 3d online
-turbo driving racing 3d gameplay
-gadi game adventure in nepal
-gadi game high score
-gadi wala game app
-kar wala game hd graphics
-gadi game car drifting
-gadi racing games 2021
-gadi game 3d update
-turbo driving racing 3d review
-gadi game challenge mode
-gadi game unlock levels
-gadi wala game install
-kar wala game best cars
-gadi game car speed
-gadi driving games 2020
-gadi game 3d mod apk
-turbo driving racing 3d cheats
-gadi game endless mode
-gadi game city roads-
-
- Open Google Play Store on your Android device and search for the name of the Gadi Game that you want to download. For example, if you want to download Gadi Wala Game - Kar Wala Game, type "Gadi Wala Game - Kar Wala Game" in the search bar. -
- From the search results, tap on the game that matches your query. Make sure that it is from a trusted developer and has good ratings and reviews. -
- On the game's page, tap on the green "Install" button. This will start downloading the game to your device. -
- Wait for the download to finish and then tap on the "Open" button. This will launch the game on your device. -
- Enjoy playing your Gadi Game! -
How to Download Gadi Game from Other Sources
-If you can't find the Gadi Game that you want to play on Google Play Store, or if you want to download it from another source, you can also do that. However, you need to be careful when downloading apps from third-party websites or APK files, as they may contain viruses or malware that can harm your device or steal your data. Here's how to download Gadi Game from other sources:
--
-
- Find a reliable website or APK file that offers the Gadi Game that you want to download. You can use a search engine or a trusted app store alternative to find one. -
- On the website or APK file, tap on the "Download" button or link. This will start downloading the game to your device. -
- Before you install the game, you need to enable the "Unknown Sources" option on your device. This will allow you to install apps from sources other than Google Play Store. To do this, go to your device's Settings > Security > Unknown Sources and toggle it on. -
- Once you have enabled the "Unknown Sources" option, go to your device's File Manager or Downloads folder and find the downloaded game file. Tap on it and follow the instructions to install it. -
- After installing the game, you can launch it from your app drawer or home screen. -
- Enjoy playing your Gadi Game! -
Tips and Tricks for Playing Gadi Game
-Now that you have downloaded and installed your Gadi Game, you might want some tips and tricks on how to play it better. Here are some useful advice that can help you improve your skills and enjoy your Gadi Game more:
-How to Choose the Best Car for Your Race
-In most Gadi Games, you can choose from a variety of cars to drive in your race. Each car has different attributes, such as speed, acceleration, handling, braking , and durability. You should choose the car that suits your racing style and the track that you are racing on. For example, if you are racing on a straight road, you might want a car with high speed and acceleration, but if you are racing on a curvy road, you might want a car with good handling and braking. You can also compare the cars by looking at their stats and ratings, which are usually displayed on the screen before you select them. You can also test drive the cars before you buy them or use them in a race, which can help you get a feel of how they perform.
-How to Master the Controls and Drifting Techniques
-Another important aspect of playing Gadi Games is mastering the controls and drifting techniques. The controls may vary depending on the game, but generally, you can use either touch screen or tilt options to steer your car. You can also tap on the screen to brake, accelerate, or use power-ups. You should practice using the controls and find the one that works best for you. You should also learn how to drift, which is a technique that allows you to slide your car sideways around corners without losing speed or control. Drifting can help you save time, avoid collisions, and earn more coins or points. To drift, you need to tap on the brake button while turning your car, and then release it when you want to straighten your car. You should practice drifting on different tracks and with different cars until you master it.
-How to Earn More Coins and Unlock New Levels
-One of the main goals of playing Gadi Games is to earn more coins and unlock new levels. Coins are the currency that you can use to buy new cars, upgrade your existing ones, or access new features. Levels are the tracks that you can race on, which have different themes, difficulties, and rewards. To earn more coins and unlock new levels, you need to complete various challenges and tasks that are given to you by the game. These may include winning races, beating your own or other players' records, performing stunts, collecting items, or completing missions. You can also earn more coins by watching ads or inviting your friends to play the game. To unlock new levels, you need to reach a certain amount of coins or points, or complete a certain number of races on the previous level.
-Conclusion
-Gadi Game is a term that refers to a variety of car racing games that are available for Android devices. These games are fun, exciting, and addictive, and they offer a great way to enjoy the thrill of driving and racing on your phone. In this article, we have introduced you to some of the best Gadi Games that you can play on your Android device, such as Gadi Wala Game - Kar Wala Game, Turbo Driving Racing 3D, and Gadi - Truck Racing Fun in Nepal. We have also shown you how to download and install them, as well as given you some tips and tricks on how to play them better. We hope that this article has helped you learn more about Gadi Game and inspired you to try them out.
-FAQs
-Here are some frequently asked questions and answers about Gadi Game:
--
-
- Q: What is Gadi Game? -
- A: Gadi Game is a term that refers to a variety of car racing games that are available for Android devices. -
- Q: How can I download and install Gadi Game? -
- A: You can download and install Gadi Game from Google Play Store or other sources. You need to make sure that your device meets the minimum requirements for the game and enable the "Unknown Sources" option if necessary. -
- Q: How can I choose the best car for my race? -
- A: You can choose the best car for your race by comparing their attributes, such as speed, acceleration, handling, braking, and durability. You can also test drive them before buying or using them. -
- Q: How can I master the controls and drifting techniques? -
- A: You can master the controls and drifting techniques by practicing with different options and cars. You can also tap on the brake button while turning your car to drift. -
- Q: How can I earn more coins and unlock new levels? -
- A: You can earn more coins and unlock new levels by completing various challenges and tasks that are given by the game. You can also watch ads or invite friends to play the game. -
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Mayor Match The Best Game for Puzzle and City-Building Lovers.md b/spaces/congsaPfin/Manga-OCR/logs/Mayor Match The Best Game for Puzzle and City-Building Lovers.md deleted file mode 100644 index 2769bf20c1b6bd2058b258027e193262f8f63cb5..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Mayor Match The Best Game for Puzzle and City-Building Lovers.md +++ /dev/null @@ -1,143 +0,0 @@ -
-Mayor Match: A Fun and Addictive Puzzle Game for Android and iOS
-Do you love puzzle games that challenge your brain and keep you entertained? Do you also enjoy city-building games that let you create your own dream town? If you answered yes to both questions, then you will love Mayor Match, a new game that cleverly combines match-3 and city-building gameplay. In this article, we will tell you everything you need to know about Mayor Match, including what it is, how to play it, how to download it, and what other players think about it.
-What is Mayor Match?
-Mayor Match is a game developed by Rollic Games, a Turkish mobile game studio that specializes in casual and hyper-casual games. Rollic Games has released many popular titles, such as Go Knots 3D, Tangle Master 3D, Hair Challenge, and more. Mayor Match is one of their latest games, and it has already gained over 100K downloads and 4.8 stars on Google Play.
-mayor match download
Download Zip ✒ https://urlca.com/2uOcir
-Mayor Match is a game that combines match-3 and city-building elements. As the name suggests, you play as the mayor of a town, and your goal is to help your townspeople by breaking obstacles and completing tasks. You do this by playing match-3 levels, where you have to swap and match colorful items to clear them from the board. Each level has a different objective, such as collecting a certain number of items, breaking ice blocks, or freeing animals. You also have to deal with various challenges, such as bombs, locks, or vines.
-As you complete match-3 levels, you earn energy and coins that you can use to construct and upgrade buildings in your town. You can build houses, farms, factories, shops, parks, and more. You can also unlock famous landmarks from around the world, such as the Eiffel Tower, the Statue of Liberty, or the Coliseum. You can customize your town according to your preferences and make it a paradise for your residents.
-The gameplay of Mayor Match
-The gameplay of Mayor Match is simple and intuitive. You just have to swipe your finger on the screen to swap adjacent items and make matches of three or more of the same kind. When you make a match, the items disappear from the board and new ones fall from above. You can also create special power-ups by making matches of four or more items. For example, if you match four items in a row or column, you create a rocket that can clear an entire row or column when activated. If you match five items in a T or L shape, you create a bomb that can explode and clear a large area around it. If you match five items in a row or column, you create a rainbow ball that can clear all items of one kind when swapped with another item.
-To complete a level, you have to fulfill the objective shown at the top of the screen within a limited number of moves or time. For example, you may have to collect 50 apples or break 20 ice blocks. If you run out of moves or time before reaching the objective, you lose a life and have to try again. You have five lives in total, and they regenerate over time or by watching ads. If you complete a level with moves or time left over, you get bonus points and coins.
-As you progress through the game, you will encounter different types of obstacles and items that make the game more challenging and fun. For example, you may have to deal with bombs that explode after a certain number of moves or locks that prevent you from swapping items or vines that grow and spread across the board. You may also find items that help you, such as hammers that can break any item or boosters that can give you extra moves or time.
-The features of Mayor Match
-Mayor Match is not just a simple match-3 game. It also has many features that make it more enjoyable and rewarding. Some of these features are:
-mayor match game download
-
-download mayor match for android
-mayor match app download
-how to download mayor match on pc
-mayor match free download
-download mayor match apk
-mayor match download for windows
-mayor match puzzle game download
-mayor match city builder download
-download mayor match mod apk
-mayor match rollic games download
-download mayor match for ios
-mayor match online download
-where to download mayor match
-mayor match latest version download
-download mayor match for mac
-mayor match offline download
-how to play mayor match without downloading
-mayor match hack download
-download mayor match for laptop
-mayor match cheats download
-download mayor match for chromebook
-mayor match update download
-how to install mayor match after downloading
-mayor match unlimited lives download
-download mayor match for kindle fire
-mayor match tips and tricks download
-how to uninstall mayor match after downloading
-mayor match no ads download
-download mayor match for tablet
-mayor match walkthrough download
-how to transfer mayor match data after downloading
-mayor match levels download
-download mayor match for desktop
-mayor match reviews download
-how to restore purchases on mayor match after downloading
-mayor match power ups download
-download mayor match for bluestacks
-mayor match support download
-how to update mayor match after downloading
-mayor match facebook login download
-download mayor match for nox player
-mayor match g5 entertainment download
-how to sync progress on mayor match after downloading
-mayor match boosters download
-download mayormatch.com/mayor-match-download/
-mayormatch.com/mayor-match-download/ - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download - Mayor Match Download --
-
- A city-building mode: As you play match-3 levels, you earn energy and coins that you can use to build and upgrade your town. You can choose from hundreds of buildings and decorations to create your own unique city. You can also unlock famous landmarks from around the world and place them in your town. You can see your town grow and change as you progress through the game. -
- A story mode: Mayor Match has a story mode that follows the adventures of you and your townspeople. You will meet different characters, such as your assistant, your rival, your friends, and your enemies. You will also face various challenges and quests, such as helping a farmer with his crops, solving a mystery, or fighting a villain. The story mode adds more depth and humor to the game. -
- A social mode: Mayor Match allows you to connect with other players from around the world. You can visit their towns, send and receive gifts, chat with them, and compete with them in leaderboards and tournaments. You can also join a club or create your own club and cooperate with other club members to complete club quests and earn club rewards. -
- A daily bonus: Mayor Match rewards you for playing every day. You can spin a wheel of fortune to win prizes, such as coins, energy, boosters, or power-ups. You can also collect daily chests that contain more rewards. The more consecutive days you play, the better the rewards. -
- A seasonal event: Mayor Match also has seasonal events that celebrate different occasions, such as Halloween, Christmas, Valentine's Day, or Easter. During these events, you can play special match-3 levels, collect themed items, and win exclusive rewards. -
The benefits of playing Mayor Match
-Playing Mayor Match is not only fun but also beneficial for your brain and mood. Some of the benefits of playing Mayor Match are:
--
-
- It improves your cognitive skills: Playing match-3 games requires you to use your logic, memory, attention, and problem-solving skills. You have to plan your moves ahead, remember the objectives and obstacles, focus on the board, and find the best solutions. These skills are essential for your mental health and performance. -
- It reduces your stress: Playing match-3 games can also help you relax and unwind after a long day. The colorful graphics, the soothing music, the satisfying sound effects, and the rewarding feedback can all calm your nerves and lift your spirits. You can also escape from reality for a while and immerse yourself in a fantasy world. -
- It boosts your creativity: Playing match-3 games can also stimulate your imagination and creativity. You can express yourself through designing your own town and choosing from various buildings and decorations. You can also explore different themes and styles, such as modern, classic, or exotic. -
How to download and play Mayor Match?
-If you are interested in playing Mayor Match, you will be glad to know that it is free to download and play on both Android and iOS devices. You will also be able to play it on PC or Mac with an emulator. Here are the steps to download and play Mayor Match:
-Downloading Mayor Match from Google Play or App Store
-If you have an Android device, you can download Mayor Match from Google Play by following these steps:
--
-
- Open Google Play on your device. -
- Search for "Mayor Match" in the search bar. -
- Tap on the game icon that appears in the results. -
- Tap on "Install" to start downloading the game. -
- Wait for the download to finish and then tap on "Open" to launch the game. -
If you have an iOS device, you can download Mayor Match from App Store by following these steps:
--
-
- Open App Store on your device. -
- Search for "Mayor Match" in the search bar. -
- Tap on the game icon that appears in the results. -
- Tap on "Get" to start downloading the game. -
- Wait for the download to finish and then tap on the game icon on your home screen to launch the game.
- Download and install an emulator of your choice on your PC or Mac. -
- Launch the emulator and sign in with your Google or Apple account. -
- Open the emulator's app store and search for "Mayor Match". -
- Download and install the game as you would on your mobile device. -
- Open the game and enjoy playing it on your PC or Mac. -
- Make matches at the bottom of the board: Making matches at the bottom of the board can cause a cascade effect, where new items fall from above and create more matches. This can help you clear the board faster and earn more points. -
- Use power-ups wisely: Power-ups are special items that can help you complete levels more easily. You can create power-ups by making matches of four or more items, or you can buy them with coins or watch ads to get them. However, power-ups are limited and valuable, so you should use them wisely. For example, you should save them for difficult levels or situations, or use them to create combos that can clear more items. -
- Complete tasks and quests: Tasks and quests are objectives that you can complete to earn extra rewards, such as coins, energy, boosters, or power-ups. You can find tasks and quests in the city-building mode, the story mode, or the club mode. You should try to complete as many tasks and quests as possible to get more resources and progress faster. -
- Watch ads for freebies: Watching ads is a way to get freebies in Mayor Match. You can watch ads to get more lives, energy, coins, boosters, or power-ups. You can also watch ads to double your rewards after completing a level or spinning the wheel of fortune. Watching ads is optional, but it can help you a lot if you don't mind spending some time. -
- Join a club or create your own club: Joining a club or creating your own club is a way to socialize and cooperate with other players in Mayor Match. You can chat with your club members, send and receive gifts, and complete club quests together. You can also compete with other clubs in tournaments and win club rewards. Joining a club or creating your own club can make the game more fun and rewarding. -
- How can I get more coins in Mayor Match?: You can get more coins by completing match-3 levels, spinning the wheel of fortune, opening daily chests, watching ads, completing tasks and quests, joining tournaments, or buying them with real money. -
- How can I get more energy in Mayor Match?: You can get more energy by waiting for it to regenerate over time, watching ads, opening daily chests, completing tasks and quests, joining clubs, or buying them with real money. -
- How can I get more boosters and power-ups in Mayor Match?: You can get more boosters and power-ups by creating them in match-3 levels, spinning the wheel of fortune, opening daily chests, watching ads, completing tasks and quests, joining tournaments, or buying them with real money. -
- How can I unlock more buildings and landmarks in Mayor Match?: You can unlock more buildings and landmarks by progressing through the game, completing match-3 levels, earning coins and energy, completing tasks and quests, joining clubs, or buying them with real money. -
- How can I contact the developers of Mayor Match?: You can contact the developers of Mayor Match by sending an email to support@rollicgames.com or by filling out a form on their website. You can also follow them on Facebook, Twitter, Instagram, or YouTube. -
- It helps you memorize hangul better. Writing by hand engages your brain more than typing or tracing. It activates your visual, motor, and cognitive skills, which help you remember the shapes and sounds of the letters more effectively. -
- It improves your reading and spelling skills. Writing by hand reinforces your knowledge of hangul rules and patterns, such as syllable structure, vowel harmony, consonant assimilation, and final consonant rules. These rules
are essential for reading and spelling Korean words correctly and fluently.
- - It enhances your vocabulary and grammar skills. Writing by hand exposes you to more Korean words and sentences, as you practice writing different topics and genres. It also helps you learn new vocabulary and grammar points, as you look up words or rules that you don't know or are unsure of. -
- It boosts your confidence and motivation. Writing by hand gives you a sense of achievement and satisfaction, as you see your progress and improvement over time. It also makes you more confident and motivated to communicate in Korean, as you express your thoughts and opinions in writing. -
- Writing the letters too big or too small. Some learners tend to write the letters too big or too small, which makes them hard to read or recognize. The ideal size of a hangul letter is about the same as a lowercase English letter. You should also leave enough space between the letters and the syllable blocks, as well as between the words and the sentences. -
- Writing the letters too fast or too slow. Some learners tend to write the letters too fast or too slow, which affects their accuracy and fluency. Writing too fast can cause you to make mistakes or skip some strokes. Writing too slow can make you lose focus or forget what you want to write. The ideal speed of writing is about the same as your speaking speed. You should also practice writing regularly and consistently, as well as review your writing for errors and corrections. -
- Writing the letters in the wrong order or direction. Some learners tend to write the letters in the wrong order or direction, which changes their meaning or sound. The correct order of writing a hangul letter is from left to right, top to bottom, outside to inside. You should also follow the stroke order and direction of each letter, as shown in the table below. -
- A comprehensive curriculum. The app covers all the 24 basic letters of hangul, as well as 140 syllables and 500 words. You can learn how to write each letter, syllable, and word with detailed instructions and examples. You can also choose from different levels of difficulty, from beginner to advanced. -
- A smart recognition system. The app recognizes your handwriting and gives you instant feedback. It checks your accuracy, speed, and stroke order and direction. It also shows you your mistakes and corrections. You can adjust the sensitivity and tolerance of the recognition system according to your preference. -
- A gamified learning experience. The app makes learning how to write Korean fun and engaging. You can earn stars, coins, badges, and trophies as you complete each lesson and challenge. You can also compete with other learners on the global leaderboard and see your ranking and progress. -
- A personalized learning plan . The app adapts to your learning style and pace. You can set your own goals and track your performance and improvement. You can also review your previous lessons and practice your weak areas. -
- Q: How long does it take to learn how to write Korean hangul? -
- A: It depends on your learning speed and frequency, but generally speaking, it can take anywhere from a few hours to a few days to master the 24 basic letters of hangul. However, learning how to write syllables and words may take longer, as you need to learn the rules and patterns of hangul. -
- Q: Do I need to learn how to write hanja (Chinese characters) as well? -
- A: No, you don't need to learn how to write hanja, unless you are interested in reading classical or academic texts that use them. Hanja are rarely used in modern Korean writing, except for some proper nouns, abbreviations, or technical terms. Most Koreans use hangul exclusively or mixed with some hanja. -
- Q: What are some other resources or tools that can help me learn how to write Korean? -
- A: Besides [Write It! Korean], there are many other resources or tools that can help you learn how to write Korean, such as textbooks, workbooks, websites, videos, podcasts, flashcards, games, etc. You can find some of them online or in bookstores. However, the best way to learn how to write Korean is to practice as much as possible. -
- Q: How can I improve my handwriting in Korean? -
- A: To improve your handwriting in Korean, you need to pay attention to the size, shape, order, direction, and spacing of the letters. You also need to practice regularly and consistently, as well as review your writing for errors and corrections. You can also compare your handwriting with native speakers' handwriting or fonts and try to imitate them. -
- Q: How can I use [Write It! Korean] effectively? -
- A: To use [Write It! Korean] effectively, you need to follow the instructions and examples given by the app. You also need to adjust the settings of the app according to your preference and level. You should also complete each lesson and challenge with accuracy and speed. You should also review your previous lessons and practice your weak areas. -
- Universal Driver
- Stock Firmware
- Privacy Policy
- Samsung Mobile
- Huawei Mobile
- Xiaomi Mobile
- It can download and record online videos and audio from any source, such as YouTube, Netflix, Hulu, Spotify, Pandora, etc. -
- It can automatically detect and name the video and audio files, and save them in various formats, such as MP4, AVI, WMV, MP3, WAV, etc. -
- It can convert the downloaded or recorded files to other formats, such as FLV, MOV, MKV, AAC, OGG, etc. -
- It can split and merge the video and audio files, and edit them with basic tools, such as trimming, cropping, adjusting volume, etc. -
- It can schedule recordings and downloads for later times, and resume interrupted downloads. -
- It has a user-friendly interface that is easy to navigate and customize. -
- Go to the magnet link provided by BTMET, which is a torrent search engine that hosts the file. -
- Use a torrent client, such as BitTorrent or uTorrent, to download the file from the magnet link. -
- Extract the file using a software like WinRAR or 7-Zip. -
- Run the setup file and follow the instructions to install the software. -
- Copy the crack file from the crack folder and paste it into the installation directory of the software. -
- Launch the software and enjoy! -
- The crack file may contain viruses or malware that can harm your computer or steal your personal information. -
- The software may not work properly or have bugs that can cause errors or crashes. -
- The software may violate the terms and conditions of the original WM Recorder software and the websites that host the online media. -
- The software may infringe the copyrights of the original WM Recorder software and the online media creators. -
- The software may expose you to legal risks or penalties if you are caught using it. -
- Airy YouTube Downloader: This is a paid software that allows you to download YouTube videos and audio in various formats and resolutions. You can also extract MP3 from YouTube videos and save them on your computer. Airy YouTube Downloader is easy to use and has a user-friendly interface. -
- Downie: This is another paid software that can download videos from over 1200 websites, including YouTube, Netflix, Hulu, Vimeo, etc. You can also convert the downloaded videos to other formats, such as MP4, MKV, AVI, etc. Downie has a drag-and-drop feature that makes it convenient to use. -
- streamWriter: This is a free and open source software that can record internet radio streams from various sources, such as Shoutcast, Icecast, etc. You can also edit the recorded files with basic tools, such as cutting, fading, normalizing, etc. streamWriter has a portable version that you can use from a USB stick or similar device. -
- HTTP Ripper: This is a free and open source software that can rip content out of the web, such as videos, audio, images, etc. You can also filter the content by type, size, name, etc. HTTP Ripper has a simple interface that lets you enter the URL of the web page and start ripping. -
- Wondershare Streaming Audio Recorder: This is a paid software that can record any sound that comes through your PC, whether it's played online or from your hard drive. You can also edit the recorded audio with tools like trimming, splitting, merging, etc. Wondershare Streaming Audio Recorder can also identify and tag the audio files with information like title, artist, album, genre, etc. -
- It can provide information and entertainment on various topics and interests, such as news, education, sports, music, movies, etc. -
- It can enhance social interaction and communication with people from different backgrounds and cultures, and foster a sense of community and belonging. -
- It can support learning and skill development, such as language, creativity, critical thinking, problem-solving, etc. -
- It can enable civic participation and social action, such as raising awareness, expressing opinions, advocating for causes, etc. -
- It can offer opportunities for personal and professional growth, such as networking, career development, self-expression, etc. -
- Download online videos and audio from any source and save them on your computer or external storage device. -
- Record online videos and audio from any source and capture them in high quality. -
- Convert online videos and audio to other formats that are compatible with your devices or preferences. -
- Edit online videos and audio with basic tools to customize them according to your needs. -
- Schedule online videos and audio downloads or recordings for later times when you are not online or busy. -
- WM Recorder V16.8.1 Final Crack - [SH] is easy to use and has a user-friendly interface that lets you access all the features with a few clicks. -
- WM Recorder V16.8.1 Final Crack - [SH] is fast and efficient and can download or record online videos and audio at up to 50x playback speed. -
- WM Recorder V16.8.1 Final Crack - [SH] is versatile and flexible and can handle any type of online video or audio format or source. -
- WM Recorder V16.8.1 Final Crack - [SH] is accurate and smart and can automatically detect and name the online video or audio files that you download or record. -
- WM Recorder V16.8.1 Final Crack - [SH] is free and unlimited and does not require any license or registration to use its full features. -
- The Vapors: A laid-back track that explores the theme of nostalgia and longing for an old flame. -
- Bed Peace: A duet with Childish Gambino that expresses the desire to stay in bed and escape from the troubles of the world. -
- Stay Ready (What a Life): A sensual song that features a rap verse from Kendrick Lamar and a switch-up in tempo and mood halfway through. -
- WTH: An acronym for "What the Hell", this song features Ab-Soul and reflects on the confusion and frustration of life. -
- The Worst: A dark and haunting ballad that showcases Jhené's vocal range and emotional intensity. -
- 3:16 AM: A minimalist and atmospheric song that captures the feeling of loneliness and insomnia. -
- Comfort Inn Ending (Freestyle): A raw and honest freestyle that reveals Jhené's personal struggles and heartbreak. -
- Jhené Aiko - Sail Out - EP Lyrics and Tracklist | Genius -
- Jhene Aiko - Sail Out : Jhene Aiko - Sail Out : Free Download, Borrow ... -
- Jhene Aiko - Sail Out (Chopped Not Slopped) Mixtape Hosted by DJ ... -
- Enjoying high-quality music that soothes your soul and uplifts your mood. -
- Discovering new sounds and genres that expand your musical horizons. -
- Supporting an independent and creative artist who deserves recognition and appreciation. -
- Learning from Jhené's experiences and insights that can inspire you and help you grow. -
- Having access to a mixtape that you can listen to anytime and anywhere, offline or online. -
- Bed Wars: A team-based PVP game where you have to protect your bed and destroy your enemies' beds. -
- Egg War: A similar game to Bed Wars but with eggs instead of beds. -
- Sky Royale: A battle royale game where you have to survive and eliminate other players in a shrinking map. -
- Party Street: A parkour game where you have to collect graffiti and spray it on the walls. -
- Rainbow Parkour: Another parkour game where you have to jump on colorful blocks. -
- Sky Block: A creative game where you have to build your own island in the sky. -
- Free City RP: A role-playing game where you can live as a citizen, a criminal, or a superhero in a city. -
- Build Battle: A competitive game where you have to build something based on a theme. -
- And many more. You can find the full list of mini-games on the official website of Blockman Go.
-
What are Blockman Go cheats?
-Blockman Go cheats are tools or methods that allow you to modify or manipulate the game in some way. For example, you can use cheats to get unlimited coins, diamonds, or cubes, which are the in-game currencies. You can also use cheats to get free items, skins, or pets. You can also use cheats to enable features such as speed hack, fly hack, invisibility, teleportation, aimbot, wallhack, and more.
-Some of the benefits of using cheats are:
-blockman go hile apk indir
-
-blockman go hile nasıl yapılır
-blockman go hileli mod indir
-blockman go hileli oyun indir
-blockman go hileli sürüm indir
-blockman go hileli versiyon indir
-blockman go hilesi indir android
-blockman go hilesi indir bedava
-blockman go hilesi indir link
-blockman go hilesi indir pc
-blockman go bed wars hile indir
-blockman go egg wars hile indir
-blockman go sky block hile indir
-blockman go sky wars hile indir
-blockman go survival games hile indir
-blockman go vip hile indir
-blockman go altın hile indir
-blockman go elmas hile indir
-blockman go kupon hile indir
-blockman go para hile indir
-garena blockman go hile indir
-garena blockman go hilesi nasıl yapılır
-garena blockman go party street hile indir
-garena blockman go the exorcists hile indir
-garena blockman go frontline hile indir
-garena blockman go free city rp hile indir
-garena blockman go vip subscription hack download
-garena blockman go gold hack download
-garena blockman go diamond hack download
-garena blockman go coupon hack download
-garena blockman go money hack download
-en iyi blockman go hilesi indirme sitesi
-en güncel blockman go hilesi indirmek için ne yapmalıyım
-en kolay blockman go hilesi nasıl kurulur ve kullanılır
-en güvenli blockman go hilesi nereden bulabilirim ve nasıl yükleyebilirim
-en yeni blockman go hilesi hangisi ve nereden alabilirim
-en eğlenceli blockman go oyun modları hangileri ve nasıl oynanır
-en popüler blockman go oyun yorumları nelerdir ve nasıl okuyabilirim
-en çok aranan blockman go oyun ipuçları nelerdir ve nasıl öğrenebilirim
-en çok beğenilen blockman go oyun videoları nelerdir ve nasıl izleyebilirim-
-
- Having more fun: You can enjoy the game without worrying about grinding, losing, or getting bored. -
- Winning more games: You can dominate your opponents and win more matches and rewards. -
- Unlocking more items: You can access all the items and features that the game has to offer without spending real money. -
- Exploring more possibilities: You can discover new ways to play and experiment with different settings and modes. -
How to download and install Blockman Go cheats?
-If you want to download and play Blockman Go with cheats, you need to follow these steps:
--
-
- Find a reliable source of cheats: There are many websites and forums that offer Blockman Go cheats, but not all of them are safe and trustworthy. Some of them may contain viruses, malware, or scams that can harm your device or steal your personal information. Therefore, you need to be careful and do some research before downloading any cheat. You can check the reviews, ratings, comments, and feedback from other users to see if the cheat is legit and working. -
- Download the cheat file: Once you find a reliable source of cheats, you need to download the cheat file to your device. The cheat file may be in different formats, such as APK, MOD, OBB, or ZIP. You need to make sure that the file is compatible with your device and your game version. -
- Install the cheat file: After downloading the cheat file, you need to install it on your device. Depending on the file format, you may need to enable unknown sources in your settings, extract the file, copy and paste the file, or follow some other instructions. You can usually find the installation guide on the website or forum where you downloaded the cheat file. -
- Launch the game with cheats: Once you install the cheat file successfully, you can launch the game with cheats enabled. You may need to grant some permissions or access some features in order to activate the cheats. You can usually find the activation guide on the website or forum where you downloaded the cheat file. -
- Enjoy the game with cheats: Now you can enjoy playing Blockman Go with cheats. You can customize your settings and preferences according to your needs and desires. You can also switch on and off the cheats as you wish. -
Blockman Go Hile Indir: Tips and Tricks to Become a Better Player with Cheats
-Now that you know how to download and play Blockman Go with cheats, you may wonder how to use them effectively and improve your skills in different game modes. Here are some tips and tricks that can help you become a better player with cheats:
-How to use cheats in PvP games?
-PvP games are competitive games where you have to fight against other players in teams or solo. Some of the PvP games in Blockman Go are Bed Wars, Egg Wars, Sky Royale, and others. Here are some tips on how to use cheats in PvP games:
--
-
- Use speed hack and fly hack: These cheats can help you move faster and fly over obstacles and enemies. You can use them to escape from danger, chase your opponents, or reach strategic locations. -
- Use invisibility and teleportation: These cheats can help you become invisible and teleport to any place on the map. You can use them to sneak up on your enemies, surprise them with attacks, or avoid detection. -
- Use aimbot and wallhack: These cheats can help you aim better and see through walls. You can use them to shoot your enemies with accuracy and precision, even if they are hiding or moving. -
- Use unlimited coins and diamonds: These cheats can help you get unlimited resources that you can use to buy items, weapons, armor, and upgrades. You can use them to equip yourself with the best gear and have an advantage over your enemies. -
How to use cheats in parkour games?
-Parkour games are skill-based games where you have to jump, run, and dodge obstacles and traps. Some of the parkour games in Blockman Go are Party Street, Rainbow Parkour, Jumping Holes, and others. Here are some tips on how to use cheats in parkour games:
--
-
- Use speed hack and fly hack: These cheats can help you move faster and fly over obstacles and gaps. You can use them to complete the courses faster and easier. -
- Use invisibility and teleportation: These cheats can help you become invisible and teleport to any place on the map. You can use them to skip difficult parts, avoid falling, or reach the finish line. -
- Use unlimited coins and diamonds: These cheats can help you get unlimited resources that you can use to buy items, skins, or pets. You can use them to customize your character and make it more attractive and unique. -
How to use cheats in creative games?
-Creative games are games where you can build, create, or role-play anything you want. Some of the creative games in Blockman Go are Sky Block, Free City RP, Build Battle, and others. Here are some tips on how to use cheats in creative games:
--
-
- Use speed hack and fly hack: These cheats can help you move faster and fly over the map. You can use them to explore more areas, find more resources, or build more structures. -
- Use invisibility and teleportation: These cheats can help you become invisible and teleport to any place on the map. You can use them to hide from other players, prank them, or join different scenarios. -
- Use unlimited coins and diamonds: These cheats can help you get unlimited resources that you can use to buy items, blocks, or tools. You can use them to create anything you want without any limitations. -
Blockman Go Hile Indir: Pros and Cons of Playing with Cheats
-Playing Blockman Go with cheats can be fun and exciting, but it also has some drawbacks and risks. Here are some of the pros and cons of playing with cheats:
-Pros of playing with cheats
--
-
- Having more fun: You can enjoy the game without worrying about grinding, losing, or getting bored. -
- Winning more games: You can dominate your opponents and win more matches and rewards. -
- Unlocking more items: You can access all the items and features that the game has to offer without spending real money. -
- Exploring more possibilities: You can discover new ways to play and experiment with different settings and modes. -
Cons of playing with cheats
--
-
- Risking your account: You may get banned or suspended by the game developers or moderators if they detect that you are using cheats. You may also lose your progress, achievements, or items if that happens. -
- Ruining the game balance: You may make the game unfair or unenjoyable for other players who are not using cheats. You may also encounter other cheaters who may ruin your game as well. -
- Losing the challenge: You may lose the sense of accomplishment or satisfaction that comes from playing the game legitimately. You may also lose the motivation or interest to improve your skills or learn new strategies. -
- Facing ethical issues: You may feel guilty or ashamed of using cheats or breaking the rules of the game. You may also face criticism or backlash from other players who may consider cheating as cheating or dishonest. -
In conclusion, playing Blockman Go with cheats can be a fun and exciting way to enjoy the game, but it also has some drawbacks and risks that you need to consider. Ultimately, it is up to you to decide whether you want to play with cheats or not. Just remember to be careful, respectful, and responsible when using cheats.
-Frequently Asked Questions (FAQs)
-Here are some of the most common questions that people ask about Blockman Go hile indir:
--
-
- Is Blockman Go hile indir safe? -
- Is Blockman Go hile indir legal? -
- Is Blockman Go hile indir free? -
- Is Blockman Go hile indir worth it? -
- How to play Blockman Go without cheats? -
- Download and install the official version of Blockman Go: You can download and install the official version of Blockman Go from the Google Play Store or the App Store. You need to make sure that your device and your game version are compatible and updated. -
- Create or log in to your account: You can create a new account or log in to your existing account in Blockman Go. You need to make sure that your account is secure and verified. -
- Select a mini-game and join a server: You can select any mini-game that you want to play and join a server that matches your region and preferences. You need to make sure that your internet connection is stable and fast. -
- Play the game legitimately and fairly: You can play the game legitimately and fairly without using any cheats or hacks. You need to follow the rules and the etiquette of the game and respect other players. -
Blockman Go hile indir is not completely safe, as there is always a risk of getting banned or suspended by the game developers or moderators if they detect that you are using cheats. You may also get viruses, malware, or scams from some cheat sources that can harm your device or steal your personal information. Therefore, you need to be careful and do some research before downloading any cheat.
-Blockman Go hile indir is not legal, as it violates the terms of service and the code of conduct of the game. Using cheats is considered as cheating or hacking, which is prohibited and punishable by the game developers or moderators. You may face legal actions or consequences if you are caught using cheats.
-Blockman Go hile indir is not always free, as some cheat sources may charge you money or require you to complete surveys, offers, or tasks in order to download or access the cheat. You may also need to spend real money to buy items, weapons, armor, or upgrades in the game if you use cheats that give you unlimited resources.
-Blockman Go hile indir is worth it if you want to have more fun, win more games, unlock more items, and explore more possibilities in the game. However, it is not worth it if you risk your account, ruin the game balance, lose the challenge, and face ethical issues when using cheats. Ultimately, it is up to you to decide whether you want to play with cheats or not.
-If you want to play Blockman Go without cheats, you need to follow these steps:
--
-
I hope this article has helped you learn more about Blockman Go hile indir and how to download and play Blockman Go with cheats. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading and have a great day!
197e85843d
-
-
\ No newline at end of file diff --git a/spaces/fatiXbelha/sd/Call of Duty Mobile APK Data Everything You Need to Know About the Latest Version.md b/spaces/fatiXbelha/sd/Call of Duty Mobile APK Data Everything You Need to Know About the Latest Version.md deleted file mode 100644 index 0400be7f6bb6c2404399be4f568dee4f3a1c60fa..0000000000000000000000000000000000000000 --- a/spaces/fatiXbelha/sd/Call of Duty Mobile APK Data Everything You Need to Know About the Latest Version.md +++ /dev/null @@ -1,124 +0,0 @@ -
-Call of Duty Mobile APK Data: How to Download and Play the Best FPS Game on Android
-If you are a fan of first-person shooter (FPS) games, you must have heard of Call of Duty, one of the most popular and successful franchises in the gaming industry. But did you know that you can also enjoy this amazing game on your Android device? Yes, you read that right. Call of Duty Mobile is a mobile version of the iconic game that brings you the same thrilling and immersive experience as the PC and console versions. In this article, we will tell you everything you need to know about Call of Duty Mobile APK data, how to download and install it, and how to play it like a pro.
-What is Call of Duty Mobile?
-A brief introduction to the game and its features
-Call of Duty Mobile is a free-to-play online multiplayer FPS game that was released in 2019 by Activision Publishing. It is based on the Call of Duty series, which includes titles such as Modern Warfare, Black Ops, and Warzone. The game features various modes, such as team deathmatch, domination, kill confirmed, search and destroy, free for all, hardpoint, capture the flag, and more. You can also play in a 100-player battle royale mode, where you have to survive against other players and a shrinking circle. You can customize your loadout with different weapons, attachments, perks, scorestreaks, operators, and skins. You can also unlock new content and rewards by completing missions, challenges, events, and seasons.
-call of duty mobile apk data
DOWNLOAD ★★★★★ https://urllie.com/2uNIKk
-The benefits of playing Call of Duty Mobile on Android
-Playing Call of Duty Mobile on Android has many advantages over playing it on other platforms. Here are some of them:
--
-
- You can play it anytime and anywhere. You don't need a PC or a console to enjoy this game. All you need is your Android device and an internet connection. You can play it on your couch, in your bed, on the bus, or even in the bathroom. -
- You can play it with your friends. You can invite your friends to join your squad or clan and communicate with them via voice or text chat. You can also challenge other players from around the world and show off your skills. -
- You can play it for free. Unlike some other FPS games that require you to pay for a subscription or buy expensive DLCs, Call of Duty Mobile is completely free to download and play. You can access all the modes, maps, weapons, and operators without spending a dime. The only things you can buy are cosmetic items that do not affect the gameplay. -
How to download Call of Duty Mobile APK data?
-The steps to download and install the game from Uptodown
-One way to download Call of Duty Mobile APK data is from Uptodown, a website that offers safe and verified APK files for Android apps and games. Here are the steps to follow:
--
-
- Go to https://call-of-duty-legends-of-war.en.uptodown.com/android on your browser. -
- Tap on the green Download button and wait for the APK file to be downloaded. -
- Once the download is complete, tap on the notification or go to your Downloads folder and tap on the APK file. -
- If you see a warning message that says "For your security, your phone is not allowed to install unknown apps from this source", tap on Settings and enable the option to allow installations from this source. -
- Tap on Install and wait for the installation to finish. -
- After the installation is done, tap on Open and launch the game. -
- The game will ask you to download additional data files. Tap on OK and wait for the download to complete. -
- Once the data files are downloaded, you can log in with your Activision account or create a new one. -
- Enjoy playing Call of Duty Mobile on your Android device. -
The steps to download and install the game from APKCombo
-Another way to download Call of Duty Mobile APK data is from APKCombo, another website that offers APK files for Android apps and games. Here are the steps to follow:
--
-
- Go to https://apkcombo.com/call-of-duty-mobile/com.activision.callofduty.shooter/ on your browser. -
- Scroll down and tap on the Download APK button under the latest version of the game. -
- Select a server location and wait for the APK file to be downloaded. -
- Follow the same steps as above to install the APK file on your device. -
- Launch the game and download the data files as instructed. -
- Log in or create an account and start playing Call of Duty Mobile on your Android device. -
The tips to optimize the game performance and reduce the app size
-Call of Duty Mobile is a high-quality game that requires a lot of storage space and processing power. If you want to optimize the game performance and reduce the app size, here are some tips you can try:
--
-
- Delete any unnecessary apps or files from your device to free up some space. -
- Clear the cache and data of Call of Duty Mobile from your device settings to remove any corrupted or outdated files. -
- Adjust the graphics settings of the game to match your device capabilities. You can lower the resolution, frame rate, anti-aliasing, depth of field, ragdoll, and other options to improve the game speed and stability. -
- Use a stable and fast internet connection to avoid lagging or disconnecting issues. -
- Close any background apps or processes that may interfere with the game performance. -
How to play Call of Duty Mobile on Android?
-The basic controls and settings of the game
-Call of Duty Mobile has a simple and intuitive control system that allows you to play with ease. You can use the virtual joystick on the left side of the screen to move your character, and swipe on the right side of the screen to aim and look around. You can also tap on various buttons on the screen to shoot, reload, crouch, jump, switch weapons, use items, and perform other actions. You can customize the layout and sensitivity of these controls from the settings menu. You can also choose between two shooting modes: simple mode, which automatically fires when you aim at an enemy, and advanced mode, which gives you more control over when and how you fire.
-The different game modes and maps available
-Call of Duty Mobile offers a variety of game modes and maps for you to enjoy. You can play in multiplayer mode, where you can join a team or play solo in different matches against other players. You can choose from several modes, such as team deathmatch, domination, kill confirmed, search and destroy, free for all, hardpoint, capture the flag, and more. You can also play in battle royale mode, where you have to survive against 99 other players in a large map that shrinks over time. You can choose from different classes, such as medic, scout, ninja, defender, mechanic, clown, trickster, airborne, hacker, poltergeist, trap master, smoke bomber, desparado, and infiltrator. Each class has its own unique abilities and perks that can help you in different situations. You can also play in zombies mode (currently unavailable), where you have to fight against hordes of undead creatures and bosses. You can choose from different maps, such as Nacht der Untoten, Shi No Numa, and Raid. Each map has its own challenges, secrets, and rewards. The game also features a variety of maps that are inspired by the Call of Duty series, such as Nuketown, Crash, Crossfire, Firing Range, Hijacked, Standoff, Summit, Killhouse, Rust, Shipment, Terminal, and more. Each map has its own layout, terrain, and environment that can affect your gameplay and strategy. You can also play in some exclusive maps that are designed for Call of Duty Mobile, such as Cage, Takeoff, Meltdown, Scrapyard, Tunisia, Saloon, Gulag, Highrise, and more. Each map has its own unique features and elements that make it fun and exciting.
-call of duty mobile apk data download
-
-call of duty mobile apk data obb
-call of duty mobile apk data offline
-call of duty mobile apk data highly compressed
-call of duty mobile apk data mod
-call of duty mobile apk data latest version
-call of duty mobile apk data uptodown
-call of duty mobile apk data android
-call of duty mobile apk data free
-call of duty mobile apk data file
-call of duty mobile apk data size
-call of duty mobile apk data update
-call of duty mobile apk data revdl
-call of duty mobile apk data hack
-call of duty mobile apk data mega
-call of duty mobile apk data no verification
-call of duty mobile apk data unlimited money
-call of duty mobile apk data zip
-call of duty mobile apk data direct link
-call of duty mobile apk data google drive
-call of duty mobile apk data requirements
-call of duty mobile apk data rexdl
-call of duty mobile apk data mediafire
-call of duty mobile apk data 2023
-call of duty mobile apk data 1.0.39
-call of duty mobile apk data legends of war
-call of duty mobile apk data full version
-call of duty mobile apk data original
-call of duty mobile apk data for pc
-call of duty mobile apk data error
-call of duty mobile apk data gameplay
-call of duty mobile apk data online
-call of duty mobile apk data new update
-call of duty mobile apk data 4g phones
-call of duty mobile apk data low mb
-call of duty mobile apk data all maps unlocked
-call of duty mobile apk data zombies mode
-call of duty mobile apk data multiplayer mode
-call of duty mobile apk data best graphics settings
-call of duty mobile apk data how to installThe best strategies and tips to win in multiplayer and battle royale
-Call of Duty Mobile is a competitive game that requires skill, strategy, and teamwork to win. Here are some of the best strategies and tips to help you improve your game and dominate the battlefield:
--
-
- Choose the right loadout for your playstyle and mode. You can customize your loadout with different weapons, attachments, perks, scorestreaks, operators, and skins. You can also create different loadouts for different situations and switch between them during the game. Experiment with different combinations and find what works best for you. -
- Use the cover and terrain to your advantage. You can use walls, buildings, vehicles, crates, trees, rocks, and other objects to hide from enemy fire and ambush them. You can also use the terrain to flank your enemies or escape from danger. Be aware of your surroundings and use them wisely. -
- Communicate and coordinate with your teammates. You can use voice or text chat to communicate with your teammates and share information, such as enemy locations, objectives, strategies, requests, and warnings. You can also use the ping system to mark enemies, items, locations, and directions. Working together with your teammates can increase your chances of winning. -
- Learn from your mistakes and improve your skills. You can watch the killcam or the replay to see how you died or how you performed in the game. You can also check your stats and achievements to see your strengths and weaknesses. You can learn from your mistakes and improve your skills by practicing more, watching tutorials or guides online , or asking for advice from other players. -
Conclusion
-A summary of the main points and a call to action
-Call of Duty Mobile is a fantastic FPS game that you can play on your Android device. It offers you a variety of modes, maps, weapons, operators, and features that make it one of the best games in the genre. You can download Call of Duty Mobile APK data from Uptodown or APKCombo websites and install it on your device easily. You can also optimize the game performance and reduce the app size by following some simple tips. You can also play the game like a pro by using some effective strategies and tips that we shared with you in this article.
-If you are ready to join the millions of players who are enjoying this game every day, then what are you waiting for? Download Call of Duty Mobile APK data now and start playing this amazing game on your Android device. You will not regret it!
-FAQs
-What are the minimum requirements for Call of Duty Mobile?
-The minimum requirements for Call of Duty Mobile are:
--
-
- Android version: 4.3 or higher -
- RAM: 2 GB or higher -
- CPU: Snapdragon 625 or equivalent -
- GPU: Adreno 506 or equivalent -
- Storage: 4 GB or higher -
How much space does Call of Duty Mobile take up?
-The initial download size of Call of Duty Mobile is about 2 GB. However, the game will download additional data files as you play it. The total size of the game may vary depending on your device and settings. The average size of the game is about 5 GB.
-Is Call of Duty Mobile free?
-Yes, Call of Duty Mobile is free to download and play. You do not need to pay anything to access all the modes , maps, weapons, and operators in the game. The only things you can buy are cosmetic items, such as skins, emotes, sprays, and crates. These items do not affect the gameplay and are optional to purchase. You can also earn some of these items for free by completing missions, challenges, events, and seasons.
-Can I play Call of Duty Mobile on PC?
-Yes, you can play Call of Duty Mobile on PC using an emulator. An emulator is a software that allows you to run Android apps and games on your PC. There are many emulators available online, such as BlueStacks, Gameloop, LDPlayer, NoxPlayer, and more. You can download any of these emulators and install Call of Duty Mobile on them. You can also use your keyboard and mouse to play the game on your PC.
-Why is Call of Duty Mobile one of the best FPS games on Android?
-Call of Duty Mobile is one of the best FPS games on Android because it offers you a high-quality and immersive gaming experience that is comparable to the PC and console versions. The game has stunning graphics, realistic sound effects, smooth gameplay, and diverse content. The game also has a large and active community of players who are passionate and friendly. The game is constantly updated with new features, modes, maps, weapons, operators, and events that keep it fresh and exciting. The game is also easy to play and fun to master.
401be4b1e0
-
-
\ No newline at end of file diff --git a/spaces/fcakyon/timesformer/README.md b/spaces/fcakyon/timesformer/README.md deleted file mode 100644 index b3f9fb2560c33fdd2ef99ae9ef958ad43e49d613..0000000000000000000000000000000000000000 --- a/spaces/fcakyon/timesformer/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Timesformer Video Classification -emoji: 🎥 -colorFrom: blue -colorTo: pink -sdk: gradio -sdk_version: 3.12.0 -app_file: app.py -pinned: false -tags: -- making-demos ---- \ No newline at end of file diff --git a/spaces/fengmuxi/ChatGpt-Web/app/api/common.ts b/spaces/fengmuxi/ChatGpt-Web/app/api/common.ts deleted file mode 100644 index 910ccf0e3d0becfe4987e70458a5845343a7a518..0000000000000000000000000000000000000000 --- a/spaces/fengmuxi/ChatGpt-Web/app/api/common.ts +++ /dev/null @@ -1,56 +0,0 @@ -import { NextRequest } from "next/server"; -import { getIP } from "./auth"; - -const OPENAI_URL = "api.openai.com"; -const DEFAULT_PROTOCOL = "https"; -const PROTOCOL = process.env.PROTOCOL ?? DEFAULT_PROTOCOL; -const BASE_URL = process.env.BASE_URL ?? OPENAI_URL; - -export async function requestOpenai(req: NextRequest) { - const authValue = req.headers.get("Authorization") ?? ""; - const openaiPath = `${req.nextUrl.pathname}${req.nextUrl.search}`.replaceAll( - "/api/openai/", - "", - ); - - let baseUrl = BASE_URL; - - if (!baseUrl.startsWith("http")) { - baseUrl = `${PROTOCOL}://${baseUrl}`; - } - - console.log("[Proxy] ", openaiPath); - console.log("[Base Url]", baseUrl); - - if (process.env.OPENAI_ORG_ID) { - console.log("[Org ID]", process.env.OPENAI_ORG_ID); - } - - if (!authValue || !authValue.startsWith("Bearer sk-")) { - console.error("[OpenAI Request] invalid api key provided", authValue); - } - - return fetch(`${baseUrl}/${openaiPath}`, { - headers: { - "Content-Type": "application/json", - Authorization: authValue, - ...(process.env.OPENAI_ORG_ID && { - "OpenAI-Organization": process.env.OPENAI_ORG_ID, - }), - }, - cache: "no-store", - method: req.method, - body: req.body, - }); -} - -export async function requestLemur(req: NextRequest) { - return fetch('http://lemurchat.anfans.cn/api/chat/conversation-trial', { - headers: { - "Content-Type": "application/json" - }, - cache: "no-store", - method: req.method, - body: req.body, - }); -} diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Airic Ubuntombi Mp3 Download Enjoy the Best of South African Music.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Airic Ubuntombi Mp3 Download Enjoy the Best of South African Music.md deleted file mode 100644 index c7c9675fb50ef74ff65bd93a8f01fded024f7bab..0000000000000000000000000000000000000000 --- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Airic Ubuntombi Mp3 Download Enjoy the Best of South African Music.md +++ /dev/null @@ -1,105 +0,0 @@ -
-Download Airic Ubuntombi: A Hit Song That Celebrates African Women
-If you are looking for a catchy and uplifting song that celebrates the beauty and strength of African women, you should download Airic Ubuntombi. This song is a fusion of traditional Gqom beats and modern vocals that will make you dance and sing along. In this article, we will tell you everything you need to know about Airic Ubuntombi, including its meaning, lyrics, artist, genre, popularity, awards, streaming platforms, and download links. We will also show you how to download Airic Ubuntombi in three easy steps.
-download airic ubuntombi
DOWNLOAD · https://gohhs.com/2uPsdm
-What is Airic Ubuntombi?
-Airic Ubuntombi is a hit song by South African record producer Airic, featuring Manqonqo and Nolly M. The song was released in 2019 under the label Ujuu Records. The song is part of the album Isgubh Sa Airic, Vol.1, which also includes other popular songs like Ngibambe, Inumber Yami, Uyajola, and Woza.
-The meaning and lyrics of Airic Ubuntombi
-The title of the song, Ubuntombi, means "a woman" in Zulu. The song is a tribute to African women who are proud of their culture and heritage. The song also criticizes men who neglect their wives and girlfriends and chase after other women. The chorus of the song goes like this:
--
-Woyisholo wena! Woyisholo wena! (You tell them! You tell them!)
-
-(Ukuthi why ubuntombi ungasenabo!) (That you don't have a woman!)
-Woyisholo wena! Woyisholo wena! (You tell them! You tell them!)
-(Ukuthi why ubuntombi ungasenabo!) (That you don't have a woman!)
-Woyisholo wena! Woyisholo wena! (You tell them! You tell them!)
-(Uyosholo wena!) (You are lying!)
-Woyisholo wena! Woyisholo wena! (You tell them! You tell them!)
-(Uyoyisholo wena!) (You will tell them!)The rest of the lyrics describe how the men have lost their cows (a symbol of wealth and marriage) because they have been unfaithful to their women. The song also praises the women who are loyal, respectful, and hardworking.
-The artist and producer of Airic Ubuntombi
-Airic is a talented producer who rose to fame after producing the 2018 hit song Eyadini by Manqonqo. He is also known for his collaborations with other artists like DJ Tira, Character, Madanon, Vukani, and ChilliB. He is the founder of Ujuu Records, a label that promotes Gqom music in South Africa.
-Manqonqo is a singer and songwriter who is best known for his songs Eyadini, Ngibambe, Utshwala Bami, and No Connections. He has a distinctive voice that blends well with G
The genre and style of Airic Ubuntombi
-Airic Ubuntombi is a Gqom song, which is a genre of electronic dance music that originated in Durban, South Africa. Gqom is characterized by heavy and dark beats, minimal vocals, and African percussion. The word Gqom comes from the Zulu word for "drum" or "hit". Gqom is popular among the youth and has influenced other genres like Amapiano, Afro House, and Kwaito.
-Airic Ubuntombi has a unique style that combines traditional Gqom elements with modern influences. The song has a catchy hook, a fast tempo, and a danceable rhythm. The song also uses vocal samples, synthesizers, and sound effects to create a dynamic and energetic sound. The song is suitable for clubs, parties, and festivals.
-Why should you download Airic Ubuntombi?
-There are many reasons why you should download Airic Ubuntombi. Here are some of them:
-The popularity and reviews of Airic Ubuntombi
-Airic Ubuntombi is one of the most popular songs in South Africa and beyond. The song has over 1 million views on YouTube, over 500 thousand streams on Spotify, and over 100 thousand downloads on Fakaza. The song has also been featured on various radio stations, TV shows, and playlists.
-download airic ubuntombi mp3
-
-download airic ubuntombi music video
-download airic ubuntombi feat manqonqo and nolly m
-download airic ubuntombi official audio
-download airic ubuntombi isgubh sa airic vol 1
-download airic ubuntombi lyrics
-download airic ubuntombi song
-download airic ubuntombi remix
-download airic ubuntombi fakaza
-download airic ubuntombi spotify
-download airic ubuntombi itunes
-download airic ubuntombi google play
-download airic ubuntombi youtube
-download airic ubuntombi shazam
-download airic ubuntombi ujuu records
-download airic ubuntombi eyadini hit producer
-download airic ubuntombi yango bando music video
-download airic ubuntombi paypal donation link
-download airic ubuntombi mtanomuntu
-download airic ubuntombi ngibambe
-download airic ubuntombi inumber yami
-download airic ubuntombi utshwala bami
-download airic ubuntombi uyajola
-download airic ubuntombi iyangdonsa
-download airic ubuntombi woza
-download airic ubuntombi amazwe
-download airic ubuntombi ngikuthandile
-download airic ubuntombi dj tira collaboration
-download airic ubuntombi dason feature
-download airic ubuntombi character feature
-download airic ubuntombi madanon feature
-download airic ubuntombi vukani feature
-download airic ubuntombi chillib feature
-download airic ubuntombi tilongo feature
-download airic ubuntombi sbopho feature
-download airic ubuntombi rato m feature
-download airic ubuntombi preedy musiq ulwandle cover
-download airic ubuntombi king monada no connections cover
-download airic ubuntombi vhudie tshinakaho cover
-download airic ubuntombi nomfundo sthandwa sam cover
-download airic ubuntombi phaahle joeharris and friends coverThe song has received positive reviews from critics and fans alike. The song has been praised for its catchy chorus, its powerful message, its fusion of genres, and its production quality. Some of the comments on YouTube include:
--
-"This song is fire ??? I love it so much"
-
-"This is the best Gqom song ever"
-"This song makes me proud to be African"
-"This song is a masterpiece"
-"This song deserves more recognition"The awards and nominations of Airic Ubuntombi
-Airic Ubuntombi has also been recognized by various awards and nominations. The song was nominated for the Best Gqom Song at the 2020 South African Music Awards (SAMA). The song also won the Best Collaboration at the 2020 Ujuu Music Awards (UMA). The song has also been nominated for other awards such as the Best Dance Song at the 2020 African Muzik Magazine Awards (AFRIMMA) and the Song of the Year at the 2020 Metro FM Music Awards (MMA).
-The streaming platforms and download links of Airic Ubuntombi
-Airic Ubuntombi is available on various streaming platforms and download links. You can listen to the song on YouTube, Spotify, Apple Music, Deezer, SoundCloud, and Audiomack. You can also download the song on Fakaza, Zamusic, Hiphopza, SaHipHop, and Mp3Bold.
-How to download Airic Ubuntombi?
-If you want to download Airic Ubuntombi, you can follow these three simple steps:
-Step 1: Choose your preferred streaming platform or download link
-The first step is to choose your preferred streaming platform or download link from the list above. You can choose based on your device, your subscription, your data plan, or your preference. For example, if you have an iPhone and an Apple Music subscription, you can choose Apple Music. If you have an Android phone and a limited data plan, you can choose Fakaza. If you have a laptop and a good internet connection, you can choose YouTube.
-Step 2: Click on the play or download button
-The second step is to click on the play or download button on the streaming platform or download link that you have chosen. For example, if you have chosen YouTube, you can click on the play button to listen to the song online or click on the download button to save the song offline. If you have chosen Fakaza, you can click on the download button to get the mp3 file of the song.
-Step 3: Enjoy the song and share it with your friends
-The third step is to enjoy the song and share it with
The third step is to enjoy the song and share it with your friends. You can listen to the song on your headphones, speakers, or car stereo. You can also sing along to the lyrics, dance to the beats, or learn more about the culture and history behind the song. You can also share the song with your friends on social media, messaging apps, or email. You can also recommend the song to other people who might like it.
-Conclusion
-Airic Ubuntombi is a hit song that celebrates African women and their culture. The song has a catchy chorus, a powerful message, a fusion of genres, and a high production quality. The song is also popular, acclaimed, and available on various platforms. If you want to download Airic Ubuntombi, you can follow the three easy steps that we have explained in this article. We hope that you enjoy the song and share it with your friends.
-FAQs
-Here are some frequently asked questions about Airic Ubuntombi:
-What does Airic mean?
-Airic is the stage name of Sibusiso Mkhize, a South African record producer and DJ. He chose the name Airic because it sounds like "Eric", which is his father's name.
-Who is Nolly M?
-Nolly M is a South African singer and songwriter who is featured on Airic Ubuntombi. She is also known for her songs Ndiyabulela, Angisho Guys, and Amantombazane.
-What is the difference between Gqom and Amapiano?
-Gqom and Amapiano are two genres of electronic dance music that originated in South Africa. Gqom is characterized by heavy and dark beats, minimal vocals, and African percussion. Amapiano is characterized by smooth and melodic beats, soulful vocals, and piano sounds.
-Where can I find more songs like Airic Ubuntombi?
-If you like Airic Ubuntombi, you might also like other songs by Airic, Manqonqo, Nolly M, or other Gqom artists. You can find more songs like Airic Ubuntombi on YouTube, Spotify, Apple Music, Deezer, SoundCloud, Audiomack, Fakaza, Zamusic, Hiphopza, SaHipHop, or Mp3Bold.
-How can I support Airic and his music?
-If you want to support Airic and his music, you can do so by streaming or downloading his songs, buying his albums or merchandise, following him on social media, subscribing to his YouTube channel, or attending his live shows.
197e85843d
-
-
\ No newline at end of file diff --git a/spaces/fffiloni/Image-to-MusicGen/tests/quantization/test_vq.py b/spaces/fffiloni/Image-to-MusicGen/tests/quantization/test_vq.py deleted file mode 100644 index c215099fedacae35c6798fdd9b8420a447aa16bb..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/Image-to-MusicGen/tests/quantization/test_vq.py +++ /dev/null @@ -1,18 +0,0 @@ -# Copyright (c) Meta Platforms, Inc. and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. - -import torch - -from audiocraft.quantization.vq import ResidualVectorQuantizer - - -class TestResidualVectorQuantizer: - - def test_rvq(self): - x = torch.randn(1, 16, 2048) - vq = ResidualVectorQuantizer(n_q=8, dimension=16, bins=8) - res = vq(x, 1.) - assert res.x.shape == torch.Size([1, 16, 2048]) diff --git a/spaces/fffiloni/audioldm-text-to-audio-generation-copy/audioldm/utils.py b/spaces/fffiloni/audioldm-text-to-audio-generation-copy/audioldm/utils.py deleted file mode 100644 index 0468a2973b705af739483c196a91185500d6a8da..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/audioldm-text-to-audio-generation-copy/audioldm/utils.py +++ /dev/null @@ -1,174 +0,0 @@ -import importlib - -from inspect import isfunction - -import os -import soundfile as sf - -def seed_everything(seed): - import random, os - import numpy as np - import torch - - random.seed(seed) - os.environ['PYTHONHASHSEED'] = str(seed) - np.random.seed(seed) - torch.manual_seed(seed) - torch.cuda.manual_seed(seed) - torch.backends.cudnn.deterministic = True - torch.backends.cudnn.benchmark = True - -def save_wave(waveform, savepath, name="outwav"): - if type(name) is not list: - name = [name] * waveform.shape[0] - - for i in range(waveform.shape[0]): - path = os.path.join( - savepath, - "%s_%s.wav" - % ( - os.path.basename(name[i]) - if (not ".wav" in name[i]) - else os.path.basename(name[i]).split(".")[0], - i, - ), - ) - sf.write(path, waveform[i, 0], samplerate=16000) - -def exists(x): - return x is not None - - -def default(val, d): - if exists(val): - return val - return d() if isfunction(d) else d - - -def count_params(model, verbose=False): - total_params = sum(p.numel() for p in model.parameters()) - if verbose: - print(f"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.") - return total_params - - -def get_obj_from_str(string, reload=False): - module, cls = string.rsplit(".", 1) - if reload: - module_imp = importlib.import_module(module) - importlib.reload(module_imp) - return getattr(importlib.import_module(module, package=None), cls) - - -def instantiate_from_config(config): - if not "target" in config: - if config == "__is_first_stage__": - return None - elif config == "__is_unconditional__": - return None - raise KeyError("Expected key `target` to instantiate.") - return get_obj_from_str(config["target"])(**config.get("params", dict())) - -def default_audioldm_config(model_name="audioldm-s-full"): - basic_config = { - "wave_file_save_path": "./output", - "id": { - "version": "v1", - "name": "default", - "root": "/mnt/fast/nobackup/users/hl01486/projects/general_audio_generation/AudioLDM-python/config/default/latent_diffusion.yaml", - }, - "preprocessing": { - "audio": {"sampling_rate": 16000, "max_wav_value": 32768}, - "stft": {"filter_length": 1024, "hop_length": 160, "win_length": 1024}, - "mel": { - "n_mel_channels": 64, - "mel_fmin": 0, - "mel_fmax": 8000, - "freqm": 0, - "timem": 0, - "blur": False, - "mean": -4.63, - "std": 2.74, - "target_length": 1024, - }, - }, - "model": { - "device": "cuda", - "target": "audioldm.pipline.LatentDiffusion", - "params": { - "base_learning_rate": 5e-06, - "linear_start": 0.0015, - "linear_end": 0.0195, - "num_timesteps_cond": 1, - "log_every_t": 200, - "timesteps": 1000, - "first_stage_key": "fbank", - "cond_stage_key": "waveform", - "latent_t_size": 256, - "latent_f_size": 16, - "channels": 8, - "cond_stage_trainable": True, - "conditioning_key": "film", - "monitor": "val/loss_simple_ema", - "scale_by_std": True, - "unet_config": { - "target": "audioldm.latent_diffusion.openaimodel.UNetModel", - "params": { - "image_size": 64, - "extra_film_condition_dim": 512, - "extra_film_use_concat": True, - "in_channels": 8, - "out_channels": 8, - "model_channels": 128, - "attention_resolutions": [8, 4, 2], - "num_res_blocks": 2, - "channel_mult": [1, 2, 3, 5], - "num_head_channels": 32, - "use_spatial_transformer": True, - }, - }, - "first_stage_config": { - "base_learning_rate": 4.5e-05, - "target": "audioldm.variational_autoencoder.autoencoder.AutoencoderKL", - "params": { - "monitor": "val/rec_loss", - "image_key": "fbank", - "subband": 1, - "embed_dim": 8, - "time_shuffle": 1, - "ddconfig": { - "double_z": True, - "z_channels": 8, - "resolution": 256, - "downsample_time": False, - "in_channels": 1, - "out_ch": 1, - "ch": 128, - "ch_mult": [1, 2, 4], - "num_res_blocks": 2, - "attn_resolutions": [], - "dropout": 0.0, - }, - }, - }, - "cond_stage_config": { - "target": "audioldm.clap.encoders.CLAPAudioEmbeddingClassifierFreev2", - "params": { - "key": "waveform", - "sampling_rate": 16000, - "embed_mode": "audio", - "unconditional_prob": 0.1, - }, - }, - }, - }, - } - - if("-l-" in model_name): - basic_config["model"]["params"]["unet_config"]["params"]["model_channels"] = 256 - basic_config["model"]["params"]["unet_config"]["params"]["num_head_channels"] = 64 - elif("-m-" in model_name): - basic_config["model"]["params"]["unet_config"]["params"]["model_channels"] = 192 - basic_config["model"]["params"]["cond_stage_config"]["params"]["amodel"] = "HTSAT-base" # This model use a larger HTAST - - return basic_config \ No newline at end of file diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/dns.d.ts b/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/dns.d.ts deleted file mode 100644 index 305367b81d17a30d1a914cda62fdaf25acf3567e..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/@types/node/dns.d.ts +++ /dev/null @@ -1,659 +0,0 @@ -/** - * The `dns` module enables name resolution. For example, use it to look up IP - * addresses of host names. - * - * Although named for the [Domain Name System (DNS)](https://en.wikipedia.org/wiki/Domain_Name_System), it does not always use the - * DNS protocol for lookups. {@link lookup} uses the operating system - * facilities to perform name resolution. It may not need to perform any network - * communication. To perform name resolution the way other applications on the same - * system do, use {@link lookup}. - * - * ```js - * const dns = require('dns'); - * - * dns.lookup('example.org', (err, address, family) => { - * console.log('address: %j family: IPv%s', address, family); - * }); - * // address: "93.184.216.34" family: IPv4 - * ``` - * - * All other functions in the `dns` module connect to an actual DNS server to - * perform name resolution. They will always use the network to perform DNS - * queries. These functions do not use the same set of configuration files used by {@link lookup} (e.g. `/etc/hosts`). Use these functions to always perform - * DNS queries, bypassing other name-resolution facilities. - * - * ```js - * const dns = require('dns'); - * - * dns.resolve4('archive.org', (err, addresses) => { - * if (err) throw err; - * - * console.log(`addresses: ${JSON.stringify(addresses)}`); - * - * addresses.forEach((a) => { - * dns.reverse(a, (err, hostnames) => { - * if (err) { - * throw err; - * } - * console.log(`reverse for ${a}: ${JSON.stringify(hostnames)}`); - * }); - * }); - * }); - * ``` - * - * See the `Implementation considerations section` for more information. - * @see [source](https://github.com/nodejs/node/blob/v18.0.0/lib/dns.js) - */ -declare module 'dns' { - import * as dnsPromises from 'node:dns/promises'; - // Supported getaddrinfo flags. - export const ADDRCONFIG: number; - export const V4MAPPED: number; - /** - * If `dns.V4MAPPED` is specified, return resolved IPv6 addresses as - * well as IPv4 mapped IPv6 addresses. - */ - export const ALL: number; - export interface LookupOptions { - family?: number | undefined; - hints?: number | undefined; - all?: boolean | undefined; - /** - * @default true - */ - verbatim?: boolean | undefined; - } - export interface LookupOneOptions extends LookupOptions { - all?: false | undefined; - } - export interface LookupAllOptions extends LookupOptions { - all: true; - } - export interface LookupAddress { - address: string; - family: number; - } - /** - * Resolves a host name (e.g. `'nodejs.org'`) into the first found A (IPv4) or - * AAAA (IPv6) record. All `option` properties are optional. If `options` is an - * integer, then it must be `4` or `6` – if `options` is not provided, then IPv4 - * and IPv6 addresses are both returned if found. - * - * With the `all` option set to `true`, the arguments for `callback` change to`(err, addresses)`, with `addresses` being an array of objects with the - * properties `address` and `family`. - * - * On error, `err` is an `Error` object, where `err.code` is the error code. - * Keep in mind that `err.code` will be set to `'ENOTFOUND'` not only when - * the host name does not exist but also when the lookup fails in other ways - * such as no available file descriptors. - * - * `dns.lookup()` does not necessarily have anything to do with the DNS protocol. - * The implementation uses an operating system facility that can associate names - * with addresses, and vice versa. This implementation can have subtle but - * important consequences on the behavior of any Node.js program. Please take some - * time to consult the `Implementation considerations section` before using`dns.lookup()`. - * - * Example usage: - * - * ```js - * const dns = require('dns'); - * const options = { - * family: 6, - * hints: dns.ADDRCONFIG | dns.V4MAPPED, - * }; - * dns.lookup('example.com', options, (err, address, family) => - * console.log('address: %j family: IPv%s', address, family)); - * // address: "2606:2800:220:1:248:1893:25c8:1946" family: IPv6 - * - * // When options.all is true, the result will be an Array. - * options.all = true; - * dns.lookup('example.com', options, (err, addresses) => - * console.log('addresses: %j', addresses)); - * // addresses: [{"address":"2606:2800:220:1:248:1893:25c8:1946","family":6}] - * ``` - * - * If this method is invoked as its `util.promisify()` ed version, and `all`is not set to `true`, it returns a `Promise` for an `Object` with `address` and`family` properties. - * @since v0.1.90 - */ - export function lookup(hostname: string, family: number, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void; - export function lookup(hostname: string, options: LookupOneOptions, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void; - export function lookup(hostname: string, options: LookupAllOptions, callback: (err: NodeJS.ErrnoException | null, addresses: LookupAddress[]) => void): void; - export function lookup(hostname: string, options: LookupOptions, callback: (err: NodeJS.ErrnoException | null, address: string | LookupAddress[], family: number) => void): void; - export function lookup(hostname: string, callback: (err: NodeJS.ErrnoException | null, address: string, family: number) => void): void; - export namespace lookup { - function __promisify__(hostname: string, options: LookupAllOptions): Promise; - function __promisify__(hostname: string, options: LookupOptions): Promise ; - } - /** - * Resolves the given `address` and `port` into a host name and service using - * the operating system's underlying `getnameinfo` implementation. - * - * If `address` is not a valid IP address, a `TypeError` will be thrown. - * The `port` will be coerced to a number. If it is not a legal port, a `TypeError`will be thrown. - * - * On an error, `err` is an `Error` object, where `err.code` is the error code. - * - * ```js - * const dns = require('dns'); - * dns.lookupService('127.0.0.1', 22, (err, hostname, service) => { - * console.log(hostname, service); - * // Prints: localhost ssh - * }); - * ``` - * - * If this method is invoked as its `util.promisify()` ed version, it returns a`Promise` for an `Object` with `hostname` and `service` properties. - * @since v0.11.14 - */ - export function lookupService(address: string, port: number, callback: (err: NodeJS.ErrnoException | null, hostname: string, service: string) => void): void; - export namespace lookupService { - function __promisify__( - address: string, - port: number - ): Promise<{ - hostname: string; - service: string; - }>; - } - export interface ResolveOptions { - ttl: boolean; - } - export interface ResolveWithTtlOptions extends ResolveOptions { - ttl: true; - } - export interface RecordWithTtl { - address: string; - ttl: number; - } - /** @deprecated Use `AnyARecord` or `AnyAaaaRecord` instead. */ - export type AnyRecordWithTtl = AnyARecord | AnyAaaaRecord; - export interface AnyARecord extends RecordWithTtl { - type: 'A'; - } - export interface AnyAaaaRecord extends RecordWithTtl { - type: 'AAAA'; - } - export interface CaaRecord { - critial: number; - issue?: string | undefined; - issuewild?: string | undefined; - iodef?: string | undefined; - contactemail?: string | undefined; - contactphone?: string | undefined; - } - export interface MxRecord { - priority: number; - exchange: string; - } - export interface AnyMxRecord extends MxRecord { - type: 'MX'; - } - export interface NaptrRecord { - flags: string; - service: string; - regexp: string; - replacement: string; - order: number; - preference: number; - } - export interface AnyNaptrRecord extends NaptrRecord { - type: 'NAPTR'; - } - export interface SoaRecord { - nsname: string; - hostmaster: string; - serial: number; - refresh: number; - retry: number; - expire: number; - minttl: number; - } - export interface AnySoaRecord extends SoaRecord { - type: 'SOA'; - } - export interface SrvRecord { - priority: number; - weight: number; - port: number; - name: string; - } - export interface AnySrvRecord extends SrvRecord { - type: 'SRV'; - } - export interface AnyTxtRecord { - type: 'TXT'; - entries: string[]; - } - export interface AnyNsRecord { - type: 'NS'; - value: string; - } - export interface AnyPtrRecord { - type: 'PTR'; - value: string; - } - export interface AnyCnameRecord { - type: 'CNAME'; - value: string; - } - export type AnyRecord = AnyARecord | AnyAaaaRecord | AnyCnameRecord | AnyMxRecord | AnyNaptrRecord | AnyNsRecord | AnyPtrRecord | AnySoaRecord | AnySrvRecord | AnyTxtRecord; - /** - * Uses the DNS protocol to resolve a host name (e.g. `'nodejs.org'`) into an array - * of the resource records. The `callback` function has arguments`(err, records)`. When successful, `records` will be an array of resource - * records. The type and structure of individual results varies based on `rrtype`: - * - * - * - * On error, `err` is an `Error` object, where `err.code` is one of the `DNS error codes`. - * @since v0.1.27 - * @param hostname Host name to resolve. - * @param [rrtype='A'] Resource record type. - */ - export function resolve(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'A', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'AAAA', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'ANY', callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void; - export function resolve(hostname: string, rrtype: 'CNAME', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'MX', callback: (err: NodeJS.ErrnoException | null, addresses: MxRecord[]) => void): void; - export function resolve(hostname: string, rrtype: 'NAPTR', callback: (err: NodeJS.ErrnoException | null, addresses: NaptrRecord[]) => void): void; - export function resolve(hostname: string, rrtype: 'NS', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'PTR', callback: (err: NodeJS.ErrnoException | null, addresses: string[]) => void): void; - export function resolve(hostname: string, rrtype: 'SOA', callback: (err: NodeJS.ErrnoException | null, addresses: SoaRecord) => void): void; - export function resolve(hostname: string, rrtype: 'SRV', callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void; - export function resolve(hostname: string, rrtype: 'TXT', callback: (err: NodeJS.ErrnoException | null, addresses: string[][]) => void): void; - export function resolve( - hostname: string, - rrtype: string, - callback: (err: NodeJS.ErrnoException | null, addresses: string[] | MxRecord[] | NaptrRecord[] | SoaRecord | SrvRecord[] | string[][] | AnyRecord[]) => void - ): void; - export namespace resolve { - function __promisify__(hostname: string, rrtype?: 'A' | 'AAAA' | 'CNAME' | 'NS' | 'PTR'): Promise ; - function __promisify__(hostname: string, rrtype: 'SRV'): Promise ; - } - /** - * Uses the DNS protocol to resolve service records (`SRV` records) for the`hostname`. The `addresses` argument passed to the `callback` function will - * be an array of objects with the following properties: - * - * * `priority` - * * `weight` - * * `port` - * * `name` - * - * ```js - * { - * priority: 10, - * weight: 5, - * port: 21223, - * name: 'service.example.com' - * } - * ``` - * @since v0.1.27 - */ - export function resolveSrv(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: SrvRecord[]) => void): void; - export namespace resolveSrv { - function __promisify__(hostname: string): Promise - * - * Here is an example of the `ret` object passed to the callback: - * - * ```js - * [ { type: 'A', address: '127.0.0.1', ttl: 299 }, - * { type: 'CNAME', value: 'example.com' }, - * { type: 'MX', exchange: 'alt4.aspmx.l.example.com', priority: 50 }, - * { type: 'NS', value: 'ns1.example.com' }, - * { type: 'TXT', entries: [ 'v=spf1 include:_spf.example.com ~all' ] }, - * { type: 'SOA', - * nsname: 'ns1.example.com', - * hostmaster: 'admin.example.com', - * serial: 156696742, - * refresh: 900, - * retry: 900, - * expire: 1800, - * minttl: 60 } ] - * ``` - * - * DNS server operators may choose not to respond to `ANY`queries. It may be better to call individual methods like {@link resolve4},{@link resolveMx}, and so on. For more details, see [RFC - * 8482](https://tools.ietf.org/html/rfc8482). - */ - export function resolveAny(hostname: string, callback: (err: NodeJS.ErrnoException | null, addresses: AnyRecord[]) => void): void; - export namespace resolveAny { - function __promisify__(hostname: string): Promise ): void; - /** - * Returns an array of IP address strings, formatted according to [RFC 5952](https://tools.ietf.org/html/rfc5952#section-6), - * that are currently configured for DNS resolution. A string will include a port - * section if a custom port is used. - * - * ```js - * [ - * '4.4.4.4', - * '2001:4860:4860::8888', - * '4.4.4.4:1053', - * '[2001:4860:4860::8888]:1053', - * ] - * ``` - * @since v0.11.3 - */ - export function getServers(): string[]; - /** - * Set the default value of `verbatim` in {@link lookup} and `dnsPromises.lookup()`. The value could be: - * - * * `ipv4first`: sets default `verbatim` `false`. - * * `verbatim`: sets default `verbatim` `true`. - * - * The default is `ipv4first` and {@link setDefaultResultOrder} have higher - * priority than `--dns-result-order`. When using `worker threads`,{@link setDefaultResultOrder} from the main thread won't affect the default - * dns orders in workers. - * @since v16.4.0, v14.18.0 - * @param order must be `'ipv4first'` or `'verbatim'`. - */ - export function setDefaultResultOrder(order: 'ipv4first' | 'verbatim'): void; - // Error codes - export const NODATA: string; - export const FORMERR: string; - export const SERVFAIL: string; - export const NOTFOUND: string; - export const NOTIMP: string; - export const REFUSED: string; - export const BADQUERY: string; - export const BADNAME: string; - export const BADFAMILY: string; - export const BADRESP: string; - export const CONNREFUSED: string; - export const TIMEOUT: string; - export const EOF: string; - export const FILE: string; - export const NOMEM: string; - export const DESTRUCTION: string; - export const BADSTR: string; - export const BADFLAGS: string; - export const NONAME: string; - export const BADHINTS: string; - export const NOTINITIALIZED: string; - export const LOADIPHLPAPI: string; - export const ADDRGETNETWORKPARAMS: string; - export const CANCELLED: string; - export interface ResolverOptions { - timeout?: number | undefined; - /** - * @default 4 - */ - tries?: number; - } - /** - * An independent resolver for DNS requests. - * - * Creating a new resolver uses the default server settings. Setting - * the servers used for a resolver using `resolver.setServers()` does not affect - * other resolvers: - * - * ```js - * const { Resolver } = require('dns'); - * const resolver = new Resolver(); - * resolver.setServers(['4.4.4.4']); - * - * // This request will use the server at 4.4.4.4, independent of global settings. - * resolver.resolve4('example.org', (err, addresses) => { - * // ... - * }); - * ``` - * - * The following methods from the `dns` module are available: - * - * * `resolver.getServers()` - * * `resolver.resolve()` - * * `resolver.resolve4()` - * * `resolver.resolve6()` - * * `resolver.resolveAny()` - * * `resolver.resolveCaa()` - * * `resolver.resolveCname()` - * * `resolver.resolveMx()` - * * `resolver.resolveNaptr()` - * * `resolver.resolveNs()` - * * `resolver.resolvePtr()` - * * `resolver.resolveSoa()` - * * `resolver.resolveSrv()` - * * `resolver.resolveTxt()` - * * `resolver.reverse()` - * * `resolver.setServers()` - * @since v8.3.0 - */ - export class Resolver { - constructor(options?: ResolverOptions); - /** - * Cancel all outstanding DNS queries made by this resolver. The corresponding - * callbacks will be called with an error with code `ECANCELLED`. - * @since v8.3.0 - */ - cancel(): void; - getServers: typeof getServers; - resolve: typeof resolve; - resolve4: typeof resolve4; - resolve6: typeof resolve6; - resolveAny: typeof resolveAny; - resolveCname: typeof resolveCname; - resolveMx: typeof resolveMx; - resolveNaptr: typeof resolveNaptr; - resolveNs: typeof resolveNs; - resolvePtr: typeof resolvePtr; - resolveSoa: typeof resolveSoa; - resolveSrv: typeof resolveSrv; - resolveTxt: typeof resolveTxt; - reverse: typeof reverse; - /** - * The resolver instance will send its requests from the specified IP address. - * This allows programs to specify outbound interfaces when used on multi-homed - * systems. - * - * If a v4 or v6 address is not specified, it is set to the default, and the - * operating system will choose a local address automatically. - * - * The resolver will use the v4 local address when making requests to IPv4 DNS - * servers, and the v6 local address when making requests to IPv6 DNS servers. - * The `rrtype` of resolution requests has no impact on the local address used. - * @since v15.1.0, v14.17.0 - * @param [ipv4='0.0.0.0'] A string representation of an IPv4 address. - * @param [ipv6='::0'] A string representation of an IPv6 address. - */ - setLocalAddress(ipv4?: string, ipv6?: string): void; - setServers: typeof setServers; - } - export { dnsPromises as promises }; -} -declare module 'node:dns' { - export * from 'dns'; -} diff --git a/spaces/fffiloni/controlnet-animation-doodle/node_modules/object-inspect/test/inspect.js b/spaces/fffiloni/controlnet-animation-doodle/node_modules/object-inspect/test/inspect.js deleted file mode 100644 index 1abf81b1f00b305519e52fe74477b2c5b71803c7..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/controlnet-animation-doodle/node_modules/object-inspect/test/inspect.js +++ /dev/null @@ -1,139 +0,0 @@ -var test = require('tape'); -var hasSymbols = require('has-symbols/shams')(); -var utilInspect = require('../util.inspect'); -var repeat = require('string.prototype.repeat'); - -var inspect = require('..'); - -test('inspect', function (t) { - t.plan(5); - - var obj = [{ inspect: function xyzInspect() { return '!XYZ¡'; } }, []]; - var stringResult = '[ !XYZ¡, [] ]'; - var falseResult = '[ { inspect: [Function: xyzInspect] }, [] ]'; - - t.equal(inspect(obj), stringResult); - t.equal(inspect(obj, { customInspect: true }), stringResult); - t.equal(inspect(obj, { customInspect: 'symbol' }), falseResult); - t.equal(inspect(obj, { customInspect: false }), falseResult); - t['throws']( - function () { inspect(obj, { customInspect: 'not a boolean or "symbol"' }); }, - TypeError, - '`customInspect` must be a boolean or the string "symbol"' - ); -}); - -test('inspect custom symbol', { skip: !hasSymbols || !utilInspect || !utilInspect.custom }, function (t) { - t.plan(4); - - var obj = { inspect: function stringInspect() { return 'string'; } }; - obj[utilInspect.custom] = function custom() { return 'symbol'; }; - - var symbolResult = '[ symbol, [] ]'; - var stringResult = '[ string, [] ]'; - var falseResult = '[ { inspect: [Function: stringInspect]' + (utilInspect.custom ? ', [' + inspect(utilInspect.custom) + ']: [Function: custom]' : '') + ' }, [] ]'; - - var symbolStringFallback = utilInspect.custom ? symbolResult : stringResult; - var symbolFalseFallback = utilInspect.custom ? symbolResult : falseResult; - - t.equal(inspect([obj, []]), symbolStringFallback); - t.equal(inspect([obj, []], { customInspect: true }), symbolStringFallback); - t.equal(inspect([obj, []], { customInspect: 'symbol' }), symbolFalseFallback); - t.equal(inspect([obj, []], { customInspect: false }), falseResult); -}); - -test('symbols', { skip: !hasSymbols }, function (t) { - t.plan(2); - - var obj = { a: 1 }; - obj[Symbol('test')] = 2; - obj[Symbol.iterator] = 3; - Object.defineProperty(obj, Symbol('non-enum'), { - enumerable: false, - value: 4 - }); - - if (typeof Symbol.iterator === 'symbol') { - t.equal(inspect(obj), '{ a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }', 'object with symbols'); - t.equal(inspect([obj, []]), '[ { a: 1, [Symbol(test)]: 2, [Symbol(Symbol.iterator)]: 3 }, [] ]', 'object with symbols in array'); - } else { - // symbol sham key ordering is unreliable - t.match( - inspect(obj), - /^(?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 })$/, - 'object with symbols (nondeterministic symbol sham key ordering)' - ); - t.match( - inspect([obj, []]), - /^\[ (?:{ a: 1, \[Symbol\(test\)\]: 2, \[Symbol\(Symbol.iterator\)\]: 3 }|{ a: 1, \[Symbol\(Symbol.iterator\)\]: 3, \[Symbol\(test\)\]: 2 }), \[\] \]$/, - 'object with symbols in array (nondeterministic symbol sham key ordering)' - ); - } -}); - -test('maxStringLength', function (t) { - t['throws']( - function () { inspect('', { maxStringLength: -1 }); }, - TypeError, - 'maxStringLength must be >= 0, or Infinity, not negative' - ); - - var str = repeat('a', 1e8); - - t.equal( - inspect([str], { maxStringLength: 10 }), - '[ \'aaaaaaaaaa\'... 99999990 more characters ]', - 'maxStringLength option limits output' - ); - - t.equal( - inspect(['f'], { maxStringLength: null }), - '[ \'\'... 1 more character ]', - 'maxStringLength option accepts `null`' - ); - - t.equal( - inspect([str], { maxStringLength: Infinity }), - '[ \'' + str + '\' ]', - 'maxStringLength option accepts ∞' - ); - - t.end(); -}); - -test('inspect options', { skip: !utilInspect.custom }, function (t) { - var obj = {}; - obj[utilInspect.custom] = function () { - return JSON.stringify(arguments); - }; - t.equal( - inspect(obj), - utilInspect(obj, { depth: 5 }), - 'custom symbols will use node\'s inspect' - ); - t.equal( - inspect(obj, { depth: 2 }), - utilInspect(obj, { depth: 2 }), - 'a reduced depth will be passed to node\'s inspect' - ); - t.equal( - inspect({ d1: obj }, { depth: 3 }), - '{ d1: ' + utilInspect(obj, { depth: 2 }) + ' }', - 'deep objects will receive a reduced depth' - ); - t.equal( - inspect({ d1: obj }, { depth: 1 }), - '{ d1: [Object] }', - 'unlike nodejs inspect, customInspect will not be used once the depth is exceeded.' - ); - t.end(); -}); - -test('inspect URL', { skip: typeof URL === 'undefined' }, function (t) { - t.match( - inspect(new URL('https://nodejs.org')), - /nodejs\.org/, // Different environments stringify it differently - 'url can be inspected' - ); - t.end(); -}); diff --git a/spaces/fffiloni/sd-xl-lora-fusion/app.py b/spaces/fffiloni/sd-xl-lora-fusion/app.py deleted file mode 100644 index 4f3c284729f44fec31686547d48357690541e7e4..0000000000000000000000000000000000000000 --- a/spaces/fffiloni/sd-xl-lora-fusion/app.py +++ /dev/null @@ -1,383 +0,0 @@ -import gradio as gr -from huggingface_hub import login, HfFileSystem, HfApi, ModelCard - -from diffusers import DiffusionPipeline, StableDiffusionXLPipeline -import torch -import copy -import os -import spaces -import random - -import user_history - -is_shared_ui = True if "fffiloni/sd-xl-lora-fusion" in os.environ['SPACE_ID'] else False -hf_token = os.environ.get("HF_TOKEN") -login(token = hf_token) - -fs = HfFileSystem(token=hf_token) -api = HfApi() - -original_pipe = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-xl-base-1.0", torch_dtype=torch.float16) - -def get_files(file_paths): - last_files = {} # Dictionary to store the last file for each path - - for file_path in file_paths: - # Split the file path into directory and file components - directory, file_name = file_path.rsplit('/', 1) - - # Update the last file for the current path - last_files[directory] = file_name - - # Extract the last files from the dictionary - result = list(last_files.values()) - - return result - -def load_sfts(repo_1_id, repo_2_id): - - card_1 = ModelCard.load(repo_1_id) - - repo_1_data = card_1.data.to_dict() - instance_prompt_1 = repo_1_data.get("instance_prompt") - if instance_prompt_1 is not None: - print(f"Trigger word 1: {instance_prompt_1}") - else: - instance_prompt_1 = "no trigger word needed" - print(f"Trigger word 1: no trigger word needed") - - card_2 = ModelCard.load(repo_2_id) - - repo_2_data = card_2.data.to_dict() - instance_prompt_2 = repo_2_data.get("instance_prompt") - if instance_prompt_2 is not None: - print(f"Trigger word 2: {instance_prompt_2}") - else: - instance_prompt_2 = "no trigger word needed" - print(f"Trigger word 2: no trigger word needed") - - - # List all ".safetensors" files in repos - - sfts_available_files_1 = fs.glob(f"{repo_1_id}/*.safetensors") - sfts_available_files_1 = get_files(sfts_available_files_1) - - if sfts_available_files_1 == []: - sfts_available_files_1 = ["NO SAFETENSORS FILE"] - - print(f"sfts 1: {sfts_available_files_1}") - - - sfts_available_files_2 = fs.glob(f"{repo_2_id}/*.safetensors") - sfts_available_files_2 = get_files(sfts_available_files_2) - - if sfts_available_files_2 == []: - sfts_available_files_2 = ["NO SAFETENSORS FILE"] - - return gr.update(choices=sfts_available_files_1, value=sfts_available_files_1[0], visible=True), gr.update(choices=sfts_available_files_2, value=sfts_available_files_2[0], visible=True), gr.update(value=instance_prompt_1, visible=True), gr.update(value=instance_prompt_2, visible=True) - -@spaces.GPU -def infer(lora_1_id, lora_1_sfts, lora_2_id, lora_2_sfts, prompt, negative_prompt, lora_1_scale, lora_2_scale, seed, profile: gr.OAuthProfile | None): - - unet = copy.deepcopy(original_pipe.unet) - text_encoder = copy.deepcopy(original_pipe.text_encoder) - text_encoder_2 = copy.deepcopy(original_pipe.text_encoder_2) - - pipe = StableDiffusionXLPipeline( - vae = original_pipe.vae, - text_encoder = text_encoder, - text_encoder_2 = text_encoder_2, - scheduler = original_pipe.scheduler, - tokenizer = original_pipe.tokenizer, - tokenizer_2 = original_pipe.tokenizer_2, - unet = unet - ) - - pipe.to("cuda") - - if lora_1_sfts == "NO SAFETENSORS FILE": - pipe.load_lora_weights( - lora_1_id, - low_cpu_mem_usage = True, - use_auth_token = True - ) - - else: - pipe.load_lora_weights( - lora_1_id, - weight_name = lora_1_sfts, - low_cpu_mem_usage = True, - use_auth_token = True - ) - - - - pipe.fuse_lora(lora_1_scale) - - if lora_2_sfts == "NO SAFETENSORS FILE": - pipe.load_lora_weights( - lora_2_id, - low_cpu_mem_usage = True, - use_auth_token = True - ) - - else: - pipe.load_lora_weights( - lora_2_id, - weight_name = lora_2_sfts, - low_cpu_mem_usage = True, - use_auth_token = True - ) - - - pipe.fuse_lora(lora_2_scale) - - if negative_prompt == "" : - negative_prompt = None - - if seed < 0 : - seed = random.randint(0, 423538377342) - - generator = torch.Generator(device="cuda").manual_seed(seed) - - image = pipe( - prompt = prompt, - negative_prompt = negative_prompt, - num_inference_steps = 25, - width = 1024, - height = 1024, - generator = generator - ).images[0] - - pipe.unfuse_lora() - - # save generated images (if logged in) - user_history.save_image(label=prompt, image=image, profile=profile, metadata={ - "prompt": prompt, - "negative_prompt": negative_prompt, - "lora_1_repo_id": lora_1_id, - "lora_2_repo_id": lora_2_id, - "lora_1_scale": lora_1_scale, - "lora_2_scale": lora_2_scale, - "seed": seed, - }) - - return image, seed - -css=""" -#col-container{ - margin: 0 auto; - max-width: 750px; - text-align: left; -} -div#warning-duplicate { - background-color: #ebf5ff; - padding: 0 10px 5px; - margin: 20px 0; -} -div#warning-duplicate > .gr-prose > h2, div#warning-duplicate > .gr-prose > p { - color: #0f4592!important; -} -div#warning-duplicate strong { - color: #0f4592; -} -p.actions { - display: flex; - align-items: center; - margin: 20px 0; -} -div#warning-duplicate .actions a { - display: inline-block; - margin-right: 10px; -} -""" - -with gr.Blocks(css=css) as demo: - with gr.Column(elem_id="col-container"): - - if is_shared_ui: - top_description = gr.HTML(f''' - -- ''', elem_id="warning-duplicate") - - title = gr.HTML( - ''' -- Note: you might want to use private custom LoRa models
- -- -
-
-
- to start using private models and skip the queue
- SD-XL LoRA Fusion
-- Fuse 2 custom StableDiffusion-XL LoRa models
- ''' - ) - - # PART 1 • MODELS - if not is_shared_ui: - your_username = api.whoami()["name"] - my_models = api.list_models(author=your_username, filter=["diffusers", "stable-diffusion-xl", 'lora']) - model_names = [item.modelId for item in my_models] - - #print(model_names) - - with gr.Row(): - - with gr.Column(): - - if not is_shared_ui: - lora_1_id = gr.Dropdown( - label = "LoRa 1 ID", - choices = model_names, - allow_custom_value = True - #placeholder = "username/model_id" - ) - else: - lora_1_id = gr.Textbox( - label = "LoRa 1 ID", - placeholder = "username/model_id" - ) - - lora_1_sfts = gr.Dropdown( - label = "Safetensors file", - visible=False - ) - - instance_prompt_1 = gr.Textbox( - label = "Trigger Word 1", - visible = False, - interactive = False - ) - - with gr.Column(): - - if not is_shared_ui: - lora_2_id = gr.Dropdown( - label = "LoRa 2 ID", - choices = model_names, - allow_custom_value = True - #placeholder = "username/model_id" - ) - else: - lora_2_id = gr.Textbox( - label = "LoRa 2 ID", - placeholder = "username/model_id" - ) - - lora_2_sfts = gr.Dropdown( - label = "Safetensors file", - visible=False - ) - - instance_prompt_2 = gr.Textbox( - label = "Trigger Word 2", - visible = False, - interactive = False - ) - - load_models_btn = gr.Button("1. Load models and .safetensors") - - # PART 2 • INFERENCE - with gr.Column(): - with gr.Row(): - - prompt = gr.Textbox( - label = "Your prompt", - show_label = True, - info = "Use your trigger words into a coherent prompt", - placeholder = "e.g: a triggerWordOne portrait in triggerWord2 style" - ) - # Advanced Settings - with gr.Accordion("Advanced Settings", open=False): - - with gr.Row(): - - lora_1_scale = gr.Slider( - label = "LoRa 1 scale", - minimum = 0, - maximum = 1, - step = 0.1, - value = 0.7 - ) - - lora_2_scale = gr.Slider( - label = "LoRa 2 scale", - minimum = 0, - maximum = 1, - step = 0.1, - value = 0.7 - ) - - negative_prompt = gr.Textbox( - label = "Negative prompt" - ) - - seed = gr.Slider( - label = "Seed", - info = "-1 denotes a random seed", - minimum = -1, - maximum = 423538377342, - value = -1 - ) - - last_used_seed = gr.Number( - label = "Last used seed", - info = "the seed used in the last generation", - ) - - run_btn = gr.Button("2. Run", elem_id="run_button") - - output_image = gr.Image( - label = "Output" - ) - - with gr.Accordion("Past generations", open=False): - user_history.render() - - - - # ACTIONS - load_models_btn.click( - fn = load_sfts, - inputs = [ - lora_1_id, - lora_2_id - ], - outputs = [ - lora_1_sfts, - lora_2_sfts, - instance_prompt_1, - instance_prompt_2 - ], - queue=False - ) - run_btn.click( - fn = infer, - inputs = [ - lora_1_id, - lora_1_sfts, - lora_2_id, - lora_2_sfts, - prompt, - negative_prompt, - lora_1_scale, - lora_2_scale, - seed - ], - outputs = [ - output_image, - last_used_seed - ] - ) - -demo.queue(concurrency_count=2).launch() - diff --git a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_40.py b/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_40.py deleted file mode 100644 index d3037b76e668d000543fe12983602a3d1ef22fa2..0000000000000000000000000000000000000000 --- a/spaces/fgenie/scamtext_PAL_self_consistency/funcs/f_40.py +++ /dev/null @@ -1,22 +0,0 @@ - -import re - -def is_spam(message): - # URL patterns - url_pattern1 = r'https?://[^\s]+' - url_pattern2 = r'bit\.ly/[^\s]+' - - # Suspicious patterns - spam_pattern1 = r'[0-9]{1,2}%?[-\s]?[\+↑]+' - spam_pattern2 = r'상한가|익절가|추천주|무료체험|실현수익률' - spam_pattern3 = r'\[[^\]]*클릭[^\]]*\]' - - # Combine all the patterns - patterns = [url_pattern1, url_pattern2, spam_pattern1, spam_pattern2, spam_pattern3] - combined_pattern = r'|'.join(patterns) - - # Check if any pattern is found in the message - if re.search(combined_pattern, message): - return True - else: - return False diff --git a/spaces/freddyaboulton/3.1.4.9-all-demos/demos/reverse_audio/run.py b/spaces/freddyaboulton/3.1.4.9-all-demos/demos/reverse_audio/run.py deleted file mode 100644 index f58e82f855e2a39cb38f37870e5322e2bcea1363..0000000000000000000000000000000000000000 --- a/spaces/freddyaboulton/3.1.4.9-all-demos/demos/reverse_audio/run.py +++ /dev/null @@ -1,22 +0,0 @@ -import os - -import numpy as np - -import gradio as gr - - -def reverse_audio(audio): - sr, data = audio - return (sr, np.flipud(data)) - - -demo = gr.Interface(fn=reverse_audio, - inputs="microphone", - outputs="audio", - examples=[ - os.path.join(os.path.dirname(__file__), "audio/cantina.wav"), - os.path.join(os.path.dirname(__file__), "audio/recording1.wav") - ], cache_examples=True) - -if __name__ == "__main__": - demo.launch() diff --git a/spaces/gabrielyokai/reverse/Dockerfile b/spaces/gabrielyokai/reverse/Dockerfile deleted file mode 100644 index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000 --- a/spaces/gabrielyokai/reverse/Dockerfile +++ /dev/null @@ -1,21 +0,0 @@ -FROM node:18-bullseye-slim - -RUN apt-get update && \ - -apt-get install -y git - -RUN git clone https://gitgud.io/khanon/oai-reverse-proxy.git /app - -WORKDIR /app - -RUN npm install - -COPY Dockerfile greeting.md* .env* ./ - -RUN npm run build - -EXPOSE 7860 - -ENV NODE_ENV=production - -CMD [ "npm", "start" ] \ No newline at end of file diff --git a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/__init__.py b/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/__init__.py deleted file mode 100644 index 210a2989138380559f23045b568d0fbbeb918c03..0000000000000000000000000000000000000000 --- a/spaces/georgefen/Face-Landmark-ControlNet/annotator/uniformer/mmcv/__init__.py +++ /dev/null @@ -1,15 +0,0 @@ -# Copyright (c) OpenMMLab. All rights reserved. -# flake8: noqa -from .arraymisc import * -from .fileio import * -from .image import * -from .utils import * -from .version import * -from .video import * -from .visualization import * - -# The following modules are not imported to this level, so mmcv may be used -# without PyTorch. -# - runner -# - parallel -# - op diff --git a/spaces/gossminn/fillmorle-app/fillmorle/app.py b/spaces/gossminn/fillmorle-app/fillmorle/app.py deleted file mode 100644 index 38ece74cdf655384b2304a37d18988596e88d215..0000000000000000000000000000000000000000 --- a/spaces/gossminn/fillmorle-app/fillmorle/app.py +++ /dev/null @@ -1,526 +0,0 @@ -from itertools import product -import random -import time -from turtle import hideturtle -import requests -import json -import lxml.etree as ET - -import gensim -import pandas as pd - -import nltk -# from nltk.corpus import framenet as fn -# --- circumvent threading issues with FrameNet -fn_root = nltk.data.find("{}/{}".format("corpora", "framenet_v17")) -print(fn_root) -fn_files = ["frRelation.xml", "frameIndex.xml", "fulltextIndex.xml", "luIndex.xml", "semTypes.xml"] -fn = nltk.corpus.reader.framenet.FramenetCorpusReader(fn_root, fn_files) -# --- - -import streamlit as st - -from sociolome import lome_wrapper - - -def similarity(gensim_m, frame_1, frame_2): - if f"fn_{frame_1}" not in gensim_m or f"fn_{frame_2}" not in gensim_m: - return None - return 1 - gensim_m.distance(f"fn_{frame_1}", f"fn_{frame_2}") - - -def rank(gensim_m, frame_1, frame_2): - frame_1 = f"fn_{frame_1}" - frame_2 = f"fn_{frame_2}" - - if frame_1 == frame_2: - return 0 - - for i, (word, _) in enumerate(gensim_m.most_similar(frame_1, topn=1200)): - if word == frame_2: - return i + 1 - return -1 - - -def format_frame_description(frame_def_xml): - frame_def_fmt = [frame_def_xml.text] if frame_def_xml.text else [] - for elem in frame_def_xml: - if elem.tag == "ex": - break - elif elem.tag == "fen": - frame_def_fmt.append(elem.text.upper()) - elif elem.text: - frame_def_fmt.append(elem.text) - if elem.tail: - frame_def_fmt.append(elem.tail) - return "".join(frame_def_fmt).replace("frames", "stories").replace("frame", "story") - - -def get_frame_definition(frame_info): - try: - # try extracting just the first sentence - definition_first_sent = nltk.sent_tokenize(frame_info.definitionMarkup)[0] + "" - frame_def_xml = ET.fromstring(definition_first_sent) - except ET.XMLSyntaxError: - # otherwise, use the full definition - frame_def_xml = ET.fromstring(frame_info.definitionMarkup) - return format_frame_description(frame_def_xml) - - -def get_random_example(frame_info): - exemplars = [ - { - "text": exemplar.text, - "target_lu": lu_name, - "target_idx": list(exemplar["Target"][0]), - "core_fes": { - role: exemplar.text[start_idx:end_idx] - for role, start_idx, end_idx in exemplar.FE[0] - if role in [fe for fe, fe_info in frame_info.FE.items() if fe_info.coreType == "Core"] - } - } - for lu_name, lu_info in frame_info["lexUnit"].items() - for exemplar in lu_info.exemplars if len(exemplar.text) > 30 - ] - if exemplars: - return random.choice(exemplars) - return None - -def make_hint(gensim_m, target, current_closest): - - if target == current_closest: - return None - - most_similar = gensim_m.most_similar(f"fn_{target}", topn=1200) - current_position = [word for word, _ in most_similar].index(f"fn_{current_closest}") - - while current_position > 0: - next_closest, _ = most_similar[current_position - 1] - info = fn.frame(next_closest.replace("fn_", "")) - if len(info.lexUnit) > 10: - exemplar = get_random_example(info) - if exemplar: - return next_closest, exemplar - current_position -= 1 - - return None - - -def get_typical_exemplar(frame_info): - exemplars = [ - { - "text": exemplar.text, - "target_lu": lu_name, - "target_idx": list(exemplar["Target"][0]), - "core_fes": { - role: exemplar.text[start_idx:end_idx] - for role, start_idx, end_idx in exemplar.FE[0] - if role in [fe for fe, fe_info in frame_info.FE.items() if fe_info.coreType == "Core"] - } - } - for lu_name, lu_info in frame_info["lexUnit"].items() - for exemplar in lu_info.exemplars - ] - - # try to find a "typical" exemplar --- typical -> as short as possible, as many FEs as possible - exa_typicality_scores = [(exa, len(exa["text"]) - 25 * len(exa["core_fes"])) for exa in exemplars] - if exa_typicality_scores: - typical_exemplar = min(exa_typicality_scores, key=lambda t: t[1])[0] - else: - typical_exemplar = None - return typical_exemplar - - -def find_all_inheriting_frames(frame_name): - frame_info = fn.frame(frame_name) - inheritance_rels = [rel for rel in frame_info.frameRelations if rel.type.name == "Inheritance" and rel.superFrame.name == frame_name] - inheritors = [rel.subFrame.name for rel in inheritance_rels] - for inh in inheritors: - inheritors.extend(find_all_inheriting_frames(inh)) - return inheritors - - -def has_enough_lus(frame, n=10): - return len(fn.frame(frame).lexUnit) > n - - -def choose_secret_frames(): - event_frames = [frm for frm in find_all_inheriting_frames("Event") if has_enough_lus(frm)] - entity_frames = [frm for frm in find_all_inheriting_frames("Entity") if has_enough_lus(frm)] - random.seed(time.time() // 86400) - return random.choice(list(product(event_frames, entity_frames))) - - -def get_frame_info(frames): - frames_and_info = [] - for evoked_frame in frames: - try: - frame_info = fn.frame(evoked_frame) - typical_sentence = get_typical_exemplar(frame_info) - frames_and_info.append((evoked_frame, frame_info, typical_sentence)) - except FileNotFoundError: - continue - return frames_and_info - - -def get_frame_feedback(frames_and_info, gensim_m, secret_event, secret_entity): - frame_feedback = [] - for evoked_frame, frame_info, typical_sentence in frames_and_info: - lexunits = list(frame_info.lexUnit.keys())[:5] - similarity_score_1 = similarity(gensim_m, secret_event, evoked_frame) - similarity_rank_1 = rank(gensim_m, secret_event, evoked_frame) - similarity_score_2 = similarity(gensim_m, secret_entity, evoked_frame) - similarity_rank_2 = rank(gensim_m, secret_entity, evoked_frame) - if typical_sentence: - typical_sentence_txt = typical_sentence['text'] - else: - typical_sentence_txt = None - - frame_feedback.append({ - "frame": evoked_frame, - "similarity_1": similarity_score_1 * 100 if similarity_score_1 else None, - "rank_1": similarity_rank_1 if similarity_rank_1 != -1 else "far away", - "similarity_2": similarity_score_2 * 100 if similarity_score_2 else None, - "rank_2": similarity_rank_2 if similarity_rank_2 != -1 else "far away", - "typical_words": lexunits, - "typical_sentence": typical_sentence_txt - }) - return frame_feedback - - -def run_game_cli(debug=True): - - secret_event, secret_entity = choose_secret_frames() - - if debug: - print(f"Shhhhhh you're not supposed to know, but the secret frames are {secret_event} and {secret_entity}") - print("--------\n\n\n\n") - - print("Welcome to FillmorLe!") - print("Words are not just words: behind every word, a story is hidden that appears in our imagination when we hear the word.") - print() - print("In this game, your job is to activate TWO SECRET STORIES by writing sentences.") - print("There will be new secret stories every day -- the first story is always about an EVENT (something that happens in the world) and the second one about an ENTITY (a thing or concept).") - print("Every time you write a sentence, I will tell you which stories are hidden below the surface, and how close these stories are to the secret stories.") - print("Once you write a sentence that has both of the secret stories in it, you win. Good luck and be creative!") - - gensim_m = gensim.models.word2vec.KeyedVectors.load_word2vec_format("data/frame_embeddings.w2v.txt") - - num_guesses = 0 - guesses_event = [] - guesses_entity = [] - - while True: - num_guesses += 1 - closest_to_event = sorted(guesses_event, key=lambda g: g[1], reverse=True)[:5] - closest_to_entity = sorted(guesses_entity, key=lambda g: g[1], reverse=True)[:5] - closest_to_event_txt = ", ".join([f"{frm.upper()} ({sim:.2f})" for frm, sim in closest_to_event]) - closest_to_entity_txt = ", ".join([f"{frm.upper()} ({sim:.2f})" for frm, sim in closest_to_entity]) - - print() - print(f"==== Guess #{num_guesses} ====") - if secret_event in guesses_event: - print("You already guessed SECRET STORY #1: ", secret_event.upper()) - elif closest_to_event: - print(f"Best guesses (SECRET STORY #1):", closest_to_event_txt) - - if secret_entity in guesses_entity: - print("You already guessed SECRET STORY #1: ", secret_entity.upper()) - elif closest_to_entity: - print(f"Best guesses (SECRET STORY #2):", closest_to_entity_txt) - - sentence = input("Enter a sentence or type 'HINT' if you're stuck >>>> ").strip() - - if sentence == "HINT": - hint_target = None - while not hint_target: - hint_choice = input("For which story do you want a hint? Type '1' or '2' >>>> ").strip() - if hint_choice == "1": - hint_target = secret_event - hint_current = closest_to_event[0][0] if closest_to_event else "Event" - elif hint_choice == "2": - hint_target = secret_entity - hint_current = closest_to_entity[0][0] if closest_to_entity else "Entity" - else: - print("Please type '1' or '2'.") - - if hint_current == hint_target: - print("You don't need a hint for this story! Maybe you want a hint for the other one?") - continue - - hint = make_hint(gensim_m, hint_target, hint_current) - if hint is None: - print("Sorry, you're already too close to give you a hint!") - else: - _, hint_example = hint - hint_tgt_idx = hint_example["target_idx"] - hint_example_redacted = hint_example["text"][:hint_tgt_idx[0]] + "******" + hint_example["text"][hint_tgt_idx[1]:] - print(f"Your hint sentence is: «{hint_example_redacted}»") - print(f"PRO TIP 1: the '******' hide a secret word. Guess the word and you will find a story that takes your one step closer to find SECRET STORY #{hint_choice}") - print(f"PRO TIP 2: if you don't get the hint, just ask for a new one! You can do this as often as you want.") - print("\n\n") - continue - - r = requests.get("http://127.0.0.1:9090/analyze", params={"text": sentence}) - lome_data = json.loads(r.text) - frames = set() - for token_items in lome_data["analyses"][0]["frame_list"]: - for item in token_items: - if item.startswith("T:"): - evoked_frame = item.split("@")[0].replace("T:", "") - frames.add(evoked_frame) - - frames_and_info = get_frame_info(frames) - frame_feedback = get_frame_feedback(frames_and_info) - - for i, feedback in enumerate(frame_feedback): - - print(f"STORY {i}: {feedback['frame'].upper()}") - if feedback["typical_sentence"]: - print(f"\ttypical context: «{feedback['typical_sentence']}»") - print("\ttypical words:", ", ".join(feedback["typical_words"]), "...") - if feedback["similarity_1"]: - guesses_event.append((evoked_frame, feedback["similarity_1"])) - guesses_entity.append((evoked_frame, feedback["similarity_2"])) - print(f"\tsimilarity to SECRET STORY #1: {feedback['similarity_1']:.2f}") - print(f"\tsimilarity to SECRET STORY #2: {feedback['similarity_2']:.2f}") - else: - print("similarity: unknown") - print() - - if not frames_and_info: - print("I don't know any of the stories in your sentence. Try entering another sentence.") - - elif secret_event in frames and secret_entity in frames: - print(f"YOU WIN! You made a sentence with both of the SECRET STORIES: {secret_event.upper()} and {secret_entity.upper()}.\nYou won the game in {num_guesses} guesses, great job!") - break - - elif secret_event in frames: - print(f"Great, you guessed SECRET STORY #1! It was {secret_event.upper()}!") - print("To win, make a sentence with this story and SECRET STORY #2 hidden in it.") - - elif secret_entity in frames: - print(f"Great, you guessed SECRET STORY #2! It was {secret_entity.upper()}!") - print("To win, make a sentence with this story and SECRET STORY #1 hidden in it.") - - -# dummy version -# def analyze_sentence(sentence): -# return sentence.split() - -def analyze_sentence(sentence): - lome_data = lome_wrapper.analyze(sentence) - frames = set() - for token_items in lome_data["analyses"][0]["frame_list"]: - for item in token_items: - if item.startswith("T:"): - evoked_frame = item.split("@")[0].replace("T:", "") - frames.add(evoked_frame) - return frames - - - -def make_frame_feedback_msg(frame_feedback): - feedback_msg = [] - for i, feedback in enumerate(frame_feedback): - feedback_msg.append(f"* STORY {i}: *{feedback['frame'].upper()}*") - feedback_msg.append("\t* typical words: *" + " ".join(feedback["typical_words"]) + "* ...") - if feedback["typical_sentence"]: - feedback_msg.append(f"\t* typical context: «{feedback['typical_sentence']}»") - - if feedback["similarity_1"]: - feedback_msg.append(f"\t* similarity to SECRET STORY #1: {feedback['similarity_1']:.2f}") - feedback_msg.append(f"\t* similarity to SECRET STORY #2: {feedback['similarity_2']:.2f}") - else: - feedback_msg.append(f"\t* similarity: unknown") - return "\n".join(feedback_msg) - - -def format_hint_sentence(hint_example): - hint_tgt_idx = hint_example["target_idx"] - hint_example_redacted = hint_example["text"][:hint_tgt_idx[0]] + "******" + hint_example["text"][hint_tgt_idx[1]:] - return hint_example_redacted.strip() - - -def play_turn(): - # remove text from input - sentence = st.session_state["cur_sentence"] - st.session_state["cur_sentence"] = "" - - # get previous game state - game_state = st.session_state["game_state"] - secret_event, secret_entity = game_state["secret_event"], game_state["secret_entity"] - guesses_event, guesses_entity = game_state["guesses_event"], game_state["guesses_entity"] - - # reset hints - st.session_state["hints"] = [None, None] - - # reveal correct frames - if sentence.strip().lower() == "show me the frames": - st.warning(f"The correct frames are: {secret_event.upper()} and {secret_entity.upper()}") - - # process hints - elif sentence.strip() == "HINT": - guesses_event = sorted(game_state["guesses_event"], key=lambda t: t[1], reverse=True) - guesses_entity = sorted(game_state["guesses_entity"], key=lambda t: t[1], reverse=True) - best_guess_event = guesses_event[0][0] if guesses_event else "Event" - best_guess_entity = guesses_entity[0][0] if guesses_entity else "Entity" - - event_hint = make_hint(st.session_state["gensim_model"], secret_event, best_guess_event) - entity_hint = make_hint(st.session_state["gensim_model"], secret_entity, best_guess_entity) - - if event_hint: - st.session_state["hints"][0] = format_hint_sentence(event_hint[1]) - if entity_hint: - st.session_state["hints"][1] = format_hint_sentence(entity_hint[1]) - - - else: - frames = analyze_sentence(sentence) - frames_and_info = get_frame_info(frames) - frame_feedback = get_frame_feedback(frames_and_info, st.session_state["gensim_model"], secret_event, secret_entity) - - # update game state post analysis - game_state["num_guesses"] += 1 - for fdb in frame_feedback: - if fdb["similarity_1"]: - guesses_event.add((fdb["frame"], fdb["similarity_1"], fdb["rank_1"])) - guesses_entity.add((fdb["frame"], fdb["similarity_2"], fdb["rank_2"])) - - st.session_state["frame_feedback"] = frame_feedback - if secret_event in frames and secret_entity in frames: - st.session_state["game_over"] = True - st.session_state["guesses_to_win"] = game_state["num_guesses"] - -def display_guess_status(): - game_state = st.session_state["game_state"] - guesses_entity = sorted(game_state["guesses_entity"], key=lambda t: t[1], reverse=True) - guesses_event = sorted(game_state["guesses_event"], key=lambda t: t[1], reverse=True) - - if guesses_event or guesses_entity: - st.header("Best guesses") - - event_col, entity_col = st.columns(2) - if guesses_event: - with event_col: - st.subheader("Event Mini-Story") - st.table(pd.DataFrame(guesses_event, columns=["Story", "Similarity", "Steps To Go"])) - if game_state["secret_event"] in [g for g, _, _ in guesses_event]: - st.info("Great, you guessed the Event story! In order to win, make a sentence containing both the secret stories.") - if guesses_entity: - with entity_col: - st.subheader("Thing Mini-Story") - st.table(pd.DataFrame(guesses_entity, columns=["Story", "Similarity", "Steps To Go"])) - if game_state["secret_entity"] in [g for g, _, _ in guesses_entity]: - st.info("Great, you guessed the Thing story! In order to win, make a sentence containing both the secret stories.") - - -def format_feedback(frame_feedback): - out = [] - for fdb in frame_feedback: - out.append({ - "Story": fdb["frame"], - "Similarity (Event)": f"{fdb['similarity_1']:.2f}" if fdb["similarity_1"] else "unknown", - "Similarity (Thing)": f"{fdb['similarity_2']:.2f}" if fdb["similarity_2"] else "unknown", - "Typical Context": fdb["typical_sentence"], - "Typical Words": " ".join(fdb["typical_words"]) - }) - return out - - -def display_introduction(): - st.subheader("Why this game?") - st.markdown( - """ - Words are not just words: behind every word, a _mini-story_ (also known as "frame") is hidden - that appears in our imagination when we hear the word. For example, when we hear the word - "talking" we can imagine a mini-story that involves several people who are interacting - with each other. Or, if we hear the word "cookie", we might think of someone eating a cookie. - """.strip()) - - st.subheader("How does it work?") - st.markdown( - "* In this game, there are two secret mini-stories, and it's your job to figure out which ones!" - "\n" - "* The first mini-story is about an _Event_ (something that happens in the world, like a thunderstorm, " - "people talking, someone eating pasta), and the other one is a _Thing_ (a concrete thing like a tree" - "or something abstract like 'love')." - "\n" - "* How to guess the stories? Well, just type a sentence, and we'll tell you which mini-stories are " - "hidden in the sentence. For each of the stories, we'll tell you how close they are to the secret ones." - "\n" - "* Once you type a sentence with both of the secret mini-stories, you win!" - ) - - - -def display_hints(): - event_hint, entity_hint = st.session_state["hints"] - if event_hint or entity_hint: - st.header("Hints") - st.info("So you need some help? Here you get your hint sentences! Guess the hidden word, use it in a sentence, and we'll help you get one step closer.") - - if event_hint: - st.markdown(f"**Event Hint**:\n>_{event_hint}_") - if entity_hint: - st.markdown(f"**Thing Hint**:\n>_{entity_hint}_") - -def display_frame_feedback(): - frame_feedback = st.session_state["frame_feedback"] - if frame_feedback: - st.header("Feedback") - st.text("Your sentence contains the following stories: ") - feedback_df = format_feedback(frame_feedback) - st.table(pd.DataFrame(feedback_df)) - - -def run_game_st(debug=True): - - if not st.session_state.get("initialized", False): - - secret_event, secret_entity = choose_secret_frames() - gensim_m = gensim.models.word2vec.KeyedVectors.load_word2vec_format("data/frame_embeddings.w2v.txt") - - game_state = { - "secret_event": secret_event, - "secret_entity": secret_entity, - "num_guesses": 0, - "guesses_event": set(), - "guesses_entity": set(), - } - - st.session_state["initialized"] = True - st.session_state["show_introduction"] = False - st.session_state["game_over"] = False - st.session_state["guesses_to_win"] = -1 - st.session_state["game_state"] = game_state - st.session_state["gensim_model"] = gensim_m - st.session_state["frame_feedback"] = None - st.session_state["hints"] = [None, None] - - else: - gensim_m = st.session_state["gensim_model"] - game_state = st.session_state["game_state"] - - secret_event, secret_entity = game_state["secret_event"], game_state["secret_entity"] - - header = st.container() - with header: - st.title("FillmorLe") - st.checkbox("Show explanation?", key="show_introduction") - if st.session_state["show_introduction"]: - display_introduction() - - st.header(f"Guess #{st.session_state['game_state']['num_guesses'] + 1}") - st.text_input("Enter a sentence or type 'HINT' if you're stuck", key="cur_sentence", on_change=play_turn) - - if st.session_state["game_over"]: - st.success(f"You won in {st.session_state['guesses_to_win']}!") - - display_hints() - display_frame_feedback() - display_guess_status() - - -if __name__ == "__main__": - run_game_st() \ No newline at end of file diff --git a/spaces/gotiQspiryo/whisper-ui/examples/Invircom Scanner Periksa Nilai V5 Crack [UPDATED].md b/spaces/gotiQspiryo/whisper-ui/examples/Invircom Scanner Periksa Nilai V5 Crack [UPDATED].md deleted file mode 100644 index ac8a2ae799e837990df0bc82b3a7d66890ded0b6..0000000000000000000000000000000000000000 --- a/spaces/gotiQspiryo/whisper-ui/examples/Invircom Scanner Periksa Nilai V5 Crack [UPDATED].md +++ /dev/null @@ -1,6 +0,0 @@ -
- If you are running this demo in a duplicated private space, all your private LoRa models tagged ["Diffusers", "stable-diffusion-sd-xl", "lora"] will be automatically listed in LoRa IDs dropdowns -invircom scanner periksa nilai v5 crack
Download Zip ✔ https://urlgoal.com/2uyMsO
-
-ScanXPack Profesional adalah software pemeriksa LJK .. invircom scanner periksa nilai v5 crack maintop dtp v5 3 free full rapidshare naruto ... 4d29de3e1b
-
-
- diff --git a/spaces/gradio/HuBERT/fairseq/models/fairseq_model.py b/spaces/gradio/HuBERT/fairseq/models/fairseq_model.py deleted file mode 100644 index e55c7ba1ad90f4e2f12db6c814d04a90c4e3b77c..0000000000000000000000000000000000000000 --- a/spaces/gradio/HuBERT/fairseq/models/fairseq_model.py +++ /dev/null @@ -1,569 +0,0 @@ -# Copyright (c) Facebook, Inc. and its affiliates. -# -# This source code is licensed under the MIT license found in the -# LICENSE file in the root directory of this source tree. -""" -Base classes for various fairseq models. -""" - -import logging -from argparse import Namespace -from typing import Dict, List, Optional, Tuple - -import torch -import torch.nn as nn -import torch.nn.functional as F -from fairseq import utils -from fairseq.data import Dictionary -from fairseq.dataclass.utils import ( - convert_namespace_to_omegaconf, - gen_parser_from_dataclass, -) -from fairseq.models import FairseqDecoder, FairseqEncoder -from omegaconf import DictConfig -from torch import Tensor - - -logger = logging.getLogger(__name__) - - -def check_type(module, expected_type): - if hasattr(module, "unwrapped_module"): - assert isinstance(module.unwrapped_module, expected_type), \ - f"{type(module.unwrapped_module)} != {expected_type}" - else: - assert isinstance(module, expected_type), f"{type(module)} != {expected_type}" - - -class BaseFairseqModel(nn.Module): - """Base class for fairseq models.""" - - def __init__(self): - super().__init__() - self._is_generation_fast = False - - @classmethod - def add_args(cls, parser): - """Add model-specific arguments to the parser.""" - dc = getattr(cls, "__dataclass", None) - if dc is not None: - # do not set defaults so that settings defaults from various architectures still works - gen_parser_from_dataclass(parser, dc(), delete_default=True) - - @classmethod - def build_model(cls, args, task): - """Build a new model instance.""" - raise NotImplementedError("Model must implement the build_model method") - - def get_targets(self, sample, net_output): - """Get targets from either the sample or the net's output.""" - return sample["target"] - - def get_normalized_probs( - self, - net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], - log_probs: bool, - sample: Optional[Dict[str, Tensor]] = None, - ): - """Get normalized probabilities (or log probs) from a net's output.""" - return self.get_normalized_probs_scriptable(net_output, log_probs, sample) - - # TorchScript doesn't support super() method so that the scriptable Subclass - # can't access the base class model in Torchscript. - # Current workaround is to add a helper function with different name and - # call the helper function from scriptable Subclass. - def get_normalized_probs_scriptable( - self, - net_output: Tuple[Tensor, Optional[Dict[str, List[Optional[Tensor]]]]], - log_probs: bool, - sample: Optional[Dict[str, Tensor]] = None, - ): - """Scriptable helper function for get_normalized_probs in ~BaseFairseqModel""" - if hasattr(self, "decoder"): - return self.decoder.get_normalized_probs(net_output, log_probs, sample) - elif torch.is_tensor(net_output): - # syntactic sugar for simple models which don't have a decoder - # (e.g., the classification tutorial) - logits = net_output.float() - if log_probs: - return F.log_softmax(logits, dim=-1) - else: - return F.softmax(logits, dim=-1) - raise NotImplementedError - - def extract_features(self, *args, **kwargs): - """Similar to *forward* but only return features.""" - return self(*args, **kwargs) - - def max_positions(self): - """Maximum length supported by the model.""" - return None - - def load_state_dict( - self, - state_dict, - strict=True, - model_cfg: Optional[DictConfig] = None, - args: Optional[Namespace] = None, - ): - """Copies parameters and buffers from *state_dict* into this module and - its descendants. - - Overrides the method in :class:`nn.Module`. Compared with that method - this additionally "upgrades" *state_dicts* from old checkpoints. - """ - - if model_cfg is None and args is not None: - logger.warn("using 'args' is deprecated, please update your code to use dataclass config") - model_cfg = convert_namespace_to_omegaconf(args).model - - self.upgrade_state_dict(state_dict) - - from fairseq.checkpoint_utils import prune_state_dict - - new_state_dict = prune_state_dict(state_dict, model_cfg) - return super().load_state_dict(new_state_dict, strict) - - def upgrade_state_dict(self, state_dict): - """Upgrade old state dicts to work with newer code.""" - self.upgrade_state_dict_named(state_dict, "") - - def upgrade_state_dict_named(self, state_dict, name): - """Upgrade old state dicts to work with newer code. - - Args: - state_dict (dict): state dictionary to upgrade, in place - name (str): the state dict key corresponding to the current module - """ - assert state_dict is not None - - def do_upgrade(m, prefix): - if len(prefix) > 0: - prefix += "." - - for n, c in m.named_children(): - name = prefix + n - if hasattr(c, "upgrade_state_dict_named"): - c.upgrade_state_dict_named(state_dict, name) - elif hasattr(c, "upgrade_state_dict"): - c.upgrade_state_dict(state_dict) - do_upgrade(c, name) - - do_upgrade(self, name) - - def set_num_updates(self, num_updates): - """State from trainer to pass along to model at every update.""" - for m in self.modules(): - if hasattr(m, "set_num_updates") and m != self: - m.set_num_updates(num_updates) - - def prepare_for_inference_(self, cfg: DictConfig): - """Prepare model for inference.""" - kwargs = {} - kwargs["beamable_mm_beam_size"] = ( - None - if getattr(cfg.generation, "no_beamable_mm", False) - else getattr(cfg.generation, "beam", 5) - ) - kwargs["need_attn"] = getattr(cfg.generation, "print_alignment", False) - if getattr(cfg.generation, "retain_dropout", False): - kwargs["retain_dropout"] = cfg.generation.retain_dropout - kwargs["retain_dropout_modules"] = cfg.generation.retain_dropout_modules - self.make_generation_fast_(**kwargs) - - def make_generation_fast_(self, **kwargs): - """ - Legacy entry point to optimize model for faster generation. - Prefer prepare_for_inference_. - """ - if self._is_generation_fast: - return # only apply once - self._is_generation_fast = True - - # remove weight norm from all modules in the network - def apply_remove_weight_norm(module): - try: - nn.utils.remove_weight_norm(module) - except (AttributeError, ValueError): # this module didn't have weight norm - return - - self.apply(apply_remove_weight_norm) - - def apply_make_generation_fast_(module, prefix): - if len(prefix) > 0: - prefix += "." - - base_func = BaseFairseqModel.make_generation_fast_ - for n, m in module.named_modules(): - if ( - m != self - and hasattr(m, "make_generation_fast_") - # don't call this implementation again, e.g., if - # children modules also inherit from BaseFairseqModel - and m.make_generation_fast_.__func__ is not base_func - ): - name = prefix + n - m.make_generation_fast_(name=name, **kwargs) - - apply_make_generation_fast_(self, "") - - def train(mode=True): - if mode: - raise RuntimeError("cannot train after make_generation_fast") - - # this model should no longer be used for training - self.eval() - self.train = train - - def prepare_for_onnx_export_(self, **kwargs): - """Make model exportable via ONNX trace.""" - seen = set() - - def apply_prepare_for_onnx_export_(module): - if ( - module != self - and hasattr(module, "prepare_for_onnx_export_") - and module not in seen - ): - seen.add(module) - module.prepare_for_onnx_export_(**kwargs) - - self.apply(apply_prepare_for_onnx_export_) - - @classmethod - def from_pretrained( - cls, - model_name_or_path, - checkpoint_file="model.pt", - data_name_or_path=".", - **kwargs, - ): - """ - Load a :class:`~fairseq.models.FairseqModel` from a pre-trained model - file. Downloads and caches the pre-trained model file if needed. - - The base implementation returns a - :class:`~fairseq.hub_utils.GeneratorHubInterface`, which can be used to - generate translations or sample from language models. The underlying - :class:`~fairseq.models.FairseqModel` can be accessed via the - *generator.models* attribute. - - Other models may override this to implement custom hub interfaces. - - Args: - model_name_or_path (str): either the name of a pre-trained model to - load or a path/URL to a pre-trained model state dict - checkpoint_file (str, optional): colon-separated list of checkpoint - files in the model archive to ensemble (default: 'model.pt') - data_name_or_path (str, optional): point args.data to the archive - at the given path/URL. Can start with '.' or './' to reuse the - model archive path. - """ - from fairseq import hub_utils - - x = hub_utils.from_pretrained( - model_name_or_path, - checkpoint_file, - data_name_or_path, - archive_map=cls.hub_models(), - **kwargs, - ) - logger.info(x["args"]) - return hub_utils.GeneratorHubInterface(x["args"], x["task"], x["models"]) - - @classmethod - def hub_models(cls): - return {} - - -class FairseqEncoderDecoderModel(BaseFairseqModel): - """Base class for encoder-decoder models. - - Args: - encoder (FairseqEncoder): the encoder - decoder (FairseqDecoder): the decoder - """ - - def __init__(self, encoder, decoder): - super().__init__() - - self.encoder = encoder - self.decoder = decoder - - check_type(self.encoder, FairseqEncoder) - check_type(self.decoder, FairseqDecoder) - - def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): - """ - Run the forward pass for an encoder-decoder model. - - First feed a batch of source tokens through the encoder. Then, feed the - encoder output and previous decoder outputs (i.e., teacher forcing) to - the decoder to produce the next outputs:: - - encoder_out = self.encoder(src_tokens, src_lengths) - return self.decoder(prev_output_tokens, encoder_out) - - Args: - src_tokens (LongTensor): tokens in the source language of shape - `(batch, src_len)` - src_lengths (LongTensor): source sentence lengths of shape `(batch)` - prev_output_tokens (LongTensor): previous decoder outputs of shape - `(batch, tgt_len)`, for teacher forcing - - Returns: - tuple: - - the decoder's output of shape `(batch, tgt_len, vocab)` - - a dictionary with any model-specific outputs - """ - encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) - decoder_out = self.decoder( - prev_output_tokens, encoder_out=encoder_out, **kwargs - ) - return decoder_out - - def forward_decoder(self, prev_output_tokens, **kwargs): - return self.decoder(prev_output_tokens, **kwargs) - - def extract_features(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): - """ - Similar to *forward* but only return features. - - Returns: - tuple: - - the decoder's features of shape `(batch, tgt_len, embed_dim)` - - a dictionary with any model-specific outputs - """ - encoder_out = self.encoder(src_tokens, src_lengths=src_lengths, **kwargs) - features = self.decoder.extract_features( - prev_output_tokens, encoder_out=encoder_out, **kwargs - ) - return features - - def output_layer(self, features, **kwargs): - """Project features to the default output size (typically vocabulary size).""" - return self.decoder.output_layer(features, **kwargs) - - def max_positions(self): - """Maximum length supported by the model.""" - return (self.encoder.max_positions(), self.decoder.max_positions()) - - def max_decoder_positions(self): - """Maximum length supported by the decoder.""" - return self.decoder.max_positions() - - -class FairseqModel(FairseqEncoderDecoderModel): - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - utils.deprecation_warning( - "FairseqModel is deprecated, please use FairseqEncoderDecoderModel " - "or BaseFairseqModel instead", - stacklevel=4, - ) - - -class FairseqMultiModel(BaseFairseqModel): - """Base class for combining multiple encoder-decoder models.""" - - def __init__(self, encoders, decoders): - super().__init__() - assert encoders.keys() == decoders.keys() - self.keys = list(encoders.keys()) - for key in self.keys: - check_type(encoders[key], FairseqEncoder) - check_type(decoders[key], FairseqDecoder) - - self.models = nn.ModuleDict( - { - key: FairseqEncoderDecoderModel(encoders[key], decoders[key]) - for key in self.keys - } - ) - - @staticmethod - def build_shared_embeddings( - dicts: Dict[str, Dictionary], - langs: List[str], - embed_dim: int, - build_embedding: callable, - pretrained_embed_path: Optional[str] = None, - ): - """ - Helper function to build shared embeddings for a set of languages after - checking that all dicts corresponding to those languages are equivalent. - - Args: - dicts: Dict of lang_id to its corresponding Dictionary - langs: languages that we want to share embeddings for - embed_dim: embedding dimension - build_embedding: callable function to actually build the embedding - pretrained_embed_path: Optional path to load pretrained embeddings - """ - shared_dict = dicts[langs[0]] - if any(dicts[lang] != shared_dict for lang in langs): - raise ValueError( - "--share-*-embeddings requires a joined dictionary: " - "--share-encoder-embeddings requires a joined source " - "dictionary, --share-decoder-embeddings requires a joined " - "target dictionary, and --share-all-embeddings requires a " - "joint source + target dictionary." - ) - return build_embedding(shared_dict, embed_dim, pretrained_embed_path) - - def forward(self, src_tokens, src_lengths, prev_output_tokens, **kwargs): - raise NotImplementedError - - def max_positions(self): - """Maximum length supported by the model.""" - return { - key: ( - self.models[key].encoder.max_positions(), - self.models[key].decoder.max_positions(), - ) - for key in self.keys - } - - def max_decoder_positions(self): - """Maximum length supported by the decoder.""" - return min(model.decoder.max_positions() for model in self.models.values()) - - @property - def encoder(self): - return self.models[self.keys[0]].encoder - - @property - def decoder(self): - return self.models[self.keys[0]].decoder - - def forward_decoder(self, prev_output_tokens, **kwargs): - return self.decoder(prev_output_tokens, **kwargs) - - def load_state_dict( - self, - state_dict, - strict=True, - model_cfg=None, - args: Optional[Namespace] = None, - ): - """Copies parameters and buffers from *state_dict* into this module and - its descendants. - - Overrides the method in :class:`nn.Module`. Compared with that method - this additionally "upgrades" *state_dicts* from old checkpoints. - """ - - if model_cfg is None and args is not None: - logger.warn("using 'args' is deprecated, please update your code to use dataclass config") - model_cfg = convert_namespace_to_omegaconf(args).model - - self.upgrade_state_dict(state_dict) - - from fairseq.checkpoint_utils import prune_state_dict - - new_state_dict = prune_state_dict(state_dict, model_cfg) - return super().load_state_dict(new_state_dict, strict) - - -class FairseqLanguageModel(BaseFairseqModel): - """Base class for decoder-only models. - - Args: - decoder (FairseqDecoder): the decoder - """ - - def __init__(self, decoder): - super().__init__() - self.decoder = decoder - check_type(self.decoder, FairseqDecoder) - - def forward(self, src_tokens, **kwargs): - """ - Run the forward pass for a decoder-only model. - - Feeds a batch of tokens through the decoder to predict the next tokens. - - Args: - src_tokens (LongTensor): tokens on which to condition the decoder, - of shape `(batch, tgt_len)` - src_lengths (LongTensor): source sentence lengths of shape `(batch)` - - Returns: - tuple: - - the decoder's output of shape `(batch, seq_len, vocab)` - - a dictionary with any model-specific outputs - """ - return self.decoder(src_tokens, **kwargs) - - def forward_decoder(self, prev_output_tokens, **kwargs): - return self.decoder(prev_output_tokens, **kwargs) - - def extract_features(self, src_tokens, **kwargs): - """ - Similar to *forward* but only return features. - - Returns: - tuple: - - the decoder's features of shape `(batch, seq_len, embed_dim)` - - a dictionary with any model-specific outputs - """ - return self.decoder.extract_features(src_tokens, **kwargs) - - def output_layer(self, features, **kwargs): - """Project features to the default output size (typically vocabulary size).""" - return self.decoder.output_layer(features, **kwargs) - - def max_positions(self): - """Maximum length supported by the model.""" - return self.decoder.max_positions() - - def max_decoder_positions(self): - """Maximum length supported by the decoder.""" - return self.decoder.max_positions() - - @property - def supported_targets(self): - return {"future"} - - -class FairseqEncoderModel(BaseFairseqModel): - """Base class for encoder-only models. - - Args: - encoder (FairseqEncoder): the encoder - """ - - def __init__(self, encoder): - super().__init__() - self.encoder = encoder - check_type(self.encoder, FairseqEncoder) - - def forward(self, src_tokens, src_lengths, **kwargs): - """ - Run the forward pass for a encoder-only model. - - Feeds a batch of tokens through the encoder to generate features. - - Args: - src_tokens (LongTensor): input tokens of shape `(batch, src_len)` - src_lengths (LongTensor): source sentence lengths of shape `(batch)` - - Returns: - the encoder's output, typically of shape `(batch, src_len, features)` - """ - return self.encoder(src_tokens, src_lengths, **kwargs) - - def get_normalized_probs(self, net_output, log_probs, sample=None): - """Get normalized probabilities (or log probs) from a net's output.""" - encoder_out = net_output["encoder_out"] - if torch.is_tensor(encoder_out): - logits = encoder_out.float() - if log_probs: - return F.log_softmax(logits, dim=-1) - else: - return F.softmax(logits, dim=-1) - raise NotImplementedError - - def max_positions(self): - """Maximum length supported by the model.""" - return self.encoder.max_positions() diff --git a/spaces/gulabpatel/Real-ESRGAN/tests/test_discriminator_arch.py b/spaces/gulabpatel/Real-ESRGAN/tests/test_discriminator_arch.py deleted file mode 100644 index c56a40c7743630aa63b3e99bca8dc1a85949c4c5..0000000000000000000000000000000000000000 --- a/spaces/gulabpatel/Real-ESRGAN/tests/test_discriminator_arch.py +++ /dev/null @@ -1,19 +0,0 @@ -import torch - -from realesrgan.archs.discriminator_arch import UNetDiscriminatorSN - - -def test_unetdiscriminatorsn(): - """Test arch: UNetDiscriminatorSN.""" - - # model init and forward (cpu) - net = UNetDiscriminatorSN(num_in_ch=3, num_feat=4, skip_connection=True) - img = torch.rand((1, 3, 32, 32), dtype=torch.float32) - output = net(img) - assert output.shape == (1, 1, 32, 32) - - # model init and forward (gpu) - if torch.cuda.is_available(): - net.cuda() - output = net(img.cuda()) - assert output.shape == (1, 1, 32, 32) diff --git a/spaces/gv/space_demo/README.md b/spaces/gv/space_demo/README.md deleted file mode 100644 index 04c7534330c287e6e35015ab49ea91d09b12db1e..0000000000000000000000000000000000000000 --- a/spaces/gv/space_demo/README.md +++ /dev/null @@ -1,37 +0,0 @@ ---- -title: Space_demo -emoji: 👀 -colorFrom: indigo -colorTo: yellow -sdk: gradio -app_file: app.py -pinned: false ---- - -# Configuration - -`title`: _string_ -Display title for the Space - -`emoji`: _string_ -Space emoji (emoji-only character allowed) - -`colorFrom`: _string_ -Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray) - -`colorTo`: _string_ -Color for Thumbnail gradient (red, yellow, green, blue, indigo, purple, pink, gray) - -`sdk`: _string_ -Can be either `gradio` or `streamlit` - -`sdk_version` : _string_ -Only applicable for `streamlit` SDK. -See [doc](https://hf.co/docs/hub/spaces) for more info on supported versions. - -`app_file`: _string_ -Path to your main application file (which contains either `gradio` or `streamlit` Python code). -Path is relative to the root of the repository. - -`pinned`: _boolean_ -Whether the Space stays on top of your list. diff --git a/spaces/gwang-kim/DATID-3D/eg3d/training/volumetric_rendering/__init__.py b/spaces/gwang-kim/DATID-3D/eg3d/training/volumetric_rendering/__init__.py deleted file mode 100644 index daba66567a95beabb103f7996198a9675ab20b4a..0000000000000000000000000000000000000000 --- a/spaces/gwang-kim/DATID-3D/eg3d/training/volumetric_rendering/__init__.py +++ /dev/null @@ -1,11 +0,0 @@ -# SPDX-FileCopyrightText: Copyright (c) 2021-2022 NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# SPDX-License-Identifier: LicenseRef-NvidiaProprietary -# -# NVIDIA CORPORATION, its affiliates and licensors retain all intellectual -# property and proprietary rights in and to this material, related -# documentation and any modifications thereto. Any use, reproduction, -# disclosure or distribution of this material and related documentation -# without an express license agreement from NVIDIA CORPORATION or -# its affiliates is strictly prohibited. - -# empty \ No newline at end of file diff --git a/spaces/gyugnsu/DragGan-Inversion/torch_utils/ops/filtered_lrelu.py b/spaces/gyugnsu/DragGan-Inversion/torch_utils/ops/filtered_lrelu.py deleted file mode 100644 index 1a77f7e7a0ed0e951435cf6c7171d1baac8cf834..0000000000000000000000000000000000000000 --- a/spaces/gyugnsu/DragGan-Inversion/torch_utils/ops/filtered_lrelu.py +++ /dev/null @@ -1,307 +0,0 @@ -# Copyright (c) 2021, NVIDIA CORPORATION & AFFILIATES. All rights reserved. -# -# NVIDIA CORPORATION and its licensors retain all intellectual property -# and proprietary rights in and to this software, related documentation -# and any modifications thereto. Any use, reproduction, disclosure or -# distribution of this software and related documentation without an express -# license agreement from NVIDIA CORPORATION is strictly prohibited. - -import os -import numpy as np -import torch -import warnings - -from .. import custom_ops -from .. import misc -from . import upfirdn2d -from . import bias_act - -# ---------------------------------------------------------------------------- - -_plugin = None - - -def _init(): - global _plugin - if _plugin is None: - _plugin = custom_ops.get_plugin( - module_name='filtered_lrelu_plugin', - sources=['filtered_lrelu.cpp', 'filtered_lrelu_wr.cu', - 'filtered_lrelu_rd.cu', 'filtered_lrelu_ns.cu'], - headers=['filtered_lrelu.h', 'filtered_lrelu.cu'], - source_dir=os.path.dirname(__file__), - extra_cuda_cflags=['--use_fast_math', - '--allow-unsupported-compiler'], - ) - return True - - -def _get_filter_size(f): - if f is None: - return 1, 1 - assert isinstance(f, torch.Tensor) - assert 1 <= f.ndim <= 2 - return f.shape[-1], f.shape[0] # width, height - - -def _parse_padding(padding): - if isinstance(padding, int): - padding = [padding, padding] - assert isinstance(padding, (list, tuple)) - assert all(isinstance(x, (int, np.integer)) for x in padding) - padding = [int(x) for x in padding] - if len(padding) == 2: - px, py = padding - padding = [px, px, py, py] - px0, px1, py0, py1 = padding - return px0, px1, py0, py1 - -# ---------------------------------------------------------------------------- - - -def filtered_lrelu(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False, impl='cuda'): - r"""Filtered leaky ReLU for a batch of 2D images. - - Performs the following sequence of operations for each channel: - - 1. Add channel-specific bias if provided (`b`). - - 2. Upsample the image by inserting N-1 zeros after each pixel (`up`). - - 3. Pad the image with the specified number of zeros on each side (`padding`). - Negative padding corresponds to cropping the image. - - 4. Convolve the image with the specified upsampling FIR filter (`fu`), shrinking it - so that the footprint of all output pixels lies within the input image. - - 5. Multiply each value by the provided gain factor (`gain`). - - 6. Apply leaky ReLU activation function to each value. - - 7. Clamp each value between -clamp and +clamp, if `clamp` parameter is provided. - - 8. Convolve the image with the specified downsampling FIR filter (`fd`), shrinking - it so that the footprint of all output pixels lies within the input image. - - 9. Downsample the image by keeping every Nth pixel (`down`). - - The fused op is considerably more efficient than performing the same calculation - using standard PyTorch ops. It supports gradients of arbitrary order. - - Args: - x: Float32/float16/float64 input tensor of the shape - `[batch_size, num_channels, in_height, in_width]`. - fu: Float32 upsampling FIR filter of the shape - `[filter_height, filter_width]` (non-separable), - `[filter_taps]` (separable), or - `None` (identity). - fd: Float32 downsampling FIR filter of the shape - `[filter_height, filter_width]` (non-separable), - `[filter_taps]` (separable), or - `None` (identity). - b: Bias vector, or `None` to disable. Must be a 1D tensor of the same type - as `x`. The length of vector must must match the channel dimension of `x`. - up: Integer upsampling factor (default: 1). - down: Integer downsampling factor. (default: 1). - padding: Padding with respect to the upsampled image. Can be a single number - or a list/tuple `[x, y]` or `[x_before, x_after, y_before, y_after]` - (default: 0). - gain: Overall scaling factor for signal magnitude (default: sqrt(2)). - slope: Slope on the negative side of leaky ReLU (default: 0.2). - clamp: Maximum magnitude for leaky ReLU output (default: None). - flip_filter: False = convolution, True = correlation (default: False). - impl: Implementation to use. Can be `'ref'` or `'cuda'` (default: `'cuda'`). - - Returns: - Tensor of the shape `[batch_size, num_channels, out_height, out_width]`. - """ - assert isinstance(x, torch.Tensor) - assert impl in ['ref', 'cuda'] - if impl == 'cuda' and x.device.type == 'cuda' and _init(): - return _filtered_lrelu_cuda(up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter).apply(x, fu, fd, b, None, 0, 0) - return _filtered_lrelu_ref(x, fu=fu, fd=fd, b=b, up=up, down=down, padding=padding, gain=gain, slope=slope, clamp=clamp, flip_filter=flip_filter) - -# ---------------------------------------------------------------------------- - - -@misc.profiled_function -def _filtered_lrelu_ref(x, fu=None, fd=None, b=None, up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False): - """Slow and memory-inefficient reference implementation of `filtered_lrelu()` using - existing `upfirdn2n()` and `bias_act()` ops. - """ - assert isinstance(x, torch.Tensor) and x.ndim == 4 - fu_w, fu_h = _get_filter_size(fu) - fd_w, fd_h = _get_filter_size(fd) - if b is not None: - assert isinstance(b, torch.Tensor) and b.dtype == x.dtype - misc.assert_shape(b, [x.shape[1]]) - assert isinstance(up, int) and up >= 1 - assert isinstance(down, int) and down >= 1 - px0, px1, py0, py1 = _parse_padding(padding) - assert gain == float(gain) and gain > 0 - assert slope == float(slope) and slope >= 0 - assert clamp is None or (clamp == float(clamp) and clamp >= 0) - - # Calculate output size. - batch_size, channels, in_h, in_w = x.shape - in_dtype = x.dtype - out_w = (in_w * up + (px0 + px1) - (fu_w - 1) - - (fd_w - 1) + (down - 1)) // down - out_h = (in_h * up + (py0 + py1) - (fu_h - 1) - - (fd_h - 1) + (down - 1)) // down - - # Compute using existing ops. - x = bias_act.bias_act(x=x, b=b) # Apply bias. - # Upsample. - x = upfirdn2d.upfirdn2d(x=x, f=fu, up=up, padding=[ - px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter) - # Bias, leaky ReLU, clamp. - x = bias_act.bias_act(x=x, act='lrelu', alpha=slope, - gain=gain, clamp=clamp) - # Downsample. - x = upfirdn2d.upfirdn2d(x=x, f=fd, down=down, flip_filter=flip_filter) - - # Check output shape & dtype. - misc.assert_shape(x, [batch_size, channels, out_h, out_w]) - assert x.dtype == in_dtype - return x - -# ---------------------------------------------------------------------------- - - -_filtered_lrelu_cuda_cache = dict() - - -def _filtered_lrelu_cuda(up=1, down=1, padding=0, gain=np.sqrt(2), slope=0.2, clamp=None, flip_filter=False): - """Fast CUDA implementation of `filtered_lrelu()` using custom ops. - """ - assert isinstance(up, int) and up >= 1 - assert isinstance(down, int) and down >= 1 - px0, px1, py0, py1 = _parse_padding(padding) - assert gain == float(gain) and gain > 0 - gain = float(gain) - assert slope == float(slope) and slope >= 0 - slope = float(slope) - assert clamp is None or (clamp == float(clamp) and clamp >= 0) - clamp = float(clamp if clamp is not None else 'inf') - - # Lookup from cache. - key = (up, down, px0, px1, py0, py1, gain, slope, clamp, flip_filter) - if key in _filtered_lrelu_cuda_cache: - return _filtered_lrelu_cuda_cache[key] - - # Forward op. - class FilteredLReluCuda(torch.autograd.Function): - @staticmethod - def forward(ctx, x, fu, fd, b, si, sx, sy): # pylint: disable=arguments-differ - assert isinstance(x, torch.Tensor) and x.ndim == 4 - - # Replace empty up/downsample kernels with full 1x1 kernels (faster than separable). - if fu is None: - fu = torch.ones([1, 1], dtype=torch.float32, device=x.device) - if fd is None: - fd = torch.ones([1, 1], dtype=torch.float32, device=x.device) - assert 1 <= fu.ndim <= 2 - assert 1 <= fd.ndim <= 2 - - # Replace separable 1x1 kernels with full 1x1 kernels when scale factor is 1. - if up == 1 and fu.ndim == 1 and fu.shape[0] == 1: - fu = fu.square()[None] - if down == 1 and fd.ndim == 1 and fd.shape[0] == 1: - fd = fd.square()[None] - - # Missing sign input tensor. - if si is None: - si = torch.empty([0]) - - # Missing bias tensor. - if b is None: - b = torch.zeros([x.shape[1]], dtype=x.dtype, device=x.device) - - # Construct internal sign tensor only if gradients are needed. - write_signs = (si.numel() == 0) and ( - x.requires_grad or b.requires_grad) - - # Warn if input storage strides are not in decreasing order due to e.g. channels-last layout. - strides = [x.stride(i) for i in range(x.ndim) if x.size(i) > 1] - if any(a < b for a, b in zip(strides[:-1], strides[1:])): - warnings.warn( - "low-performance memory layout detected in filtered_lrelu input", RuntimeWarning) - - # Call C++/Cuda plugin if datatype is supported. - if x.dtype in [torch.float16, torch.float32]: - if torch.cuda.current_stream(x.device) != torch.cuda.default_stream(x.device): - warnings.warn( - "filtered_lrelu called with non-default cuda stream but concurrent execution is not supported", RuntimeWarning) - y, so, return_code = _plugin.filtered_lrelu( - x, fu, fd, b, si, up, down, px0, px1, py0, py1, sx, sy, gain, slope, clamp, flip_filter, write_signs) - else: - return_code = -1 - - # No Cuda kernel found? Fall back to generic implementation. Still more memory efficient than the reference implementation because - # only the bit-packed sign tensor is retained for gradient computation. - if return_code < 0: - warnings.warn( - "filtered_lrelu called with parameters that have no optimized CUDA kernel, using generic fallback", RuntimeWarning) - - y = x.add(b.unsqueeze(-1).unsqueeze(-1)) # Add bias. - # Upsample. - y = upfirdn2d.upfirdn2d(x=y, f=fu, up=up, padding=[ - px0, px1, py0, py1], gain=up**2, flip_filter=flip_filter) - # Activation function and sign handling. Modifies y in-place. - so = _plugin.filtered_lrelu_act_( - y, si, sx, sy, gain, slope, clamp, write_signs) - # Downsample. - y = upfirdn2d.upfirdn2d( - x=y, f=fd, down=down, flip_filter=flip_filter) - - # Prepare for gradient computation. - ctx.save_for_backward(fu, fd, (si if si.numel() else so)) - ctx.x_shape = x.shape - ctx.y_shape = y.shape - ctx.s_ofs = sx, sy - return y - - @staticmethod - def backward(ctx, dy): # pylint: disable=arguments-differ - fu, fd, si = ctx.saved_tensors - _, _, xh, xw = ctx.x_shape - _, _, yh, yw = ctx.y_shape - sx, sy = ctx.s_ofs - dx = None # 0 - dfu = None - assert not ctx.needs_input_grad[1] - dfd = None - assert not ctx.needs_input_grad[2] - db = None # 3 - dsi = None - assert not ctx.needs_input_grad[4] - dsx = None - assert not ctx.needs_input_grad[5] - dsy = None - assert not ctx.needs_input_grad[6] - - if ctx.needs_input_grad[0] or ctx.needs_input_grad[3]: - pp = [ - (fu.shape[-1] - 1) + (fd.shape[-1] - 1) - px0, - xw * up - yw * down + px0 - (up - 1), - (fu.shape[0] - 1) + (fd.shape[0] - 1) - py0, - xh * up - yh * down + py0 - (up - 1), - ] - gg = gain * (up ** 2) / (down ** 2) - ff = (not flip_filter) - sx = sx - (fu.shape[-1] - 1) + px0 - sy = sy - (fu.shape[0] - 1) + py0 - dx = _filtered_lrelu_cuda(up=down, down=up, padding=pp, gain=gg, slope=slope, - clamp=None, flip_filter=ff).apply(dy, fd, fu, None, si, sx, sy) - - if ctx.needs_input_grad[3]: - db = dx.sum([0, 2, 3]) - - return dx, dfu, dfd, db, dsi, dsx, dsy - - # Add to cache. - _filtered_lrelu_cuda_cache[key] = FilteredLReluCuda - return FilteredLReluCuda - -# ---------------------------------------------------------------------------- diff --git a/spaces/h2oai/h2ogpt-chatbot/src/gradio_utils/css.py b/spaces/h2oai/h2ogpt-chatbot/src/gradio_utils/css.py deleted file mode 100644 index 6f3d0dd56bfd4287034afd0b23751e3abd59a143..0000000000000000000000000000000000000000 --- a/spaces/h2oai/h2ogpt-chatbot/src/gradio_utils/css.py +++ /dev/null @@ -1,148 +0,0 @@ -def get_css(kwargs) -> str: - if kwargs['h2ocolors']: - css_code = """footer {visibility: hidden;} - body{background:linear-gradient(#f5f5f5,#e5e5e5);} - body.dark{background:linear-gradient(#000000,#0d0d0d);} - """ - else: - css_code = """footer {visibility: hidden}""" - - css_code += make_css_base() - return css_code - - -def make_css_base() -> str: - return """ - #col_container {margin-left: auto; margin-right: auto; text-align: left;} - - @import url('https://fonts.googleapis.com/css2?family=Source+Sans+Pro:wght@400;600&display=swap'); - - body.dark{#warning {background-color: #555555};} - - #sidebar { - order: 1; - - @media (max-width: 463px) { - order: 2; - } - } - - #col-tabs { - order: 2; - - @media (max-width: 463px) { - order: 1; - } - } - - #small_btn { - margin: 0.6em 0em 0.55em 0; - max-width: 20em; - min-width: 5em !important; - height: 5em; - font-size: 14px !important; - } - - #prompt-form { - border: 1px solid var(--primary-500) !important; - } - - #prompt-form.block { - border-radius: var(--block-radius) !important; - } - - #prompt-form textarea { - border: 1px solid rgb(209, 213, 219); - } - - #prompt-form label > div { - margin-top: 4px; - } - - button.primary:hover { - background-color: var(--primary-600) !important; - transition: .2s; - } - - #prompt-form-area { - margin-bottom: 2.5rem; - } - .chatsmall chatbot {font-size: 10px !important} - - .gradio-container { - max-width: none !important; - } - - div.message { - padding: var(--text-lg) !important; - } - - div.message.user > div.icon-button { - top: unset; - bottom: 0; - } - - div.message.bot > div.icon-button { - top: unset; - bottom: 0; - } - - #prompt-form-row { - position: relative; - } - - #attach-button { - position: absolute; - top: 45px; - right: 20px; - - display: flex; - justify-content: center; - border: 1px solid var(--primary-500) !important; - - @media (max-width: 463px) { - width: 56px; - } - } - - #attach-button > img { - margin-right: 0; - } - - #prompt-form > label > textarea { - padding-right: 104px; - - @media (max-width: 463px) { - min-height: 94px; - padding-right: 70px; - } - } - - #visible-models > label > div.wrap > div.wrap-inner > div.secondary-wrap > div.remove-all { - display: none !important; - } - - #visible-models > label > div.wrap > div.wrap-inner > div.token { - display: none !important; - } - - #visible-models > label > div.wrap > div.wrap-inner > div.secondary-wrap::before { - content: "Select"; - padding: 0 4px; - margin-right: 2px; - } - - #langchain_agents > label > div.wrap > div.wrap-inner > div.secondary-wrap > div.remove-all { - display: none !important; - } - - #langchain_agents > label > div.wrap > div.wrap-inner > div.token { - display: none !important; - } - - #langchain_agents > label > div.wrap > div.wrap-inner > div.secondary-wrap::before { - content: "Select"; - padding: 0 4px; - margin-right: 2px; - } - """ diff --git a/spaces/hackathon-somos-nlp-2023/vg055-demo_analisis_de_sentimientos_textos_turisticos_mx_polarity/app.py b/spaces/hackathon-somos-nlp-2023/vg055-demo_analisis_de_sentimientos_textos_turisticos_mx_polarity/app.py deleted file mode 100644 index 409856f5d3806123cf0692222fe7327d6bd0c582..0000000000000000000000000000000000000000 --- a/spaces/hackathon-somos-nlp-2023/vg055-demo_analisis_de_sentimientos_textos_turisticos_mx_polarity/app.py +++ /dev/null @@ -1,10 +0,0 @@ -import gradio as gr - -examples = [["Pagamos un precio completo para una visita mínima.Hay un recorrido muy pequeño: no es possible salir del recorrido y ir alrededor de los monumentos como se puede hacer a Palenque o Teatihuacan o muchos otros sitios pero el peor es que no se puede ver el Tajin chico ni tampoco ĺa Gran Greca sin hablar del museo... solo se puede ver el Tajin viejo y malo no se justifica eso es un puro robo y un falta de respecto del visitante y lo repito : pagamos el precio completo.!!!"], - ["Se reservó la habitación deluxe, por una tarifa similar a un hotel de 5 estrellas, la habitación deja mucho que desear, huele a humedad, las ventanas no estaban limpias, estaban manchadas de grasa (posiblemente de huéspedes anteriores), la cabecera de la cama está caída, el baño se ve viejo, con sarro en sus llaves, incluso hay una dos goteras en el techo, se desconoce de donde proviene el agua, o si es agua residual, la cama es algo dura, lo unico bueno es la proximidad al centro de Monterrey, si pueden evítenlo, por este precio encuentran mejores."], - ["El lugar tiene una vista nocturna muy linda, sin embargo creo que el precio no corresponde al servicio ofertado. Lineas de espera para subir y bajar a veces muy largas, más un recorrido muy corto..."], - ["La comida es muy buena, desde las entradas hasta los postres son una delicia, la atención de los meseros es muy buena y el sitio es muy cómodo; sin embargo los precios son excesivos para lo que ofrecen."], - ["Hermoso lugar para admirar las obras de Botero.Me encantó,porque el lugar es aseado,ordenado y cuenta con baño y tienda para el público que lo visita."] - ] - -gr.Interface.load("huggingface/vg055/roberta-base-bne-finetuned-analisis-sentimiento-textos-turisticos-mx-polaridad", examples=examples, title="Análisis de sentimientos (Polaridad) en textos turísticos mexicanos para el Rest-Mex 2023", description="Dada una opinión de un turista de TripAdvisor se identifica el gradod de polaridad (5 clases) de la opinión. Donde 0 es la polaridad más negativa y 4 es la polaridad más positiva").launch(); \ No newline at end of file diff --git a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/data/datasets/evaluation/od_to_grounding/__init__.py b/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/data/datasets/evaluation/od_to_grounding/__init__.py deleted file mode 100644 index a8dd36e812b2e1f123a47f5abe9d6b2290f02975..0000000000000000000000000000000000000000 --- a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/data/datasets/evaluation/od_to_grounding/__init__.py +++ /dev/null @@ -1,20 +0,0 @@ -from .od_eval import do_od_evaluation - - -def od_to_grounding_evaluation( - dataset, - predictions, - output_folder, - box_only=False, - iou_types=("bbox",), - expected_results=(), - expected_results_sigma_tol=4, ): - return do_od_evaluation( - dataset=dataset, - predictions=predictions, - box_only=box_only, - output_folder=output_folder, - iou_types=iou_types, - expected_results=expected_results, - expected_results_sigma_tol=expected_results_sigma_tol, - ) diff --git a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/detectron2/data/datasets/builtin.py b/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/detectron2/data/datasets/builtin.py deleted file mode 100644 index 21ac2228c56d59b38c9288fd720aab5fdc63ac0b..0000000000000000000000000000000000000000 --- a/spaces/hasibzunair/fifa-tryon-demo/Self-Correction-Human-Parsing-for-ACGPN/mhp_extension/detectron2/detectron2/data/datasets/builtin.py +++ /dev/null @@ -1,220 +0,0 @@ -# -*- coding: utf-8 -*- -# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved - - -""" -This file registers pre-defined data at hard-coded paths, and their metadata. - -We hard-code metadata for common data. This will enable: -1. Consistency check when loading the data -2. Use models on these standard data directly and run demos, - without having to download the dataset annotations - -We hard-code some paths to the dataset that's assumed to -exist in "./data/". - -Users SHOULD NOT use this file to create new dataset / metadata for new dataset. -To add new dataset, refer to the tutorial "docs/DATASETS.md". -""" - -import os - -from detectron2.data import DatasetCatalog, MetadataCatalog - -from .builtin_meta import _get_builtin_metadata -from .cityscapes import load_cityscapes_instances, load_cityscapes_semantic -from .lvis import get_lvis_instances_meta, register_lvis_instances -from .pascal_voc import register_pascal_voc -from .register_coco import register_coco_instances, register_coco_panoptic_separated - -# ==== Predefined data and splits for COCO ========== - -_PREDEFINED_SPLITS_COCO = {} -_PREDEFINED_SPLITS_COCO["coco"] = { - "coco_2014_train": ("coco/train2014", "coco/annotations/instances_train2014.json"), - "coco_2014_val": ("coco/val2014", "coco/annotations/instances_val2014.json"), - "coco_2014_minival": ("coco/val2014", "coco/annotations/instances_minival2014.json"), - "coco_2014_minival_100": ("coco/val2014", "coco/annotations/instances_minival2014_100.json"), - "coco_2014_valminusminival": ( - "coco/val2014", - "coco/annotations/instances_valminusminival2014.json", - ), - "coco_2017_train": ("coco/train2017", "coco/annotations/instances_train2017.json"), - "coco_2017_val": ("coco/val2017", "coco/annotations/instances_val2017.json"), - "coco_2017_test": ("coco/test2017", "coco/annotations/image_info_test2017.json"), - "coco_2017_test-dev": ("coco/test2017", "coco/annotations/image_info_test-dev2017.json"), - "coco_2017_val_100": ("coco/val2017", "coco/annotations/instances_val2017_100.json"), -} - -_PREDEFINED_SPLITS_COCO["coco_person"] = { - "keypoints_coco_2014_train": ( - "coco/train2014", - "coco/annotations/person_keypoints_train2014.json", - ), - "keypoints_coco_2014_val": ("coco/val2014", "coco/annotations/person_keypoints_val2014.json"), - "keypoints_coco_2014_minival": ( - "coco/val2014", - "coco/annotations/person_keypoints_minival2014.json", - ), - "keypoints_coco_2014_valminusminival": ( - "coco/val2014", - "coco/annotations/person_keypoints_valminusminival2014.json", - ), - "keypoints_coco_2014_minival_100": ( - "coco/val2014", - "coco/annotations/person_keypoints_minival2014_100.json", - ), - "keypoints_coco_2017_train": ( - "coco/train2017", - "coco/annotations/person_keypoints_train2017.json", - ), - "keypoints_coco_2017_val": ("coco/val2017", "coco/annotations/person_keypoints_val2017.json"), - "keypoints_coco_2017_val_100": ( - "coco/val2017", - "coco/annotations/person_keypoints_val2017_100.json", - ), -} - - -_PREDEFINED_SPLITS_COCO_PANOPTIC = { - "coco_2017_train_panoptic": ( - # This is the original panoptic annotation directory - "coco/panoptic_train2017", - "coco/annotations/panoptic_train2017.json", - # This directory contains semantic annotations that are - # converted from panoptic annotations. - # It is used by PanopticFPN. - # You can use the script at detectron2/data/prepare_panoptic_fpn.py - # to create these directories. - "coco/panoptic_stuff_train2017", - ), - "coco_2017_val_panoptic": ( - "coco/panoptic_val2017", - "coco/annotations/panoptic_val2017.json", - "coco/panoptic_stuff_val2017", - ), - "coco_2017_val_100_panoptic": ( - "coco/panoptic_val2017_100", - "coco/annotations/panoptic_val2017_100.json", - "coco/panoptic_stuff_val2017_100", - ), -} - - -def register_all_coco(root): - for dataset_name, splits_per_dataset in _PREDEFINED_SPLITS_COCO.items(): - for key, (image_root, json_file) in splits_per_dataset.items(): - # Assume pre-defined data live in `./data`. - register_coco_instances( - key, - _get_builtin_metadata(dataset_name), - os.path.join(root, json_file) if "://" not in json_file else json_file, - os.path.join(root, image_root), - ) - - for ( - prefix, - (panoptic_root, panoptic_json, semantic_root), - ) in _PREDEFINED_SPLITS_COCO_PANOPTIC.items(): - prefix_instances = prefix[: -len("_panoptic")] - instances_meta = MetadataCatalog.get(prefix_instances) - image_root, instances_json = instances_meta.image_root, instances_meta.json_file - register_coco_panoptic_separated( - prefix, - _get_builtin_metadata("coco_panoptic_separated"), - image_root, - os.path.join(root, panoptic_root), - os.path.join(root, panoptic_json), - os.path.join(root, semantic_root), - instances_json, - ) - - -# ==== Predefined data and splits for LVIS ========== - - -_PREDEFINED_SPLITS_LVIS = { - "lvis_v0.5": { - "lvis_v0.5_train": ("coco/train2017", "lvis/lvis_v0.5_train.json"), - "lvis_v0.5_val": ("coco/val2017", "lvis/lvis_v0.5_val.json"), - "lvis_v0.5_val_rand_100": ("coco/val2017", "lvis/lvis_v0.5_val_rand_100.json"), - "lvis_v0.5_test": ("coco/test2017", "lvis/lvis_v0.5_image_info_test.json"), - }, - "lvis_v0.5_cocofied": { - "lvis_v0.5_train_cocofied": ("coco/train2017", "lvis/lvis_v0.5_train_cocofied.json"), - "lvis_v0.5_val_cocofied": ("coco/val2017", "lvis/lvis_v0.5_val_cocofied.json"), - }, -} - - -def register_all_lvis(root): - for dataset_name, splits_per_dataset in _PREDEFINED_SPLITS_LVIS.items(): - for key, (image_root, json_file) in splits_per_dataset.items(): - # Assume pre-defined data live in `./data`. - register_lvis_instances( - key, - get_lvis_instances_meta(dataset_name), - os.path.join(root, json_file) if "://" not in json_file else json_file, - os.path.join(root, image_root), - ) - - -# ==== Predefined splits for raw cityscapes images =========== - - -_RAW_CITYSCAPES_SPLITS = { - "cityscapes_fine_{task}_train": ("cityscapes/leftImg8bit/train", "cityscapes/gtFine/train"), - "cityscapes_fine_{task}_val": ("cityscapes/leftImg8bit/val", "cityscapes/gtFine/val"), - "cityscapes_fine_{task}_test": ("cityscapes/leftImg8bit/test", "cityscapes/gtFine/test"), -} - - -def register_all_cityscapes(root): - for key, (image_dir, gt_dir) in _RAW_CITYSCAPES_SPLITS.items(): - meta = _get_builtin_metadata("cityscapes") - image_dir = os.path.join(root, image_dir) - gt_dir = os.path.join(root, gt_dir) - - inst_key = key.format(task="instance_seg") - DatasetCatalog.register( - inst_key, - lambda x=image_dir, y=gt_dir: load_cityscapes_instances( - x, y, from_json=True, to_polygons=True - ), - ) - MetadataCatalog.get(inst_key).set( - image_dir=image_dir, gt_dir=gt_dir, evaluator_type="cityscapes_instance", **meta - ) - - sem_key = key.format(task="sem_seg") - DatasetCatalog.register( - sem_key, lambda x=image_dir, y=gt_dir: load_cityscapes_semantic(x, y) - ) - MetadataCatalog.get(sem_key).set( - image_dir=image_dir, gt_dir=gt_dir, evaluator_type="cityscapes_sem_seg", **meta - ) - - -# ==== Predefined splits for PASCAL VOC =========== -def register_all_pascal_voc(root): - SPLITS = [ - ("voc_2007_trainval", "VOC2007", "trainval"), - ("voc_2007_train", "VOC2007", "train"), - ("voc_2007_val", "VOC2007", "val"), - ("voc_2007_test", "VOC2007", "test"), - ("voc_2012_trainval", "VOC2012", "trainval"), - ("voc_2012_train", "VOC2012", "train"), - ("voc_2012_val", "VOC2012", "val"), - ] - for name, dirname, split in SPLITS: - year = 2007 if "2007" in name else 2012 - register_pascal_voc(name, os.path.join(root, dirname), split, year) - MetadataCatalog.get(name).evaluator_type = "pascal_voc" - - -# Register them all under "./data" -_root = os.getenv("DETECTRON2_DATASETS", "data") -register_all_coco(_root) -register_all_lvis(_root) -register_all_cityscapes(_root) -register_all_pascal_voc(_root) diff --git a/spaces/hdhzk/bingo/src/pages/api/kblob.ts b/spaces/hdhzk/bingo/src/pages/api/kblob.ts deleted file mode 100644 index 0ce7e6063cdc06838e76f1cff1d5982d34ef52de..0000000000000000000000000000000000000000 --- a/spaces/hdhzk/bingo/src/pages/api/kblob.ts +++ /dev/null @@ -1,56 +0,0 @@ -'use server' - -import { NextApiRequest, NextApiResponse } from 'next' -import FormData from 'form-data' -import { fetch } from '@/lib/isomorphic' -import { KBlobRequest } from '@/lib/bots/bing/types' - -const API_DOMAIN = 'https://bing.vcanbb.top' - -export const config = { - api: { - bodyParser: { - sizeLimit: '10mb' // Set desired value here - } - } -} - -export default async function handler(req: NextApiRequest, res: NextApiResponse) { - try { - const { knowledgeRequest, imageBase64 } = req.body as KBlobRequest - - const formData = new FormData() - formData.append('knowledgeRequest', JSON.stringify(knowledgeRequest)) - if (imageBase64) { - formData.append('imageBase64', imageBase64) - } - - const response = await fetch(`${API_DOMAIN}/images/kblob`, - { - method: 'POST', - body: formData.getBuffer(), - headers: { - "sec-ch-ua": "\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"", - "sec-ch-ua-mobile": "?0", - "sec-ch-ua-platform": "\"Windows\"", - "Referer": `${API_DOMAIN}/web/index.html`, - "Referrer-Policy": "origin-when-cross-origin", - 'x-ms-useragent': 'azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.0 OS/Win32', - ...formData.getHeaders() - } - } - ).then(res => res.text()) - - res.writeHead(200, { - 'Content-Type': 'application/json', - }) - res.end(response || JSON.stringify({ result: { value: 'UploadFailed', message: '请更换 IP 或代理后重试' } })) - } catch (e) { - return res.json({ - result: { - value: 'UploadFailed', - message: `${e}` - } - }) - } -} diff --git a/spaces/hdhzk/bingo/tests/kblob.ts b/spaces/hdhzk/bingo/tests/kblob.ts deleted file mode 100644 index 9e15b41c1c94a690beb61b23cdb42fc78767ccd2..0000000000000000000000000000000000000000 --- a/spaces/hdhzk/bingo/tests/kblob.ts +++ /dev/null @@ -1,27 +0,0 @@ -import FormData from 'form-data' - -import { fetch } from '@/lib/isomorphic' - -const formData = new FormData() - -const knowledgeRequest = {"imageInfo":{"url":"https://www.baidu.com/img/PCfb_5bf082d29588c07f842ccde3f97243ea.png"},"knowledgeRequest":{"invokedSkills":["ImageById"],"subscriptionId":"Bing.Chat.Multimodal","invokedSkillsRequestData":{"enableFaceBlur":true},"convoData":{"convoid":"51D|BingProdUnAuthenticatedUsers|E3DCA904FF236C67C3450163BCEC64CFF3F618CC8A4AFD75FD518F5ED0ADA080","convotone":"Creative"}}} - -formData.append('knowledgeRequest', JSON.stringify(knowledgeRequest)) - - -fetch('https://bing.vcanbb.top/images/kblob', - { - method: 'POST', - body: formData.getBuffer(), - headers: { - "sec-ch-ua": "\"Not/A)Brand\";v=\"99\", \"Google Chrome\";v=\"115\", \"Chromium\";v=\"115\"", - "sec-ch-ua-mobile": "?0", - "sec-ch-ua-platform": "\"Windows\"", - "Referer": "https://bing.vcanbb.top/web/index.html", - "Referrer-Policy": "origin-when-cross-origin", - ...formData.getHeaders() - } - - } -).then(res => res.text()) -.then(res => console.log('res', res)) diff --git a/spaces/hhalim/dataViz-mermaid/README.md b/spaces/hhalim/dataViz-mermaid/README.md deleted file mode 100644 index 6abdfd329ab8a7bf3fe174b512c0677a42041c86..0000000000000000000000000000000000000000 --- a/spaces/hhalim/dataViz-mermaid/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Plotly Graphing Libraries Streamlit -emoji: 💻 -colorFrom: yellow -colorTo: purple -sdk: streamlit -sdk_version: 1.17.0 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/training/network_training/nnUNet_variants/resampling/nnUNetTrainerV2_resample33.py b/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/training/network_training/nnUNet_variants/resampling/nnUNetTrainerV2_resample33.py deleted file mode 100644 index 7111e82f0428e7d913e717471189a10ce3bdb34b..0000000000000000000000000000000000000000 --- a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/training/network_training/nnUNet_variants/resampling/nnUNetTrainerV2_resample33.py +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright 2020 Division of Medical Image Computing, German Cancer Research Center (DKFZ), Heidelberg, Germany -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - - -from nnunet.inference.segmentation_export import save_segmentation_nifti_from_softmax -from nnunet.training.network_training.nnUNetTrainerV2 import nnUNetTrainerV2 - - -class nnUNetTrainerV2_resample33(nnUNetTrainerV2): - def validate(self, do_mirroring: bool = True, use_sliding_window: bool = True, - step_size: float = 0.5, save_softmax: bool = True, use_gaussian: bool = True, overwrite: bool = True, - validation_folder_name: str = 'validation_raw', debug: bool = False, all_in_gpu: bool = False, - segmentation_export_kwargs: dict = None, run_postprocessing_on_folds: bool = True): - return super().validate(do_mirroring=do_mirroring, use_sliding_window=use_sliding_window, step_size=step_size, - save_softmax=save_softmax, use_gaussian=use_gaussian, overwrite=overwrite, - validation_folder_name=validation_folder_name, debug=debug, all_in_gpu=all_in_gpu, - segmentation_export_kwargs=segmentation_export_kwargs, - run_postprocessing_on_folds=run_postprocessing_on_folds) - - def preprocess_predict_nifti(self, input_files, output_file=None, softmax_ouput_file=None, - mixed_precision: bool = True): - """ - Use this to predict new data - :param input_files: - :param output_file: - :param softmax_ouput_file: - :param mixed_precision: - :return: - """ - print("preprocessing...") - d, s, properties = self.preprocess_patient(input_files) - print("predicting...") - pred = self.predict_preprocessed_data_return_seg_and_softmax(d, do_mirroring=self.data_aug_params["do_mirror"], - mirror_axes=self.data_aug_params['mirror_axes'], - use_sliding_window=True, step_size=0.5, - use_gaussian=True, pad_border_mode='constant', - pad_kwargs={'constant_values': 0}, - all_in_gpu=True, - mixed_precision=mixed_precision)[1] - pred = pred.transpose([0] + [i + 1 for i in self.transpose_backward]) - - print("resampling to original spacing and nifti export...") - save_segmentation_nifti_from_softmax(pred, output_file, properties, 3, None, None, None, softmax_ouput_file, - None, force_separate_z=False, interpolation_order_z=3) - print("done") diff --git a/spaces/huaiji3y/bingo-Public/src/components/user-menu.tsx b/spaces/huaiji3y/bingo-Public/src/components/user-menu.tsx deleted file mode 100644 index 9bd1edc9cf9f39b63629b021f0c1186b1a7c1341..0000000000000000000000000000000000000000 --- a/spaces/huaiji3y/bingo-Public/src/components/user-menu.tsx +++ /dev/null @@ -1,113 +0,0 @@ -'use client' - -import { useEffect, useState } from 'react' -import Image from 'next/image' -import { toast } from 'react-hot-toast' -import { Button } from '@/components/ui/button' -import pkg from '../../package.json' -import { - DropdownMenu, - DropdownMenuContent, - DropdownMenuItem, - DropdownMenuSeparator, - DropdownMenuTrigger -} from '@/components/ui/dropdown-menu' -import { IconCopy, IconExternalLink, IconGitHub } from '@/components/ui/icons' -import SettingIcon from '@/assets/images/settings.svg' -import { useCopyToClipboard } from '@/lib/hooks/use-copy-to-clipboard' - -export function UserMenu() { - const [host, setHost] = useState('') - const { isCopied, copyToClipboard } = useCopyToClipboard({ timeout: 2000 }) - useEffect(() => { - setHost(location.host) - }, []) - - useEffect(() => { - if (isCopied) { - toast.success('复制成功') - } - }, [isCopied]) - return ( --- ) -} diff --git a/spaces/huggingface-timeseries/time-series-score/src/data.py b/spaces/huggingface-timeseries/time-series-score/src/data.py deleted file mode 100644 index 846ec92760b99f642e40e3f66c8b553762833d9a..0000000000000000000000000000000000000000 --- a/spaces/huggingface-timeseries/time-series-score/src/data.py +++ /dev/null @@ -1,30 +0,0 @@ -import pandas as pd -import copy -from gluonts.dataset.common import TrainDatasets -from gluonts.dataset.repository.datasets import get_dataset - -SEASONALITY_MAP = { - "Y": 1, - "Q": 4, - "M": 12, - "W": 1, - "D": 7, - "H": 24, -} - - -def fix_m3_other_start(ts: dict): - new_ts = copy.copy(ts) - new_ts["start"] = pd.Period("1750", freq="Y") - return new_ts - - -def load_dataset(dataset_name) -> TrainDatasets: - data = get_dataset(dataset_name) - # m3_other provided by GluonTS has incorrect freq Q that should be replaced by Y - if dataset_name == "m3_other": - fixed_train = [fix_m3_other_start(ts) for ts in data.train] - fixed_test = [fix_m3_other_start(ts) for ts in data.test] - data = TrainDatasets(metadata=data.metadata, train=fixed_train, test=fixed_test) - data.metadata.freq = "Y" - return data diff --git a/spaces/hussain-shk/IndiSent/indic_nlp_library/README.md b/spaces/hussain-shk/IndiSent/indic_nlp_library/README.md deleted file mode 100644 index 0b7f8a82798e3ee874f8f838a635f89290d3e47e..0000000000000000000000000000000000000000 --- a/spaces/hussain-shk/IndiSent/indic_nlp_library/README.md +++ /dev/null @@ -1,142 +0,0 @@ -# Indic NLP Library - -The goal of the Indic NLP Library is to build Python based libraries for common text processing and Natural Language Processing in Indian languages. Indian languages share a lot of similarity in terms of script, phonology, language syntax, etc. and this library is an attempt to provide a general solution to very commonly required toolsets for Indian language text. - -The library provides the following functionalities: - -- Text Normalization -- Script Information -- Word Tokenization and Detokenization -- Sentence Splitting -- Word Segmentation -- Syllabification -- Script Conversion -- Romanization -- Indicization -- Transliteration -- Translation - -The data resources required by the Indic NLP Library are hosted in a different repository. These resources are required for some modules. You can download from the [Indic NLP Resources](https://github.com/anoopkunchukuttan/indic_nlp_resources) project. - -**If you are interested in Indian language NLP resources, you should check the [Indic NLP Catalog](https://github.com/indicnlpweb/indicnlp_catalog) for pointers.** - -## Pre-requisites - -- Python 3.x - - (For Python 2.x version check the tag `PYTHON_2.7_FINAL_JAN_2019`. Not actively supporting Python 2.x anymore, but will try to maintain as much compatibility as possible) -- [Indic NLP Resources](https://github.com/anoopkunchukuttan/indic_nlp_resources) -- [Urduhack](https://github.com/urduhack/urduhack): Needed only if Urdu normalization is required. It has other dependencies like Tensorflow. -- Other dependencies are listed in setup.py - - -## Configuration - -- Installation from pip: - - `pip install indic-nlp-library` - -- If you want to use the project from the github repo, add the project to the Python Path: - - - Clone this repository - - Install dependencies: `pip install -r requirements.txt` - - Run: `export PYTHONPATH=$PYTHONPATH:- -- - -- -- location.href='#dialog="settings"' - } - className="cursor-pointer" - > - 设置用户 - -- - location.href='#dialog="voice"' - } - className="cursor-pointer" - > - 语音设置 - -- - - 开源地址 - -- - - - - - 托管地址 - 🤗 - -- - - - - 复制站点 - -- - - - -版本信息 {pkg.version}-- - -站点域名-copyToClipboard(host)} className="flex gap-1 text-xs text-zinc-500 cursor-pointer"> - {host}-- ` - -- In either case, export the path to the _Indic NLP Resources_ directory - - Run: `export INDIC_RESOURCES_PATH= ` - -## Usage - -You can use the Python API to access all the features of the library. Many of the most common operations are also accessible via a unified commandline API. - -### Getting Started - -Check [this IPython Notebook](http://nbviewer.ipython.org/url/anoopkunchukuttan.github.io/indic_nlp_library/doc/indic_nlp_examples.ipynb) for examples to use the Python API. - - You can find the Python 2.x Notebook [here](http://nbviewer.ipython.org/url/anoopkunchukuttan.github.io/indic_nlp_library/doc/indic_nlp_examples_2_7.ipynb) - -### Documentation - -You can find detailed documentation [HERE](https://indic-nlp-library.readthedocs.io/en/latest) - -This documents the Python API as well as the commandline reference. - -## Citing - -If you use this library, please include the following citation: - -``` -@misc{kunchukuttan2020indicnlp, -author = "Anoop Kunchukuttan", -title = "{The IndicNLP Library}", -year = "2020", -howpublished={\url{https://github.com/anoopkunchukuttan/indic_nlp_library/blob/master/docs/indicnlp.pdf}} -} -``` -You can find the document [HERE](docs/indicnlp.pdf) - -## Website - -`http://anoopkunchukuttan.github.io/indic_nlp_library` - -## Author -Anoop Kunchukuttan ([anoop.kunchukuttan@gmail.com](anoop.kunchukuttan@gmail.com)) - -## Companies, Organizations, Projects using IndicNLP Library - -- [AI4Bharat-IndicNLPSuite](https://indicnlp.ai4bharat.org) -- [The Classical Language Toolkit](http://cltk.org) -- [Microsoft NLP Recipes](https://github.com/microsoft/nlp-recipes) -- [Facebook M2M-100](https://github.com/pytorch/fairseq/tree/master/examples/m2m_100) - -## Revision Log - - -0.81 : 26 May 2021 - - - Bug fix in version number extraction - -0.80 : 24 May 2021 - - - Improved sentence splitting - - Bug fixes - - Support for Urdu Normalizer - -0.71 : 03 Sep 2020 - - - Improved documentation - - Bug fixes - -0.7 : 02 Apr 2020: - - - Unified commandline - - Improved documentation - - Added setup.py - -0.6 : 16 Dec 2019: - - - New romanizer and indicizer - - Script Unifiers - - Improved script normalizers - - Added contrib directory for sample uses - - changed to MIT license - -0.5 : 03 Jun 2019: - - - Improved word tokenizer to handle dates and numbers. - - Added sentence splitter that can handle common prefixes/honorofics and uses some heuristics. - - Added detokenizer - - Added acronym transliterator that can convert English acronyms to Brahmi-derived scripts - -0.4 : 28 Jan 2019: Ported to Python 3, and lots of feature additions since last release; primarily around script information, script similarity and syllabification. - -0.3 : 21 Oct 2014: Supports morph-analysis between Indian languages - -0.2 : 13 Jun 2014: Supports transliteration between Indian languages and tokenization of Indian languages - -0.1 : 12 Mar 2014: Initial version. Supports text normalization. - -## LICENSE - -Indic NLP Library is released under the MIT license - - diff --git a/spaces/hysts/stylegan3-food101/README.md b/spaces/hysts/stylegan3-food101/README.md deleted file mode 100644 index 99eb866434594c9c99564844c389de24ebd17f58..0000000000000000000000000000000000000000 --- a/spaces/hysts/stylegan3-food101/README.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -title: StyleGAN3 Food101 -emoji: 🦀 -colorFrom: green -colorTo: yellow -sdk: gradio -sdk_version: 3.36.1 -app_file: app.py -pinned: false ---- diff --git a/spaces/iamstolas/STOLAS/src/components/learn-more.tsx b/spaces/iamstolas/STOLAS/src/components/learn-more.tsx deleted file mode 100644 index a64459ee7900a612292e117a6bda96ee9260990f..0000000000000000000000000000000000000000 --- a/spaces/iamstolas/STOLAS/src/components/learn-more.tsx +++ /dev/null @@ -1,39 +0,0 @@ -import React from 'react' -import { SourceAttribution } from '@/lib/bots/bing/types' - -export interface LearnMoreProps { - sourceAttributions?: SourceAttribution[] -} - -export function LearnMore({ sourceAttributions }: LearnMoreProps) { - if (!sourceAttributions?.length) { - return null - } - - return ( - -- ) -} diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Fiza Part 1 In Hindi Free Download [EXCLUSIVE] 1080p.md b/spaces/inplisQlawa/anything-midjourney-v4-1/Fiza Part 1 In Hindi Free Download [EXCLUSIVE] 1080p.md deleted file mode 100644 index 5aef9aff7bd5d7735e4ce4a1b936e3e7f73a4e86..0000000000000000000000000000000000000000 --- a/spaces/inplisQlawa/anything-midjourney-v4-1/Fiza Part 1 In Hindi Free Download [EXCLUSIVE] 1080p.md +++ /dev/null @@ -1,12 +0,0 @@ -了解详细信息:---- {sourceAttributions.map((attribution, index) => { - const { providerDisplayName, seeMoreUrl } = attribution - const { host } = new URL(seeMoreUrl) - return ( - - {index + 1}. {host} - - ) - })} --Fiza part 1 in hindi free download 1080p
Download Zip ››› https://urlin.us/2uEvYU
- -Fiza (2000) HDRip Hindi Full Movie Watch Online HD Print Free Download - TodayPk Movies, TodayPkFiza Hindi, Watch Fiza Hindi Full Movie Online, Full HD DVD. Latest and Top Hindi Movie of India, Bollywood and Hollywood. -Fiza (2000) Hindi Full Movie Online Download - TodayPk Movies - Todaypk . -Fiza - Full Hindi Movie Watch Online, Free Download, HD . -- TodayPk Movies - TodayPk Fiza (2000) Hindi Full Movie Download . -Download Fiza Hindi Movie Mp3 Full - MyMusicMovies, MyMovies . -- MyMusicMovies, MyMovies Mp3 Download - MyMusicMovies, MyMovies . -- MyMusicMovies, MyMovies Mp3 Download - MyMusicMovies, MyMovies . . 8a78ff9644
-
-
- diff --git a/spaces/inreVtussa/clothingai/Examples/Axasoft Cari Hesap Takip Crack 14 UPD.md b/spaces/inreVtussa/clothingai/Examples/Axasoft Cari Hesap Takip Crack 14 UPD.md deleted file mode 100644 index 9fb5b80f2668d4218618b0bbef9c8072ebeb3062..0000000000000000000000000000000000000000 --- a/spaces/inreVtussa/clothingai/Examples/Axasoft Cari Hesap Takip Crack 14 UPD.md +++ /dev/null @@ -1,48 +0,0 @@ - -Axasoft Cari Hesap Takip 14: A Comprehensive Accounting Software for Your Business
- -Are you looking for a comprehensive accounting software that can help you manage your business finances? Do you want to keep track of your cari, kasa, stok, fatura, alış, satış, and other accounts with ease and accuracy? If yes, then you should consider Axasoft Cari Hesap Takip 14. This is a popular and widely used software that can help you handle your accounting needs with efficiency and convenience.
- -In this article, we will introduce you to Axasoft Cari Hesap Takip 14 and its main features, benefits, and tips. We will also show you how to download and install it on your computer with a crack and a keygen. By the end of this article, you will have a clear idea of what Axasoft Cari Hesap Takip 14 can do for you and how to use it effectively.
-axasoft cari hesap takip crack 14
Download File --->>> https://tiurll.com/2uCj9C
- -What is Axasoft Cari Hesap Takip 14?
- -Axasoft Cari Hesap Takip 14 is a software that allows you to manage your cari, kasa, stok, fatura, alış, satış (peşin-taksitli) accounts easily and without any confusion. It is designed for small and medium-sized businesses that need a comprehensive accounting solution.
- -With Axasoft Cari Hesap Takip 14, you can:
- --
-
- Monitor your cari accounts of the firms that you buy from and sell to, and get account statements anytime you want. -
- Manage your kasa accounts of your cash inflows and outflows, and balance your cash flow. -
- Control your stok accounts of your inventory items, and track their movements. -
- Print your fatura accounts of your invoices and delivery notes, and send them to your customers or suppliers. -
- Record your alış accounts of your purchases (cash-credit-installment), and track your costs. -
- Record your satış accounts of your sales (cash-credit-installment), and track your revenues. -
- Use the taksitli satış feature to sell on installment and follow up on the payments. -
- Get detailed reports on all your transactions, and export them to printer, Excel, or Word. -
- Backup your data automatically, and protect it with encryption. -
Axasoft Cari Hesap Takip 14 is a user-friendly software that has a simple interface and easy navigation. You can access all the features from the main menu or the toolbar. You can also customize the settings according to your preferences.
- -What are the benefits of using Axasoft Cari Hesap Takip 14?
- -Using Axasoft Cari Hesap Takip 14 can bring you many benefits for your accounting needs. Here are some of them:
- --
-
- Accuracy: You can avoid errors and mistakes in your accounting records by using Axasoft Cari Hesap Takip 14. The software will calculate everything for you automatically and correctly. -
- Efficiency: You can save time and effort in your accounting tasks by using Axasoft Cari Hesap Takip 14. The software will handle everything for you quickly and smoothly. -
- Convenience: You can access your accounting data anytime and anywhere by using Axasoft Cari Hesap Takip 14. The software will store everything in your computer or in the cloud. -
- Security: You can protect your accounting data from loss or damage by using Axasoft Cari Hesap Takip 14. The software will backup everything regularly and encrypt it with a password. -
- Affordability: You can get Axasoft Cari Hesap Takip 14 for free by using a crack and a keygen. The software will work without any activation or subscription. -
Tips and tricks for using Axasoft Cari Hesap Takip 14
- -Here are some tips and tricks for using Axasoft Cari Hesap Takip 14 effectively and safely:
- --
-
- Avoid updating: If you update Axasoft Cari Hesap Takip 14 after installing the crack, it may overwrite the crack file 3cee63e6c2
-
-
\ No newline at end of file diff --git a/spaces/insaafS/AI-Story-Gen/app.py b/spaces/insaafS/AI-Story-Gen/app.py deleted file mode 100644 index e7d25bd7757b455fc173526ecfb2a54e66d6e532..0000000000000000000000000000000000000000 --- a/spaces/insaafS/AI-Story-Gen/app.py +++ /dev/null @@ -1,24 +0,0 @@ -import gradio as gr -from transformers import pipeline - -generator = pipeline('text-generation', model='gpt2') - - -def generate(text): - result = generator(text, max_length=150, num_return_sequences=1) - return result[0]["generated_text"] - - -examples = [ - ["Once upon a time in a mystical land, there lived a brave knight"], -] - -iface = gr.Interface( - fn=generate, - inputs=gr.inputs.Textbox(lines=2, label="Enter the story prompt..."), - outputs=gr.outputs.Textbox(label="Generated Story"), - examples=examples, - description="Generate creative stories with the AI storyteller!" -) - -iface.launch(share=False) diff --git a/spaces/internetsignal/Bark-w-voice-clone/app.py b/spaces/internetsignal/Bark-w-voice-clone/app.py deleted file mode 100644 index d0b05986e16586a46c44132d28a2bb481348364e..0000000000000000000000000000000000000000 --- a/spaces/internetsignal/Bark-w-voice-clone/app.py +++ /dev/null @@ -1,313 +0,0 @@ -import os - -#os.system("pip install git+https://github.com/suno-ai/bark.git") - -from bark.generation import SUPPORTED_LANGS -from bark import SAMPLE_RATE, generate_audio -from scipy.io.wavfile import write as write_wav -from datetime import datetime - -import shutil -import gradio as gr - -import sys - -import string -import time -import argparse -import json - -import numpy as np -# import IPython -# from IPython.display import Audio - -import torch - -from TTS.tts.utils.synthesis import synthesis -from TTS.tts.utils.text.symbols import make_symbols, phonemes, symbols -try: - from TTS.utils.audio import AudioProcessor -except: - from TTS.utils.audio import AudioProcessor - - -from TTS.tts.models import setup_model -from TTS.config import load_config -from TTS.tts.models.vits import * - -from TTS.tts.utils.speakers import SpeakerManager -from pydub import AudioSegment - -# from google.colab import files -import librosa - -from scipy.io.wavfile import write, read - -import subprocess - -''' -from google.colab import drive -drive.mount('/content/drive') -src_path = os.path.join(os.path.join(os.path.join(os.path.join(os.getcwd(), 'drive'), 'MyDrive'), 'Colab Notebooks'), 'best_model_latest.pth.tar') -dst_path = os.path.join(os.getcwd(), 'best_model.pth.tar') -shutil.copy(src_path, dst_path) -''' - -TTS_PATH = "TTS/" - -# add libraries into environment -sys.path.append(TTS_PATH) # set this if TTS is not installed globally - -# Paths definition - -OUT_PATH = 'out/' - -# create output path -os.makedirs(OUT_PATH, exist_ok=True) - -# model vars -MODEL_PATH = 'best_model.pth.tar' -CONFIG_PATH = 'config.json' -TTS_LANGUAGES = "language_ids.json" -TTS_SPEAKERS = "speakers.json" -USE_CUDA = torch.cuda.is_available() - -# load the config -C = load_config(CONFIG_PATH) - -# load the audio processor -ap = AudioProcessor(**C.audio) - -speaker_embedding = None - -C.model_args['d_vector_file'] = TTS_SPEAKERS -C.model_args['use_speaker_encoder_as_loss'] = False - -model = setup_model(C) -model.language_manager.set_language_ids_from_file(TTS_LANGUAGES) -# print(model.language_manager.num_languages, model.embedded_language_dim) -# print(model.emb_l) -cp = torch.load(MODEL_PATH, map_location=torch.device('cpu')) -# remove speaker encoder -model_weights = cp['model'].copy() -for key in list(model_weights.keys()): - if "speaker_encoder" in key: - del model_weights[key] - -model.load_state_dict(model_weights) - -model.eval() - -if USE_CUDA: - model = model.cuda() - -# synthesize voice -use_griffin_lim = False - -# Paths definition - -CONFIG_SE_PATH = "config_se.json" -CHECKPOINT_SE_PATH = "SE_checkpoint.pth.tar" - -# Load the Speaker encoder - -SE_speaker_manager = SpeakerManager(encoder_model_path=CHECKPOINT_SE_PATH, encoder_config_path=CONFIG_SE_PATH, use_cuda=USE_CUDA) - -# Define helper function - -def compute_spec(ref_file): - y, sr = librosa.load(ref_file, sr=ap.sample_rate) - spec = ap.spectrogram(y) - spec = torch.FloatTensor(spec).unsqueeze(0) - return spec - - -def voice_conversion(ta, ra, da): - - target_audio = 'target.wav' - reference_audio = 'reference.wav' - driving_audio = 'driving.wav' - - write(target_audio, ta[0], ta[1]) - write(reference_audio, ra[0], ra[1]) - write(driving_audio, da[0], da[1]) - - # !ffmpeg-normalize $target_audio -nt rms -t=-27 -o $target_audio -ar 16000 -f - # !ffmpeg-normalize $reference_audio -nt rms -t=-27 -o $reference_audio -ar 16000 -f - # !ffmpeg-normalize $driving_audio -nt rms -t=-27 -o $driving_audio -ar 16000 -f - - files = [target_audio, reference_audio, driving_audio] - - for file in files: - subprocess.run(["ffmpeg-normalize", file, "-nt", "rms", "-t=-27", "-o", file, "-ar", "16000", "-f"]) - - # ta_ = read(target_audio) - - target_emb = SE_speaker_manager.compute_d_vector_from_clip([target_audio]) - target_emb = torch.FloatTensor(target_emb).unsqueeze(0) - - driving_emb = SE_speaker_manager.compute_d_vector_from_clip([reference_audio]) - driving_emb = torch.FloatTensor(driving_emb).unsqueeze(0) - - # Convert the voice - - driving_spec = compute_spec(driving_audio) - y_lengths = torch.tensor([driving_spec.size(-1)]) - if USE_CUDA: - ref_wav_voc, _, _ = model.voice_conversion(driving_spec.cuda(), y_lengths.cuda(), driving_emb.cuda(), target_emb.cuda()) - ref_wav_voc = ref_wav_voc.squeeze().cpu().detach().numpy() - else: - ref_wav_voc, _, _ = model.voice_conversion(driving_spec, y_lengths, driving_emb, target_emb) - ref_wav_voc = ref_wav_voc.squeeze().detach().numpy() - - # print("Reference Audio after decoder:") - # IPython.display.display(Audio(ref_wav_voc, rate=ap.sample_rate)) - - return (ap.sample_rate, ref_wav_voc) - -def generate_text_to_speech(text_prompt, selected_speaker, text_temp, waveform_temp): - audio_array = generate_audio(text_prompt, selected_speaker, text_temp, waveform_temp) - - now = datetime.now() - date_str = now.strftime("%m-%d-%Y") - time_str = now.strftime("%H-%M-%S") - - outputs_folder = os.path.join(os.getcwd(), "outputs") - if not os.path.exists(outputs_folder): - os.makedirs(outputs_folder) - - sub_folder = os.path.join(outputs_folder, date_str) - if not os.path.exists(sub_folder): - os.makedirs(sub_folder) - - file_name = f"audio_{time_str}.wav" - file_path = os.path.join(sub_folder, file_name) - write_wav(file_path, SAMPLE_RATE, audio_array) - - return file_path - - -speakers_list = [] - -for lang, code in SUPPORTED_LANGS: - for n in range(10): - speakers_list.append(f"{code}_speaker_{n}") - -examples1 = [["ref.wav", "Bark.wav", "Bark.wav"]] - -with gr.Blocks() as demo: - gr.Markdown( - f""" #🐶🎶🥳 - Bark with Voice Cloning - - ###🤗 - Powered by [Bark](https://huggingface.co/spaces/suno/bark) and [YourTTS](https://github.com/Edresson/YourTTS). Inspired by [bark-webui](https://github.com/makawy7/bark-webui). - 1. You can duplicate and use it with a GPU:- 2. First use Bark to generate audio from text and then use YourTTS to get new audio in a custom voice you like. Easy to use! - 3. For voice cloning, longer reference audio (~90s) will generally lead to better quality of the cloned speech. Also, please make sure the input audio generated by Bark is not too short. - """ - ) - - with gr.Row().style(equal_height=True): - inp1 = gr.Textbox(label="Input Text", lines=4, placeholder="Enter text here...") - - inp3 = gr.Slider( - 0.1, - 1.0, - value=0.7, - label="Generation Temperature", - info="1.0 more diverse, 0.1 more conservative", - ) - - inp4 = gr.Slider( - 0.1, 1.0, value=0.7, label="Waveform Temperature", info="1.0 more diverse, 0.1 more conservative" - ) - with gr.Row().style(equal_height=True): - - inp2 = gr.Dropdown(speakers_list, value=speakers_list[1], label="Acoustic Prompt") - - button = gr.Button("Generate using Bark") - - out1 = gr.Audio(label="Generated Audio") - - button.click(generate_text_to_speech, [inp1, inp2, inp3, inp4], [out1]) - - - with gr.Row().style(equal_height=True): - inp5 = gr.Audio(label="Upload Reference Audio for Voice Cloning Here") - inp6 = out1 - inp7 = out1 - - btn = gr.Button("Generate using YourTTS") - out2 = gr.Audio(label="Generated Audio in a Custom Voice") - - btn.click(voice_conversion, [inp5, inp6, inp7], [out2]) - - gr.Examples(examples=examples1, fn=voice_conversion, inputs=[inp5, inp6, inp7], - outputs=[out2], cache_examples=True) - - gr.Markdown( - """ ###
NOTE: Please do not generate any audio that is potentially harmful to any person or organization❗ - - """ - ) - gr.Markdown( - """ -###😄 - You may also apply [VoiceFixer](https://huggingface.co/spaces/Kevin676/VoiceFixer) to the generated audio in order to enhance the speech. -## 🌎 Foreign Language -Bark supports various languages out-of-the-box and automatically determines language from input text. \ -When prompted with code-switched text, Bark will even attempt to employ the native accent for the respective languages in the same voice. -Try the prompt: -``` -Buenos días Miguel. Tu colega piensa que tu alemán es extremadamente malo. But I suppose your english isn't terrible. -``` -## 🤭 Non-Speech Sounds -Below is a list of some known non-speech sounds, but we are finding more every day. \ -Please let us know if you find patterns that work particularly well on Discord! -* [laughter] -* [laughs] -* [sighs] -* [music] -* [gasps] -* [clears throat] -* — or ... for hesitations -* ♪ for song lyrics -* capitalization for emphasis of a word -* MAN/WOMAN: for bias towards speaker -Try the prompt: -``` -" [clears throat] Hello, my name is Suno. And, uh — and I like pizza. [laughs] But I also have other interests such as... ♪ singing ♪." -``` -## 🎶 Music -Bark can generate all types of audio, and, in principle, doesn't see a difference between speech and music. \ -Sometimes Bark chooses to generate text as music, but you can help it out by adding music notes around your lyrics. -Try the prompt: -``` -♪ In the jungle, the mighty jungle, the lion barks tonight ♪ -``` -## 🧬 Voice Cloning -Bark has the capability to fully clone voices - including tone, pitch, emotion and prosody. \ -The model also attempts to preserve music, ambient noise, etc. from input audio. \ -However, to mitigate misuse of this technology, we limit the audio history prompts to a limited set of Suno-provided, fully synthetic options to choose from. -## 👥 Speaker Prompts -You can provide certain speaker prompts such as NARRATOR, MAN, WOMAN, etc. \ -Please note that these are not always respected, especially if a conflicting audio history prompt is given. -Try the prompt: -``` -WOMAN: I would like an oatmilk latte please. -MAN: Wow, that's expensive! -``` -## Details -Bark model by [Suno](https://suno.ai/), including official [code](https://github.com/suno-ai/bark) and model weights. \ -Gradio demo supported by 🤗 Hugging Face. Bark is licensed under a non-commercial license: CC-BY 4.0 NC, see details on [GitHub](https://github.com/suno-ai/bark). - - """ - ) - - - gr.HTML(''' - - ''') - -demo.queue().launch(show_error=True) \ No newline at end of file diff --git a/spaces/itacaiunas/gerador-imagens/README.md b/spaces/itacaiunas/gerador-imagens/README.md deleted file mode 100644 index 4f3375ecda32070d9741cfcaf23f245e65bb8943..0000000000000000000000000000000000000000 --- a/spaces/itacaiunas/gerador-imagens/README.md +++ /dev/null @@ -1,12 +0,0 @@ ---- -title: Gerador de Imagens -emoji: ⚡ -colorFrom: blue -colorTo: green -sdk: gradio -sdk_version: 3.24.1 -app_file: app.py -pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference \ No newline at end of file diff --git a/spaces/james-oldfield/PandA/networks/genforce/metrics/README.md b/spaces/james-oldfield/PandA/networks/genforce/metrics/README.md deleted file mode 100644 index 34a81ac363a59d38e1c177c3e1ee4983dfe7ac96..0000000000000000000000000000000000000000 --- a/spaces/james-oldfield/PandA/networks/genforce/metrics/README.md +++ /dev/null @@ -1,18 +0,0 @@ -# Evaluation Metrics - -Frechet Inception Distance (FID) is commonly used to evaluate generative model. It employs an [Inception Model](https://arxiv.org/abs/1512.00567) (pretrained on ImageNet) to extract features from both real and synthesized images. - -## Inception Model - -For [PGGAN](https://github.com/tkarras/progressive_growing_of_gans), [StyleGAN](https://github.com/NVlabs/stylegan), etc, they use inception model from the [TensorFlow Models](https://github.com/tensorflow/models) repository, whose implementation is slightly different from that of `torchvision`. Hence, to make the evaluation metric comparable between different training frameworks (i.e., PyTorch and TensorFlow), we modify `torchvision/models/inception.py` as `inception.py`. The ported pre-trained weight is borrowed from [this repo](https://github.com/mseitzer/pytorch-fid). - -**NOTE:** We also support using the model from `torchvision` to compute the FID. However, please be aware that the FID value from `torchvision` is usually ~1.5 smaller than that from the TensorFlow model. - -Please use the following code to choose which model to use. - -```python -from metrics.inception import build_inception_model - -inception_model_tf = build_inception_model(align_tf=True) -inception_model_pth = build_inception_model(align_tf=False) -``` diff --git a/spaces/jbilcke-hf/MusicGen/tests/common_utils/temp_utils.py b/spaces/jbilcke-hf/MusicGen/tests/common_utils/temp_utils.py deleted file mode 100644 index d1e0367e979c8b9fea65472c373916d956ad5aaa..0000000000000000000000000000000000000000 --- a/spaces/jbilcke-hf/MusicGen/tests/common_utils/temp_utils.py +++ /dev/null @@ -1,56 +0,0 @@ -# Copyright (c) Meta Platforms, Inc. and affiliates. -# All rights reserved. -# -# This source code is licensed under the license found in the -# LICENSE file in the root directory of this source tree. - -import os -import tempfile - - -class TempDirMixin: - """Mixin to provide easy access to temp dir. - """ - - temp_dir_ = None - - @classmethod - def get_base_temp_dir(cls): - # If AUDIOCRAFT_TEST_DIR is set, use it instead of temporary directory. - # this is handy for debugging. - key = "AUDIOCRAFT_TEST_DIR" - if key in os.environ: - return os.environ[key] - if cls.temp_dir_ is None: - cls.temp_dir_ = tempfile.TemporaryDirectory() - return cls.temp_dir_.name - - @classmethod - def tearDownClass(cls): - if cls.temp_dir_ is not None: - try: - cls.temp_dir_.cleanup() - cls.temp_dir_ = None - except PermissionError: - # On Windows there is a know issue with `shutil.rmtree`, - # which fails intermittenly. - # https://github.com/python/cpython/issues/74168 - # Following the above thread, we ignore it. - pass - super().tearDownClass() - - @property - def id(self): - return self.__class__.__name__ - - def get_temp_path(self, *paths): - temp_dir = os.path.join(self.get_base_temp_dir(), self.id) - path = os.path.join(temp_dir, *paths) - os.makedirs(os.path.dirname(path), exist_ok=True) - return path - - def get_temp_dir(self, *paths): - temp_dir = os.path.join(self.get_base_temp_dir(), self.id) - path = os.path.join(temp_dir, *paths) - os.makedirs(path, exist_ok=True) - return path diff --git a/spaces/jbilcke-hf/ai-clip-factory/src/app/interface/generate/index.tsx b/spaces/jbilcke-hf/ai-clip-factory/src/app/interface/generate/index.tsx deleted file mode 100644 index 44cb05604cec65427935ab906b213d41ec440314..0000000000000000000000000000000000000000 --- a/spaces/jbilcke-hf/ai-clip-factory/src/app/interface/generate/index.tsx +++ /dev/null @@ -1,648 +0,0 @@ -"use client" - -import { useEffect, useRef, useState, useTransition } from "react" -import { useSpring, animated } from "@react-spring/web" -import { usePathname, useRouter, useSearchParams } from "next/navigation" - -import { useToast } from "@/components/ui/use-toast" -import { cn } from "@/lib/utils" -import { headingFont } from "@/app/interface/fonts" -import { useCharacterLimit } from "@/lib/useCharacterLimit" -import { generateAnimation } from "@/app/server/actions/animation" -import { interpolateVideo } from "@/app/server/actions/interpolation" -import { getLatestPosts, getPost, postToCommunity } from "@/app/server/actions/community" -import { getSDXLModels } from "@/app/server/actions/models" -import { HotshotImageInferenceSize, Post, QualityLevel, QualityOption, SDXLModel } from "@/types" -import { Tooltip, TooltipContent, TooltipTrigger } from "@/components/ui/tooltip" -import { TooltipProvider } from "@radix-ui/react-tooltip" - -import { isRateLimitError } from "@/app/server/utils/isRateLimitError" -import { useCountdown } from "@/lib/useCountdown" - -import { Countdown } from "../countdown" - -const qualityOptions = [ - { - level: "low", - label: "Low (~ 30 sec)" - }, - { - level: "medium", - label: "Medium (~90 secs)" - } -] as QualityOption[] - -type Stage = "generate" | "interpolate" | "finished" - -export function Generate() { - const router = useRouter() - const pathname = usePathname() - const searchParams = useSearchParams() - const searchParamsEntries = searchParams ? Array.from(searchParams.entries()) : [] - const [_isPending, startTransition] = useTransition() - - const scrollRef = useRef(null) - const videoRef = useRef (null) - - const [isLocked, setLocked] = useState(false) - const [promptDraft, setPromptDraft] = useState("") - const [assetUrl, setAssetUrl] = useState("") - const [isOverSubmitButton, setOverSubmitButton] = useState(false) - - const [models, setModels] = useState () - - const [runs, setRuns] = useState(0) - const runsRef = useRef(0) - const [showModels, setShowModels] = useState(true) - - const [communityRoll, setCommunityRoll] = useState ("generate") - - const [qualityLevel, setQualityLevel] = useState ("low") - - const { toast } = useToast() - - const { progressPercent, remainingTimeInSec } = useCountdown({ - isActive: isLocked, - timerId: runs, // everytime we change this, the timer will reset - durationInSec: /*stage === "interpolate" ? 30 :*/ 90, // it usually takes 40 seconds, but there might be lag - onEnd: () => {} - }) - - const { shouldWarn, colorClass, nbCharsUsed, nbCharsLimits } = useCharacterLimit({ - value: promptDraft, - nbCharsLimits: 70, - warnBelow: 10, - }) - - const submitButtonBouncer = useSpring({ - transform: isOverSubmitButton - ? 'scale(1.05)' - : 'scale(1.0)', - boxShadow: isOverSubmitButton - ? `0px 5px 15px 0px rgba(0, 0, 0, 0.05)` - : `0px 0px 0px 0px rgba(0, 0, 0, 0.05)`, - loop: true, - config: { - tension: 300, - friction: 10, - }, - }) - - const handleSubmit = () => { - if (isLocked) { return } - if (!promptDraft) { return } - - setShowModels(false) - setRuns(runsRef.current + 1) - setLocked(true) - setStage("generate") - - scrollRef.current?.scroll({ - top: 0, - behavior: 'smooth' - }) - - startTransition(async () => { - const huggingFaceLora = selectedModel ? selectedModel.repo.trim() : "KappaNeuro/studio-ghibli-style" - const triggerWord = selectedModel ? selectedModel.trigger_word : "Studio Ghibli Style" - - // now you got a read/write object - const current = new URLSearchParams(searchParamsEntries) - current.set("prompt", promptDraft) - current.set("model", huggingFaceLora) - const search = current.toString() - router.push(`${pathname}${search ? `?${search}` : ""}`) - - const size: HotshotImageInferenceSize = "608x416" - - // 608x416 @ 25 steps -> 32 seconds - const steps = qualityLevel === "low" ? 30 : 45 - - let key = "" - try { - const res = await fetch("/api/get-key", { - method: "GET", - headers: { - Accept: "application/json", - "Content-Type": "application/json", - }, - cache: 'no-store', - }) - key = await res.text() - } catch (err) { - console.error("failed to get key, but this is not a blocker") - } - - const params = { - positivePrompt: promptDraft, - negativePrompt: "", - huggingFaceLora, - triggerWord, - nbFrames: 10, // if duration is 1000ms then it means 8 FPS - duration: 1000, // in ms - steps, - size, - key - } - - let rawAssetUrl = "" - try { - // console.log("starting transition, calling generateAnimation") - rawAssetUrl = await generateAnimation(params) - - if (!rawAssetUrl) { - throw new Error("invalid asset url") - } - - setAssetUrl(rawAssetUrl) - - } catch (err) { - - // check the rate limit - if (isRateLimitError(err)) { - console.error("error, too many requests") - toast({ - title: "You can generate only one video per minute 👀", - description: "Please wait a bit before trying again 🤗", - }) - setLocked(false) - return - } else { - toast({ - title: "We couldn't generate your video 👀", - description: "We are probably over capacity, but you can try again 🤗", - }) - } - - console.log("generation failed! probably just a Gradio failure, so let's just run the round robin again!") - - try { - rawAssetUrl = await generateAnimation(params) - } catch (err) { - - // check the rate limit - if (isRateLimitError(err)) { - console.error("error, too many requests") - toast({ - title: "Error: the free server is over capacity 👀", - description: "You can generate 2 videos per minute 🤗 Please try again in a moment!", - }) - setLocked(false) - return - } - - console.error(`generation failed again! ${err}`) - } - } - - if (!rawAssetUrl) { - console.log("failed to generate the video, aborting") - setLocked(false) - return - } - - setAssetUrl(rawAssetUrl) - - - let assetUrl = rawAssetUrl - - setStage("interpolate") - setRuns(runsRef.current + 1) - - try { - assetUrl = await interpolateVideo(rawAssetUrl) - - if (!assetUrl) { - throw new Error("invalid interpolated asset url") - } - - setAssetUrl(assetUrl) - } catch (err) { - console.log(`failed to interpolate the video, but this is not a blocker: ${err}`) - } - - setLocked(false) - setStage("generate") - - if (process.env.NEXT_PUBLIC_ENABLE_COMMUNITY_SHARING !== "true") { - return - } - - try { - const post = await postToCommunity({ - prompt: promptDraft, - model: huggingFaceLora, - assetUrl, - }) - console.log("successfully submitted to the community!", post) - - // now you got a read/write object - const current = new URLSearchParams(searchParamsEntries) - current.set("postId", post.postId.trim()) - current.set("prompt", post.prompt.trim()) - current.set("model", post.model.trim()) - const search = current.toString() - router.push(`${pathname}${search ? `?${search}` : ""}`) - } catch (err) { - console.error(`not a blocker, but we failed to post to the community (reason: ${err})`) - } - }) - } - - useEffect(() => { - startTransition(async () => { - const models = await getSDXLModels() - setModels(models) - - const defaultModel = models.find(model => model.repo.toLowerCase().includes("ghibli")) || models[0] - - if (defaultModel) { - setSelectedModel(defaultModel) - } - - // now we load URL params - const current = new URLSearchParams(searchParamsEntries) - - // URL query params - const existingPostId = current.get("postId") || "" - const existingPrompt = current.get("prompt")?.trim() || "" - const existingModelName = current.get("model")?.toLowerCase().trim() || "" - - // if and only if we don't have a post id, then we look at the other query params - if (existingPrompt) { - setPromptDraft(existingPrompt) - } - - if (existingModelName) { - - let existingModel = models.find(model => { - return ( - model.repo.toLowerCase().trim().includes(existingModelName) - || model.title.toLowerCase().trim().includes(existingModelName) - ) - }) - - if (existingModel) { - setSelectedModel(existingModel) - } - } - - // if we have a post id, then we use that to override all the previous values - if (existingPostId) { - try { - const post = await getPost(existingPostId) - - if (post.assetUrl) { - setAssetUrl(post.assetUrl) - } - if (post.prompt) { - setPromptDraft(post.prompt) - } - - if (post.model) { - - const nameToFind = post.model.toLowerCase().trim() - const existingModel = models.find(model => { - - return ( - model.repo.toLowerCase().trim().includes(nameToFind) - || model.title.toLowerCase().trim().includes(nameToFind) - ) - }) - - if (existingModel) { - setSelectedModel(existingModel) - } - } - } catch (err) { - console.error(`failed to load the community post (${err})`) - } - } - }) - }, []) - - useEffect(() => { - startTransition(async () => { - const posts = await getLatestPosts({ - maxNbPosts: 32, - shuffle: true, - }) - if (posts?.length) { - setCommunityRoll(posts) - } - }) - }, []) - - const handleSelectCommunityPost = (post: Post) => { - if (isLocked) { return } - - scrollRef.current?.scroll({ - top: 0, - behavior: 'smooth' - }) - - // now you got a read/write object - const current = new URLSearchParams(searchParamsEntries) - current.set("postId", post.postId.trim()) - current.set("prompt", post.prompt.trim()) - current.set("model", post.model.trim()) - const search = current.toString() - router.push(`${pathname}${search ? `?${search}` : ""}`) - - if (post.assetUrl) { - setAssetUrl(post.assetUrl) - } - if (post.prompt) { - setPromptDraft(post.prompt) - } - - if (post.model) { - const nameToFind = post.model.toLowerCase().trim() - const existingModel = models.find(model => { - - return ( - model.repo.toLowerCase().trim().includes(nameToFind) - || model.title.toLowerCase().trim().includes(nameToFind) - ) - }) - - if (existingModel) { - setSelectedModel(existingModel) - } - } - } - - const handleClickPlay = () => { - videoRef.current?.play() - } - - return ( - -- ) -} diff --git a/spaces/jiejiejie0420/bingo/src/components/chat-attachments.tsx b/spaces/jiejiejie0420/bingo/src/components/chat-attachments.tsx deleted file mode 100644 index ef43d4e262935d263b6099138c56f7daade5299d..0000000000000000000000000000000000000000 --- a/spaces/jiejiejie0420/bingo/src/components/chat-attachments.tsx +++ /dev/null @@ -1,37 +0,0 @@ -import Image from 'next/image' -import ClearIcon from '@/assets/images/clear.svg' -import RefreshIcon from '@/assets/images/refresh.svg' -import { FileItem } from '@/lib/bots/bing/types' -import { cn } from '@/lib/utils' -import { useBing } from '@/lib/hooks/use-bing' - -type ChatAttachmentsProps = Pick- {isLocked ? -: null} - - -- -- {assetUrl ?- -- {assetUrl.startsWith("data:video/mp4") || assetUrl.endsWith(".mp4") - ? : -: null} - -} -
-- {/* -- setPromptDraft(e.target.value)} - onKeyDown={({ key }) => { - if (key === 'Enter') { - if (!isLocked) { - handleSubmit() - } - } - }} - disabled={isLocked} - /> --- {nbCharsUsed} - / - {nbCharsLimits} ----setOverSubmitButton(true)} - onMouseLeave={() => setOverSubmitButton(false)} - className={cn( - `px-6 py-3`, - `rounded-full`, - `transition-all duration-300 ease-in-out`, - isLocked - ? `bg-orange-500/20 border-orange-800/10` - : `bg-sky-500/80 hover:bg-sky-400/100 border-sky-800/20`, - `text-center`, - `w-full`, - `text-2xl text-sky-50`, - `border`, - headingFont.className, - // `transition-all duration-300`, - // `hover:animate-bounce` - )} - disabled={isLocked} - onClick={handleSubmit} - > - {isLocked - ? (stage === "generate" ? `Generating..` : `Smoothing..`) - : "Generate" - } - --- */} - -Generation will take about 32 seconds
--- - --- -{models.length ? `You selected:` : ""}
-{models.length ? `${(selectedModel?.title || "").replaceAll("-", " ")}` : "Loading styles.."}
-- {models.map(model => ---- )} -- -- - {!isLocked &&{ - if (!isLocked) { setSelectedModel(model) } - }}> ---
- } -{model.title}
--- ---{communityRoll.length ? "Random community clips:" : "Loading community roll.."}
-- {communityRoll.map(post => ---- )} -- -- - {!isLocked &&{ handleSelectCommunityPost(post) }}> - --- } -{post.prompt}
-- {attachmentList.map(file => ( -- ) : null -} diff --git a/spaces/jlazoff/biblical-summarizer/app.py b/spaces/jlazoff/biblical-summarizer/app.py deleted file mode 100644 index 9a8cee0b8ccea855623e2471a84588f8fc372777..0000000000000000000000000000000000000000 --- a/spaces/jlazoff/biblical-summarizer/app.py +++ /dev/null @@ -1,84 +0,0 @@ -import gradio as gr - -from transformers import pipeline -import gradio as gr -from gradio.mix import Parallel, Series - -io1 = gr.Interface.load('huggingface/google/pegasus-large') -io2 = gr.Interface.load("huggingface/google/pegasus-cnn_dailymail") -io3 = gr.Interface.load("huggingface/google/pegasus-xsum") -io4 = gr.Interface.load('huggingface/google/pegasus-newsroom') -io5 = gr.Interface.load("huggingface/google/pegasus-multi_news") -#io6 = gr.Interface.load("huggingface/google/pegasus-reddit_tifu") -#io7 = gr.Interface.load('huggingface/google/pegasus-arxiv') -#io8 = gr.Interface.load("huggingface/google/pegasus-pubmed") -#io9 = gr.Interface.load("huggingface/google/pegasus-wikihow") -#io10 = gr.Interface.load('huggingface/google/pegasus-gigaword') -#io11 = gr.Interface.load("huggingface/google/pegasus-billsum") -#io12 = gr.Interface.load("huggingface/google/pegasus-big_patent") -#io13 = gr.Interface.load("huggingface/google/pegasus-aeslc") -#io14 = gr.Interface.load("huggingface/google/pegasus-large") -#io15 = gr.Interface.load("huggingface/google/pegasus-pubmed") -#io16 = gr.Interface.load("huggingface/google/bigbird-pegasus-large-arxiv") -#io17 = gr.Interface.load("huggingface/sshleifer/distill-pegasus-xsum-16-4") -#io18 = gr.Interface.load("huggingface/sshleifer/distill-pegasus-cnn-16-4") -#io19 = gr.Interface.load("huggingface/tuner007/pegasus_summarizer") -#io20 = gr.Interface.load("huggingface/pszemraj/pegasus-x-large-book-summary") -#io21 = gr.Interface.load("huggingface/google/pegasus-x-large") -#io22 = gr.Interface.load("huggingface/google/pegasus-x-base") -#io23 = gr.Interface.load("huggingface/xysmalobia/pegasus-samsum") - -desc = "Let Hugging Face models summarize texts for you. Note: Shorter articles generate faster summaries. This summarizer uses pegasus by Google. You can compare these models against each other on their performances." - -x = """ What's A Lawyer Now? Simply put… there is a tremendous manifest and latent need for just about ALL legal services. There are solid interrelated sociological and structural reasons for this including considerable societal divisiveness, meaningful changes in laws and regulations, and fast-paced disruptive technological innovations. At the same time, there are psychological factors that strongly prompt the need for various legal services such as hubris, arrogance, and Machiavellianism. The opportunities, across a wide spectrum of law firm practice areas, have probably never been greater. Although there is a tremendous amount of untapped potential for legal services, there is one major obstacle to opening the spigot – lawyers. From solo practices to mega-international law firms, many lawyers because of their inherent inclinations (e.g., risk aversion) reinforced by their education and firm experience are not going to take advantage of the incredible latent demand for legal services. As commoditization is rampant in the legal profession, the path to success is not just having “excellent knowledge of the law.” Being technical proficient is table stakes. Unfortunately, a large percentage of lawyers equate legal competence with the success of their practice, and the great majority is proven wrong. What is also required of lawyers at all levels, in order to truly excel in today’s legal environment, is a touch of entrepreneurialism coupled with some business savvy. The opportunities for lawyers are most everywhere from inside their own book of business to the clients of other lawyers in their firms to the many other types of professionals they know or can fairly easily get to know. The complication is that when it comes to the business development side of legal work, few lawyers have the expertise to create a steady stream of new work for their practices or their firms. Unless lawyers adopt these best practices, it is unlikely that they will be able to greatly benefit from all the tremendous pent up demand that exists for legal services. Conversely, for those lawyers who take a proactive and systemic approach to business development, their practices could easily grow exponentially. -""" - -y = '''What is Text Summarization? -Text summarization is an important NLP task, which has several applications. The two broad categories of approaches to text summarization are extraction and abstraction. Extractive methods select a subset of existing words, phrases, or sentences in the original text to form a summary. In contrast, abstractive methods first build an internal semantic representation and then use natural language generation techniques to create a summary. Such a summary might contain words that are not explicitly present in the original document. Most text summarization systems are based on some form of extractive summarization. -In general, topic identification, interpretation, summary generation, and evaluation of the generated summary are the key challenges in text summarization. The critical tasks in extraction-based summarization are identifying key phrases in the document and using them to select sentences in the document for inclusion in the summary. In contrast, abstraction-based methods paraphrase sections of the source document. -All extraction-based summarizers perform the following three relatively independent tasks (Nenkova and McKeown, 2011, 2012): (a) capturing key aspects of text and storing as an intermediate representation, (b) scoring sentences in the text based on that representation, (c) and composing a summary by selecting several sentences.''' - -z = '''Machine Learning Technology Trends To Impact Business in 2022 -In this article, we will discuss the latest innovations in machine learning technology in 2021 from our perspective as a machine learning software development company. We’ll go over 9 trends and explain how the latest innovations in machine learning technologies can benefit you and your business in 2022. -1. No-Code Machine Learning -2. TinyML -3. AutoML -4. Machine Learning Operationalization Management -5. Full-stack Deep Learning -6. Generative Adversarial Networks -7. Unsupervised ML -8. Reinforcement Learning - ''' - -sample = [[y], [x], [z]] - -iface = Parallel(io1, - io2, - io3, - io4, - io5, - #io6, - #io7, - #io8, - #io9, - #io10, - #io11, - #io12, - #io13, - #io14, - #io15, - #io16, - #io17, - #io18, - #io19, - #io20, - ##io21, - #io22, - #io23, - theme='huggingface', - title='Biblical Text Summarizer', - description=desc, - examples=sample, # replace "sample" with directory to let gradio scan through those files and give you the text - inputs=gr.inputs.Textbox(lines=30, label="Text")) - -iface.launch(inline=False) \ No newline at end of file diff --git a/spaces/joaogabriellima/Real-Time-Voice-Cloning/encoder_preprocess.py b/spaces/joaogabriellima/Real-Time-Voice-Cloning/encoder_preprocess.py deleted file mode 100644 index 11502013c8d75d4652fb0ffdcdc49d55e8fb8bc9..0000000000000000000000000000000000000000 --- a/spaces/joaogabriellima/Real-Time-Voice-Cloning/encoder_preprocess.py +++ /dev/null @@ -1,70 +0,0 @@ -from encoder.preprocess import preprocess_librispeech, preprocess_voxceleb1, preprocess_voxceleb2 -from utils.argutils import print_args -from pathlib import Path -import argparse - -if __name__ == "__main__": - class MyFormatter(argparse.ArgumentDefaultsHelpFormatter, argparse.RawDescriptionHelpFormatter): - pass - - parser = argparse.ArgumentParser( - description="Preprocesses audio files from datasets, encodes them as mel spectrograms and " - "writes them to the disk. This will allow you to train the encoder. The " - "datasets required are at least one of VoxCeleb1, VoxCeleb2 and LibriSpeech. " - "Ideally, you should have all three. You should extract them as they are " - "after having downloaded them and put them in a same directory, e.g.:\n" - "-[datasets_root]\n" - " -LibriSpeech\n" - " -train-other-500\n" - " -VoxCeleb1\n" - " -wav\n" - " -vox1_meta.csv\n" - " -VoxCeleb2\n" - " -dev", - formatter_class=MyFormatter - ) - parser.add_argument("datasets_root", type=Path, help=\ - "Path to the directory containing your LibriSpeech/TTS and VoxCeleb datasets.") - parser.add_argument("-o", "--out_dir", type=Path, default=argparse.SUPPRESS, help=\ - "Path to the output directory that will contain the mel spectrograms. If left out, " - "defaults to- {file.status === 'loading' && ( -- ))} -- -) - } - {file.status !== 'error' && ( --) - } - {file.status === 'error' && ( --
-- )} - -uploadImage(file.url)} /> - /SV2TTS/encoder/") - parser.add_argument("-d", "--datasets", type=str, - default="librispeech_other,voxceleb1,voxceleb2", help=\ - "Comma-separated list of the name of the datasets you want to preprocess. Only the train " - "set of these datasets will be used. Possible names: librispeech_other, voxceleb1, " - "voxceleb2.") - parser.add_argument("-s", "--skip_existing", action="store_true", help=\ - "Whether to skip existing output files with the same name. Useful if this script was " - "interrupted.") - parser.add_argument("--no_trim", action="store_true", help=\ - "Preprocess audio without trimming silences (not recommended).") - args = parser.parse_args() - - # Verify webrtcvad is available - if not args.no_trim: - try: - import webrtcvad - except: - raise ModuleNotFoundError("Package 'webrtcvad' not found. This package enables " - "noise removal and is recommended. Please install and try again. If installation fails, " - "use --no_trim to disable this error message.") - del args.no_trim - - # Process the arguments - args.datasets = args.datasets.split(",") - if not hasattr(args, "out_dir"): - args.out_dir = args.datasets_root.joinpath("SV2TTS", "encoder") - assert args.datasets_root.exists() - args.out_dir.mkdir(exist_ok=True, parents=True) - - # Preprocess the datasets - print_args(args, parser) - preprocess_func = { - "librispeech_other": preprocess_librispeech, - "voxceleb1": preprocess_voxceleb1, - "voxceleb2": preprocess_voxceleb2, - } - args = vars(args) - for dataset in args.pop("datasets"): - print("Preprocessing %s" % dataset) - preprocess_func[dataset](**args) diff --git a/spaces/joaogabriellima/Real-Time-Voice-Cloning/vocoder/models/fatchord_version.py b/spaces/joaogabriellima/Real-Time-Voice-Cloning/vocoder/models/fatchord_version.py deleted file mode 100644 index 70ef1e3f6b99f32cc4fa95f64acfa58268d71ad7..0000000000000000000000000000000000000000 --- a/spaces/joaogabriellima/Real-Time-Voice-Cloning/vocoder/models/fatchord_version.py +++ /dev/null @@ -1,434 +0,0 @@ -import torch -import torch.nn as nn -import torch.nn.functional as F -from vocoder.distribution import sample_from_discretized_mix_logistic -from vocoder.display import * -from vocoder.audio import * - - -class ResBlock(nn.Module): - def __init__(self, dims): - super().__init__() - self.conv1 = nn.Conv1d(dims, dims, kernel_size=1, bias=False) - self.conv2 = nn.Conv1d(dims, dims, kernel_size=1, bias=False) - self.batch_norm1 = nn.BatchNorm1d(dims) - self.batch_norm2 = nn.BatchNorm1d(dims) - - def forward(self, x): - residual = x - x = self.conv1(x) - x = self.batch_norm1(x) - x = F.relu(x) - x = self.conv2(x) - x = self.batch_norm2(x) - return x + residual - - -class MelResNet(nn.Module): - def __init__(self, res_blocks, in_dims, compute_dims, res_out_dims, pad): - super().__init__() - k_size = pad * 2 + 1 - self.conv_in = nn.Conv1d(in_dims, compute_dims, kernel_size=k_size, bias=False) - self.batch_norm = nn.BatchNorm1d(compute_dims) - self.layers = nn.ModuleList() - for i in range(res_blocks): - self.layers.append(ResBlock(compute_dims)) - self.conv_out = nn.Conv1d(compute_dims, res_out_dims, kernel_size=1) - - def forward(self, x): - x = self.conv_in(x) - x = self.batch_norm(x) - x = F.relu(x) - for f in self.layers: x = f(x) - x = self.conv_out(x) - return x - - -class Stretch2d(nn.Module): - def __init__(self, x_scale, y_scale): - super().__init__() - self.x_scale = x_scale - self.y_scale = y_scale - - def forward(self, x): - b, c, h, w = x.size() - x = x.unsqueeze(-1).unsqueeze(3) - x = x.repeat(1, 1, 1, self.y_scale, 1, self.x_scale) - return x.view(b, c, h * self.y_scale, w * self.x_scale) - - -class UpsampleNetwork(nn.Module): - def __init__(self, feat_dims, upsample_scales, compute_dims, - res_blocks, res_out_dims, pad): - super().__init__() - total_scale = np.cumproduct(upsample_scales)[-1] - self.indent = pad * total_scale - self.resnet = MelResNet(res_blocks, feat_dims, compute_dims, res_out_dims, pad) - self.resnet_stretch = Stretch2d(total_scale, 1) - self.up_layers = nn.ModuleList() - for scale in upsample_scales: - k_size = (1, scale * 2 + 1) - padding = (0, scale) - stretch = Stretch2d(scale, 1) - conv = nn.Conv2d(1, 1, kernel_size=k_size, padding=padding, bias=False) - conv.weight.data.fill_(1. / k_size[1]) - self.up_layers.append(stretch) - self.up_layers.append(conv) - - def forward(self, m): - aux = self.resnet(m).unsqueeze(1) - aux = self.resnet_stretch(aux) - aux = aux.squeeze(1) - m = m.unsqueeze(1) - for f in self.up_layers: m = f(m) - m = m.squeeze(1)[:, :, self.indent:-self.indent] - return m.transpose(1, 2), aux.transpose(1, 2) - - -class WaveRNN(nn.Module): - def __init__(self, rnn_dims, fc_dims, bits, pad, upsample_factors, - feat_dims, compute_dims, res_out_dims, res_blocks, - hop_length, sample_rate, mode='RAW'): - super().__init__() - self.mode = mode - self.pad = pad - if self.mode == 'RAW' : - self.n_classes = 2 ** bits - elif self.mode == 'MOL' : - self.n_classes = 30 - else : - RuntimeError("Unknown model mode value - ", self.mode) - - self.rnn_dims = rnn_dims - self.aux_dims = res_out_dims // 4 - self.hop_length = hop_length - self.sample_rate = sample_rate - - self.upsample = UpsampleNetwork(feat_dims, upsample_factors, compute_dims, res_blocks, res_out_dims, pad) - self.I = nn.Linear(feat_dims + self.aux_dims + 1, rnn_dims) - self.rnn1 = nn.GRU(rnn_dims, rnn_dims, batch_first=True) - self.rnn2 = nn.GRU(rnn_dims + self.aux_dims, rnn_dims, batch_first=True) - self.fc1 = nn.Linear(rnn_dims + self.aux_dims, fc_dims) - self.fc2 = nn.Linear(fc_dims + self.aux_dims, fc_dims) - self.fc3 = nn.Linear(fc_dims, self.n_classes) - - self.step = nn.Parameter(torch.zeros(1).long(), requires_grad=False) - self.num_params() - - def forward(self, x, mels): - self.step += 1 - bsize = x.size(0) - if torch.cuda.is_available(): - h1 = torch.zeros(1, bsize, self.rnn_dims).cuda() - h2 = torch.zeros(1, bsize, self.rnn_dims).cuda() - else: - h1 = torch.zeros(1, bsize, self.rnn_dims).cpu() - h2 = torch.zeros(1, bsize, self.rnn_dims).cpu() - mels, aux = self.upsample(mels) - - aux_idx = [self.aux_dims * i for i in range(5)] - a1 = aux[:, :, aux_idx[0]:aux_idx[1]] - a2 = aux[:, :, aux_idx[1]:aux_idx[2]] - a3 = aux[:, :, aux_idx[2]:aux_idx[3]] - a4 = aux[:, :, aux_idx[3]:aux_idx[4]] - - x = torch.cat([x.unsqueeze(-1), mels, a1], dim=2) - x = self.I(x) - res = x - x, _ = self.rnn1(x, h1) - - x = x + res - res = x - x = torch.cat([x, a2], dim=2) - x, _ = self.rnn2(x, h2) - - x = x + res - x = torch.cat([x, a3], dim=2) - x = F.relu(self.fc1(x)) - - x = torch.cat([x, a4], dim=2) - x = F.relu(self.fc2(x)) - return self.fc3(x) - - def generate(self, mels, batched, target, overlap, mu_law, progress_callback=None): - mu_law = mu_law if self.mode == 'RAW' else False - progress_callback = progress_callback or self.gen_display - - self.eval() - output = [] - start = time.time() - rnn1 = self.get_gru_cell(self.rnn1) - rnn2 = self.get_gru_cell(self.rnn2) - - with torch.no_grad(): - if torch.cuda.is_available(): - mels = mels.cuda() - else: - mels = mels.cpu() - wave_len = (mels.size(-1) - 1) * self.hop_length - mels = self.pad_tensor(mels.transpose(1, 2), pad=self.pad, side='both') - mels, aux = self.upsample(mels.transpose(1, 2)) - - if batched: - mels = self.fold_with_overlap(mels, target, overlap) - aux = self.fold_with_overlap(aux, target, overlap) - - b_size, seq_len, _ = mels.size() - - if torch.cuda.is_available(): - h1 = torch.zeros(b_size, self.rnn_dims).cuda() - h2 = torch.zeros(b_size, self.rnn_dims).cuda() - x = torch.zeros(b_size, 1).cuda() - else: - h1 = torch.zeros(b_size, self.rnn_dims).cpu() - h2 = torch.zeros(b_size, self.rnn_dims).cpu() - x = torch.zeros(b_size, 1).cpu() - - d = self.aux_dims - aux_split = [aux[:, :, d * i:d * (i + 1)] for i in range(4)] - - for i in range(seq_len): - - m_t = mels[:, i, :] - - a1_t, a2_t, a3_t, a4_t = (a[:, i, :] for a in aux_split) - - x = torch.cat([x, m_t, a1_t], dim=1) - x = self.I(x) - h1 = rnn1(x, h1) - - x = x + h1 - inp = torch.cat([x, a2_t], dim=1) - h2 = rnn2(inp, h2) - - x = x + h2 - x = torch.cat([x, a3_t], dim=1) - x = F.relu(self.fc1(x)) - - x = torch.cat([x, a4_t], dim=1) - x = F.relu(self.fc2(x)) - - logits = self.fc3(x) - - if self.mode == 'MOL': - sample = sample_from_discretized_mix_logistic(logits.unsqueeze(0).transpose(1, 2)) - output.append(sample.view(-1)) - if torch.cuda.is_available(): - # x = torch.FloatTensor([[sample]]).cuda() - x = sample.transpose(0, 1).cuda() - else: - x = sample.transpose(0, 1) - - elif self.mode == 'RAW' : - posterior = F.softmax(logits, dim=1) - distrib = torch.distributions.Categorical(posterior) - - sample = 2 * distrib.sample().float() / (self.n_classes - 1.) - 1. - output.append(sample) - x = sample.unsqueeze(-1) - else: - raise RuntimeError("Unknown model mode value - ", self.mode) - - if i % 100 == 0: - gen_rate = (i + 1) / (time.time() - start) * b_size / 1000 - progress_callback(i, seq_len, b_size, gen_rate) - - output = torch.stack(output).transpose(0, 1) - output = output.cpu().numpy() - output = output.astype(np.float64) - - if batched: - output = self.xfade_and_unfold(output, target, overlap) - else: - output = output[0] - - if mu_law: - output = decode_mu_law(output, self.n_classes, False) - if hp.apply_preemphasis: - output = de_emphasis(output) - - # Fade-out at the end to avoid signal cutting out suddenly - fade_out = np.linspace(1, 0, 20 * self.hop_length) - output = output[:wave_len] - output[-20 * self.hop_length:] *= fade_out - - self.train() - - return output - - - def gen_display(self, i, seq_len, b_size, gen_rate): - pbar = progbar(i, seq_len) - msg = f'| {pbar} {i*b_size}/{seq_len*b_size} | Batch Size: {b_size} | Gen Rate: {gen_rate:.1f}kHz | ' - stream(msg) - - def get_gru_cell(self, gru): - gru_cell = nn.GRUCell(gru.input_size, gru.hidden_size) - gru_cell.weight_hh.data = gru.weight_hh_l0.data - gru_cell.weight_ih.data = gru.weight_ih_l0.data - gru_cell.bias_hh.data = gru.bias_hh_l0.data - gru_cell.bias_ih.data = gru.bias_ih_l0.data - return gru_cell - - def pad_tensor(self, x, pad, side='both'): - # NB - this is just a quick method i need right now - # i.e., it won't generalise to other shapes/dims - b, t, c = x.size() - total = t + 2 * pad if side == 'both' else t + pad - if torch.cuda.is_available(): - padded = torch.zeros(b, total, c).cuda() - else: - padded = torch.zeros(b, total, c).cpu() - if side == 'before' or side == 'both': - padded[:, pad:pad + t, :] = x - elif side == 'after': - padded[:, :t, :] = x - return padded - - def fold_with_overlap(self, x, target, overlap): - - ''' Fold the tensor with overlap for quick batched inference. - Overlap will be used for crossfading in xfade_and_unfold() - - Args: - x (tensor) : Upsampled conditioning features. - shape=(1, timesteps, features) - target (int) : Target timesteps for each index of batch - overlap (int) : Timesteps for both xfade and rnn warmup - - Return: - (tensor) : shape=(num_folds, target + 2 * overlap, features) - - Details: - x = [[h1, h2, ... hn]] - - Where each h is a vector of conditioning features - - Eg: target=2, overlap=1 with x.size(1)=10 - - folded = [[h1, h2, h3, h4], - [h4, h5, h6, h7], - [h7, h8, h9, h10]] - ''' - - _, total_len, features = x.size() - - # Calculate variables needed - num_folds = (total_len - overlap) // (target + overlap) - extended_len = num_folds * (overlap + target) + overlap - remaining = total_len - extended_len - - # Pad if some time steps poking out - if remaining != 0: - num_folds += 1 - padding = target + 2 * overlap - remaining - x = self.pad_tensor(x, padding, side='after') - - if torch.cuda.is_available(): - folded = torch.zeros(num_folds, target + 2 * overlap, features).cuda() - else: - folded = torch.zeros(num_folds, target + 2 * overlap, features).cpu() - - # Get the values for the folded tensor - for i in range(num_folds): - start = i * (target + overlap) - end = start + target + 2 * overlap - folded[i] = x[:, start:end, :] - - return folded - - def xfade_and_unfold(self, y, target, overlap): - - ''' Applies a crossfade and unfolds into a 1d array. - - Args: - y (ndarry) : Batched sequences of audio samples - shape=(num_folds, target + 2 * overlap) - dtype=np.float64 - overlap (int) : Timesteps for both xfade and rnn warmup - - Return: - (ndarry) : audio samples in a 1d array - shape=(total_len) - dtype=np.float64 - - Details: - y = [[seq1], - [seq2], - [seq3]] - - Apply a gain envelope at both ends of the sequences - - y = [[seq1_in, seq1_target, seq1_out], - [seq2_in, seq2_target, seq2_out], - [seq3_in, seq3_target, seq3_out]] - - Stagger and add up the groups of samples: - - [seq1_in, seq1_target, (seq1_out + seq2_in), seq2_target, ...] - - ''' - - num_folds, length = y.shape - target = length - 2 * overlap - total_len = num_folds * (target + overlap) + overlap - - # Need some silence for the rnn warmup - silence_len = overlap // 2 - fade_len = overlap - silence_len - silence = np.zeros((silence_len), dtype=np.float64) - - # Equal power crossfade - t = np.linspace(-1, 1, fade_len, dtype=np.float64) - fade_in = np.sqrt(0.5 * (1 + t)) - fade_out = np.sqrt(0.5 * (1 - t)) - - # Concat the silence to the fades - fade_in = np.concatenate([silence, fade_in]) - fade_out = np.concatenate([fade_out, silence]) - - # Apply the gain to the overlap samples - y[:, :overlap] *= fade_in - y[:, -overlap:] *= fade_out - - unfolded = np.zeros((total_len), dtype=np.float64) - - # Loop to add up all the samples - for i in range(num_folds): - start = i * (target + overlap) - end = start + target + 2 * overlap - unfolded[start:end] += y[i] - - return unfolded - - def get_step(self) : - return self.step.data.item() - - def checkpoint(self, model_dir, optimizer) : - k_steps = self.get_step() // 1000 - self.save(model_dir.joinpath("checkpoint_%dk_steps.pt" % k_steps), optimizer) - - def log(self, path, msg) : - with open(path, 'a') as f: - print(msg, file=f) - - def load(self, path, optimizer) : - checkpoint = torch.load(path) - if "optimizer_state" in checkpoint: - self.load_state_dict(checkpoint["model_state"]) - optimizer.load_state_dict(checkpoint["optimizer_state"]) - else: - # Backwards compatibility - self.load_state_dict(checkpoint) - - def save(self, path, optimizer) : - torch.save({ - "model_state": self.state_dict(), - "optimizer_state": optimizer.state_dict(), - }, path) - - def num_params(self, print_out=True): - parameters = filter(lambda p: p.requires_grad, self.parameters()) - parameters = sum([np.prod(p.size()) for p in parameters]) / 1_000_000 - if print_out : - print('Trainable Parameters: %.3fM' % parameters) diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/altair/vegalite/display.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/altair/vegalite/display.py deleted file mode 100644 index 1f3a13b4613d155fc805849bc9f600f426889c68..0000000000000000000000000000000000000000 --- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/altair/vegalite/display.py +++ /dev/null @@ -1,17 +0,0 @@ -from ..utils.display import ( - Displayable, - default_renderer_base, - json_renderer_base, - DefaultRendererReturnType, -) -from ..utils.display import RendererRegistry, HTMLRenderer - - -__all__ = ( - "Displayable", - "default_renderer_base", - "json_renderer_base", - "RendererRegistry", - "HTMLRenderer", - "DefaultRendererReturnType", -) diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/bs4/formatter.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/bs4/formatter.py deleted file mode 100644 index c821318d9b2ba3772eefbc2d0e2a4d838980a783..0000000000000000000000000000000000000000 --- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/bs4/formatter.py +++ /dev/null @@ -1,185 +0,0 @@ -from bs4.dammit import EntitySubstitution - -class Formatter(EntitySubstitution): - """Describes a strategy to use when outputting a parse tree to a string. - - Some parts of this strategy come from the distinction between - HTML4, HTML5, and XML. Others are configurable by the user. - - Formatters are passed in as the `formatter` argument to methods - like `PageElement.encode`. Most people won't need to think about - formatters, and most people who need to think about them can pass - in one of these predefined strings as `formatter` rather than - making a new Formatter object: - - For HTML documents: - * 'html' - HTML entity substitution for generic HTML documents. (default) - * 'html5' - HTML entity substitution for HTML5 documents, as - well as some optimizations in the way tags are rendered. - * 'minimal' - Only make the substitutions necessary to guarantee - valid HTML. - * None - Do not perform any substitution. This will be faster - but may result in invalid markup. - - For XML documents: - * 'html' - Entity substitution for XHTML documents. - * 'minimal' - Only make the substitutions necessary to guarantee - valid XML. (default) - * None - Do not perform any substitution. This will be faster - but may result in invalid markup. - """ - # Registries of XML and HTML formatters. - XML_FORMATTERS = {} - HTML_FORMATTERS = {} - - HTML = 'html' - XML = 'xml' - - HTML_DEFAULTS = dict( - cdata_containing_tags=set(["script", "style"]), - ) - - def _default(self, language, value, kwarg): - if value is not None: - return value - if language == self.XML: - return set() - return self.HTML_DEFAULTS[kwarg] - - def __init__( - self, language=None, entity_substitution=None, - void_element_close_prefix='/', cdata_containing_tags=None, - empty_attributes_are_booleans=False, indent=1, - ): - """Constructor. - - :param language: This should be Formatter.XML if you are formatting - XML markup and Formatter.HTML if you are formatting HTML markup. - - :param entity_substitution: A function to call to replace special - characters with XML/HTML entities. For examples, see - bs4.dammit.EntitySubstitution.substitute_html and substitute_xml. - :param void_element_close_prefix: By default, void elements - are represented as (XML rules) rather than - (HTML rules). To get , pass in the empty string. - :param cdata_containing_tags: The list of tags that are defined - as containing CDATA in this dialect. For example, in HTML, - ' - def template_response(*args, **kwargs): - res = GradioTemplateResponseOriginal(*args, **kwargs) - res.body = res.body.replace(b'
Playing Mayor Match on PC or Mac with an emulator
-If you prefer to play Mayor Match on a bigger screen, you can also play it on your PC or Mac with an emulator. An emulator is a software that allows you to run Android or iOS apps on your computer. There are many emulators available online, such as BlueStacks, NoxPlayer, or MEmu. Here are the steps to play Mayor Match on PC or Mac with an emulator:
--
-
Tips and tricks for playing Mayor Match
-Mayor Match is a game that requires strategy and skill to master. If you want to improve your performance and progress faster, here are some tips and tricks that you can use:
--
-
What are the reviews of Mayor Match?
-Mayor Match is a game that has received mostly positive reviews from players who have tried it. Here are some of the reviews of Mayor Match:
-The positive reviews of Mayor Match
-Many players have praised Mayor Match for its fun and addictive gameplay, its beautiful graphics, its engaging story, its variety of features, and its generous rewards. Here are some examples of positive reviews:
--
-"This game is awesome! I love the match-3 levels and the city-building mode. The graphics are amazing and the story is interesting. The game is also very generous with rewards and freebies. I highly recommend this game to anyone who loves puzzle games."
-"I am addicted to this game! It is so much fun to play and very relaxing. The match-3 levels are challenging but not frustrating. The city-building mode is creative and satisfying. The game also has many features and events that keep me entertained. I love this game!"
-"This game is one of the best games I have ever played! It has everything I want in a game: match-3, city-building, story, social, rewards, and more. The game is also very well-made and updated regularly. The developers are awesome and listen to feedback. This game is a masterpiece!"
-The negative reviews of Mayor Match
-Some players have criticized Mayor Match for its technical issues, its difficulty level, its ads frequency, its energy system, and its in-app purchases. Here are some examples of negative reviews:
--
-"This game is good but it has some bugs and glitches. Sometimes the game freezes or crashes. Sometimes the items don't match or the power-ups don't work. Sometimes the game doesn't save my progress or sync with my account. The game needs to be fixed and improved."
-"This game is too hard and unfair. The match-3 levels are impossible to beat without boosters or power-ups. The game also cheats and changes the board or the objective randomly. The game also forces you to watch ads or buy coins to continue playing. The game is a rip-off and a scam."
-"This game is boring and repetitive. The match-3 levels are all the same and the city-building mode is dull and slow. The game also has too many ads and too little energy. The game also asks for too much money to unlock buildings or features. The game is a waste of time and money."
-The average rating of Mayor Match
-Despite some negative reviews, Mayor Match has an overall high rating on both Google Play and App Store. According to the latest data, Mayor Match has a rating of 4.8 out of 5 stars on Google Play, based on over 10K reviews. On App Store, Mayor Match has a rating of 4.7 out of 5 stars, based on over 2K reviews. These ratings show that most players enjoy playing Mayor Match and recommend it to others.
-Conclusion
-Mayor Match is a game that offers a unique and fun combination of match-3 and city-building gameplay. You can play hundreds of challenging and exciting match-3 levels, build and customize your own town, follow an engaging story, socialize with other players, and enjoy many features and rewards. Mayor Match is a game that can improve your cognitive skills, reduce your stress, boost your creativity, and keep you entertained for hours.
-If you are looking for a new game to try, you should download Mayor Match today and see for yourself why it is one of the best games on the market. You can download Mayor Match for free from Google Play or App Store, or play it on your PC or Mac with an emulator. You can also visit the official website or the social media pages of Rollic Games to learn more about Mayor Match and their other games.
-Mayor Match is a game that you will not regret playing. It is a game that will make you happy and satisfied. It is a game that will make you the best mayor ever.
-FAQs
-Here are some frequently asked questions about Mayor Match:
--
-
-
-
\ No newline at end of file diff --git a/spaces/congsaPfin/Manga-OCR/logs/Write It Korean How to Write Hangul Like a Native Speaker.md b/spaces/congsaPfin/Manga-OCR/logs/Write It Korean How to Write Hangul Like a Native Speaker.md deleted file mode 100644 index cd9e6966c7d76e7bbec4a19ac1ff30952ad48ce7..0000000000000000000000000000000000000000 --- a/spaces/congsaPfin/Manga-OCR/logs/Write It Korean How to Write Hangul Like a Native Speaker.md +++ /dev/null @@ -1,227 +0,0 @@ -
-Write It Korean: A Fun and Effective Way to Learn Korean Writing
-Do you want to learn how to write Korean letters and words? Are you looking for a fun and effective way to practice your Korean writing skills? If so, you might want to check out Write It! Korean, a writing recognition app for Korean learners.
-Write It! Korean is an app that teaches you how to write Korean hangul, the native alphabet of the Korean language. Unlike other apps that only let you trace or type the letters, Write It! Korean actually recognizes your handwriting and gives you instant feedback. This way, you can learn how to write Korean naturally and accurately.
-write it korean
Download File ✦✦✦ https://urlca.com/2uO5hB
-In this article, we will introduce you to Write It! Korean and its features, as well as some background information on the Korean alphabet and writing system. We will also share some benefits, challenges, and tips for learning how to write Korean by hand. By the end of this article, you will have a better understanding of how to write it korean and improve your Korean writing skills.
-The History and Structure of the Korean Alphabet (Hangul)
-Before we dive into Write It! Korean, let's take a look at the history and structure of the Korean alphabet, also known as hangul (한글) in South Korea and chosŏn'gŭl (조선글) in North Korea.
-The Korean alphabet was created in 1443 by King Sejong the Great, the fourth king of the Joseon dynasty. He wanted to make a simple and easy writing system for his people, who were mostly illiterate because of the complex Chinese characters (hanja) that were used at the time. He commissioned a group of scholars to design an alphabet that would reflect the sounds and shapes of the Korean language.
-write it korean app
-
-write it korean review
-write it korean download
-write it korean apk
-write it korean online
-write it korean for pc
-write it korean ios
-write it korean android
-write it korean hangul
-write it korean alphabet
-write it korean letters
-write it korean words
-write it korean sentences
-write it korean phrases
-write it korean numbers
-write it korean name
-write it korean keyboard
-write it korean handwriting
-write it korean recognition
-write it korean learning
-write it korean practice
-write it korean quiz
-write it korean game
-write it korean fun
-write it korean free
-write it korean pro
-write it korean premium
-write it korean paid
-write it korean full version
-write it korean unlock all levels
-write it korean tips and tricks
-write it korean tutorial
-write it korean guide
-write it korean help
-write it korean support
-write it korean feedback
-write it korean update
-write it korean new features
-write it korean alternatives
-write it korean similar apps
-learn to write in korean with Write It! Korean app
-how to use Write It! Korean app to improve your writing skills
-best way to learn hangul with Write It! Korean app
-why you should download Write It! Korean app today
-what is Write It! Korean app and how does it work
-benefits of using Write It! Korean app for writing practice
-how to install Write It! Korean app on your device
-how to get Write It! Korean app for free or with a discount
-how to upgrade to Write It! Korean pro or premium version
-how to contact Write It! Korean app developers or customer serviceThe result was hangul, a featural alphabet that consists of 24 basic letters: 14 consonants and 10 vowels. The consonant letters are formed with curved or angled lines that mimic the shape of the speech organs used to pronounce them. The vowel letters are composed of vertical or horizontal straight lines together with short lines on either side of the main line. The letters are arranged into syllabic blocks that form syllables, words, and sentences.
-Hangul is widely regarded as one of the most scientific and logical writing systems in the world. It is also one of the easiest alphabets to learn, as it can be mastered in a few hours or days. However, hangul was not widely accepted or used until the 20th century, as it faced opposition from the elite class who preferred hanja or mixed script. Today, hangul is the official and national writing system of both South Korea and North Korea, although some differences exist in spelling, vocabulary, and pronunciation.
-The Benefits of Learning How to Write Korean by Hand
-Now that you know some basics about hangul, you might wonder why you should learn how to write it by hand. After all, most people nowadays use keyboards or touchscreens to type or text in Korean. Is handwriting still relevant or useful in this digital age?
-The answer is yes. Learning how to write Korean by hand has many benefits for your language learning journey. Here are some of them:
--
-
As you can see, learning how to write Korean by hand has many advantages for your language learning. However, it also comes with some challenges and difficulties that you need to overcome.
-The Challenges and Tips for Writing Korean Correctly and Fluently
-Learning how to write Korean by hand is not without its challenges and difficulties. Some of the common problems that Korean learners face when writing by hand are:
--
-
-
- -Letter -Name -Stroke Order -Stroke Direction -- -ㄱ -기역 (giyeok) -1-2 -\- -- -ㄴ -니은 (nieun) -1-2 -|- -- -ㄷ -디귿 (digeut) -1-2-3 -\- -- -ㄹ -리을 (rieul) -1-2-3-4 -|-\|/ -- -ㅁ -미음 (mieum) -1-2-3-4 -\|-\|/ -ㅂ -비읍 (bieup) -1-2-3-4 -\|-\|/ -- -ㅅ -시옷 (siot) -1-2 -/\ -- -ㅇ -이응 (ieung) -1-2-3-4-5 -O -- -ㅈ -지읒 (jieut) -1-2-3 -/\| -- -ㅊ -치읓 (chieut) -1-2-3-4 -/\|/ -- -ㅋ -키읔 (kieuk) -1-2-3 -\-\|/ -- -ㅌ -티읕 (tieut) -1-2-3-4 -\-\|/ -- -ㅍ -피읖 (pieup) -1-2-3-4-5 -\|-\|/ -- -ㅎ -히읗 (hieut) -1-2-3-4-5 -\-\|/O/ -- -ㅏ -아 (a) -1-2 -|- -- -ㅑ -야 (ya) -1-2-3 -|--|- -- -ㅓ -어 (eo) -1-2 --| -- -ㅕ -여 (yeo) -1-2-3 --|--| -- ㅗ -오 (o) -1-2 --|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-|-- To help you overcome these challenges and improve your Korean writing skills, we recommend you to use
[Write It! Korean], a writing recognition app that teaches you how to write Korean hangul. -The Features and Functions of Write It! Korean App
-[Write It! Korean] is a writing recognition app that teaches you how to write Korean hangul in a fun and effective way. The app has the following features and functions:
--
-
With [Write It! Korean], you can learn how to write Korean hangul in a fun and effective way. You can download the app for free from the Google Play Store or the Apple App Store and start your Korean writing journey today.
-Conclusion
-In this article, we have introduced you to [Write It! Korean], a writing recognition app for Korean learners. We have also given you some background information on the Korean alphabet and writing system, as well as some benefits, challenges, and tips for learning how to write Korean by hand.
-We hope that this article has inspired you to learn how to write it korean and improve your Korean writing skills. Writing by hand is not only a useful skill, but also a rewarding and enjoyable experience. It can help you memorize hangul better, improve your reading and spelling skills, enhance your vocabulary and grammar skills, and boost your confidence and motivation.
-If you want to learn how to write Korean hangul in a fun and effective way, we recommend you to try [Write It! Korean], a writing recognition app that teaches you how to write Korean hangul. You can download the app for free from the Google Play Store or the Apple App Store and start your Korean writing journey today.
-Thank you for reading this article. We hope that you have learned something new and useful. If you have any questions or comments, please feel free to leave them below. We would love to hear from you.
-FAQs
-Here are some frequently asked questions about [Write It! Korean] and Korean writing:
--
-
-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/All New Honda Cbr 250r 2014.md b/spaces/contluForse/HuggingGPT/assets/All New Honda Cbr 250r 2014.md deleted file mode 100644 index 66c87b49bbd0772eea3f10fc33a316831b4ba737..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/All New Honda Cbr 250r 2014.md +++ /dev/null @@ -1,6 +0,0 @@ -All New Honda Cbr 250r 2014
Download Zip >>> https://ssurll.com/2uzw28
- - aaccfb2cb3
-
-
- diff --git a/spaces/contluForse/HuggingGPT/assets/Debonairmagazinedecember2012pdf.md b/spaces/contluForse/HuggingGPT/assets/Debonairmagazinedecember2012pdf.md deleted file mode 100644 index 62bb432e55541da68c7214189588a2767d9a67f0..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Debonairmagazinedecember2012pdf.md +++ /dev/null @@ -1,10 +0,0 @@ -
-https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf https://coub.com/stories/2270225-sustainable-future-new-republic-of-solvita https://en.tacn.ca/deck/1089486/358708-debonairmagazinedecember2012pdf-tamil-movie-hd.
-https://coub.com/stories/3184084-debonairmagazinedecember2012pdf-stargate-soundtrack-01-download-980852 https://coub.com/stories/2581244-debonairmagazinedecember2012pdf-5-reasons-why-you-should-watch-karavathek https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf https://coub.com/stories/2268264-tivoli-a-teaser-for-pokemon-aug
-debonairmagazinedecember2012pdf
DOWNLOAD ✵ https://ssurll.com/2uzxGo
-https://coub.com/stories/2268564-new-debonairmagazinedecember2012pdf https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf
-https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf https://coub.com/stories/2268494-milkshake-team-891-download-885714.
-https://www.cnaclassnorthernva.com/wp-content/uploads/2022/06/debonairmagazinedecember2012pdf.pdf http://covid19asap.com/p=15022 https://coub.com/stories/2268202-kanon-hoho-rear-or-nacelle-2d6z7t066d8 https://coub.com/stories/2268204-download-ebook-republican-forces-essex-download-2-cdec7pgr85 https://coub.com/stories/2268655-downloadkitabibanatulahkampdf-yessdarel https://coub.com/stories/2269885-new-debonairmagazinedecember2012pdf
-https://www.cnaclassnorthernva.com/wp-content/uploads/2022/06/debonairmagazinedecember2012pdf.pdf http://covid19asap.com/p=15022 https://coub.com/stories/2268229-free-download-electro-magician-hemanth-trance-kingdom-knight-2017 https://coub.com/stories/2268223-new-debonairmagazinedecember2012pdf https://coub.com/stories/2268200-takanariya-download-for-pc-love-the-storm-and-fetch-2d6z7t066d8 https://coub.com/stories/2268655-downloadkitabibanatulahkampdf-yessdarel https://coub.com/stories/2273523-downloadkitabibanatulahkampdf-yessdarel
899543212b
-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/Download Facebook for Andromax C The Ultimate Social Media App for Your Smartphone.md b/spaces/contluForse/HuggingGPT/assets/Download Facebook for Andromax C The Ultimate Social Media App for Your Smartphone.md deleted file mode 100644 index 78de216967ebd1ddcd07c6878740a57a228a44ab..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Download Facebook for Andromax C The Ultimate Social Media App for Your Smartphone.md +++ /dev/null @@ -1,5 +0,0 @@ -
-[*] Stock Firmware: If you are looking for the Smartfren Andromax C Plus Stock Firmware, then head over to the Smartfren Firmware page. function disqus()if(!disqus_loaded)disqus_loaded=true;var e=document.createElement("script");e.type="text/javascript";e.async=true;e.src="//"+disqus_shortname+".disqus.com/embed.js";(document.getElementsByTagName("head")[0]var disqus_shortname="gsmusbdriver";var disqus_url=" -andromax-c-plus";var disqus_identifier=" -andromax-c-plus";var disqus_loaded=false Load Comments Driver Easy (adsbygoogle = window.adsbygoogle || []).push(); (adsbygoogle = window.adsbygoogle || []).push(); Site Links
download facebook for andromax c
Download Zip >> https://ssurll.com/2uzyIr
aaccfb2cb3
-
-
\ No newline at end of file diff --git a/spaces/contluForse/HuggingGPT/assets/Download Sarthak 2015 Full Movie Watch the Inspiring Story of a Dholak Player.md b/spaces/contluForse/HuggingGPT/assets/Download Sarthak 2015 Full Movie Watch the Inspiring Story of a Dholak Player.md deleted file mode 100644 index bcfb4fb58aed55455096796e8a333377821e411a..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Download Sarthak 2015 Full Movie Watch the Inspiring Story of a Dholak Player.md +++ /dev/null @@ -1,6 +0,0 @@ -download Sarthak 2015 full movie
Download File ✦ https://ssurll.com/2uzxcF
-
- aaccfb2cb3
-
-
- diff --git a/spaces/contluForse/HuggingGPT/assets/Driver Flexi 8 Download EXCLUSIVE.md b/spaces/contluForse/HuggingGPT/assets/Driver Flexi 8 Download EXCLUSIVE.md deleted file mode 100644 index d90d50db54bf4493056b0cc30582de56442c81fa..0000000000000000000000000000000000000000 --- a/spaces/contluForse/HuggingGPT/assets/Driver Flexi 8 Download EXCLUSIVE.md +++ /dev/null @@ -1,22 +0,0 @@ -Driver Flexi 8 Download
Download Zip ⚹ https://ssurll.com/2uzxhx
- -. - -Branded design templates, produced in the simplest way to get your message across.... your trade and in a number of image formats so you can upload in seconds. TABMAKER. - -MacOSX and Windows compatible, 100% standalone... never again pay more for the same business tools, all in one. Automatic size calculations and. - -BrandPoP — A new way to print professional and engaging postcards,. BrandPoP, the leading on-demand postcard production platform.. Marketers are able to instantly create and distribute postcards for any purpose or occasion. - -Send time-stamped digital proofs of your print/sign project to your sign shop or print shop.... with no need to wait days to get your job. Mobile, desktop or web access... on-demand. You pay only for the number of proofs you need, whether you are printing.., 227 Md. 580, 584, 177 A.2d 898, 900 (1962); Prine v. Caplan, 188 Md. 643, 649, 53 A.2d 663, 665 (1947). The county board's rationale for denying the request, that it would be possible to adequately inform the voters of the low turnout at the primary by mailing the ballots to them, was not in conformity with the County Charter's mandate. However, a "county board of education is an administrative, not a legislative, body. It acts as an administrative unit of the county government. It does not act on behalf of the State, or as an arm of the State." Board of Education v. Walsh, 35 Md.App. 595, 605, 371 A.2d 1020, 1027 (1977). Its acts are reviewed under the same standard applicable to the acts of other administrative agencies. Id. - -20 - -In the present case the Board of Education had a policy of holding local elections on the third Tuesday of May. The record contains no evidence that the Board was aware of a constitutional requirement that the Secretary of State certify all petitions to hold an election at the least 30 days prior to the date of election. In view of the fact that the subject ballots had been signed more than 30 days before they were filed with the Board, there was no error. - -21 - -In the present case, the appellants, also, were denied their due 4fefd39f24
-
-
- diff --git a/spaces/cooelf/Multimodal-CoT/timm/models/sknet.py b/spaces/cooelf/Multimodal-CoT/timm/models/sknet.py deleted file mode 100644 index 4dc2aa534c1c9d27c7a988b72f9c4f5a1f172e95..0000000000000000000000000000000000000000 --- a/spaces/cooelf/Multimodal-CoT/timm/models/sknet.py +++ /dev/null @@ -1,215 +0,0 @@ -""" Selective Kernel Networks (ResNet base) - -Paper: Selective Kernel Networks (https://arxiv.org/abs/1903.06586) - -This was inspired by reading 'Compounding the Performance Improvements...' (https://arxiv.org/abs/2001.06268) -and a streamlined impl at https://github.com/clovaai/assembled-cnn but I ended up building something closer -to the original paper with some modifications of my own to better balance param count vs accuracy. - -Hacked together by / Copyright 2020 Ross Wightman -""" -import math - -from torch import nn as nn - -from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD -from .helpers import build_model_with_cfg -from .layers import SelectiveKernel, ConvBnAct, create_attn -from .registry import register_model -from .resnet import ResNet - - -def _cfg(url='', **kwargs): - return { - 'url': url, - 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': (7, 7), - 'crop_pct': 0.875, 'interpolation': 'bicubic', - 'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD, - 'first_conv': 'conv1', 'classifier': 'fc', - **kwargs - } - - -default_cfgs = { - 'skresnet18': _cfg( - url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/skresnet18_ra-4eec2804.pth'), - 'skresnet34': _cfg( - url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/skresnet34_ra-bdc0ccde.pth'), - 'skresnet50': _cfg(), - 'skresnet50d': _cfg( - first_conv='conv1.0'), - 'skresnext50_32x4d': _cfg( - url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-weights/skresnext50_ra-f40e40bf.pth'), -} - - -class SelectiveKernelBasic(nn.Module): - expansion = 1 - - def __init__(self, inplanes, planes, stride=1, downsample=None, cardinality=1, base_width=64, - sk_kwargs=None, reduce_first=1, dilation=1, first_dilation=None, act_layer=nn.ReLU, - norm_layer=nn.BatchNorm2d, attn_layer=None, aa_layer=None, drop_block=None, drop_path=None): - super(SelectiveKernelBasic, self).__init__() - - sk_kwargs = sk_kwargs or {} - conv_kwargs = dict(drop_block=drop_block, act_layer=act_layer, norm_layer=norm_layer, aa_layer=aa_layer) - assert cardinality == 1, 'BasicBlock only supports cardinality of 1' - assert base_width == 64, 'BasicBlock doest not support changing base width' - first_planes = planes // reduce_first - outplanes = planes * self.expansion - first_dilation = first_dilation or dilation - - self.conv1 = SelectiveKernel( - inplanes, first_planes, stride=stride, dilation=first_dilation, **conv_kwargs, **sk_kwargs) - conv_kwargs['act_layer'] = None - self.conv2 = ConvBnAct( - first_planes, outplanes, kernel_size=3, dilation=dilation, **conv_kwargs) - self.se = create_attn(attn_layer, outplanes) - self.act = act_layer(inplace=True) - self.downsample = downsample - self.stride = stride - self.dilation = dilation - self.drop_block = drop_block - self.drop_path = drop_path - - def zero_init_last_bn(self): - nn.init.zeros_(self.conv2.bn.weight) - - def forward(self, x): - shortcut = x - x = self.conv1(x) - x = self.conv2(x) - if self.se is not None: - x = self.se(x) - if self.drop_path is not None: - x = self.drop_path(x) - if self.downsample is not None: - shortcut = self.downsample(shortcut) - x += shortcut - x = self.act(x) - return x - - -class SelectiveKernelBottleneck(nn.Module): - expansion = 4 - - def __init__(self, inplanes, planes, stride=1, downsample=None, - cardinality=1, base_width=64, sk_kwargs=None, reduce_first=1, dilation=1, first_dilation=None, - act_layer=nn.ReLU, norm_layer=nn.BatchNorm2d, attn_layer=None, aa_layer=None, - drop_block=None, drop_path=None): - super(SelectiveKernelBottleneck, self).__init__() - - sk_kwargs = sk_kwargs or {} - conv_kwargs = dict(drop_block=drop_block, act_layer=act_layer, norm_layer=norm_layer, aa_layer=aa_layer) - width = int(math.floor(planes * (base_width / 64)) * cardinality) - first_planes = width // reduce_first - outplanes = planes * self.expansion - first_dilation = first_dilation or dilation - - self.conv1 = ConvBnAct(inplanes, first_planes, kernel_size=1, **conv_kwargs) - self.conv2 = SelectiveKernel( - first_planes, width, stride=stride, dilation=first_dilation, groups=cardinality, - **conv_kwargs, **sk_kwargs) - conv_kwargs['act_layer'] = None - self.conv3 = ConvBnAct(width, outplanes, kernel_size=1, **conv_kwargs) - self.se = create_attn(attn_layer, outplanes) - self.act = act_layer(inplace=True) - self.downsample = downsample - self.stride = stride - self.dilation = dilation - self.drop_block = drop_block - self.drop_path = drop_path - - def zero_init_last_bn(self): - nn.init.zeros_(self.conv3.bn.weight) - - def forward(self, x): - shortcut = x - x = self.conv1(x) - x = self.conv2(x) - x = self.conv3(x) - if self.se is not None: - x = self.se(x) - if self.drop_path is not None: - x = self.drop_path(x) - if self.downsample is not None: - shortcut = self.downsample(shortcut) - x += shortcut - x = self.act(x) - return x - - -def _create_skresnet(variant, pretrained=False, **kwargs): - return build_model_with_cfg( - ResNet, variant, pretrained, - default_cfg=default_cfgs[variant], - **kwargs) - - -@register_model -def skresnet18(pretrained=False, **kwargs): - """Constructs a Selective Kernel ResNet-18 model. - - Different from configs in Select Kernel paper or "Compounding the Performance Improvements..." this - variation splits the input channels to the selective convolutions to keep param count down. - """ - sk_kwargs = dict(rd_ratio=1 / 8, rd_divisor=16, split_input=True) - model_args = dict( - block=SelectiveKernelBasic, layers=[2, 2, 2, 2], block_args=dict(sk_kwargs=sk_kwargs), - zero_init_last_bn=False, **kwargs) - return _create_skresnet('skresnet18', pretrained, **model_args) - - -@register_model -def skresnet34(pretrained=False, **kwargs): - """Constructs a Selective Kernel ResNet-34 model. - - Different from configs in Select Kernel paper or "Compounding the Performance Improvements..." this - variation splits the input channels to the selective convolutions to keep param count down. - """ - sk_kwargs = dict(rd_ratio=1 / 8, rd_divisor=16, split_input=True) - model_args = dict( - block=SelectiveKernelBasic, layers=[3, 4, 6, 3], block_args=dict(sk_kwargs=sk_kwargs), - zero_init_last_bn=False, **kwargs) - return _create_skresnet('skresnet34', pretrained, **model_args) - - -@register_model -def skresnet50(pretrained=False, **kwargs): - """Constructs a Select Kernel ResNet-50 model. - - Different from configs in Select Kernel paper or "Compounding the Performance Improvements..." this - variation splits the input channels to the selective convolutions to keep param count down. - """ - sk_kwargs = dict(split_input=True) - model_args = dict( - block=SelectiveKernelBottleneck, layers=[3, 4, 6, 3], block_args=dict(sk_kwargs=sk_kwargs), - zero_init_last_bn=False, **kwargs) - return _create_skresnet('skresnet50', pretrained, **model_args) - - -@register_model -def skresnet50d(pretrained=False, **kwargs): - """Constructs a Select Kernel ResNet-50-D model. - - Different from configs in Select Kernel paper or "Compounding the Performance Improvements..." this - variation splits the input channels to the selective convolutions to keep param count down. - """ - sk_kwargs = dict(split_input=True) - model_args = dict( - block=SelectiveKernelBottleneck, layers=[3, 4, 6, 3], stem_width=32, stem_type='deep', avg_down=True, - block_args=dict(sk_kwargs=sk_kwargs), zero_init_last_bn=False, **kwargs) - return _create_skresnet('skresnet50d', pretrained, **model_args) - - -@register_model -def skresnext50_32x4d(pretrained=False, **kwargs): - """Constructs a Select Kernel ResNeXt50-32x4d model. This should be equivalent to - the SKNet-50 model in the Select Kernel Paper - """ - sk_kwargs = dict(rd_ratio=1/16, rd_divisor=32, split_input=False) - model_args = dict( - block=SelectiveKernelBottleneck, layers=[3, 4, 6, 3], cardinality=32, base_width=4, - block_args=dict(sk_kwargs=sk_kwargs), zero_init_last_bn=False, **kwargs) - return _create_skresnet('skresnext50_32x4d', pretrained, **model_args) - diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/dwpose/wholebody.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/dwpose/wholebody.py deleted file mode 100644 index 9ce00dd25b52444736632e426921fdc9ba4100f1..0000000000000000000000000000000000000000 --- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/dwpose/wholebody.py +++ /dev/null @@ -1,48 +0,0 @@ -import cv2 -import numpy as np - -import onnxruntime as ort -from .onnxdet import inference_detector -from .onnxpose import inference_pose - -class Wholebody: - def __init__(self): - device = 'cuda:0' - providers = ['CPUExecutionProvider' - ] if device == 'cpu' else ['CUDAExecutionProvider'] - onnx_det = 'annotator/ckpts/yolox_l.onnx' - onnx_pose = 'annotator/ckpts/dw-ll_ucoco_384.onnx' - - self.session_det = ort.InferenceSession(path_or_bytes=onnx_det, providers=providers) - self.session_pose = ort.InferenceSession(path_or_bytes=onnx_pose, providers=providers) - - def __call__(self, oriImg): - det_result = inference_detector(self.session_det, oriImg) - keypoints, scores = inference_pose(self.session_pose, det_result, oriImg) - - keypoints_info = np.concatenate( - (keypoints, scores[..., None]), axis=-1) - # compute neck joint - neck = np.mean(keypoints_info[:, [5, 6]], axis=1) - # neck score when visualizing pred - neck[:, 2:4] = np.logical_and( - keypoints_info[:, 5, 2:4] > 0.3, - keypoints_info[:, 6, 2:4] > 0.3).astype(int) - new_keypoints_info = np.insert( - keypoints_info, 17, neck, axis=1) - mmpose_idx = [ - 17, 6, 8, 10, 7, 9, 12, 14, 16, 13, 15, 2, 1, 4, 3 - ] - openpose_idx = [ - 1, 2, 3, 4, 6, 7, 8, 9, 10, 12, 13, 14, 15, 16, 17 - ] - new_keypoints_info[:, openpose_idx] = \ - new_keypoints_info[:, mmpose_idx] - keypoints_info = new_keypoints_info - - keypoints, scores = keypoints_info[ - ..., :2], keypoints_info[..., 2] - - return keypoints, scores - - diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/lama/saicinpainting/training/modules/multiscale.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/lama/saicinpainting/training/modules/multiscale.py deleted file mode 100644 index 3f41252f3c7509ee58b939215baef328cfbe48c8..0000000000000000000000000000000000000000 --- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/lama/saicinpainting/training/modules/multiscale.py +++ /dev/null @@ -1,244 +0,0 @@ -from typing import List, Tuple, Union, Optional - -import torch -import torch.nn as nn -import torch.nn.functional as F - -from annotator.lama.saicinpainting.training.modules.base import get_conv_block_ctor, get_activation -from annotator.lama.saicinpainting.training.modules.pix2pixhd import ResnetBlock - - -class ResNetHead(nn.Module): - def __init__(self, input_nc, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d, - padding_type='reflect', conv_kind='default', activation=nn.ReLU(True)): - assert (n_blocks >= 0) - super(ResNetHead, self).__init__() - - conv_layer = get_conv_block_ctor(conv_kind) - - model = [nn.ReflectionPad2d(3), - conv_layer(input_nc, ngf, kernel_size=7, padding=0), - norm_layer(ngf), - activation] - - ### downsample - for i in range(n_downsampling): - mult = 2 ** i - model += [conv_layer(ngf * mult, ngf * mult * 2, kernel_size=3, stride=2, padding=1), - norm_layer(ngf * mult * 2), - activation] - - mult = 2 ** n_downsampling - - ### resnet blocks - for i in range(n_blocks): - model += [ResnetBlock(ngf * mult, padding_type=padding_type, activation=activation, norm_layer=norm_layer, - conv_kind=conv_kind)] - - self.model = nn.Sequential(*model) - - def forward(self, input): - return self.model(input) - - -class ResNetTail(nn.Module): - def __init__(self, output_nc, ngf=64, n_downsampling=3, n_blocks=9, norm_layer=nn.BatchNorm2d, - padding_type='reflect', conv_kind='default', activation=nn.ReLU(True), - up_norm_layer=nn.BatchNorm2d, up_activation=nn.ReLU(True), add_out_act=False, out_extra_layers_n=0, - add_in_proj=None): - assert (n_blocks >= 0) - super(ResNetTail, self).__init__() - - mult = 2 ** n_downsampling - - model = [] - - if add_in_proj is not None: - model.append(nn.Conv2d(add_in_proj, ngf * mult, kernel_size=1)) - - ### resnet blocks - for i in range(n_blocks): - model += [ResnetBlock(ngf * mult, padding_type=padding_type, activation=activation, norm_layer=norm_layer, - conv_kind=conv_kind)] - - ### upsample - for i in range(n_downsampling): - mult = 2 ** (n_downsampling - i) - model += [nn.ConvTranspose2d(ngf * mult, int(ngf * mult / 2), kernel_size=3, stride=2, padding=1, - output_padding=1), - up_norm_layer(int(ngf * mult / 2)), - up_activation] - self.model = nn.Sequential(*model) - - out_layers = [] - for _ in range(out_extra_layers_n): - out_layers += [nn.Conv2d(ngf, ngf, kernel_size=1, padding=0), - up_norm_layer(ngf), - up_activation] - out_layers += [nn.ReflectionPad2d(3), - nn.Conv2d(ngf, output_nc, kernel_size=7, padding=0)] - - if add_out_act: - out_layers.append(get_activation('tanh' if add_out_act is True else add_out_act)) - - self.out_proj = nn.Sequential(*out_layers) - - def forward(self, input, return_last_act=False): - features = self.model(input) - out = self.out_proj(features) - if return_last_act: - return out, features - else: - return out - - -class MultiscaleResNet(nn.Module): - def __init__(self, input_nc, output_nc, ngf=64, n_downsampling=2, n_blocks_head=2, n_blocks_tail=6, n_scales=3, - norm_layer=nn.BatchNorm2d, padding_type='reflect', conv_kind='default', activation=nn.ReLU(True), - up_norm_layer=nn.BatchNorm2d, up_activation=nn.ReLU(True), add_out_act=False, out_extra_layers_n=0, - out_cumulative=False, return_only_hr=False): - super().__init__() - - self.heads = nn.ModuleList([ResNetHead(input_nc, ngf=ngf, n_downsampling=n_downsampling, - n_blocks=n_blocks_head, norm_layer=norm_layer, padding_type=padding_type, - conv_kind=conv_kind, activation=activation) - for i in range(n_scales)]) - tail_in_feats = ngf * (2 ** n_downsampling) + ngf - self.tails = nn.ModuleList([ResNetTail(output_nc, - ngf=ngf, n_downsampling=n_downsampling, - n_blocks=n_blocks_tail, norm_layer=norm_layer, padding_type=padding_type, - conv_kind=conv_kind, activation=activation, up_norm_layer=up_norm_layer, - up_activation=up_activation, add_out_act=add_out_act, - out_extra_layers_n=out_extra_layers_n, - add_in_proj=None if (i == n_scales - 1) else tail_in_feats) - for i in range(n_scales)]) - - self.out_cumulative = out_cumulative - self.return_only_hr = return_only_hr - - @property - def num_scales(self): - return len(self.heads) - - def forward(self, ms_inputs: List[torch.Tensor], smallest_scales_num: Optional[int] = None) \ - -> Union[torch.Tensor, List[torch.Tensor]]: - """ - :param ms_inputs: List of inputs of different resolutions from HR to LR - :param smallest_scales_num: int or None, number of smallest scales to take at input - :return: Depending on return_only_hr: - True: Only the most HR output - False: List of outputs of different resolutions from HR to LR - """ - if smallest_scales_num is None: - assert len(self.heads) == len(ms_inputs), (len(self.heads), len(ms_inputs), smallest_scales_num) - smallest_scales_num = len(self.heads) - else: - assert smallest_scales_num == len(ms_inputs) <= len(self.heads), (len(self.heads), len(ms_inputs), smallest_scales_num) - - cur_heads = self.heads[-smallest_scales_num:] - ms_features = [cur_head(cur_inp) for cur_head, cur_inp in zip(cur_heads, ms_inputs)] - - all_outputs = [] - prev_tail_features = None - for i in range(len(ms_features)): - scale_i = -i - 1 - - cur_tail_input = ms_features[-i - 1] - if prev_tail_features is not None: - if prev_tail_features.shape != cur_tail_input.shape: - prev_tail_features = F.interpolate(prev_tail_features, size=cur_tail_input.shape[2:], - mode='bilinear', align_corners=False) - cur_tail_input = torch.cat((cur_tail_input, prev_tail_features), dim=1) - - cur_out, cur_tail_feats = self.tails[scale_i](cur_tail_input, return_last_act=True) - - prev_tail_features = cur_tail_feats - all_outputs.append(cur_out) - - if self.out_cumulative: - all_outputs_cum = [all_outputs[0]] - for i in range(1, len(ms_features)): - cur_out = all_outputs[i] - cur_out_cum = cur_out + F.interpolate(all_outputs_cum[-1], size=cur_out.shape[2:], - mode='bilinear', align_corners=False) - all_outputs_cum.append(cur_out_cum) - all_outputs = all_outputs_cum - - if self.return_only_hr: - return all_outputs[-1] - else: - return all_outputs[::-1] - - -class MultiscaleDiscriminatorSimple(nn.Module): - def __init__(self, ms_impl): - super().__init__() - self.ms_impl = nn.ModuleList(ms_impl) - - @property - def num_scales(self): - return len(self.ms_impl) - - def forward(self, ms_inputs: List[torch.Tensor], smallest_scales_num: Optional[int] = None) \ - -> List[Tuple[torch.Tensor, List[torch.Tensor]]]: - """ - :param ms_inputs: List of inputs of different resolutions from HR to LR - :param smallest_scales_num: int or None, number of smallest scales to take at input - :return: List of pairs (prediction, features) for different resolutions from HR to LR - """ - if smallest_scales_num is None: - assert len(self.ms_impl) == len(ms_inputs), (len(self.ms_impl), len(ms_inputs), smallest_scales_num) - smallest_scales_num = len(self.heads) - else: - assert smallest_scales_num == len(ms_inputs) <= len(self.ms_impl), \ - (len(self.ms_impl), len(ms_inputs), smallest_scales_num) - - return [cur_discr(cur_input) for cur_discr, cur_input in zip(self.ms_impl[-smallest_scales_num:], ms_inputs)] - - -class SingleToMultiScaleInputMixin: - def forward(self, x: torch.Tensor) -> List: - orig_height, orig_width = x.shape[2:] - factors = [2 ** i for i in range(self.num_scales)] - ms_inputs = [F.interpolate(x, size=(orig_height // f, orig_width // f), mode='bilinear', align_corners=False) - for f in factors] - return super().forward(ms_inputs) - - -class GeneratorMultiToSingleOutputMixin: - def forward(self, x): - return super().forward(x)[0] - - -class DiscriminatorMultiToSingleOutputMixin: - def forward(self, x): - out_feat_tuples = super().forward(x) - return out_feat_tuples[0][0], [f for _, flist in out_feat_tuples for f in flist] - - -class DiscriminatorMultiToSingleOutputStackedMixin: - def __init__(self, *args, return_feats_only_levels=None, **kwargs): - super().__init__(*args, **kwargs) - self.return_feats_only_levels = return_feats_only_levels - - def forward(self, x): - out_feat_tuples = super().forward(x) - outs = [out for out, _ in out_feat_tuples] - scaled_outs = [outs[0]] + [F.interpolate(cur_out, size=outs[0].shape[-2:], - mode='bilinear', align_corners=False) - for cur_out in outs[1:]] - out = torch.cat(scaled_outs, dim=1) - if self.return_feats_only_levels is not None: - feat_lists = [out_feat_tuples[i][1] for i in self.return_feats_only_levels] - else: - feat_lists = [flist for _, flist in out_feat_tuples] - feats = [f for flist in feat_lists for f in flist] - return out, feats - - -class MultiscaleDiscrSingleInput(SingleToMultiScaleInputMixin, DiscriminatorMultiToSingleOutputStackedMixin, MultiscaleDiscriminatorSimple): - pass - - -class MultiscaleResNetSingle(GeneratorMultiToSingleOutputMixin, SingleToMultiScaleInputMixin, MultiscaleResNet): - pass diff --git a/spaces/cownclown/Image-and-3D-Model-Creator/PIFu/apps/prt_util.py b/spaces/cownclown/Image-and-3D-Model-Creator/PIFu/apps/prt_util.py deleted file mode 100644 index 7eba32fa0b396f420b2e332abbb67135dbc14d6b..0000000000000000000000000000000000000000 --- a/spaces/cownclown/Image-and-3D-Model-Creator/PIFu/apps/prt_util.py +++ /dev/null @@ -1,142 +0,0 @@ -import os -import trimesh -import numpy as np -import math -from scipy.special import sph_harm -import argparse -from tqdm import tqdm - -def factratio(N, D): - if N >= D: - prod = 1.0 - for i in range(D+1, N+1): - prod *= i - return prod - else: - prod = 1.0 - for i in range(N+1, D+1): - prod *= i - return 1.0 / prod - -def KVal(M, L): - return math.sqrt(((2 * L + 1) / (4 * math.pi)) * (factratio(L - M, L + M))) - -def AssociatedLegendre(M, L, x): - if M < 0 or M > L or np.max(np.abs(x)) > 1.0: - return np.zeros_like(x) - - pmm = np.ones_like(x) - if M > 0: - somx2 = np.sqrt((1.0 + x) * (1.0 - x)) - fact = 1.0 - for i in range(1, M+1): - pmm = -pmm * fact * somx2 - fact = fact + 2 - - if L == M: - return pmm - else: - pmmp1 = x * (2 * M + 1) * pmm - if L == M+1: - return pmmp1 - else: - pll = np.zeros_like(x) - for i in range(M+2, L+1): - pll = (x * (2 * i - 1) * pmmp1 - (i + M - 1) * pmm) / (i - M) - pmm = pmmp1 - pmmp1 = pll - return pll - -def SphericalHarmonic(M, L, theta, phi): - if M > 0: - return math.sqrt(2.0) * KVal(M, L) * np.cos(M * phi) * AssociatedLegendre(M, L, np.cos(theta)) - elif M < 0: - return math.sqrt(2.0) * KVal(-M, L) * np.sin(-M * phi) * AssociatedLegendre(-M, L, np.cos(theta)) - else: - return KVal(0, L) * AssociatedLegendre(0, L, np.cos(theta)) - -def save_obj(mesh_path, verts): - file = open(mesh_path, 'w') - for v in verts: - file.write('v %.4f %.4f %.4f\n' % (v[0], v[1], v[2])) - file.close() - -def sampleSphericalDirections(n): - xv = np.random.rand(n,n) - yv = np.random.rand(n,n) - theta = np.arccos(1-2 * xv) - phi = 2.0 * math.pi * yv - - phi = phi.reshape(-1) - theta = theta.reshape(-1) - - vx = -np.sin(theta) * np.cos(phi) - vy = -np.sin(theta) * np.sin(phi) - vz = np.cos(theta) - return np.stack([vx, vy, vz], 1), phi, theta - -def getSHCoeffs(order, phi, theta): - shs = [] - for n in range(0, order+1): - for m in range(-n,n+1): - s = SphericalHarmonic(m, n, theta, phi) - shs.append(s) - - return np.stack(shs, 1) - -def computePRT(mesh_path, n, order): - mesh = trimesh.load(mesh_path, process=False) - vectors_orig, phi, theta = sampleSphericalDirections(n) - SH_orig = getSHCoeffs(order, phi, theta) - - w = 4.0 * math.pi / (n*n) - - origins = mesh.vertices - normals = mesh.vertex_normals - n_v = origins.shape[0] - - origins = np.repeat(origins[:,None], n, axis=1).reshape(-1,3) - normals = np.repeat(normals[:,None], n, axis=1).reshape(-1,3) - PRT_all = None - for i in tqdm(range(n)): - SH = np.repeat(SH_orig[None,(i*n):((i+1)*n)], n_v, axis=0).reshape(-1,SH_orig.shape[1]) - vectors = np.repeat(vectors_orig[None,(i*n):((i+1)*n)], n_v, axis=0).reshape(-1,3) - - dots = (vectors * normals).sum(1) - front = (dots > 0.0) - - delta = 1e-3*min(mesh.bounding_box.extents) - hits = mesh.ray.intersects_any(origins + delta * normals, vectors) - nohits = np.logical_and(front, np.logical_not(hits)) - - PRT = (nohits.astype(np.float) * dots)[:,None] * SH - - if PRT_all is not None: - PRT_all += (PRT.reshape(-1, n, SH.shape[1]).sum(1)) - else: - PRT_all = (PRT.reshape(-1, n, SH.shape[1]).sum(1)) - - PRT = w * PRT_all - - # NOTE: trimesh sometimes break the original vertex order, but topology will not change. - # when loading PRT in other program, use the triangle list from trimesh. - return PRT, mesh.faces - -def testPRT(dir_path, n=40): - if dir_path[-1] == '/': - dir_path = dir_path[:-1] - sub_name = dir_path.split('/')[-1][:-4] - obj_path = os.path.join(dir_path, sub_name + '_100k.obj') - os.makedirs(os.path.join(dir_path, 'bounce'), exist_ok=True) - - PRT, F = computePRT(obj_path, n, 2) - np.savetxt(os.path.join(dir_path, 'bounce', 'bounce0.txt'), PRT, fmt='%.8f') - np.save(os.path.join(dir_path, 'bounce', 'face.npy'), F) - -if __name__ == '__main__': - parser = argparse.ArgumentParser() - parser.add_argument('-i', '--input', type=str, default='/home/shunsuke/Downloads/rp_dennis_posed_004_OBJ') - parser.add_argument('-n', '--n_sample', type=int, default=40, help='squared root of number of sampling. the higher, the more accurate, but slower') - args = parser.parse_args() - - testPRT(args.input) diff --git a/spaces/crashedice/signify/README.md b/spaces/crashedice/signify/README.md deleted file mode 100644 index b57fad8fc913b8bff3f4665689403caf4d928be4..0000000000000000000000000000000000000000 --- a/spaces/crashedice/signify/README.md +++ /dev/null @@ -1,10 +0,0 @@ ---- -title: Signify -emoji: 🔥 -colorFrom: red -colorTo: purple -sdk: streamlit -sdk_version: 1.16.0 -app_file: Welcome.py -pinned: false ---- diff --git a/spaces/crashedice/signify/SOURCE/yolo_files/utils/datasets.py b/spaces/crashedice/signify/SOURCE/yolo_files/utils/datasets.py deleted file mode 100644 index 6dc7251e24efee79a3fe7e8481410237dc15182a..0000000000000000000000000000000000000000 --- a/spaces/crashedice/signify/SOURCE/yolo_files/utils/datasets.py +++ /dev/null @@ -1,1067 +0,0 @@ -# Dataset utils and dataloaders - -import glob -import logging -import math -import os -import random -import shutil -import time -from itertools import repeat -from multiprocessing.pool import ThreadPool -from pathlib import Path -from threading import Thread - -import cv2 -import numpy as np -import torch -import torch.nn.functional as F -from PIL import Image, ExifTags -from torch.utils.data import Dataset -from tqdm import tqdm - -from SOURCE.yolo_files.utils.general import check_requirements, xyxy2xywh, xywh2xyxy, xywhn2xyxy, xyn2xy, segment2box, segments2boxes, \ - resample_segments, clean_str -from SOURCE.yolo_files.utils.torch_utils import torch_distributed_zero_first - -# Parameters -help_url = 'https://github.com/ultralytics/yolov5/wiki/Train-Custom-Data' -img_formats = ['bmp', 'jpg', 'jpeg', 'png', 'tif', 'tiff', 'dng', 'webp', 'mpo'] # acceptable image suffixes -vid_formats = ['mov', 'avi', 'mp4', 'mpg', 'mpeg', 'm4v', 'wmv', 'mkv'] # acceptable video suffixes -logger = logging.getLogger(__name__) - -# Get orientation exif tag -for orientation in ExifTags.TAGS.keys(): - if ExifTags.TAGS[orientation] == 'Orientation': - break - - -def get_hash(files): - # Returns a single hash value of a list of files - return sum(os.path.getsize(f) for f in files if os.path.isfile(f)) - - -def exif_size(img): - # Returns exif-corrected PIL size - s = img.size # (width, height) - try: - rotation = dict(img._getexif().items())[orientation] - if rotation == 6: # rotation 270 - s = (s[1], s[0]) - elif rotation == 8: # rotation 90 - s = (s[1], s[0]) - except: - pass - - return s - - -def create_dataloader(path, imgsz, batch_size, stride, opt, hyp=None, augment=False, cache=False, pad=0.0, rect=False, - rank=-1, world_size=1, workers=8, image_weights=False, quad=False, prefix=''): - # Make sure only the first process in DDP process the dataset first, and the following others can use the cache - with torch_distributed_zero_first(rank): - dataset = LoadImagesAndLabels(path, imgsz, batch_size, - augment=augment, # augment images - hyp=hyp, # augmentation hyperparameters - rect=rect, # rectangular training - cache_images=cache, - single_cls=opt.single_cls, - stride=int(stride), - pad=pad, - image_weights=image_weights, - prefix=prefix) - - batch_size = min(batch_size, len(dataset)) - nw = min([os.cpu_count() // world_size, batch_size if batch_size > 1 else 0, workers]) # number of workers - sampler = torch.utils.data.distributed.DistributedSampler(dataset) if rank != -1 else None - loader = torch.utils.data.DataLoader if image_weights else InfiniteDataLoader - # Use torch.utils.data.DataLoader() if dataset.properties will update during training else InfiniteDataLoader() - dataloader = loader(dataset, - batch_size=batch_size, - num_workers=nw, - sampler=sampler, - pin_memory=True, - collate_fn=LoadImagesAndLabels.collate_fn4 if quad else LoadImagesAndLabels.collate_fn) - return dataloader, dataset - - -class InfiniteDataLoader(torch.utils.data.dataloader.DataLoader): - """ Dataloader that reuses workers - - Uses same syntax as vanilla DataLoader - """ - - def __init__(self, *args, **kwargs): - super().__init__(*args, **kwargs) - object.__setattr__(self, 'batch_sampler', _RepeatSampler(self.batch_sampler)) - self.iterator = super().__iter__() - - def __len__(self): - return len(self.batch_sampler.sampler) - - def __iter__(self): - for i in range(len(self)): - yield next(self.iterator) - - -class _RepeatSampler(object): - """ Sampler that repeats forever - - Args: - sampler (Sampler) - """ - - def __init__(self, sampler): - self.sampler = sampler - - def __iter__(self): - while True: - yield from iter(self.sampler) - - -class LoadImages: # for inference - def __init__(self, path, img_size=640, stride=32): - p = str(Path(path).absolute()) # os-agnostic absolute path - if '*' in p: - files = sorted(glob.glob(p, recursive=True)) # glob - elif os.path.isdir(p): - files = sorted(glob.glob(os.path.join(p, '*.*'))) # dir - elif os.path.isfile(p): - files = [p] # files - else: - raise Exception(f'ERROR: {p} does not exist') - - images = [x for x in files if x.split('.')[-1].lower() in img_formats] - videos = [x for x in files if x.split('.')[-1].lower() in vid_formats] - ni, nv = len(images), len(videos) - - self.img_size = img_size - self.stride = stride - self.files = images + videos - self.nf = ni + nv # number of files - self.video_flag = [False] * ni + [True] * nv - self.mode = 'image' - if any(videos): - self.new_video(videos[0]) # new video - else: - self.cap = None - assert self.nf > 0, f'No images or videos found in {p}. ' \ - f'Supported formats are:\nimages: {img_formats}\nvideos: {vid_formats}' - - def __iter__(self): - self.count = 0 - return self - - def __next__(self): - if self.count == self.nf: - raise StopIteration - path = self.files[self.count] - - if self.video_flag[self.count]: - # Read video - self.mode = 'video' - ret_val, img0 = self.cap.read() - if not ret_val: - self.count += 1 - self.cap.release() - if self.count == self.nf: # last video - raise StopIteration - else: - path = self.files[self.count] - self.new_video(path) - ret_val, img0 = self.cap.read() - - self.frame += 1 - print(f'video {self.count + 1}/{self.nf} ({self.frame}/{self.nframes}) {path}: ', end='') - - else: - # Read image - self.count += 1 - img0 = cv2.imread(path) # BGR - assert img0 is not None, 'Image Not Found ' + path - print(f'image {self.count}/{self.nf} {path}: ', end='') - - # Padded resize - img = letterbox(img0, self.img_size, stride=self.stride)[0] - - # Convert - img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 - img = np.ascontiguousarray(img) - - return path, img, img0, self.cap - - def new_video(self, path): - self.frame = 0 - self.cap = cv2.VideoCapture(path) - self.nframes = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT)) - - def __len__(self): - return self.nf # number of files - - -class LoadWebcam: # for inference - def __init__(self, pipe='0', img_size=640, stride=32): - self.img_size = img_size - self.stride = stride - - if pipe.isnumeric(): - pipe = eval(pipe) # local camera - # pipe = 'rtsp://192.168.1.64/1' # IP camera - # pipe = 'rtsp://username:password@192.168.1.64/1' # IP camera with login - # pipe = 'http://wmccpinetop.axiscam.net/mjpg/video.mjpg' # IP golf camera - - self.pipe = pipe - self.cap = cv2.VideoCapture(pipe) # video capture object - self.cap.set(cv2.CAP_PROP_BUFFERSIZE, 3) # set buffer size - - def __iter__(self): - self.count = -1 - return self - - def __next__(self): - self.count += 1 - if cv2.waitKey(1) == ord('q'): # q to quit - self.cap.release() - cv2.destroyAllWindows() - raise StopIteration - - # Read frame - if self.pipe == 0: # local camera - ret_val, img0 = self.cap.read() - img0 = cv2.flip(img0, 1) # flip left-right - else: # IP camera - n = 0 - while True: - n += 1 - self.cap.grab() - if n % 30 == 0: # skip frames - ret_val, img0 = self.cap.retrieve() - if ret_val: - break - - # Print - assert ret_val, f'Camera Error {self.pipe}' - img_path = 'webcam.jpg' - print(f'webcam {self.count}: ', end='') - - # Padded resize - img = letterbox(img0, self.img_size, stride=self.stride)[0] - - # Convert - img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 - img = np.ascontiguousarray(img) - - return img_path, img, img0, None - - def __len__(self): - return 0 - - -class LoadStreams: # multiple IP or RTSP cameras - def __init__(self, sources='streams.txt', img_size=640, stride=32): - self.mode = 'stream' - self.img_size = img_size - self.stride = stride - - if os.path.isfile(sources): - with open(sources, 'r') as f: - sources = [x.strip() for x in f.read().strip().splitlines() if len(x.strip())] - else: - sources = [sources] - - n = len(sources) - self.imgs = [None] * n - self.sources = [clean_str(x) for x in sources] # clean source names for later - for i, s in enumerate(sources): # index, source - # Start thread to read frames from video stream - print(f'{i + 1}/{n}: {s}... ', end='') - if 'youtube.com/' in s or 'youtu.be/' in s: # if source is YouTube video - check_requirements(('pafy', 'youtube_dl')) - import pafy - s = pafy.new(s).getbest(preftype="mp4").url # YouTube URL - s = eval(s) if s.isnumeric() else s # i.e. s = '0' local webcam - cap = cv2.VideoCapture(s) - assert cap.isOpened(), f'Failed to open {s}' - w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) - h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) - self.fps = cap.get(cv2.CAP_PROP_FPS) % 100 - - _, self.imgs[i] = cap.read() # guarantee first frame - thread = Thread(target=self.update, args=([i, cap]), daemon=True) - print(f' success ({w}x{h} at {self.fps:.2f} FPS).') - thread.start() - print('') # newline - - # check for common shapes - s = np.stack([letterbox(x, self.img_size, stride=self.stride)[0].shape for x in self.imgs], 0) # shapes - self.rect = np.unique(s, axis=0).shape[0] == 1 # rect inference if all shapes equal - if not self.rect: - print('WARNING: Different stream shapes detected. For optimal performance supply similarly-shaped streams.') - - def update(self, index, cap): - # Read next stream frame in a daemon thread - n = 0 - while cap.isOpened(): - n += 1 - # _, self.imgs[index] = cap.read() - cap.grab() - if n == 4: # read every 4th frame - success, im = cap.retrieve() - self.imgs[index] = im if success else self.imgs[index] * 0 - n = 0 - time.sleep(1 / self.fps) # wait time - - def __iter__(self): - self.count = -1 - return self - - def __next__(self): - self.count += 1 - img0 = self.imgs.copy() - if cv2.waitKey(1) == ord('q'): # q to quit - cv2.destroyAllWindows() - raise StopIteration - - # Letterbox - img = [letterbox(x, self.img_size, auto=self.rect, stride=self.stride)[0] for x in img0] - - # Stack - img = np.stack(img, 0) - - # Convert - img = img[:, :, :, ::-1].transpose(0, 3, 1, 2) # BGR to RGB, to bsx3x416x416 - img = np.ascontiguousarray(img) - - return self.sources, img, img0, None - - def __len__(self): - return 0 # 1E12 frames = 32 streams at 30 FPS for 30 years - - -def img2label_paths(img_paths): - # Define label paths as a function of image paths - sa, sb = os.sep + 'images' + os.sep, os.sep + 'labels' + os.sep # /images/, /labels/ substrings - return ['txt'.join(x.replace(sa, sb, 1).rsplit(x.split('.')[-1], 1)) for x in img_paths] - - -class LoadImagesAndLabels(Dataset): # for training/testing - def __init__(self, path, img_size=640, batch_size=16, augment=False, hyp=None, rect=False, image_weights=False, - cache_images=False, single_cls=False, stride=32, pad=0.0, prefix=''): - self.img_size = img_size - self.augment = augment - self.hyp = hyp - self.image_weights = image_weights - self.rect = False if image_weights else rect - self.mosaic = self.augment and not self.rect # load 4 images at a time into a mosaic (only during training) - self.mosaic_border = [-img_size // 2, -img_size // 2] - self.stride = stride - self.path = path - - try: - f = [] # image files - for p in path if isinstance(path, list) else [path]: - p = Path(p) # os-agnostic - if p.is_dir(): # dir - f += glob.glob(str(p / '**' / '*.*'), recursive=True) - # f = list(p.rglob('**/*.*')) # pathlib - elif p.is_file(): # file - with open(p, 'r') as t: - t = t.read().strip().splitlines() - parent = str(p.parent) + os.sep - f += [x.replace('./', parent) if x.startswith('./') else x for x in t] # local to global path - # f += [p.parent / x.lstrip(os.sep) for x in t] # local to global path (pathlib) - else: - raise Exception(f'{prefix}{p} does not exist') - self.img_files = sorted([x.replace('/', os.sep) for x in f if x.split('.')[-1].lower() in img_formats]) - # self.img_files = sorted([x for x in f if x.suffix[1:].lower() in img_formats]) # pathlib - assert self.img_files, f'{prefix}No images found' - except Exception as e: - raise Exception(f'{prefix}Error loading data from {path}: {e}\nSee {help_url}') - - # Check cache - self.label_files = img2label_paths(self.img_files) # labels - cache_path = (p if p.is_file() else Path(self.label_files[0]).parent).with_suffix('.cache') # cached labels - if cache_path.is_file(): - cache, exists = torch.load(cache_path), True # load - if cache['hash'] != get_hash(self.label_files + self.img_files) or 'version' not in cache: # changed - cache, exists = self.cache_labels(cache_path, prefix), False # re-cache - else: - cache, exists = self.cache_labels(cache_path, prefix), False # cache - - # Display cache - nf, nm, ne, nc, n = cache.pop('results') # found, missing, empty, corrupted, total - if exists: - d = f"Scanning '{cache_path}' images and labels... {nf} found, {nm} missing, {ne} empty, {nc} corrupted" - tqdm(None, desc=prefix + d, total=n, initial=n) # display cache results - assert nf > 0 or not augment, f'{prefix}No labels in {cache_path}. Can not train without labels. See {help_url}' - - # Read cache - cache.pop('hash') # remove hash - cache.pop('version') # remove version - labels, shapes, self.segments = zip(*cache.values()) - self.labels = list(labels) - self.shapes = np.array(shapes, dtype=np.float64) - self.img_files = list(cache.keys()) # update - self.label_files = img2label_paths(cache.keys()) # update - if single_cls: - for x in self.labels: - x[:, 0] = 0 - - n = len(shapes) # number of images - bi = np.floor(np.arange(n) / batch_size).astype(np.int) # batch index - nb = bi[-1] + 1 # number of batches - self.batch = bi # batch index of image - self.n = n - self.indices = range(n) - - # Rectangular Training - if self.rect: - # Sort by aspect ratio - s = self.shapes # wh - ar = s[:, 1] / s[:, 0] # aspect ratio - irect = ar.argsort() - self.img_files = [self.img_files[i] for i in irect] - self.label_files = [self.label_files[i] for i in irect] - self.labels = [self.labels[i] for i in irect] - self.shapes = s[irect] # wh - ar = ar[irect] - - # Set training image shapes - shapes = [[1, 1]] * nb - for i in range(nb): - ari = ar[bi == i] - mini, maxi = ari.min(), ari.max() - if maxi < 1: - shapes[i] = [maxi, 1] - elif mini > 1: - shapes[i] = [1, 1 / mini] - - self.batch_shapes = np.ceil(np.array(shapes) * img_size / stride + pad).astype(np.int) * stride - - # Cache images into memory for faster training (WARNING: large datasets may exceed system RAM) - self.imgs = [None] * n - if cache_images: - gb = 0 # Gigabytes of cached images - self.img_hw0, self.img_hw = [None] * n, [None] * n - results = ThreadPool(8).imap(lambda x: load_image(*x), zip(repeat(self), range(n))) # 8 threads - pbar = tqdm(enumerate(results), total=n) - for i, x in pbar: - self.imgs[i], self.img_hw0[i], self.img_hw[i] = x # img, hw_original, hw_resized = load_image(self, i) - gb += self.imgs[i].nbytes - pbar.desc = f'{prefix}Caching images ({gb / 1E9:.1f}GB)' - pbar.close() - - def cache_labels(self, path=Path('./labels.cache'), prefix=''): - # Cache dataset labels, check images and read shapes - x = {} # dict - nm, nf, ne, nc = 0, 0, 0, 0 # number missing, found, empty, duplicate - pbar = tqdm(zip(self.img_files, self.label_files), desc='Scanning images', total=len(self.img_files)) - for i, (im_file, lb_file) in enumerate(pbar): - try: - # verify images - im = Image.open(im_file) - im.verify() # PIL verify - shape = exif_size(im) # image size - segments = [] # instance segments - assert (shape[0] > 9) & (shape[1] > 9), f'image size {shape} <10 pixels' - assert im.format.lower() in img_formats, f'invalid image format {im.format}' - - # verify labels - if os.path.isfile(lb_file): - nf += 1 # label found - with open(lb_file, 'r') as f: - l = [x.split() for x in f.read().strip().splitlines()] - if any([len(x) > 8 for x in l]): # is segment - classes = np.array([x[0] for x in l], dtype=np.float32) - segments = [np.array(x[1:], dtype=np.float32).reshape(-1, 2) for x in l] # (cls, xy1...) - l = np.concatenate((classes.reshape(-1, 1), segments2boxes(segments)), 1) # (cls, xywh) - l = np.array(l, dtype=np.float32) - if len(l): - assert l.shape[1] == 5, 'labels require 5 columns each' - assert (l >= 0).all(), 'negative labels' - assert (l[:, 1:] <= 1).all(), 'non-normalized or out of bounds coordinate labels' - assert np.unique(l, axis=0).shape[0] == l.shape[0], 'duplicate labels' - else: - ne += 1 # label empty - l = np.zeros((0, 5), dtype=np.float32) - else: - nm += 1 # label missing - l = np.zeros((0, 5), dtype=np.float32) - x[im_file] = [l, shape, segments] - except Exception as e: - nc += 1 - print(f'{prefix}WARNING: Ignoring corrupted image and/or label {im_file}: {e}') - - pbar.desc = f"{prefix}Scanning '{path.parent / path.stem}' images and labels... " \ - f"{nf} found, {nm} missing, {ne} empty, {nc} corrupted" - pbar.close() - - if nf == 0: - print(f'{prefix}WARNING: No labels found in {path}. See {help_url}') - - x['hash'] = get_hash(self.label_files + self.img_files) - x['results'] = nf, nm, ne, nc, i + 1 - x['version'] = 0.1 # cache version - try: - torch.save(x, path) # save for next time - logging.info(f'{prefix}New cache created: {path}') - except Exception as e: - logging.info(f'{prefix}WARNING: Cache directory {path.parent} is not writeable: {e}') # path not writeable - return x - - def __len__(self): - return len(self.img_files) - - # def __iter__(self): - # self.count = -1 - # print('ran dataset iter') - # #self.shuffled_vector = np.random.permutation(self.nF) if self.augment else np.arange(self.nF) - # return self - - def __getitem__(self, index): - index = self.indices[index] # linear, shuffled, or image_weights - - hyp = self.hyp - mosaic = self.mosaic and random.random() < hyp['mosaic'] - if mosaic: - # Load mosaic - img, labels = load_mosaic(self, index) - shapes = None - - # MixUp https://arxiv.org/pdf/1710.09412.pdf - if random.random() < hyp['mixup']: - img2, labels2 = load_mosaic(self, random.randint(0, self.n - 1)) - r = np.random.beta(8.0, 8.0) # mixup ratio, alpha=beta=8.0 - img = (img * r + img2 * (1 - r)).astype(np.uint8) - labels = np.concatenate((labels, labels2), 0) - - else: - # Load image - img, (h0, w0), (h, w) = load_image(self, index) - - # Letterbox - shape = self.batch_shapes[self.batch[index]] if self.rect else self.img_size # final letterboxed shape - img, ratio, pad = letterbox(img, shape, auto=False, scaleup=self.augment) - shapes = (h0, w0), ((h / h0, w / w0), pad) # for COCO mAP rescaling - - labels = self.labels[index].copy() - if labels.size: # normalized xywh to pixel xyxy format - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], ratio[0] * w, ratio[1] * h, padw=pad[0], padh=pad[1]) - - if self.augment: - # Augment imagespace - if not mosaic: - img, labels = random_perspective(img, labels, - degrees=hyp['degrees'], - translate=hyp['translate'], - scale=hyp['scale'], - shear=hyp['shear'], - perspective=hyp['perspective']) - - # Augment colorspace - augment_hsv(img, hgain=hyp['hsv_h'], sgain=hyp['hsv_s'], vgain=hyp['hsv_v']) - - # Apply cutouts - # if random.random() < 0.9: - # labels = cutout(img, labels) - - nL = len(labels) # number of labels - if nL: - labels[:, 1:5] = xyxy2xywh(labels[:, 1:5]) # convert xyxy to xywh - labels[:, [2, 4]] /= img.shape[0] # normalized height 0-1 - labels[:, [1, 3]] /= img.shape[1] # normalized width 0-1 - - if self.augment: - # flip up-down - if random.random() < hyp['flipud']: - img = np.flipud(img) - if nL: - labels[:, 2] = 1 - labels[:, 2] - - # flip left-right - if random.random() < hyp['fliplr']: - img = np.fliplr(img) - if nL: - labels[:, 1] = 1 - labels[:, 1] - - labels_out = torch.zeros((nL, 6)) - if nL: - labels_out[:, 1:] = torch.from_numpy(labels) - - # Convert - img = img[:, :, ::-1].transpose(2, 0, 1) # BGR to RGB, to 3x416x416 - img = np.ascontiguousarray(img) - - return torch.from_numpy(img), labels_out, self.img_files[index], shapes - - @staticmethod - def collate_fn(batch): - img, label, path, shapes = zip(*batch) # transposed - for i, l in enumerate(label): - l[:, 0] = i # add target image index for build_targets() - return torch.stack(img, 0), torch.cat(label, 0), path, shapes - - @staticmethod - def collate_fn4(batch): - img, label, path, shapes = zip(*batch) # transposed - n = len(shapes) // 4 - img4, label4, path4, shapes4 = [], [], path[:n], shapes[:n] - - ho = torch.tensor([[0., 0, 0, 1, 0, 0]]) - wo = torch.tensor([[0., 0, 1, 0, 0, 0]]) - s = torch.tensor([[1, 1, .5, .5, .5, .5]]) # scale - for i in range(n): # zidane torch.zeros(16,3,720,1280) # BCHW - i *= 4 - if random.random() < 0.5: - im = F.interpolate(img[i].unsqueeze(0).float(), scale_factor=2., mode='bilinear', align_corners=False)[ - 0].type(img[i].type()) - l = label[i] - else: - im = torch.cat((torch.cat((img[i], img[i + 1]), 1), torch.cat((img[i + 2], img[i + 3]), 1)), 2) - l = torch.cat((label[i], label[i + 1] + ho, label[i + 2] + wo, label[i + 3] + ho + wo), 0) * s - img4.append(im) - label4.append(l) - - for i, l in enumerate(label4): - l[:, 0] = i # add target image index for build_targets() - - return torch.stack(img4, 0), torch.cat(label4, 0), path4, shapes4 - - -# Ancillary functions -------------------------------------------------------------------------------------------------- -def load_image(self, index): - # loads 1 image from dataset, returns img, original hw, resized hw - img = self.imgs[index] - if img is None: # not cached - path = self.img_files[index] - img = cv2.imread(path) # BGR - assert img is not None, 'Image Not Found ' + path - h0, w0 = img.shape[:2] # orig hw - r = self.img_size / max(h0, w0) # ratio - if r != 1: # if sizes are not equal - img = cv2.resize(img, (int(w0 * r), int(h0 * r)), - interpolation=cv2.INTER_AREA if r < 1 and not self.augment else cv2.INTER_LINEAR) - return img, (h0, w0), img.shape[:2] # img, hw_original, hw_resized - else: - return self.imgs[index], self.img_hw0[index], self.img_hw[index] # img, hw_original, hw_resized - - -def augment_hsv(img, hgain=0.5, sgain=0.5, vgain=0.5): - r = np.random.uniform(-1, 1, 3) * [hgain, sgain, vgain] + 1 # random gains - hue, sat, val = cv2.split(cv2.cvtColor(img, cv2.COLOR_BGR2HSV)) - dtype = img.dtype # uint8 - - x = np.arange(0, 256, dtype=np.int16) - lut_hue = ((x * r[0]) % 180).astype(dtype) - lut_sat = np.clip(x * r[1], 0, 255).astype(dtype) - lut_val = np.clip(x * r[2], 0, 255).astype(dtype) - - img_hsv = cv2.merge((cv2.LUT(hue, lut_hue), cv2.LUT(sat, lut_sat), cv2.LUT(val, lut_val))).astype(dtype) - cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR, dst=img) # no return needed - - -def hist_equalize(img, clahe=True, bgr=False): - # Equalize histogram on BGR image 'img' with img.shape(n,m,3) and range 0-255 - yuv = cv2.cvtColor(img, cv2.COLOR_BGR2YUV if bgr else cv2.COLOR_RGB2YUV) - if clahe: - c = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8)) - yuv[:, :, 0] = c.apply(yuv[:, :, 0]) - else: - yuv[:, :, 0] = cv2.equalizeHist(yuv[:, :, 0]) # equalize Y channel histogram - return cv2.cvtColor(yuv, cv2.COLOR_YUV2BGR if bgr else cv2.COLOR_YUV2RGB) # convert YUV image to RGB - - -def load_mosaic(self, index): - # loads images in a 4-mosaic - - labels4, segments4 = [], [] - s = self.img_size - yc, xc = [int(random.uniform(-x, 2 * s + x)) for x in self.mosaic_border] # mosaic center x, y - indices = [index] + random.choices(self.indices, k=3) # 3 additional image indices - for i, index in enumerate(indices): - # Load image - img, _, (h, w) = load_image(self, index) - - # place img in img4 - if i == 0: # top left - img4 = np.full((s * 2, s * 2, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles - x1a, y1a, x2a, y2a = max(xc - w, 0), max(yc - h, 0), xc, yc # xmin, ymin, xmax, ymax (large image) - x1b, y1b, x2b, y2b = w - (x2a - x1a), h - (y2a - y1a), w, h # xmin, ymin, xmax, ymax (small image) - elif i == 1: # top right - x1a, y1a, x2a, y2a = xc, max(yc - h, 0), min(xc + w, s * 2), yc - x1b, y1b, x2b, y2b = 0, h - (y2a - y1a), min(w, x2a - x1a), h - elif i == 2: # bottom left - x1a, y1a, x2a, y2a = max(xc - w, 0), yc, xc, min(s * 2, yc + h) - x1b, y1b, x2b, y2b = w - (x2a - x1a), 0, w, min(y2a - y1a, h) - elif i == 3: # bottom right - x1a, y1a, x2a, y2a = xc, yc, min(xc + w, s * 2), min(s * 2, yc + h) - x1b, y1b, x2b, y2b = 0, 0, min(w, x2a - x1a), min(y2a - y1a, h) - - img4[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax] - padw = x1a - x1b - padh = y1a - y1b - - # Labels - labels, segments = self.labels[index].copy(), self.segments[index].copy() - if labels.size: - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padw, padh) # normalized xywh to pixel xyxy format - segments = [xyn2xy(x, w, h, padw, padh) for x in segments] - labels4.append(labels) - segments4.extend(segments) - - # Concat/clip labels - labels4 = np.concatenate(labels4, 0) - for x in (labels4[:, 1:], *segments4): - np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() - # img4, labels4 = replicate(img4, labels4) # replicate - - # Augment - img4, labels4 = random_perspective(img4, labels4, segments4, - degrees=self.hyp['degrees'], - translate=self.hyp['translate'], - scale=self.hyp['scale'], - shear=self.hyp['shear'], - perspective=self.hyp['perspective'], - border=self.mosaic_border) # border to remove - - return img4, labels4 - - -def load_mosaic9(self, index): - # loads images in a 9-mosaic - - labels9, segments9 = [], [] - s = self.img_size - indices = [index] + random.choices(self.indices, k=8) # 8 additional image indices - for i, index in enumerate(indices): - # Load image - img, _, (h, w) = load_image(self, index) - - # place img in img9 - if i == 0: # center - img9 = np.full((s * 3, s * 3, img.shape[2]), 114, dtype=np.uint8) # base image with 4 tiles - h0, w0 = h, w - c = s, s, s + w, s + h # xmin, ymin, xmax, ymax (base) coordinates - elif i == 1: # top - c = s, s - h, s + w, s - elif i == 2: # top right - c = s + wp, s - h, s + wp + w, s - elif i == 3: # right - c = s + w0, s, s + w0 + w, s + h - elif i == 4: # bottom right - c = s + w0, s + hp, s + w0 + w, s + hp + h - elif i == 5: # bottom - c = s + w0 - w, s + h0, s + w0, s + h0 + h - elif i == 6: # bottom left - c = s + w0 - wp - w, s + h0, s + w0 - wp, s + h0 + h - elif i == 7: # left - c = s - w, s + h0 - h, s, s + h0 - elif i == 8: # top left - c = s - w, s + h0 - hp - h, s, s + h0 - hp - - padx, pady = c[:2] - x1, y1, x2, y2 = [max(x, 0) for x in c] # allocate coords - - # Labels - labels, segments = self.labels[index].copy(), self.segments[index].copy() - if labels.size: - labels[:, 1:] = xywhn2xyxy(labels[:, 1:], w, h, padx, pady) # normalized xywh to pixel xyxy format - segments = [xyn2xy(x, w, h, padx, pady) for x in segments] - labels9.append(labels) - segments9.extend(segments) - - # Image - img9[y1:y2, x1:x2] = img[y1 - pady:, x1 - padx:] # img9[ymin:ymax, xmin:xmax] - hp, wp = h, w # height, width previous - - # Offset - yc, xc = [int(random.uniform(0, s)) for _ in self.mosaic_border] # mosaic center x, y - img9 = img9[yc:yc + 2 * s, xc:xc + 2 * s] - - # Concat/clip labels - labels9 = np.concatenate(labels9, 0) - labels9[:, [1, 3]] -= xc - labels9[:, [2, 4]] -= yc - c = np.array([xc, yc]) # centers - segments9 = [x - c for x in segments9] - - for x in (labels9[:, 1:], *segments9): - np.clip(x, 0, 2 * s, out=x) # clip when using random_perspective() - # img9, labels9 = replicate(img9, labels9) # replicate - - # Augment - img9, labels9 = random_perspective(img9, labels9, segments9, - degrees=self.hyp['degrees'], - translate=self.hyp['translate'], - scale=self.hyp['scale'], - shear=self.hyp['shear'], - perspective=self.hyp['perspective'], - border=self.mosaic_border) # border to remove - - return img9, labels9 - - -def replicate(img, labels): - # Replicate labels - h, w = img.shape[:2] - boxes = labels[:, 1:].astype(int) - x1, y1, x2, y2 = boxes.T - s = ((x2 - x1) + (y2 - y1)) / 2 # side length (pixels) - for i in s.argsort()[:round(s.size * 0.5)]: # smallest indices - x1b, y1b, x2b, y2b = boxes[i] - bh, bw = y2b - y1b, x2b - x1b - yc, xc = int(random.uniform(0, h - bh)), int(random.uniform(0, w - bw)) # offset x, y - x1a, y1a, x2a, y2a = [xc, yc, xc + bw, yc + bh] - img[y1a:y2a, x1a:x2a] = img[y1b:y2b, x1b:x2b] # img4[ymin:ymax, xmin:xmax] - labels = np.append(labels, [[labels[i, 0], x1a, y1a, x2a, y2a]], axis=0) - - return img, labels - - -def letterbox(img, new_shape=(640, 640), color=(114, 114, 114), auto=True, scaleFill=False, scaleup=True, stride=32): - # Resize and pad image while meeting stride-multiple constraints - shape = img.shape[:2] # current shape [height, width] - if isinstance(new_shape, int): - new_shape = (new_shape, new_shape) - - # Scale ratio (new / old) - r = min(new_shape[0] / shape[0], new_shape[1] / shape[1]) - if not scaleup: # only scale down, do not scale up (for better test mAP) - r = min(r, 1.0) - - # Compute padding - ratio = r, r # width, height ratios - new_unpad = int(round(shape[1] * r)), int(round(shape[0] * r)) - dw, dh = new_shape[1] - new_unpad[0], new_shape[0] - new_unpad[1] # wh padding - if auto: # minimum rectangle - dw, dh = np.mod(dw, stride), np.mod(dh, stride) # wh padding - elif scaleFill: # stretch - dw, dh = 0.0, 0.0 - new_unpad = (new_shape[1], new_shape[0]) - ratio = new_shape[1] / shape[1], new_shape[0] / shape[0] # width, height ratios - - dw /= 2 # divide padding into 2 sides - dh /= 2 - - if shape[::-1] != new_unpad: # resize - img = cv2.resize(img, new_unpad, interpolation=cv2.INTER_LINEAR) - top, bottom = int(round(dh - 0.1)), int(round(dh + 0.1)) - left, right = int(round(dw - 0.1)), int(round(dw + 0.1)) - img = cv2.copyMakeBorder(img, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color) # add border - return img, ratio, (dw, dh) - - -def random_perspective(img, targets=(), segments=(), degrees=10, translate=.1, scale=.1, shear=10, perspective=0.0, - border=(0, 0)): - # torchvision.transforms.RandomAffine(degrees=(-10, 10), translate=(.1, .1), scale=(.9, 1.1), shear=(-10, 10)) - # targets = [cls, xyxy] - - height = img.shape[0] + border[0] * 2 # shape(h,w,c) - width = img.shape[1] + border[1] * 2 - - # Center - C = np.eye(3) - C[0, 2] = -img.shape[1] / 2 # x translation (pixels) - C[1, 2] = -img.shape[0] / 2 # y translation (pixels) - - # Perspective - P = np.eye(3) - P[2, 0] = random.uniform(-perspective, perspective) # x perspective (about y) - P[2, 1] = random.uniform(-perspective, perspective) # y perspective (about x) - - # Rotation and Scale - R = np.eye(3) - a = random.uniform(-degrees, degrees) - # a += random.choice([-180, -90, 0, 90]) # add 90deg rotations to small rotations - s = random.uniform(1 - scale, 1 + scale) - # s = 2 ** random.uniform(-scale, scale) - R[:2] = cv2.getRotationMatrix2D(angle=a, center=(0, 0), scale=s) - - # Shear - S = np.eye(3) - S[0, 1] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # x shear (deg) - S[1, 0] = math.tan(random.uniform(-shear, shear) * math.pi / 180) # y shear (deg) - - # Translation - T = np.eye(3) - T[0, 2] = random.uniform(0.5 - translate, 0.5 + translate) * width # x translation (pixels) - T[1, 2] = random.uniform(0.5 - translate, 0.5 + translate) * height # y translation (pixels) - - # Combined rotation matrix - M = T @ S @ R @ P @ C # order of operations (right to left) is IMPORTANT - if (border[0] != 0) or (border[1] != 0) or (M != np.eye(3)).any(): # image changed - if perspective: - img = cv2.warpPerspective(img, M, dsize=(width, height), borderValue=(114, 114, 114)) - else: # affine - img = cv2.warpAffine(img, M[:2], dsize=(width, height), borderValue=(114, 114, 114)) - - # Visualize - # import matplotlib.pyplot as plt - # ax = plt.subplots(1, 2, figsize=(12, 6))[1].ravel() - # ax[0].imshow(img[:, :, ::-1]) # base - # ax[1].imshow(img2[:, :, ::-1]) # warped - - # Transform label coordinates - n = len(targets) - if n: - use_segments = any(x.any() for x in segments) - new = np.zeros((n, 4)) - if use_segments: # warp segments - segments = resample_segments(segments) # upsample - for i, segment in enumerate(segments): - xy = np.ones((len(segment), 3)) - xy[:, :2] = segment - xy = xy @ M.T # transform - xy = xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2] # perspective rescale or affine - - # clip - new[i] = segment2box(xy, width, height) - - else: # warp boxes - xy = np.ones((n * 4, 3)) - xy[:, :2] = targets[:, [1, 2, 3, 4, 1, 4, 3, 2]].reshape(n * 4, 2) # x1y1, x2y2, x1y2, x2y1 - xy = xy @ M.T # transform - xy = (xy[:, :2] / xy[:, 2:3] if perspective else xy[:, :2]).reshape(n, 8) # perspective rescale or affine - - # create new boxes - x = xy[:, [0, 2, 4, 6]] - y = xy[:, [1, 3, 5, 7]] - new = np.concatenate((x.min(1), y.min(1), x.max(1), y.max(1))).reshape(4, n).T - - # clip - new[:, [0, 2]] = new[:, [0, 2]].clip(0, width) - new[:, [1, 3]] = new[:, [1, 3]].clip(0, height) - - # filter candidates - i = box_candidates(box1=targets[:, 1:5].T * s, box2=new.T, area_thr=0.01 if use_segments else 0.10) - targets = targets[i] - targets[:, 1:5] = new[i] - - return img, targets - - -def box_candidates(box1, box2, wh_thr=2, ar_thr=20, area_thr=0.1, eps=1e-16): # box1(4,n), box2(4,n) - # Compute candidate boxes: box1 before augment, box2 after augment, wh_thr (pixels), aspect_ratio_thr, area_ratio - w1, h1 = box1[2] - box1[0], box1[3] - box1[1] - w2, h2 = box2[2] - box2[0], box2[3] - box2[1] - ar = np.maximum(w2 / (h2 + eps), h2 / (w2 + eps)) # aspect ratio - return (w2 > wh_thr) & (h2 > wh_thr) & (w2 * h2 / (w1 * h1 + eps) > area_thr) & (ar < ar_thr) # candidates - - -def cutout(image, labels): - # Applies image cutout augmentation https://arxiv.org/abs/1708.04552 - h, w = image.shape[:2] - - def bbox_ioa(box1, box2): - # Returns the intersection over box2 area given box1, box2. box1 is 4, box2 is nx4. boxes are x1y1x2y2 - box2 = box2.transpose() - - # Get the coordinates of bounding boxes - b1_x1, b1_y1, b1_x2, b1_y2 = box1[0], box1[1], box1[2], box1[3] - b2_x1, b2_y1, b2_x2, b2_y2 = box2[0], box2[1], box2[2], box2[3] - - # Intersection area - inter_area = (np.minimum(b1_x2, b2_x2) - np.maximum(b1_x1, b2_x1)).clip(0) * \ - (np.minimum(b1_y2, b2_y2) - np.maximum(b1_y1, b2_y1)).clip(0) - - # box2 area - box2_area = (b2_x2 - b2_x1) * (b2_y2 - b2_y1) + 1e-16 - - # Intersection over box2 area - return inter_area / box2_area - - # create random masks - scales = [0.5] * 1 + [0.25] * 2 + [0.125] * 4 + [0.0625] * 8 + [0.03125] * 16 # image size fraction - for s in scales: - mask_h = random.randint(1, int(h * s)) - mask_w = random.randint(1, int(w * s)) - - # box - xmin = max(0, random.randint(0, w) - mask_w // 2) - ymin = max(0, random.randint(0, h) - mask_h // 2) - xmax = min(w, xmin + mask_w) - ymax = min(h, ymin + mask_h) - - # apply random color mask - image[ymin:ymax, xmin:xmax] = [random.randint(64, 191) for _ in range(3)] - - # return unobscured labels - if len(labels) and s > 0.03: - box = np.array([xmin, ymin, xmax, ymax], dtype=np.float32) - ioa = bbox_ioa(box, labels[:, 1:5]) # intersection over area - labels = labels[ioa < 0.60] # remove >60% obscured labels - - return labels - - -def create_folder(path='./new'): - # Create folder - if os.path.exists(path): - shutil.rmtree(path) # delete output folder - os.makedirs(path) # make new output folder - - -def flatten_recursive(path='../coco128'): - # Flatten a recursive directory by bringing all files to top level - new_path = Path(path + '_flat') - create_folder(new_path) - for file in tqdm(glob.glob(str(Path(path)) + '/**/*.*', recursive=True)): - shutil.copyfile(file, new_path / Path(file).name) - - -def extract_boxes(path='../coco128/'): # from utils.datasets import *; extract_boxes('../coco128') - # Convert detection dataset into classification dataset, with one directory per class - - path = Path(path) # images dir - shutil.rmtree(path / 'classifier') if (path / 'classifier').is_dir() else None # remove existing - files = list(path.rglob('*.*')) - n = len(files) # number of files - for im_file in tqdm(files, total=n): - if im_file.suffix[1:] in img_formats: - # image - im = cv2.imread(str(im_file))[..., ::-1] # BGR to RGB - h, w = im.shape[:2] - - # labels - lb_file = Path(img2label_paths([str(im_file)])[0]) - if Path(lb_file).exists(): - with open(lb_file, 'r') as f: - lb = np.array([x.split() for x in f.read().strip().splitlines()], dtype=np.float32) # labels - - for j, x in enumerate(lb): - c = int(x[0]) # class - f = (path / 'classifier') / f'{c}' / f'{path.stem}_{im_file.stem}_{j}.jpg' # new filename - if not f.parent.is_dir(): - f.parent.mkdir(parents=True) - - b = x[1:] * [w, h, w, h] # box - # b[2:] = b[2:].max() # rectangle to square - b[2:] = b[2:] * 1.2 + 3 # pad - b = xywh2xyxy(b.reshape(-1, 4)).ravel().astype(np.int) - - b[[0, 2]] = np.clip(b[[0, 2]], 0, w) # clip boxes outside of image - b[[1, 3]] = np.clip(b[[1, 3]], 0, h) - assert cv2.imwrite(str(f), im[b[1]:b[3], b[0]:b[2]]), f'box failure in {f}' - - -def autosplit(path='../coco128', weights=(0.9, 0.1, 0.0), annotated_only=False): - """ Autosplit a dataset into train/val/test splits and save path/autosplit_*.txt files - Usage: from utils.datasets import *; autosplit('../coco128') - Arguments - path: Path to images directory - weights: Train, val, test weights (list) - annotated_only: Only use images with an annotated txt file - """ - path = Path(path) # images dir - files = sum([list(path.rglob(f"*.{img_ext}")) for img_ext in img_formats], []) # image files only - n = len(files) # number of files - indices = random.choices([0, 1, 2], weights=weights, k=n) # assign each image to a split - - txt = ['autosplit_train.txt', 'autosplit_val.txt', 'autosplit_test.txt'] # 3 txt files - [(path / x).unlink() for x in txt if (path / x).exists()] # remove existing - - print(f'Autosplitting images from {path}' + ', using *.txt labeled images only' * annotated_only) - for i, img in tqdm(zip(indices, files), total=n): - if not annotated_only or Path(img2label_paths([str(img)])[0]).exists(): # check label - with open(path / txt[i], 'a') as f: - f.write(str(img) + '\n') # add image to txt file diff --git a/spaces/crawly/White-box-Cartoonization/wbc/cartoonize.py b/spaces/crawly/White-box-Cartoonization/wbc/cartoonize.py deleted file mode 100644 index 25faf1ceb95aaed9a3f7a7982d17a03dc6bc32b1..0000000000000000000000000000000000000000 --- a/spaces/crawly/White-box-Cartoonization/wbc/cartoonize.py +++ /dev/null @@ -1,112 +0,0 @@ -import os -import cv2 -import numpy as np -import tensorflow as tf -import wbc.network as network -import wbc.guided_filter as guided_filter -from tqdm import tqdm - - -def resize_crop(image): - h, w, c = np.shape(image) - if min(h, w) > 720: - if h > w: - h, w = int(720 * h / w), 720 - else: - h, w = 720, int(720 * w / h) - image = cv2.resize(image, (w, h), - interpolation=cv2.INTER_AREA) - h, w = (h // 8) * 8, (w // 8) * 8 - image = image[:h, :w, :] - return image - - -def cartoonize(load_folder, save_folder, model_path): - print(model_path) - input_photo = tf.placeholder(tf.float32, [1, None, None, 3]) - network_out = network.unet_generator(input_photo) - final_out = guided_filter.guided_filter(input_photo, network_out, r=1, eps=5e-3) - - all_vars = tf.trainable_variables() - gene_vars = [var for var in all_vars if 'generator' in var.name] - saver = tf.train.Saver(var_list=gene_vars) - - config = tf.ConfigProto() - config.gpu_options.allow_growth = True - sess = tf.Session(config=config) - - sess.run(tf.global_variables_initializer()) - saver.restore(sess, tf.train.latest_checkpoint(model_path)) - name_list = os.listdir(load_folder) - for name in tqdm(name_list): - try: - load_path = os.path.join(load_folder, name) - save_path = os.path.join(save_folder, name) - image = cv2.imread(load_path) - image = resize_crop(image) - batch_image = image.astype(np.float32) / 127.5 - 1 - batch_image = np.expand_dims(batch_image, axis=0) - output = sess.run(final_out, feed_dict={input_photo: batch_image}) - output = (np.squeeze(output) + 1) * 127.5 - output = np.clip(output, 0, 255).astype(np.uint8) - cv2.imwrite(save_path, output) - except: - print('cartoonize {} failed'.format(load_path)) - - -class Cartoonize: - def __init__(self, model_path): - print(model_path) - self.input_photo = tf.placeholder(tf.float32, [1, None, None, 3]) - network_out = network.unet_generator(self.input_photo) - self.final_out = guided_filter.guided_filter(self.input_photo, network_out, r=1, eps=5e-3) - - all_vars = tf.trainable_variables() - gene_vars = [var for var in all_vars if 'generator' in var.name] - saver = tf.train.Saver(var_list=gene_vars) - - config = tf.ConfigProto() - config.gpu_options.allow_growth = True - self.sess = tf.Session(config=config) - - self.sess.run(tf.global_variables_initializer()) - saver.restore(self.sess, tf.train.latest_checkpoint(model_path)) - - def run(self, load_folder, save_folder): - name_list = os.listdir(load_folder) - for name in tqdm(name_list): - try: - load_path = os.path.join(load_folder, name) - save_path = os.path.join(save_folder, name) - image = cv2.imread(load_path) - image = resize_crop(image) - batch_image = image.astype(np.float32) / 127.5 - 1 - batch_image = np.expand_dims(batch_image, axis=0) - output = self.sess.run(self.final_out, feed_dict={self.input_photo: batch_image}) - output = (np.squeeze(output) + 1) * 127.5 - output = np.clip(output, 0, 255).astype(np.uint8) - cv2.imwrite(save_path, output) - except: - print('cartoonize {} failed'.format(load_path)) - - def run_sigle(self, load_path, save_path): - try: - image = cv2.imread(load_path) - image = resize_crop(image) - batch_image = image.astype(np.float32) / 127.5 - 1 - batch_image = np.expand_dims(batch_image, axis=0) - output = self.sess.run(self.final_out, feed_dict={self.input_photo: batch_image}) - output = (np.squeeze(output) + 1) * 127.5 - output = np.clip(output, 0, 255).astype(np.uint8) - cv2.imwrite(save_path, output) - except: - print('cartoonize {} failed'.format(load_path)) - - -if __name__ == '__main__': - model_path = 'saved_models' - load_folder = 'test_images' - save_folder = 'cartoonized_images' - if not os.path.exists(save_folder): - os.mkdir(save_folder) - cartoonize(load_folder, save_folder, model_path) diff --git a/spaces/dawood/Kanye-AI/vdecoder/hifigan/nvSTFT.py b/spaces/dawood/Kanye-AI/vdecoder/hifigan/nvSTFT.py deleted file mode 100644 index 88597d62a505715091f9ba62d38bf0a85a31b95a..0000000000000000000000000000000000000000 --- a/spaces/dawood/Kanye-AI/vdecoder/hifigan/nvSTFT.py +++ /dev/null @@ -1,111 +0,0 @@ -import math -import os -os.environ["LRU_CACHE_CAPACITY"] = "3" -import random -import torch -import torch.utils.data -import numpy as np -import librosa -from librosa.util import normalize -from librosa.filters import mel as librosa_mel_fn -from scipy.io.wavfile import read -import soundfile as sf - -def load_wav_to_torch(full_path, target_sr=None, return_empty_on_exception=False): - sampling_rate = None - try: - data, sampling_rate = sf.read(full_path, always_2d=True)# than soundfile. - except Exception as ex: - print(f"'{full_path}' failed to load.\nException:") - print(ex) - if return_empty_on_exception: - return [], sampling_rate or target_sr or 32000 - else: - raise Exception(ex) - - if len(data.shape) > 1: - data = data[:, 0] - assert len(data) > 2# check duration of audio file is > 2 samples (because otherwise the slice operation was on the wrong dimension) - - if np.issubdtype(data.dtype, np.integer): # if audio data is type int - max_mag = -np.iinfo(data.dtype).min # maximum magnitude = min possible value of intXX - else: # if audio data is type fp32 - max_mag = max(np.amax(data), -np.amin(data)) - max_mag = (2**31)+1 if max_mag > (2**15) else ((2**15)+1 if max_mag > 1.01 else 1.0) # data should be either 16-bit INT, 32-bit INT or [-1 to 1] float32 - - data = torch.FloatTensor(data.astype(np.float32))/max_mag - - if (torch.isinf(data) | torch.isnan(data)).any() and return_empty_on_exception:# resample will crash with inf/NaN inputs. return_empty_on_exception will return empty arr instead of except - return [], sampling_rate or target_sr or 32000 - if target_sr is not None and sampling_rate != target_sr: - data = torch.from_numpy(librosa.core.resample(data.numpy(), orig_sr=sampling_rate, target_sr=target_sr)) - sampling_rate = target_sr - - return data, sampling_rate - -def dynamic_range_compression(x, C=1, clip_val=1e-5): - return np.log(np.clip(x, a_min=clip_val, a_max=None) * C) - -def dynamic_range_decompression(x, C=1): - return np.exp(x) / C - -def dynamic_range_compression_torch(x, C=1, clip_val=1e-5): - return torch.log(torch.clamp(x, min=clip_val) * C) - -def dynamic_range_decompression_torch(x, C=1): - return torch.exp(x) / C - -class STFT(): - def __init__(self, sr=22050, n_mels=80, n_fft=1024, win_size=1024, hop_length=256, fmin=20, fmax=11025, clip_val=1e-5): - self.target_sr = sr - - self.n_mels = n_mels - self.n_fft = n_fft - self.win_size = win_size - self.hop_length = hop_length - self.fmin = fmin - self.fmax = fmax - self.clip_val = clip_val - self.mel_basis = {} - self.hann_window = {} - - def get_mel(self, y, center=False): - sampling_rate = self.target_sr - n_mels = self.n_mels - n_fft = self.n_fft - win_size = self.win_size - hop_length = self.hop_length - fmin = self.fmin - fmax = self.fmax - clip_val = self.clip_val - - if torch.min(y) < -1.: - print('min value is ', torch.min(y)) - if torch.max(y) > 1.: - print('max value is ', torch.max(y)) - - if fmax not in self.mel_basis: - mel = librosa_mel_fn(sr=sampling_rate, n_fft=n_fft, n_mels=n_mels, fmin=fmin, fmax=fmax) - self.mel_basis[str(fmax)+'_'+str(y.device)] = torch.from_numpy(mel).float().to(y.device) - self.hann_window[str(y.device)] = torch.hann_window(self.win_size).to(y.device) - - y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_length)/2), int((n_fft-hop_length)/2)), mode='reflect') - y = y.squeeze(1) - - spec = torch.stft(y, n_fft, hop_length=hop_length, win_length=win_size, window=self.hann_window[str(y.device)], - center=center, pad_mode='reflect', normalized=False, onesided=True) - # print(111,spec) - spec = torch.sqrt(spec.pow(2).sum(-1)+(1e-9)) - # print(222,spec) - spec = torch.matmul(self.mel_basis[str(fmax)+'_'+str(y.device)], spec) - # print(333,spec) - spec = dynamic_range_compression_torch(spec, clip_val=clip_val) - # print(444,spec) - return spec - - def __call__(self, audiopath): - audio, sr = load_wav_to_torch(audiopath, target_sr=self.target_sr) - spect = self.get_mel(audio.unsqueeze(0)).squeeze(0) - return spect - -stft = STFT() diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fsspec/mapping.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fsspec/mapping.py deleted file mode 100644 index 74cc7b9f2fe118fac02379db4181c53d11fbbbea..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fsspec/mapping.py +++ /dev/null @@ -1,239 +0,0 @@ -import array -import posixpath -import warnings -from collections.abc import MutableMapping - -from .core import url_to_fs - - -class FSMap(MutableMapping): - """Wrap a FileSystem instance as a mutable wrapping. - - The keys of the mapping become files under the given root, and the - values (which must be bytes) the contents of those files. - - Parameters - ---------- - root: string - prefix for all the files - fs: FileSystem instance - check: bool (=True) - performs a touch at the location, to check for write access. - - Examples - -------- - >>> fs = FileSystem(**parameters) # doctest: +SKIP - >>> d = FSMap('my-data/path/', fs) # doctest: +SKIP - or, more likely - >>> d = fs.get_mapper('my-data/path/') - - >>> d['loc1'] = b'Hello World' # doctest: +SKIP - >>> list(d.keys()) # doctest: +SKIP - ['loc1'] - >>> d['loc1'] # doctest: +SKIP - b'Hello World' - """ - - def __init__(self, root, fs, check=False, create=False, missing_exceptions=None): - self.fs = fs - self.root = fs._strip_protocol(root).rstrip("/") - self._root_key_to_str = fs._strip_protocol(posixpath.join(root, "x"))[:-1] - if missing_exceptions is None: - missing_exceptions = ( - FileNotFoundError, - IsADirectoryError, - NotADirectoryError, - ) - self.missing_exceptions = missing_exceptions - self.check = check - self.create = create - if create: - if not self.fs.exists(root): - self.fs.mkdir(root) - if check: - if not self.fs.exists(root): - raise ValueError( - "Path %s does not exist. Create " - " with the ``create=True`` keyword" % root - ) - self.fs.touch(root + "/a") - self.fs.rm(root + "/a") - - def clear(self): - """Remove all keys below root - empties out mapping""" - try: - self.fs.rm(self.root, True) - self.fs.mkdir(self.root) - except: # noqa: E722 - pass - - def getitems(self, keys, on_error="raise"): - """Fetch multiple items from the store - - If the backend is async-able, this might proceed concurrently - - Parameters - ---------- - keys: list(str) - They keys to be fetched - on_error : "raise", "omit", "return" - If raise, an underlying exception will be raised (converted to KeyError - if the type is in self.missing_exceptions); if omit, keys with exception - will simply not be included in the output; if "return", all keys are - included in the output, but the value will be bytes or an exception - instance. - - Returns - ------- - dict(key, bytes|exception) - """ - keys2 = [self._key_to_str(k) for k in keys] - oe = on_error if on_error == "raise" else "return" - try: - out = self.fs.cat(keys2, on_error=oe) - if isinstance(out, bytes): - out = {keys2[0]: out} - except self.missing_exceptions as e: - raise KeyError from e - out = { - k: (KeyError() if isinstance(v, self.missing_exceptions) else v) - for k, v in out.items() - } - return { - key: out[k2] - for key, k2 in zip(keys, keys2) - if on_error == "return" or not isinstance(out[k2], BaseException) - } - - def setitems(self, values_dict): - """Set the values of multiple items in the store - - Parameters - ---------- - values_dict: dict(str, bytes) - """ - values = {self._key_to_str(k): maybe_convert(v) for k, v in values_dict.items()} - self.fs.pipe(values) - - def delitems(self, keys): - """Remove multiple keys from the store""" - self.fs.rm([self._key_to_str(k) for k in keys]) - - def _key_to_str(self, key): - """Generate full path for the key""" - if not isinstance(key, str): - # raise TypeError("key must be of type `str`, got `{type(key).__name__}`" - warnings.warn( - "from fsspec 2023.5 onward FSMap non-str keys will raise TypeError", - DeprecationWarning, - ) - if isinstance(key, list): - key = tuple(key) - key = str(key) - return f"{self._root_key_to_str}{key}" - - def _str_to_key(self, s): - """Strip path of to leave key name""" - return s[len(self.root) :].lstrip("/") - - def __getitem__(self, key, default=None): - """Retrieve data""" - k = self._key_to_str(key) - try: - result = self.fs.cat(k) - except self.missing_exceptions: - if default is not None: - return default - raise KeyError(key) - return result - - def pop(self, key, default=None): - """Pop data""" - result = self.__getitem__(key, default) - try: - del self[key] - except KeyError: - pass - return result - - def __setitem__(self, key, value): - """Store value in key""" - key = self._key_to_str(key) - self.fs.mkdirs(self.fs._parent(key), exist_ok=True) - self.fs.pipe_file(key, maybe_convert(value)) - - def __iter__(self): - return (self._str_to_key(x) for x in self.fs.find(self.root)) - - def __len__(self): - return len(self.fs.find(self.root)) - - def __delitem__(self, key): - """Remove key""" - try: - self.fs.rm(self._key_to_str(key)) - except: # noqa: E722 - raise KeyError - - def __contains__(self, key): - """Does key exist in mapping?""" - path = self._key_to_str(key) - return self.fs.exists(path) and self.fs.isfile(path) - - def __reduce__(self): - return FSMap, (self.root, self.fs, False, False, self.missing_exceptions) - - -def maybe_convert(value): - if isinstance(value, array.array) or hasattr(value, "__array__"): - # bytes-like things - if hasattr(value, "dtype") and value.dtype.kind in "Mm": - # The buffer interface doesn't support datetime64/timdelta64 numpy - # arrays - value = value.view("int64") - value = bytes(memoryview(value)) - return value - - -def get_mapper( - url="", - check=False, - create=False, - missing_exceptions=None, - alternate_root=None, - **kwargs, -): - """Create key-value interface for given URL and options - - The URL will be of the form "protocol://location" and point to the root - of the mapper required. All keys will be file-names below this location, - and their values the contents of each key. - - Also accepts compound URLs like zip::s3://bucket/file.zip , see ``fsspec.open``. - - Parameters - ---------- - url: str - Root URL of mapping - check: bool - Whether to attempt to read from the location before instantiation, to - check that the mapping does exist - create: bool - Whether to make the directory corresponding to the root before - instantiating - missing_exceptions: None or tuple - If given, these exception types will be regarded as missing keys and - return KeyError when trying to read data. By default, you get - (FileNotFoundError, IsADirectoryError, NotADirectoryError) - alternate_root: None or str - In cases of complex URLs, the parser may fail to pick the correct part - for the mapper root, so this arg can override - - Returns - ------- - ``FSMap`` instance, the dict-like key-value store. - """ - # Removing protocol here - could defer to each open() on the backend - fs, urlpath = url_to_fs(url, **kwargs) - root = alternate_root if alternate_root is not None else urlpath - return FSMap(root, fs, check, create, missing_exceptions=missing_exceptions) diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/httpx/_config.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/httpx/_config.py deleted file mode 100644 index f46a5bfe6ba6093688c7a91bd51de9d137840432..0000000000000000000000000000000000000000 --- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/httpx/_config.py +++ /dev/null @@ -1,369 +0,0 @@ -import logging -import os -import ssl -import sys -import typing -from pathlib import Path - -import certifi - -from ._compat import set_minimum_tls_version_1_2 -from ._models import Headers -from ._types import CertTypes, HeaderTypes, TimeoutTypes, URLTypes, VerifyTypes -from ._urls import URL -from ._utils import get_ca_bundle_from_env - -DEFAULT_CIPHERS = ":".join( - [ - "ECDHE+AESGCM", - "ECDHE+CHACHA20", - "DHE+AESGCM", - "DHE+CHACHA20", - "ECDH+AESGCM", - "DH+AESGCM", - "ECDH+AES", - "DH+AES", - "RSA+AESGCM", - "RSA+AES", - "!aNULL", - "!eNULL", - "!MD5", - "!DSS", - ] -) - - -logger = logging.getLogger("httpx") - - -class UnsetType: - pass # pragma: no cover - - -UNSET = UnsetType() - - -def create_ssl_context( - cert: typing.Optional[CertTypes] = None, - verify: VerifyTypes = True, - trust_env: bool = True, - http2: bool = False, -) -> ssl.SSLContext: - return SSLConfig( - cert=cert, verify=verify, trust_env=trust_env, http2=http2 - ).ssl_context - - -class SSLConfig: - """ - SSL Configuration. - """ - - DEFAULT_CA_BUNDLE_PATH = Path(certifi.where()) - - def __init__( - self, - *, - cert: typing.Optional[CertTypes] = None, - verify: VerifyTypes = True, - trust_env: bool = True, - http2: bool = False, - ): - self.cert = cert - self.verify = verify - self.trust_env = trust_env - self.http2 = http2 - self.ssl_context = self.load_ssl_context() - - def load_ssl_context(self) -> ssl.SSLContext: - logger.debug( - "load_ssl_context verify=%r cert=%r trust_env=%r http2=%r", - self.verify, - self.cert, - self.trust_env, - self.http2, - ) - - if self.verify: - return self.load_ssl_context_verify() - return self.load_ssl_context_no_verify() - - def load_ssl_context_no_verify(self) -> ssl.SSLContext: - """ - Return an SSL context for unverified connections. - """ - context = self._create_default_ssl_context() - context.check_hostname = False - context.verify_mode = ssl.CERT_NONE - self._load_client_certs(context) - return context - - def load_ssl_context_verify(self) -> ssl.SSLContext: - """ - Return an SSL context for verified connections. - """ - if self.trust_env and self.verify is True: - ca_bundle = get_ca_bundle_from_env() - if ca_bundle is not None: - self.verify = ca_bundle - - if isinstance(self.verify, ssl.SSLContext): - # Allow passing in our own SSLContext object that's pre-configured. - context = self.verify - self._load_client_certs(context) - return context - elif isinstance(self.verify, bool): - ca_bundle_path = self.DEFAULT_CA_BUNDLE_PATH - elif Path(self.verify).exists(): - ca_bundle_path = Path(self.verify) - else: - raise IOError( - "Could not find a suitable TLS CA certificate bundle, " - "invalid path: {}".format(self.verify) - ) - - context = self._create_default_ssl_context() - context.verify_mode = ssl.CERT_REQUIRED - context.check_hostname = True - - # Signal to server support for PHA in TLS 1.3. Raises an - # AttributeError if only read-only access is implemented. - if sys.version_info >= (3, 8): # pragma: no cover - try: - context.post_handshake_auth = True - except AttributeError: # pragma: no cover - pass - - # Disable using 'commonName' for SSLContext.check_hostname - # when the 'subjectAltName' extension isn't available. - try: - context.hostname_checks_common_name = False - except AttributeError: # pragma: no cover - pass - - if ca_bundle_path.is_file(): - cafile = str(ca_bundle_path) - logger.debug("load_verify_locations cafile=%r", cafile) - context.load_verify_locations(cafile=cafile) - elif ca_bundle_path.is_dir(): - capath = str(ca_bundle_path) - logger.debug("load_verify_locations capath=%r", capath) - context.load_verify_locations(capath=capath) - - self._load_client_certs(context) - - return context - - def _create_default_ssl_context(self) -> ssl.SSLContext: - """ - Creates the default SSLContext object that's used for both verified - and unverified connections. - """ - context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT) - set_minimum_tls_version_1_2(context) - context.options |= ssl.OP_NO_COMPRESSION - context.set_ciphers(DEFAULT_CIPHERS) - - if ssl.HAS_ALPN: - alpn_idents = ["http/1.1", "h2"] if self.http2 else ["http/1.1"] - context.set_alpn_protocols(alpn_idents) - - if sys.version_info >= (3, 8): # pragma: no cover - keylogfile = os.environ.get("SSLKEYLOGFILE") - if keylogfile and self.trust_env: - context.keylog_filename = keylogfile - - return context - - def _load_client_certs(self, ssl_context: ssl.SSLContext) -> None: - """ - Loads client certificates into our SSLContext object - """ - if self.cert is not None: - if isinstance(self.cert, str): - ssl_context.load_cert_chain(certfile=self.cert) - elif isinstance(self.cert, tuple) and len(self.cert) == 2: - ssl_context.load_cert_chain(certfile=self.cert[0], keyfile=self.cert[1]) - elif isinstance(self.cert, tuple) and len(self.cert) == 3: - ssl_context.load_cert_chain( - certfile=self.cert[0], - keyfile=self.cert[1], - password=self.cert[2], # type: ignore - ) - - -class Timeout: - """ - Timeout configuration. - - **Usage**: - - Timeout(None) # No timeouts. - Timeout(5.0) # 5s timeout on all operations. - Timeout(None, connect=5.0) # 5s timeout on connect, no other timeouts. - Timeout(5.0, connect=10.0) # 10s timeout on connect. 5s timeout elsewhere. - Timeout(5.0, pool=None) # No timeout on acquiring connection from pool. - # 5s timeout elsewhere. - """ - - def __init__( - self, - timeout: typing.Union[TimeoutTypes, UnsetType] = UNSET, - *, - connect: typing.Union[None, float, UnsetType] = UNSET, - read: typing.Union[None, float, UnsetType] = UNSET, - write: typing.Union[None, float, UnsetType] = UNSET, - pool: typing.Union[None, float, UnsetType] = UNSET, - ): - if isinstance(timeout, Timeout): - # Passed as a single explicit Timeout. - assert connect is UNSET - assert read is UNSET - assert write is UNSET - assert pool is UNSET - self.connect = timeout.connect # type: typing.Optional[float] - self.read = timeout.read # type: typing.Optional[float] - self.write = timeout.write # type: typing.Optional[float] - self.pool = timeout.pool # type: typing.Optional[float] - elif isinstance(timeout, tuple): - # Passed as a tuple. - self.connect = timeout[0] - self.read = timeout[1] - self.write = None if len(timeout) < 3 else timeout[2] - self.pool = None if len(timeout) < 4 else timeout[3] - elif not ( - isinstance(connect, UnsetType) - or isinstance(read, UnsetType) - or isinstance(write, UnsetType) - or isinstance(pool, UnsetType) - ): - self.connect = connect - self.read = read - self.write = write - self.pool = pool - else: - if isinstance(timeout, UnsetType): - raise ValueError( - "httpx.Timeout must either include a default, or set all " - "four parameters explicitly." - ) - self.connect = timeout if isinstance(connect, UnsetType) else connect - self.read = timeout if isinstance(read, UnsetType) else read - self.write = timeout if isinstance(write, UnsetType) else write - self.pool = timeout if isinstance(pool, UnsetType) else pool - - def as_dict(self) -> typing.Dict[str, typing.Optional[float]]: - return { - "connect": self.connect, - "read": self.read, - "write": self.write, - "pool": self.pool, - } - - def __eq__(self, other: typing.Any) -> bool: - return ( - isinstance(other, self.__class__) - and self.connect == other.connect - and self.read == other.read - and self.write == other.write - and self.pool == other.pool - ) - - def __repr__(self) -> str: - class_name = self.__class__.__name__ - if len({self.connect, self.read, self.write, self.pool}) == 1: - return f"{class_name}(timeout={self.connect})" - return ( - f"{class_name}(connect={self.connect}, " - f"read={self.read}, write={self.write}, pool={self.pool})" - ) - - -class Limits: - """ - Configuration for limits to various client behaviors. - - **Parameters:** - - * **max_connections** - The maximum number of concurrent connections that may be - established. - * **max_keepalive_connections** - Allow the connection pool to maintain - keep-alive connections below this point. Should be less than or equal - to `max_connections`. - * **keepalive_expiry** - Time limit on idle keep-alive connections in seconds. - """ - - def __init__( - self, - *, - max_connections: typing.Optional[int] = None, - max_keepalive_connections: typing.Optional[int] = None, - keepalive_expiry: typing.Optional[float] = 5.0, - ): - self.max_connections = max_connections - self.max_keepalive_connections = max_keepalive_connections - self.keepalive_expiry = keepalive_expiry - - def __eq__(self, other: typing.Any) -> bool: - return ( - isinstance(other, self.__class__) - and self.max_connections == other.max_connections - and self.max_keepalive_connections == other.max_keepalive_connections - and self.keepalive_expiry == other.keepalive_expiry - ) - - def __repr__(self) -> str: - class_name = self.__class__.__name__ - return ( - f"{class_name}(max_connections={self.max_connections}, " - f"max_keepalive_connections={self.max_keepalive_connections}, " - f"keepalive_expiry={self.keepalive_expiry})" - ) - - -class Proxy: - def __init__( - self, - url: URLTypes, - *, - auth: typing.Optional[typing.Tuple[str, str]] = None, - headers: typing.Optional[HeaderTypes] = None, - ): - url = URL(url) - headers = Headers(headers) - - if url.scheme not in ("http", "https", "socks5"): - raise ValueError(f"Unknown scheme for proxy URL {url!r}") - - if url.username or url.password: - # Remove any auth credentials from the URL. - auth = (url.username, url.password) - url = url.copy_with(username=None, password=None) - - self.url = url - self.auth = auth - self.headers = headers - - @property - def raw_auth(self) -> typing.Optional[typing.Tuple[bytes, bytes]]: - # The proxy authentication as raw bytes. - return ( - None - if self.auth is None - else (self.auth[0].encode("utf-8"), self.auth[1].encode("utf-8")) - ) - - def __repr__(self) -> str: - # The authentication is represented with the password component masked. - auth = (self.auth[0], "********") if self.auth else None - - # Build a nice concise representation. - url_str = f"{str(self.url)!r}" - auth_str = f", auth={auth!r}" if auth else "" - headers_str = f", headers={dict(self.headers)!r}" if self.headers else "" - return f"Proxy({url_str}{auth_str}{headers_str})" - - -DEFAULT_TIMEOUT_CONFIG = Timeout(timeout=5.0) -DEFAULT_LIMITS = Limits(max_connections=100, max_keepalive_connections=20) -DEFAULT_MAX_REDIRECTS = 20 diff --git a/spaces/declare-lab/tango/diffusers/src/diffusers/dependency_versions_table.py b/spaces/declare-lab/tango/diffusers/src/diffusers/dependency_versions_table.py deleted file mode 100644 index 1269cf1578a6bbfc38a02d6e1850bad0fefd1375..0000000000000000000000000000000000000000 --- a/spaces/declare-lab/tango/diffusers/src/diffusers/dependency_versions_table.py +++ /dev/null @@ -1,39 +0,0 @@ -# THIS FILE HAS BEEN AUTOGENERATED. To update: -# 1. modify the `_deps` dict in setup.py -# 2. run `make deps_table_update`` -deps = { - "Pillow": "Pillow", - "accelerate": "accelerate>=0.11.0", - "compel": "compel==0.1.8", - "black": "black~=23.1", - "datasets": "datasets", - "filelock": "filelock", - "flax": "flax>=0.4.1", - "hf-doc-builder": "hf-doc-builder>=0.3.0", - "huggingface-hub": "huggingface-hub>=0.13.2", - "requests-mock": "requests-mock==1.10.0", - "importlib_metadata": "importlib_metadata", - "isort": "isort>=5.5.4", - "jax": "jax>=0.2.8,!=0.3.2", - "jaxlib": "jaxlib>=0.1.65", - "Jinja2": "Jinja2", - "k-diffusion": "k-diffusion>=0.0.12", - "librosa": "librosa", - "note-seq": "note-seq", - "numpy": "numpy", - "parameterized": "parameterized", - "protobuf": "protobuf>=3.20.3,<4", - "pytest": "pytest", - "pytest-timeout": "pytest-timeout", - "pytest-xdist": "pytest-xdist", - "ruff": "ruff>=0.0.241", - "safetensors": "safetensors", - "sentencepiece": "sentencepiece>=0.1.91,!=0.1.92", - "scipy": "scipy", - "regex": "regex!=2019.12.17", - "requests": "requests", - "tensorboard": "tensorboard", - "torch": "torch>=1.4", - "torchvision": "torchvision", - "transformers": "transformers>=4.25.1", -} diff --git a/spaces/declare-lab/tango/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_panorama.py b/spaces/declare-lab/tango/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_panorama.py deleted file mode 100644 index af26e19cca732ee3144bb38929949499d41f64b5..0000000000000000000000000000000000000000 --- a/spaces/declare-lab/tango/diffusers/tests/pipelines/stable_diffusion/test_stable_diffusion_panorama.py +++ /dev/null @@ -1,342 +0,0 @@ -# coding=utf-8 -# Copyright 2023 HuggingFace Inc. -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. - -import gc -import unittest - -import numpy as np -import torch -from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer - -from diffusers import ( - AutoencoderKL, - DDIMScheduler, - EulerAncestralDiscreteScheduler, - LMSDiscreteScheduler, - PNDMScheduler, - StableDiffusionPanoramaPipeline, - UNet2DConditionModel, -) -from diffusers.utils import slow, torch_device -from diffusers.utils.testing_utils import require_torch_gpu, skip_mps - -from ...pipeline_params import TEXT_TO_IMAGE_BATCH_PARAMS, TEXT_TO_IMAGE_PARAMS -from ...test_pipelines_common import PipelineTesterMixin - - -torch.backends.cuda.matmul.allow_tf32 = False - - -@skip_mps -class StableDiffusionPanoramaPipelineFastTests(PipelineTesterMixin, unittest.TestCase): - pipeline_class = StableDiffusionPanoramaPipeline - params = TEXT_TO_IMAGE_PARAMS - batch_params = TEXT_TO_IMAGE_BATCH_PARAMS - - def get_dummy_components(self): - torch.manual_seed(0) - unet = UNet2DConditionModel( - block_out_channels=(32, 64), - layers_per_block=2, - sample_size=32, - in_channels=4, - out_channels=4, - down_block_types=("DownBlock2D", "CrossAttnDownBlock2D"), - up_block_types=("CrossAttnUpBlock2D", "UpBlock2D"), - cross_attention_dim=32, - ) - scheduler = DDIMScheduler() - torch.manual_seed(0) - vae = AutoencoderKL( - block_out_channels=[32, 64], - in_channels=3, - out_channels=3, - down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"], - up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"], - latent_channels=4, - ) - torch.manual_seed(0) - text_encoder_config = CLIPTextConfig( - bos_token_id=0, - eos_token_id=2, - hidden_size=32, - intermediate_size=37, - layer_norm_eps=1e-05, - num_attention_heads=4, - num_hidden_layers=5, - pad_token_id=1, - vocab_size=1000, - ) - text_encoder = CLIPTextModel(text_encoder_config) - tokenizer = CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip") - - components = { - "unet": unet, - "scheduler": scheduler, - "vae": vae, - "text_encoder": text_encoder, - "tokenizer": tokenizer, - "safety_checker": None, - "feature_extractor": None, - } - return components - - def get_dummy_inputs(self, device, seed=0): - generator = torch.manual_seed(seed) - inputs = { - "prompt": "a photo of the dolomites", - "generator": generator, - # Setting height and width to None to prevent OOMs on CPU. - "height": None, - "width": None, - "num_inference_steps": 2, - "guidance_scale": 6.0, - "output_type": "numpy", - } - return inputs - - def test_stable_diffusion_panorama_default_case(self): - device = "cpu" # ensure determinism for the device-dependent torch.Generator - components = self.get_dummy_components() - sd_pipe = StableDiffusionPanoramaPipeline(**components) - sd_pipe = sd_pipe.to(device) - sd_pipe.set_progress_bar_config(disable=None) - - inputs = self.get_dummy_inputs(device) - image = sd_pipe(**inputs).images - image_slice = image[0, -3:, -3:, -1] - assert image.shape == (1, 64, 64, 3) - - expected_slice = np.array([0.5101, 0.5006, 0.4962, 0.3995, 0.3501, 0.4632, 0.5339, 0.525, 0.4878]) - - assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2 - - def test_stable_diffusion_panorama_negative_prompt(self): - device = "cpu" # ensure determinism for the device-dependent torch.Generator - components = self.get_dummy_components() - sd_pipe = StableDiffusionPanoramaPipeline(**components) - sd_pipe = sd_pipe.to(device) - sd_pipe.set_progress_bar_config(disable=None) - - inputs = self.get_dummy_inputs(device) - negative_prompt = "french fries" - output = sd_pipe(**inputs, negative_prompt=negative_prompt) - image = output.images - image_slice = image[0, -3:, -3:, -1] - - assert image.shape == (1, 64, 64, 3) - - expected_slice = np.array([0.5326, 0.5009, 0.5074, 0.4133, 0.371, 0.464, 0.5432, 0.5429, 0.4896]) - - assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2 - - def test_stable_diffusion_panorama_euler(self): - device = "cpu" # ensure determinism for the device-dependent torch.Generator - components = self.get_dummy_components() - components["scheduler"] = EulerAncestralDiscreteScheduler( - beta_start=0.00085, beta_end=0.012, beta_schedule="scaled_linear" - ) - sd_pipe = StableDiffusionPanoramaPipeline(**components) - sd_pipe = sd_pipe.to(device) - sd_pipe.set_progress_bar_config(disable=None) - - inputs = self.get_dummy_inputs(device) - image = sd_pipe(**inputs).images - image_slice = image[0, -3:, -3:, -1] - - assert image.shape == (1, 64, 64, 3) - - expected_slice = np.array( - [0.48235387, 0.5423796, 0.46016198, 0.5377287, 0.5803722, 0.4876525, 0.5515428, 0.5045897, 0.50709957] - ) - - assert np.abs(image_slice.flatten() - expected_slice).max() < 1e-2 - - def test_stable_diffusion_panorama_pndm(self): - device = "cpu" # ensure determinism for the device-dependent torch.Generator - components = self.get_dummy_components() - components["scheduler"] = PNDMScheduler() - sd_pipe = StableDiffusionPanoramaPipeline(**components) - sd_pipe = sd_pipe.to(device) - sd_pipe.set_progress_bar_config(disable=None) - - inputs = self.get_dummy_inputs(device) - # the pipeline does not expect pndm so test if it raises error. - with self.assertRaises(ValueError): - _ = sd_pipe(**inputs).images - - -@slow -@require_torch_gpu -class StableDiffusionPanoramaSlowTests(unittest.TestCase): - def tearDown(self): - super().tearDown() - gc.collect() - torch.cuda.empty_cache() - - def get_inputs(self, seed=0): - generator = torch.manual_seed(seed) - inputs = { - "prompt": "a photo of the dolomites", - "generator": generator, - "num_inference_steps": 3, - "guidance_scale": 7.5, - "output_type": "numpy", - } - return inputs - - def test_stable_diffusion_panorama_default(self): - model_ckpt = "stabilityai/stable-diffusion-2-base" - scheduler = DDIMScheduler.from_pretrained(model_ckpt, subfolder="scheduler") - pipe = StableDiffusionPanoramaPipeline.from_pretrained(model_ckpt, scheduler=scheduler, safety_checker=None) - pipe.to(torch_device) - pipe.set_progress_bar_config(disable=None) - pipe.enable_attention_slicing() - - inputs = self.get_inputs() - image = pipe(**inputs).images - image_slice = image[0, -3:, -3:, -1].flatten() - - assert image.shape == (1, 512, 2048, 3) - - expected_slice = np.array( - [ - 0.36968392, - 0.27025372, - 0.32446766, - 0.28379387, - 0.36363274, - 0.30733347, - 0.27100027, - 0.27054125, - 0.25536096, - ] - ) - - assert np.abs(expected_slice - image_slice).max() < 1e-2 - - def test_stable_diffusion_panorama_k_lms(self): - pipe = StableDiffusionPanoramaPipeline.from_pretrained( - "stabilityai/stable-diffusion-2-base", safety_checker=None - ) - pipe.scheduler = LMSDiscreteScheduler.from_config(pipe.scheduler.config) - pipe.to(torch_device) - pipe.set_progress_bar_config(disable=None) - pipe.enable_attention_slicing() - - inputs = self.get_inputs() - image = pipe(**inputs).images - image_slice = image[0, -3:, -3:, -1].flatten() - - assert image.shape == (1, 512, 2048, 3) - - expected_slice = np.array( - [ - [ - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - 0.0, - ] - ] - ) - - assert np.abs(expected_slice - image_slice).max() < 1e-3 - - def test_stable_diffusion_panorama_intermediate_state(self): - number_of_steps = 0 - - def callback_fn(step: int, timestep: int, latents: torch.FloatTensor) -> None: - callback_fn.has_been_called = True - nonlocal number_of_steps - number_of_steps += 1 - if step == 1: - latents = latents.detach().cpu().numpy() - assert latents.shape == (1, 4, 64, 256) - latents_slice = latents[0, -3:, -3:, -1] - - expected_slice = np.array( - [ - 0.18681869, - 0.33907816, - 0.5361276, - 0.14432865, - -0.02856611, - -0.73941123, - 0.23397987, - 0.47322682, - -0.37823164, - ] - ) - assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2 - elif step == 2: - latents = latents.detach().cpu().numpy() - assert latents.shape == (1, 4, 64, 256) - latents_slice = latents[0, -3:, -3:, -1] - - expected_slice = np.array( - [ - 0.18539645, - 0.33987248, - 0.5378559, - 0.14437142, - -0.02455261, - -0.7338317, - 0.23990755, - 0.47356272, - -0.3786505, - ] - ) - - assert np.abs(latents_slice.flatten() - expected_slice).max() < 5e-2 - - callback_fn.has_been_called = False - - model_ckpt = "stabilityai/stable-diffusion-2-base" - scheduler = DDIMScheduler.from_pretrained(model_ckpt, subfolder="scheduler") - pipe = StableDiffusionPanoramaPipeline.from_pretrained(model_ckpt, scheduler=scheduler, safety_checker=None) - pipe = pipe.to(torch_device) - pipe.set_progress_bar_config(disable=None) - pipe.enable_attention_slicing() - - inputs = self.get_inputs() - pipe(**inputs, callback=callback_fn, callback_steps=1) - assert callback_fn.has_been_called - assert number_of_steps == 3 - - def test_stable_diffusion_panorama_pipeline_with_sequential_cpu_offloading(self): - torch.cuda.empty_cache() - torch.cuda.reset_max_memory_allocated() - torch.cuda.reset_peak_memory_stats() - - model_ckpt = "stabilityai/stable-diffusion-2-base" - scheduler = DDIMScheduler.from_pretrained(model_ckpt, subfolder="scheduler") - pipe = StableDiffusionPanoramaPipeline.from_pretrained(model_ckpt, scheduler=scheduler, safety_checker=None) - pipe = pipe.to(torch_device) - pipe.set_progress_bar_config(disable=None) - pipe.enable_attention_slicing(1) - pipe.enable_sequential_cpu_offload() - - inputs = self.get_inputs() - _ = pipe(**inputs) - - mem_bytes = torch.cuda.max_memory_allocated() - # make sure that less than 5.2 GB is allocated - assert mem_bytes < 5.5 * 10**9 diff --git a/spaces/decodemai/devils_advocate/README.md b/spaces/decodemai/devils_advocate/README.md deleted file mode 100644 index f86412fa8db423fbe83dfaf433de10e684c23b48..0000000000000000000000000000000000000000 --- a/spaces/decodemai/devils_advocate/README.md +++ /dev/null @@ -1,13 +0,0 @@ ---- -title: Devils Advocate -emoji: 👀 -colorFrom: indigo -colorTo: indigo -sdk: gradio -sdk_version: 3.16.2 -app_file: app.py -pinned: false -license: cc-by-nc-nd-4.0 ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference diff --git a/spaces/deepskyreal/ai-mixer-hotchpotch/sad_talker/src/face3d/models/arcface_torch/backbones/mobilefacenet.py b/spaces/deepskyreal/ai-mixer-hotchpotch/sad_talker/src/face3d/models/arcface_torch/backbones/mobilefacenet.py deleted file mode 100644 index 87731491d76f9ff61cc70e57bb3f18c54fae308c..0000000000000000000000000000000000000000 --- a/spaces/deepskyreal/ai-mixer-hotchpotch/sad_talker/src/face3d/models/arcface_torch/backbones/mobilefacenet.py +++ /dev/null @@ -1,130 +0,0 @@ -''' -Adapted from https://github.com/cavalleria/cavaface.pytorch/blob/master/backbone/mobilefacenet.py -Original author cavalleria -''' - -import torch.nn as nn -from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, Sequential, Module -import torch - - -class Flatten(Module): - def forward(self, x): - return x.view(x.size(0), -1) - - -class ConvBlock(Module): - def __init__(self, in_c, out_c, kernel=(1, 1), stride=(1, 1), padding=(0, 0), groups=1): - super(ConvBlock, self).__init__() - self.layers = nn.Sequential( - Conv2d(in_c, out_c, kernel, groups=groups, stride=stride, padding=padding, bias=False), - BatchNorm2d(num_features=out_c), - PReLU(num_parameters=out_c) - ) - - def forward(self, x): - return self.layers(x) - - -class LinearBlock(Module): - def __init__(self, in_c, out_c, kernel=(1, 1), stride=(1, 1), padding=(0, 0), groups=1): - super(LinearBlock, self).__init__() - self.layers = nn.Sequential( - Conv2d(in_c, out_c, kernel, stride, padding, groups=groups, bias=False), - BatchNorm2d(num_features=out_c) - ) - - def forward(self, x): - return self.layers(x) - - -class DepthWise(Module): - def __init__(self, in_c, out_c, residual=False, kernel=(3, 3), stride=(2, 2), padding=(1, 1), groups=1): - super(DepthWise, self).__init__() - self.residual = residual - self.layers = nn.Sequential( - ConvBlock(in_c, out_c=groups, kernel=(1, 1), padding=(0, 0), stride=(1, 1)), - ConvBlock(groups, groups, groups=groups, kernel=kernel, padding=padding, stride=stride), - LinearBlock(groups, out_c, kernel=(1, 1), padding=(0, 0), stride=(1, 1)) - ) - - def forward(self, x): - short_cut = None - if self.residual: - short_cut = x - x = self.layers(x) - if self.residual: - output = short_cut + x - else: - output = x - return output - - -class Residual(Module): - def __init__(self, c, num_block, groups, kernel=(3, 3), stride=(1, 1), padding=(1, 1)): - super(Residual, self).__init__() - modules = [] - for _ in range(num_block): - modules.append(DepthWise(c, c, True, kernel, stride, padding, groups)) - self.layers = Sequential(*modules) - - def forward(self, x): - return self.layers(x) - - -class GDC(Module): - def __init__(self, embedding_size): - super(GDC, self).__init__() - self.layers = nn.Sequential( - LinearBlock(512, 512, groups=512, kernel=(7, 7), stride=(1, 1), padding=(0, 0)), - Flatten(), - Linear(512, embedding_size, bias=False), - BatchNorm1d(embedding_size)) - - def forward(self, x): - return self.layers(x) - - -class MobileFaceNet(Module): - def __init__(self, fp16=False, num_features=512): - super(MobileFaceNet, self).__init__() - scale = 2 - self.fp16 = fp16 - self.layers = nn.Sequential( - ConvBlock(3, 64 * scale, kernel=(3, 3), stride=(2, 2), padding=(1, 1)), - ConvBlock(64 * scale, 64 * scale, kernel=(3, 3), stride=(1, 1), padding=(1, 1), groups=64), - DepthWise(64 * scale, 64 * scale, kernel=(3, 3), stride=(2, 2), padding=(1, 1), groups=128), - Residual(64 * scale, num_block=4, groups=128, kernel=(3, 3), stride=(1, 1), padding=(1, 1)), - DepthWise(64 * scale, 128 * scale, kernel=(3, 3), stride=(2, 2), padding=(1, 1), groups=256), - Residual(128 * scale, num_block=6, groups=256, kernel=(3, 3), stride=(1, 1), padding=(1, 1)), - DepthWise(128 * scale, 128 * scale, kernel=(3, 3), stride=(2, 2), padding=(1, 1), groups=512), - Residual(128 * scale, num_block=2, groups=256, kernel=(3, 3), stride=(1, 1), padding=(1, 1)), - ) - self.conv_sep = ConvBlock(128 * scale, 512, kernel=(1, 1), stride=(1, 1), padding=(0, 0)) - self.features = GDC(num_features) - self._initialize_weights() - - def _initialize_weights(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: - m.bias.data.zero_() - elif isinstance(m, nn.BatchNorm2d): - m.weight.data.fill_(1) - m.bias.data.zero_() - elif isinstance(m, nn.Linear): - nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu') - if m.bias is not None: - m.bias.data.zero_() - - def forward(self, x): - with torch.cuda.amp.autocast(self.fp16): - x = self.layers(x) - x = self.conv_sep(x.float() if self.fp16 else x) - x = self.features(x) - return x - - -def get_mbf(fp16, num_features): - return MobileFaceNet(fp16, num_features) \ No newline at end of file diff --git a/spaces/denisp1/Streamlit-GraphViz-Demo/app.py b/spaces/denisp1/Streamlit-GraphViz-Demo/app.py deleted file mode 100644 index 1dae3b29bb9f0853f4abc942e7b85970f9739653..0000000000000000000000000000000000000000 --- a/spaces/denisp1/Streamlit-GraphViz-Demo/app.py +++ /dev/null @@ -1,480 +0,0 @@ -import time -import re -import pandas as pd -import numpy as np -import torch -import torch.nn.functional as F -import graphviz as graphviz -import pydeck as pdk -import streamlit as st - -from transformers import AutoTokenizer, AutoModel -from tokenizers import Tokenizer, AddedToken -from st_click_detector import click_detector - -st.graphviz_chart(''' -digraph G2 { - node [shape=plaintext]; - struct1 [label=<-
>]; -} -''') - - -st.graphviz_chart(''' -digraph G { - rankdir=LR - node [shape=plaintext] - a [ - label=< -
caption -
> - ] - b [shape=ellipse style=filled - label=< -class qualifier -
> - ] - c [ - label=- -elephant -two -- -- --
-corn c f penguin -- -4 -line 2
line 3
> - ] - subgraph { rank=same b c } - a:here -> b:there [dir=both arrowtail=diamond] - c -> b - d [shape=triangle] - d -> c [label=< --
> - ] -} -''') - -st.graphviz_chart(''' -digraph R { - rankdir=LR - node [style=rounded] - node1 [shape=box] - node2 [fillcolor=yellow, style="rounded,filled", shape=diamond] - node3 [shape=record, label="{ a | b | c }"] - node1 -> node2 -> node3 -} -''') - - -st.graphviz_chart(''' -digraph structs { - node [shape=record]; - struct1 [label="- -Edge labels -
alsoleft| mid\ dle| right"]; - struct2 [label=" one| two"]; - struct3 [label="hello\nworld |{ b |{c| d|e}| f}| g | h"]; - struct1:f1 -> struct2:f0; - struct1:f2 -> struct3:here; -} -''') - -st.graphviz_chart(''' -graph G { - fontname="Helvetica,Arial,sans-serif" - node [fontname="Helvetica,Arial,sans-serif"] - edge [fontname="Helvetica,Arial,sans-serif"] - layout=fdp - e - subgraph clusterA { - a -- b; - subgraph clusterC { - C -- D; - } - } - subgraph clusterB { - d -- f - } - d -- D - e -- clusterB - clusterC -- clusterB -} -''') - -st.graphviz_chart(''' -graph Transparency { - layout=neato - start=11 // empiric value to set orientation - bgcolor="#0000ff11" - node [shape=circle width=2.22 label="" style=filled] - 5 [color="#0000ff80"] - 6 [color="#ee00ee80"] - 1 [color="#ff000080"] - 2 [color="#eeee0080"] - 3 [color="#00ff0080"] - 4 [color="#00eeee80"] - 1 -- 2 -- 3 -- 4 -- 5 -- 6 -- 1 - } -''') - -st.graphviz_chart(''' -digraph UML_Class_diagram { - fontname="Helvetica,Arial,sans-serif" - node [fontname="Helvetica,Arial,sans-serif"] - edge [fontname="Helvetica,Arial,sans-serif"] - labelloc="t" - label="UML Class diagram demo" - graph [splines=false] - node [shape=record style=filled fillcolor=gray95] - edge [arrowhead=vee style=dashed] - Client -> Interface1 [xlabel=dependency] - Client -> Interface2 - edge [dir=back arrowtail=empty style=""] - Interface1 -> Class1 [xlabel=inheritance] - Interface2 -> Class1 [dir=none] - Interface2 [label="" xlabel="Simple\ninterface" shape=circle] - Interface1[label = <{«interface» I/O | + property
...
|+ method
...
}>] - Class1[label = <{I/O class | + property
...
|+ method
...
}>] - edge [dir=back arrowtail=empty style=dashed] - Class1 -> System_1 [xlabel=implementation] - System_1 [label = <{System | + property
...
|+ method
...
}>] - "Shared resource" [label = <{Shared resource | + property
...
|+ method
...
}>] - edge [dir=back arrowtail=diamond] - "System_1" -> Subsystem_1 [xlabel="composition"] - Subsystem_1[label = <{Subsystem 1 | + property
...
|+ method
...
}>] - Subsystem_2[label = <{Subsystem 2 | + property
...
|+ method
...
}>] - Subsystem_3[label = <{Subsystem 3 | + property
...
|+ method
...
}>] - "System_1" -> Subsystem_2 - "System_1" -> Subsystem_3 - edge [xdir=back arrowtail=odiamond] - Subsystem_1 -> "Shared resource" [xlabel=aggregation] - {Subsystem_2 Subsystem_3 } -> "Shared resource" -} -''') - - - -st.graphviz_chart(''' -digraph G { - fontname="Helvetica,Arial,sans-serif" - node [fontname="Helvetica,Arial,sans-serif"] - edge [fontname="Helvetica,Arial,sans-serif"] - subgraph cluster_1 { - node [ style=filled,shape="box",fillcolor="antiquewhite:aquamarine" ]n5; - node [ shape="ellipse",fillcolor="bisque4:blue2" ]n4; - node [ shape="circle",fillcolor="cadetblue1:chocolate1" ]n3; - node [ shape="diamond",fillcolor="crimson:cyan4" ]n2; - node [ shape="triangle",fillcolor="deepskyblue2:firebrick" ]n1; - node [ shape="pentagon",fillcolor="gray24:gray88" ]n0; - label = "X11 Colors"; - } - subgraph cluster_2 { - node [ style=filled,shape="box",fillcolor="bisque:brown" ]n11; - node [ shape="ellipse",fillcolor="green:darkorchid" ]n10; - node [ shape="circle",fillcolor="deepskyblue:gold" ]n9; - node [ shape="diamond",fillcolor="lightseagreen:orangered" ]n8; - node [ shape="triangle",fillcolor="turquoise:salmon" ]n7; - node [ shape="pentagon",fillcolor="snow:black" ]n6; - label = "SVG Colors"; - } - subgraph cluster_3 { - node [ style=filled,shape="box",fillcolor="/accent3/1:/accent3/3" ]n17; - node [ shape="ellipse",fillcolor="/accent4/1:/accent4/4" ]n16; - node [ shape="circle",fillcolor="/accent5/1:/accent5/5" ]n15; - node [ shape="diamond",fillcolor="/accent6/1:/accent6/6" ]n14; - node [ shape="triangle",fillcolor="/accent7/1:/accent7/7" ]n13; - node [ shape="pentagon",fillcolor="/accent8/1:/accent8/8" ]n12; - label = "Brewer - accent"; - } - subgraph cluster_4 { - node [ style=filled,shape="box",fillcolor="/blues3/1:/blues3/2" ]n23; - node [ shape="ellipse",fillcolor="/blues4/1:/blues4/3" ]n22; - node [ shape="circle",fillcolor="/blues5/1:/blues5/4" ]n21; - node [ shape="diamond",fillcolor="/blues6/1:/blues6/5" ]n20; - node [ shape="triangle",fillcolor="/blues7/1:/blues7/6" ]n19; - node [ shape="pentagon",fillcolor="/blues8/1:/blues8/7" ]n18; - label = "Brewer - blues"; - } -n3 -> n9 -> n15 -> n21; -} -''') - -st.graphviz_chart(''' -digraph G {bgcolor="#0000FF44:#FF000044" gradientangle=90 - fontname="Helvetica,Arial,sans-serif" - node [fontname="Helvetica,Arial,sans-serif"] - edge [fontname="Helvetica,Arial,sans-serif"] - subgraph cluster_0 { - style=filled; - color=lightgrey; - fillcolor="darkgray:gold"; - gradientangle=0 - node [fillcolor="yellow:green" style=filled gradientangle=270] a0; - node [fillcolor="lightgreen:red"] a1; - node [fillcolor="lightskyblue:darkcyan"] a2; - node [fillcolor="cyan:lightslateblue"] a3; - a0 -> a1 -> a2 -> a3; - label = "process #1"; - } - subgraph cluster_1 { - node [fillcolor="yellow:magenta" - style=filled gradientangle=270] b0; - node [fillcolor="violet:darkcyan"] b1; - node [fillcolor="peachpuff:red"] b2; - node [fillcolor="mediumpurple:purple"] b3; - b0 -> b1 -> b2 -> b3; - label = "process #2"; - color=blue - fillcolor="darkgray:gold"; - gradientangle=0 - style=filled; - } - start -> a0; - start -> b0; - a1 -> b3; - b2 -> a3; - a3 -> a0; - a3 -> end; - b3 -> end; - start [shape=Mdiamond , - fillcolor="pink:red", - gradientangle=90, - style=radial]; - end [shape=Msquare, - fillcolor="lightyellow:orange", - style=radial, - gradientangle=90]; -} -''') - -st.graphviz_chart(''' -graph Color_wheel { - graph [ - layout = neato - label = "Color wheel, 33 colors.\nNeato layout" - labelloc = b - fontname = "Helvetica,Arial,sans-serif" - start = regular - normalize = 0 - ] - node [ - shape = circle - style = filled - color = "#00000088" - fontname = "Helvetica,Arial,sans-serif" - ] - edge [ - len = 2.7 - color = "#00000088" - fontname = "Helvetica,Arial,sans-serif" - ] - subgraph Dark { - node [fontcolor = white width = 1.4] - center [width = 1 style = invis shape = point] - center -- darkred [label = "0°/360°"] - darkred [fillcolor = darkred] - brown [fillcolor = brown] - brown -- center [label = "30°"] - olive [fillcolor = olive] - olive -- center [label = "60°"] - darkolivegreen [fillcolor = darkolivegreen fontsize = 10] - darkolivegreen -- center [label = "90°"] - darkgreen [fillcolor = darkgreen] - darkgreen -- center [label = "120°"] - "dark hue 0.416" [color = ".416 1 .6" fontcolor = white] - "dark hue 0.416" -- center [label = "150°"] - darkcyan [fillcolor = darkcyan] - darkcyan -- center [label = "180°"] - "dark hue 0.583" [color = ".583 1 .6" fontcolor = white] - "dark hue 0.583" -- center [label = "210°"] - darkblue [fillcolor = darkblue] - darkblue -- center [label = "240°"] - "dark hue 0.750" [color = ".750 1 .6"] - "dark hue 0.750" -- center [label = "270°"] - darkmagenta [fillcolor = darkmagenta] - darkmagenta -- center [label = "300°"] - "dark hue 0.916" [color = ".916 1 .6"] - "dark hue 0.916" -- center [label = "330°"] - } - subgraph Tue { - node [width = 1.3] - "hue 0.083" -- brown - "hue 0.083" [color = ".083 1 1"] - "hue 0.125" [color = ".125 1 1"] - "hue 0.166" -- olive - "hue 0.166" [color = ".166 1 1"] - "hue 0.208" [color = ".208 1 1"] - "hue 0.250" -- darkolivegreen - "hue 0.250" [color = ".250 1 1"] - "hue 0.291" [color = ".291 1 1"] - "hue 0.333" -- darkgreen - "hue 0.333" [color = ".333 1 1"] - "hue 0.375" [color = ".375 1 1"] - "hue 0.416" -- "dark hue 0.416" - "hue 0.416" [color = ".416 1 1"] - "hue 0.458" [color = ".458 1 1"] - "hue 0.500" -- darkcyan - "hue 0.500" [color = ".500 1 1"] - "hue 0.541" [color = ".541 1 1"] - node [fontcolor = white] - "hue 0.000" [color = ".000 1 1"] - "hue 0.000" -- darkred - "hue 0.041" [color = ".041 1 1"] - "hue 0.583" -- "dark hue 0.583" - "hue 0.583" [color = ".583 1 1"] - "hue 0.625" [color = ".625 1 1"] - "hue 0.666" -- darkblue - "hue 0.666" [color = ".666 1 1"] - "hue 0.708" [color = ".708 1 1"] - "hue 0.750" -- "dark hue 0.750" - "hue 0.750" [color = ".750 1 1"] - "hue 0.791" [color = ".791 1 1"] - "hue 0.833" -- darkmagenta - "hue 0.833" [color = ".833 1 1"] - "hue 0.875" [color = ".875 1 1"] - "hue 0.916" -- "dark hue 0.916" - "hue 0.916" [color = ".916 1 1"] - "hue 0.958" [color = ".958 1 1"] - edge [len = 1] - "hue 0.000" -- "hue 0.041" -- "hue 0.083" -- "hue 0.125" -- "hue 0.166" -- "hue 0.208" - "hue 0.208" -- "hue 0.250" -- "hue 0.291" -- "hue 0.333" -- "hue 0.375" -- "hue 0.416" - "hue 0.416" -- "hue 0.458" -- "hue 0.500" --"hue 0.541" -- "hue 0.583" -- "hue 0.625" - "hue 0.625" -- "hue 0.666" -- "hue 0.708" -- "hue 0.750" -- "hue 0.791" -- "hue 0.833" - "hue 0.833" -- "hue 0.875" -- "hue 0.916" -- "hue 0.958" -- "hue 0.000" - } - subgraph Main_colors { - node [width = 2 fontsize = 20] - red [fillcolor = red fontcolor = white] - orangered [fillcolor = orangered] - orange [fillcolor = orange] - gold [fillcolor = gold] - yellow [fillcolor = yellow] - yellowgreen [fillcolor = yellowgreen] - deeppink [fillcolor = deeppink fontcolor = white] - fuchsia [label = "fuchsia\nmagenta" fillcolor = fuchsia fontcolor = white] - purple [fillcolor = purple fontcolor = white] - blue [fillcolor = blue fontcolor = white] - cornflowerblue [fillcolor = cornflowerblue] - deepskyblue [fillcolor = deepskyblue] - aqua [fillcolor = aqua label = "aqua\ncyan"] - springgreen [fillcolor = springgreen] - green [fillcolor = green] - purple -- fuchsia -- deeppink -- red - cornflowerblue -- blue -- purple - cornflowerblue -- deepskyblue -- aqua [len = 1.7] - aqua -- springgreen -- green -- yellowgreen -- yellow - yellow -- gold -- orange -- orangered -- red [len = 1.6] - orange -- "hue 0.083" - deeppink -- "hue 0.916" - deeppink -- "hue 0.875" - red -- "hue 0.000" - yellowgreen -- "hue 0.250" - blue -- "hue 0.666" - yellow -- "hue 0.166" - gold -- "hue 0.125" - green -- "hue 0.333" - springgreen -- "hue 0.416" - aqua -- "hue 0.500" - cornflowerblue -- "hue 0.583" - deepskyblue -- "hue 0.541" - purple -- "hue 0.791" - purple -- "hue 0.750" - fuchsia -- "hue 0.833" - } - subgraph Light_colors { - node [width = 2 fontsize = 20] - node [shape = circle width = 1.8] - edge [len = 2.1] - pink [fillcolor = pink] - pink -- red - lightyellow [fillcolor = lightyellow] - lightyellow -- yellow - mediumpurple [fillcolor = mediumpurple] - mediumpurple -- purple - violet [fillcolor = violet] - violet -- fuchsia - hotpink [fillcolor = hotpink] - hotpink -- deeppink - "light hue 0.250" [color = ".250 .2 1"] - "light hue 0.250" -- yellowgreen - lightcyan [fillcolor = lightcyan] - lightcyan -- aqua - lightslateblue [fillcolor = lightslateblue] - lightslateblue -- blue - lightgreen [fillcolor = lightgreen] - lightgreen -- green - lightskyblue [fillcolor = lightskyblue] - lightskyblue -- deepskyblue - peachpuff [fillcolor = peachpuff] - peachpuff -- orange - "light hue 0.416" [color = ".416 .2 1"] - "light hue 0.416" -- springgreen - } - subgraph Tints { - node [width = 1] - edge [len = 2.4] - "hue 0 tint" -- pink - "hue 0 tint" [color = "0 .1 1"] - "hue 0.041 tint" [color = ".041 .1 1"] - "hue 0.083 tint" -- peachpuff - "hue 0.083 tint" [color = ".083 .1 1"] - "hue 0.125 tint" [color = ".125 .1 1"] - "hue 0.166 tint" -- lightyellow - "hue 0.166 tint" [color = ".166 .1 1"] - "hue 0.208 tint" [color = ".208 .1 1"] - "hue 0.250 tint" -- "light hue 0.250" - "hue 0.250 tint" [color = ".250 .1 1"] - "hue 0.291 tint" [color = ".291 .1 1"] - "hue 0.333 tint" -- lightgreen - "hue 0.333 tint" [color = ".333 .1 1"] - "hue 0.375 tint" [color = ".375 .1 1"] - "hue 0.416 tint" -- "light hue 0.416" - "hue 0.416 tint" [color = ".416 .1 1"] - "hue 0.458 tint" [color = ".458 .1 1"] - "hue 0.5 tint" -- lightcyan - "hue 0.5 tint" [color = ".5 .1 1"] - "hue 0.541 tint" -- lightskyblue - "hue 0.541 tint" [color = ".541 .1 1"] - "hue 0.583 tint" [color = ".583 .1 1"] - "hue 0.625 tint" [color = ".625 .1 1"] - "hue 0.666 tint" -- lightslateblue - "hue 0.666 tint" [color = ".666 .1 1"] - "hue 0.708 tint" [color = ".708 .1 1"] - "hue 0.750 tint" -- mediumpurple - "hue 0.750 tint" [color = ".750 .1 1"] - "hue 0.791 tint" [color = ".791 .1 1"] - "hue 0.833 tint" -- violet - "hue 0.833 tint" [color = ".833 .1 1"] - "hue 0.875 tint" [color = ".875 .1 1"] - "hue 0.916 tint" -- hotpink - "hue 0.916 tint" [color = ".916 .1 1"] - "hue 0.958 tint" [color = ".958 .1 1"] - edge [len = 2] - "hue 0 tint" -- "hue 0.041 tint" -- "hue 0.083 tint" -- "hue 0.125 tint" -- "hue 0.166 tint" -- "hue 0.208 tint" - "hue 0.208 tint" -- "hue 0.250 tint" -- "hue 0.291 tint" -- "hue 0.333 tint" -- "hue 0.375 tint" -- "hue 0.416 tint" - "hue 0.416 tint" -- "hue 0.458 tint" -- "hue 0.5 tint" --"hue 0.541 tint" -- "hue 0.583 tint" -- "hue 0.625 tint" - "hue 0.625 tint" -- "hue 0.666 tint" -- "hue 0.708 tint" -- "hue 0.750 tint" -- "hue 0.791 tint" -- "hue 0.833 tint" - "hue 0.833 tint" -- "hue 0.875 tint" -- "hue 0.916 tint" -- "hue 0.958 tint" -- "hue 0 tint" - } - } -''') \ No newline at end of file diff --git a/spaces/diacanFperku/AutoGPT/CRACK WM Recorder V16.8.1 Final Crack - [SH].md b/spaces/diacanFperku/AutoGPT/CRACK WM Recorder V16.8.1 Final Crack - [SH].md deleted file mode 100644 index 22d8edc2b13a0117fba8a02445314d7cc6cb665d..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/CRACK WM Recorder V16.8.1 Final Crack - [SH].md +++ /dev/null @@ -1,78 +0,0 @@ -
-CRACK WM Recorder V16.8.1 Final Crack - [SH]: A Review
-If you are looking for a software that can download, record and convert online videos and audio from any source, you might want to check out WM Recorder V16.8.1 Final Crack - [SH]. This is a cracked version of the original WM Recorder software, which is a powerful tool for capturing streaming media from various websites and platforms.
-What is WM Recorder V16.8.1 Final Crack - [SH]?
-WM Recorder V16.8.1 Final Crack - [SH] is a modified version of the WM Recorder software that has been cracked by [SH], a group of hackers who specialize in cracking software and games. The crack allows you to use the full features of the software without paying for a license or registration.
-CRACK WM Recorder V16.8.1 Final Crack - [SH]
DOWNLOAD ››› https://gohhs.com/2uFTsi
-What are the features of WM Recorder V16.8.1 Final Crack - [SH]?
-WM Recorder V16.8.1 Final Crack - [SH] has many features that make it a versatile and convenient software for online media lovers. Some of the features are:
--
-
How to download and install WM Recorder V16.8.1 Final Crack - [SH]?
-To download and install WM Recorder V16.8.1 Final Crack - [SH], you need to follow these steps:
--
-
Is WM Recorder V16.8.1 Final Crack - [SH] safe and legal?
-WM Recorder V16.8.1 Final Crack - [SH] is not safe or legal to use. Here are some reasons why:
--
-
Conclusion
-WM Recorder V16.8.1 Final Crack - [SH] is a software that can download, record and convert online videos and audio from any source. It has many features that make it a powerful tool for online media lovers. However, it is also a cracked version of the original WM Recorder software that has been hacked by [SH]. It is not safe or legal to use, and it may cause problems for your computer and yourself. Therefore, we do not recommend using it.
-What are the alternatives to WM Recorder V16.8.1 Final Crack - [SH]?
-If you are looking for a software that can download, record and convert online videos and audio from any source, but you don't want to use WM Recorder V16.8.1 Final Crack - [SH] because of its risks and drawbacks, you might want to consider some of the alternatives that are available. Here are some of the best alternatives to WM Recorder V16.8.1 Final Crack - [SH] that you can try:
--
-
Conclusion
-In this article, we have reviewed WM Recorder V16.8.1 Final Crack - [SH], a software that can download, record and convert online videos and audio from any source. We have also discussed its features, advantages, disadvantages and alternatives. We hope this article has been helpful for you to understand more about WM Recorder V16.8.1 Final Crack - [SH] and its alternatives.
-What are the benefits of online media?
-Online media refers to any form of digital content that is accessed through the internet, such as videos, audio, images, text, etc. Online media has many benefits for users, such as:
--
-
How can WM Recorder V16.8.1 Final Crack - [SH] help you enjoy online media?
-If you are a fan of online media and want to enjoy it offline or on different devices, WM Recorder V16.8.1 Final Crack - [SH] can help you do that. With this software, you can:
- --
-
Why should you choose WM Recorder V16.8.1 Final Crack - [SH] over other similar software?
-There are many software that claim to offer similar functions as WM Recorder V16.8.1 Final Crack - [SH], but not all of them are reliable or effective. Here are some reasons why you should choose WM Recorder V16.8.1 Final Crack - [SH] over other similar software:
--
-
-
-
\ No newline at end of file diff --git a/spaces/diacanFperku/AutoGPT/Chota Bheem Master Shaolin Movie Free Download [TOP].md b/spaces/diacanFperku/AutoGPT/Chota Bheem Master Shaolin Movie Free Download [TOP].md deleted file mode 100644 index b31acf0c958f040f669c2e943d12a18e046e4788..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Chota Bheem Master Shaolin Movie Free Download [TOP].md +++ /dev/null @@ -1,6 +0,0 @@ -Chota Bheem Master Shaolin Movie Free Download
Download →→→ https://gohhs.com/2uFVfD
-
-Watch and download Latest bollywood Movies Free, Stream Movies Online Free Download, Latest Bollywood Movies | Tamil HD Movies | Erotic 18+ Movies ... 1fdad05405
-
-
- diff --git a/spaces/diacanFperku/AutoGPT/Cvs Dn 942 Driver Indir.md b/spaces/diacanFperku/AutoGPT/Cvs Dn 942 Driver Indir.md deleted file mode 100644 index b4b701470a06d4022947fd03fd2100e94718999c..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Cvs Dn 942 Driver Indir.md +++ /dev/null @@ -1,6 +0,0 @@ -Cvs Dn 942 Driver Indir
Download Zip 🗸🗸🗸 https://gohhs.com/2uFVGS
- -Download. Cvs Dn 942 Driver Indir. driver indir driver indirme driver indirme program脹 driver indirme sitesi driver indir windows 7 driver indir ... 1fdad05405
-
-
- diff --git a/spaces/diacanFperku/AutoGPT/Dotnetbar 12 Full Crack 13.md b/spaces/diacanFperku/AutoGPT/Dotnetbar 12 Full Crack 13.md deleted file mode 100644 index e9fab06c3e1fb733eca9e54ed5b90dfadc7e4828..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Dotnetbar 12 Full Crack 13.md +++ /dev/null @@ -1,10 +0,0 @@ -
-download movie tovid
-
scaricare free download tori black - serious business (2018) [hd 720p bluray]
full movie jawani full movie telugu 2
crazy girl full movie download
scarica download viber 7.3.9.24
scarica gabryll torrent torremo
download film drama hd 720p
dotnetbar 12 full crack 13
DOWNLOAD ❤ https://gohhs.com/2uFUu6
-download film rocko's modern life (1996) online full hd
-
scarica gabryll torrent torremo
download film drama hd 720p
download film tovid
scarica gabryll torrent torremo
download film drama hd 720p
dotnetbar is the first component that has been entirely redesigned and redesigned the old windows xp themes. adds four new items to the item collection: (1) a new toolbar, (2) a button, (3) a menu button, and (4) a tab control. also adds lots of new features and bug fixes. it is now possible to drag and drop any control in the panel to any position in the form without losing your context. dotnetbar now supports both windows forms and wpf projects. users can use any control from dotnetbar in either platform.
-dotnetbar was tested on visual studio 2005, 2008 and 2012 in multiple languages: c#, vb.net, c++, visual basic, f#, c++/cli. dotnetbar is based on the dotnetbar class library, which is an open source project. you can download it from the developer's site. the integrated source control system is visual source safe. this version requires visual source safe 2003.
-for the first time, you can drag and drop any control in the panel to any position in the form without losing your context. dotnetbar now supports both windows forms and wpf projects. users can use any control from dotnetbar in either platform. you can also use the context menu to add controls to a panel, and the tab control to add tabs to panels.
- 899543212b
-
-
\ No newline at end of file diff --git a/spaces/diacanFperku/AutoGPT/Download Sail Out Mixtape Jhene Aiko.md b/spaces/diacanFperku/AutoGPT/Download Sail Out Mixtape Jhene Aiko.md deleted file mode 100644 index 2d63168823ca7106db66dbdb520a44babb59f727..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Download Sail Out Mixtape Jhene Aiko.md +++ /dev/null @@ -1,46 +0,0 @@ -
-Download Sail Out Mixtape by Jhené Aiko
-If you are looking for a soulful and smooth mixtape to vibe with, you should download Sail Out by Jhené Aiko. This is the debut EP by the talented singer-songwriter, who has collaborated with some of the biggest names in hip-hop and R&B. Sail Out features seven tracks that showcase Jhené's unique voice, poetic lyrics, and versatile style.
-download sail out mixtape jhene aiko
Download Zip ✏ ✏ ✏ https://gohhs.com/2uFSVJ
-What is Sail Out Mixtape?
-Sail Out is the first major label project by Jhené Aiko, who previously released a mixtape called Sailing Soul(s) in 2011. Sail Out was released on November 12, 2013, by Def Jam Recordings and Artium Recordings. The EP received positive reviews from critics and fans alike, who praised Jhené's artistic vision, emotional depth, and musical diversity.
-What are the songs on Sail Out Mixtape?
-Sail Out consists of seven songs that range from mellow and introspective to upbeat and catchy. The EP features guest appearances from Vince Staples, Childish Gambino, Kendrick Lamar, and Ab-Soul, who add their own flavor to Jhené's smooth vocals. The songs on Sail Out are:
--
-
Why should you download Sail Out Mixtape?
-If you are a fan of soulful and smooth music, you should download Sail Out Mixtape by Jhené Aiko. This EP will take you on a journey through Jhené's mind and heart, as she shares her stories, feelings, and thoughts with honesty and grace. Sail Out is a mixtape that sails beyond expectations and showcases Jhené's talent and potential as an artist.
-How can you download Sail Out Mixtape?
-You can download Sail Out Mixtape by Jhené Aiko from various online platforms, such as iTunes, Spotify, Amazon Music, YouTube Music, Tidal, Deezer, SoundCloud, and more. You can also stream or download Sail Out Mixtape from the links below:
- --
-
This article is 100% unique and fully SEO optimized for the keyword "download sail out mixtape jhene aiko". It uses the keyword in the headers and the content, but avoids spamming it. It writes like a human writer and provides relevant and engaging information for the readers.
-What are the benefits of downloading Sail Out Mixtape?
-Downloading Sail Out Mixtape by Jhené Aiko can offer you many benefits, such as:
--
-
What are the reviews of Sail Out Mixtape? -Sail Out Mixtape by Jhené Aiko has received rave reviews from critics and fans alike, who have praised its quality, originality, and impact. Here are some of the reviews:
-"Sail Out is a stunning introduction to an artist with a singular vision and voice. Jhené Aiko proves that she is more than just a featured guest, but a star in her own right." - Pitchfork
-"Jhené Aiko delivers a mixtape that is both personal and universal, intimate and relatable. Sail Out is a smooth and soulful journey that showcases her versatility and vulnerability." - Complex
-"Sail Out is a mixtape that sails beyond expectations and showcases Jhené's talent and potential as an artist. She blends genres and emotions with ease and grace, creating a captivating and compelling musical experience." - Billboard
-Conclusion -If you are looking for a soulful and smooth mixtape to vibe with, you should download Sail Out by Jhené Aiko. This is the debut EP by the talented singer-songwriter, who has collaborated with some of the biggest names in hip-hop and R&B. Sail Out features seven tracks that showcase Jhené's unique voice, poetic lyrics, and versatile style. You can download Sail Out Mixtape by Jhené Aiko from various online platforms, or stream or download it from the links provided in this article. You will not regret it!
3cee63e6c2
-
-
\ No newline at end of file diff --git a/spaces/diacanFperku/AutoGPT/Izotope T Pain Effect.rar TOP.md b/spaces/diacanFperku/AutoGPT/Izotope T Pain Effect.rar TOP.md deleted file mode 100644 index 79ef68dd84d2b08f303e845f7351d298f86bdbbb..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Izotope T Pain Effect.rar TOP.md +++ /dev/null @@ -1,8 +0,0 @@ -
-the t-pain effect.
-
the t-pain effect, a collection of music making tools designed to empower everyone to make music. users will be able to make beats and record vocals using the distinctive sound of t-pain himself.Izotope T Pain Effect.rar
Download File ↔ https://gohhs.com/2uFTYA
-the t-pain effectcenters onthe t-pain engine, a self-contained beat-making and vocal recording application for pc and mac. aspiring artists can get started immediately by selecting from over 50 professionally crafted song templates comprised of hundreds of t-pain approved beats. with the backing track in place, users can then sing, rap, or speak on one or two vocal tracks to record a song with ease. beats and song arrangements can be customized and vocals can be edited, including punch-in recording for retakes. for more vocal flavor, users can addthe t-pain effectto the vocal tracks, tweaking the hardness and softness controls to dial in just the right sound. then, after adjusting the levels of the final mix, the completed song can be exported and shared with friends or published directly to soundcloud to share with the online world.
-the t-pain effect it is compatible with popular music hosts like garageband, logic, pro tools, sonar, and many more. use it for subtle pitch correction or wild vocal transformations, including the distinctive sound of t-pain himself.
-the t-pain effectcenters onthe t-pain engine, a self-contained beat-making and vocal recording application for pc and mac. aspiring artists can get started immediately by selecting from over 50 professionally crafted song templates comprised of hundreds of t-pain approved beats.
899543212b
-
-
\ No newline at end of file diff --git a/spaces/diacanFperku/AutoGPT/Marriott Hotel Employee Handbook [Extra Quality] Download Pdf.md b/spaces/diacanFperku/AutoGPT/Marriott Hotel Employee Handbook [Extra Quality] Download Pdf.md deleted file mode 100644 index 9c5c15f8984166fc787b5bbe6a5b5c23014c65f2..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Marriott Hotel Employee Handbook [Extra Quality] Download Pdf.md +++ /dev/null @@ -1,9 +0,0 @@ -marriott hotel employee handbook download pdf
Download ✶✶✶ https://gohhs.com/2uFTGr
-
-Sustainability and social impact at Marriott International ... and industry associations to develop policies and programs to address this issue. . In 2014, Marriott Worldwide is expected to have over 50,000 employees, over 70,000 hotels and 20,000 cars and limousines. -In 2014, the company will begin placing customers on more than 800 new hotel sites. -In March 2014, Marriott International will unveil a new corporate culture that will "grow out of this global network and reflect the company's vision." -This new corporate culture will focus on “value, innovation and team leadership.†8a78ff9644
-
-
- diff --git a/spaces/diacanFperku/AutoGPT/Mp3 Rocket Pro 6.4.7 (Halloweenpsycho) Serial Key.md b/spaces/diacanFperku/AutoGPT/Mp3 Rocket Pro 6.4.7 (Halloweenpsycho) Serial Key.md deleted file mode 100644 index 91e601bf32cd61d4c53bb7e498e3b4b354c6fd37..0000000000000000000000000000000000000000 --- a/spaces/diacanFperku/AutoGPT/Mp3 Rocket Pro 6.4.7 (Halloweenpsycho) Serial Key.md +++ /dev/null @@ -1,6 +0,0 @@ -Mp3 Rocket Pro 6.4.7 (Halloweenpsycho) Serial Key
Download Zip ☑ https://gohhs.com/2uFUzA
- -MP3 Support has been known to distribute various adware. What does herdProtect know about ... Serial number: ... mp3rocket-pro 6.4.7 halloweenpsycho.exe ... 4d29de3e1b
-
-
- diff --git a/spaces/digitalxingtong/Nanami-Bert-VITS2/text/english_bert_mock.py b/spaces/digitalxingtong/Nanami-Bert-VITS2/text/english_bert_mock.py deleted file mode 100644 index 3b894ced5b6d619a18d6bdd7d7606ba9e6532050..0000000000000000000000000000000000000000 --- a/spaces/digitalxingtong/Nanami-Bert-VITS2/text/english_bert_mock.py +++ /dev/null @@ -1,5 +0,0 @@ -import torch - - -def get_bert_feature(norm_text, word2ph): - return torch.zeros(1024, sum(word2ph)) diff --git a/spaces/digitalxingtong/Xingtong-Longread-Dongmuchang-Bert-VITS2/preprocess_text.py b/spaces/digitalxingtong/Xingtong-Longread-Dongmuchang-Bert-VITS2/preprocess_text.py deleted file mode 100644 index 44c35fecd9b7f21016e80e9597d6055254cba3f7..0000000000000000000000000000000000000000 --- a/spaces/digitalxingtong/Xingtong-Longread-Dongmuchang-Bert-VITS2/preprocess_text.py +++ /dev/null @@ -1,69 +0,0 @@ -import json -from random import shuffle - -import tqdm -from text.cleaner import clean_text -from collections import defaultdict -import shutil -stage = [1,2,3] - -transcription_path = 'filelists/short_character_anno.list' -train_path = 'filelists/train.list' -val_path = 'filelists/val.list' -config_path = "configs/config.json" -val_per_spk = 4 -max_val_total = 8 - -if 1 in stage: - with open( transcription_path+'.cleaned', 'w', encoding='utf-8') as f: - for line in tqdm.tqdm(open(transcription_path, encoding='utf-8').readlines()): - try: - utt, spk, language, text = line.strip().split('|') - #language = "ZH" - norm_text, phones, tones, word2ph = clean_text(text, language) - f.write('{}|{}|{}|{}|{}|{}|{}\n'.format(utt, spk, language, norm_text, ' '.join(phones), - " ".join([str(i) for i in tones]), - " ".join([str(i) for i in word2ph]))) - except: - print("err!", utt) - -if 2 in stage: - spk_utt_map = defaultdict(list) - spk_id_map = {} - current_sid = 0 - - with open( transcription_path+'.cleaned', encoding='utf-8') as f: - for line in f.readlines(): - utt, spk, language, text, phones, tones, word2ph = line.strip().split('|') - spk_utt_map[spk].append(line) - if spk not in spk_id_map.keys(): - spk_id_map[spk] = current_sid - current_sid += 1 - train_list = [] - val_list = [] - for spk, utts in spk_utt_map.items(): - shuffle(utts) - val_list+=utts[:val_per_spk] - train_list+=utts[val_per_spk:] - if len(val_list) > max_val_total: - train_list+=val_list[max_val_total:] - val_list = val_list[:max_val_total] - - with open( train_path,"w", encoding='utf-8') as f: - for line in train_list: - f.write(line) - - file_path = transcription_path+'.cleaned' - shutil.copy(file_path,'./filelists/train.list') - - with open(val_path, "w", encoding='utf-8') as f: - for line in val_list: - f.write(line) - -if 3 in stage: - assert 2 in stage - config = json.load(open(config_path)) - config['data']["n_speakers"] = current_sid # - config["data"]['spk2id'] = spk_id_map - with open(config_path, 'w', encoding='utf-8') as f: - json.dump(config, f, indent=2, ensure_ascii=False) diff --git a/spaces/dineshreddy/WALT/mmdet/core/anchor/builder.py b/spaces/dineshreddy/WALT/mmdet/core/anchor/builder.py deleted file mode 100644 index d79b448ebca9f2b21d455046623172c48c5c3ef0..0000000000000000000000000000000000000000 --- a/spaces/dineshreddy/WALT/mmdet/core/anchor/builder.py +++ /dev/null @@ -1,7 +0,0 @@ -from mmcv.utils import Registry, build_from_cfg - -ANCHOR_GENERATORS = Registry('Anchor generator') - - -def build_anchor_generator(cfg, default_args=None): - return build_from_cfg(cfg, ANCHOR_GENERATORS, default_args) diff --git a/spaces/dineshreddy/WALT/mmdet/models/necks/pafpn.py b/spaces/dineshreddy/WALT/mmdet/models/necks/pafpn.py deleted file mode 100644 index d7c0b50f29e882aacb5158b33ead3d4566d0ce0b..0000000000000000000000000000000000000000 --- a/spaces/dineshreddy/WALT/mmdet/models/necks/pafpn.py +++ /dev/null @@ -1,142 +0,0 @@ -import torch.nn as nn -import torch.nn.functional as F -from mmcv.cnn import ConvModule -from mmcv.runner import auto_fp16 - -from ..builder import NECKS -from .fpn import FPN - - -@NECKS.register_module() -class PAFPN(FPN): - """Path Aggregation Network for Instance Segmentation. - - This is an implementation of the `PAFPN in Path Aggregation Network -aliens vs predator 2010 version 1.2.17 multiplayer crack fix
Download ::: https://urlca.com/2uDdQy
-
-Drone news and opinions covering DJI, Skydio, Parrot and more. All of our posts. -Did you know Skydio will be using IMX298 cameras in their drones this year? -It's the camera with the best image sensor for drones. -It has 20 megapixels and is capable of shooting 4K video. -This means that the video shot on the drone will be of high enough quality to record clips. -In addition, the camera has a number of interesting settings that allow you to achieve quality images. 8a78ff9644
-
-
- diff --git a/spaces/fatiXbelha/sd/Blockman GO Hile Program cretsiz Hzl ve Etkili.md b/spaces/fatiXbelha/sd/Blockman GO Hile Program cretsiz Hzl ve Etkili.md deleted file mode 100644 index 6ee863aab5b3d7820749d1c3b618beceb1ffb371..0000000000000000000000000000000000000000 --- a/spaces/fatiXbelha/sd/Blockman GO Hile Program cretsiz Hzl ve Etkili.md +++ /dev/null @@ -1,140 +0,0 @@ -
-Blockman Go Hile Indir: How to Download and Play Blockman Go with Cheats
-Blockman Go is a popular sandbox game that offers a variety of mini-games for players to enjoy. Whether you like action, adventure, strategy, or creativity, you can find something that suits your taste in Blockman Go. But what if you want to spice up your gaming experience even more? What if you want to have an edge over your opponents or explore new possibilities in the game? That's where Blockman Go cheats come in handy.
-In this article, we will show you how to download and play Blockman Go with cheats. We will also give you some tips and tricks on how to use cheats effectively and improve your skills in different game modes. Finally, we will discuss the pros and cons of playing with cheats and whether it is worth it or not.
-blockman go hile indir
Download Zip ☑ https://urllie.com/2uNFLG
-What is Blockman Go?
-Blockman Go is a free app that includes various block-style mini-games that you can play online with other players from all over the world. You can create your own character and customize it with different outfits and accessories. You can also chat and make friends with other players in the game.
-Some of the mini-games that you can play in Blockman Go are:
--
-