**Notebook: API**
-#
-# ## link to the created HuggingFace Space:
-#
-# # https://huggingface.co/spaces/FadouaFGM/Stackoverflow_Questions_Categorisation
-#
-#
-# ", '', str(text))
- text = re.sub("", '', str(text))
- text = re.sub("
", '', str(text))
- text = re.sub("&", '', str(text))
- text = re.sub(";", '', str(text))
- text = re.sub("gt", ' ', str(text))
- text = re.sub("pre", '', str(text))
- # Removing any reference to outside text
- text = re.sub("[\(\[].*?[\)\]]", "", str(text))
- # Removing numbers
- text = re.sub('[0-9]', '', str(text))
- # Removing new line characters
- text = re.sub('\n ', '', str(text))
- text = re.sub('\n', ' ', str(text))
- # Removing apostrophes
- text = re.sub("'s", '', str(text))
- # Removing hyphens
- text = re.sub("-", ' ', str(text))
- text = re.sub("—", '', str(text))
- # Removing > or < or = signs
- text = re.sub("<", ' ', str(text))
- text = re.sub(">", '', str(text))
- text = re.sub("=", '', str(text))
- # Removing quotation marks
- text = re.sub('\"', '', str(text))
- # Removing quotation marks
- text = re.sub('/', '', str(text))
- # Use regex to delete all what's inside < >
- CLEANR = re.compile('<.*?>')
- text = re.sub(CLEANR, '', text)
-
- return text
-
-def remove_code(text):
-
- #first position of the code in code
- codepointer=text.find('')
- result=''
-
- while codepointer!=-1:
- #last position of /code
- codeender=text.find(u'',codepointer)
- #the code between pointer and ender
- result=result+text[codepointer:codeender+7]
- codepointer=text.find('',codeender)
-
- listOfWords2remove = ([i for i in result.split()])
-
- for i in listOfWords2remove:
- text = text.replace(i, '')
-
- return text
-
-def text_processing(dfoftext):
-
- cleaneddftext = dfoftext.apply(lambda txt : remove_code(txt))
- cleaneddftext = cleaneddftext.apply(lambda txt : clean(txt))
- cleaneddftext = cleaneddftext.apply(lambda txt : lemmatize(txt))
-
- return cleaneddftext
-
-# Define function to predict with the new list of thresholds with attributing a threshold per label
-def predict_with_thresholds(y_prob, thresholds):
- y_pred = np.zeros_like(y_prob)
- for i in range(y_prob.shape[1]):
- y_pred[:, i] = (y_prob[:, i] >= thresholds[i]).astype(int)
- return y_pred
-
-
-import joblib
-
-def makeprediction(text):
- # load the pre-trained TfidfVectorizer from disk
- tfidfvectorizer = joblib.load('tfidf_vectorizer_100523.joblib')
-
- # load the pre-trained Linear_SGD classifier from disk
- ovr = joblib.load('linear_regression_classifier_100523.joblib')
-
- # Processing the text
- cleanedtext = text_processing(text)
- #print(cleanedtext)
- #print(type(cleanedtext))
-
- # applying the model and reconstruction predicted targets
- texttfidf = tfidfvectorizer.transform(cleanedtext)
-
- # make prediction with pretrained classifier
- ypred = ovr.predict_proba(texttfidf)
- #print(ypred)
-
- # recontructing tags from predicted y
- thresholds = joblib.load('thresholds_100523.joblib')
- labels = joblib.load('labels_100523.joblib')
-
- y_pred_thr = predict_with_thresholds(ypred,thresholds)
- #print(y_pred_thr)
-
- tags_pred = [[labels[i] for i in range(len(yp)) if yp[i] == 1] for yp in y_pred_thr]
- #tags_pred = tags_pred.apply(lambda x: x if x else ['no predicted labels'])
-
- # Predict with unsupervised model the most important topics and key words related to the document
- # Load unsupervised pretrained model and dictionary
- lda_model = joblib.load('best_lda_model.joblib')
- lda_dictionary = joblib.load('lda_dictionary.joblib')
-
- # process the document to be a corpus as needed for LDA algorithm
- cleanedtext = pd.Series(cleanedtext)
- text_lda = ' '.join((cleanedtext.tolist()))
- corpus = lda_dictionary.doc2bow(text_lda.split())
-
- # get the topic distribution for the document
- doc_topics = lda_model.get_document_topics(corpus)
-
- # filter topics with probability > 0.2 and sort them by probability
- important_topics = sorted([(topic, prob) for topic, prob in doc_topics if prob > 0.2], key=lambda x: x[1], reverse=True)
-
- # print the most important topics related to the document and their probability
- print('The most important topics related to the document, and there probabilities, are:')
- for topic, prob in important_topics:
- print(f'Topic {topic}: {prob:.2f}')
-
- # get the main keywords for each important topic
- important_topic_ids = [topic for topic, _ in important_topics]
- topic_keywords = lda_model.show_topics(num_topics=-1, formatted=False)
- main_keywords = []
- main_keywords = []
- for topic_id, topic_prob in topic_keywords:
- if topic_id in important_topic_ids:
- keywords = [(word, prob) for word, prob in topic_prob if prob > 0.05]
- main_keywords.append(keywords)
-
- return tags_pred, important_topics, main_keywords
-
-# ### **Implémentation de l'API: GradioAPI**
-import gradio as gra
-from typing import List
-
-def predict(text: List[str]):
- data = [[text]]
- data = pd.DataFrame(data, columns = ['Text'])
- tags, topics, keywords = makeprediction(data['Text'])
- #return {"tags!😎": tags, "Related Topics": topics, "Most important key words": keywords }
- return tags, topics, keywords
-
-inputs = gra.inputs.Textbox(label="Question to predict tags, topics, and keywords", lines=10)
-outputs = [
- gra.outputs.Textbox(label="Tags"),
- gra.outputs.Textbox(label="Related Topics"),
- gra.outputs.Textbox(label="Related Keywords")
-]
-title = "Prediction: Tags, Topics, and Keywords for StackOverflow Questions"
-
-app = gra.Interface(fn=predict, inputs=inputs, outputs=outputs, title=title)
-
-app.launch(debug=True,enable_queue=True)
-
-#link to the created HuggingFace Space
-# https://huggingface.co/spaces/FadouaFGM/Stackoverflow_Questions_Categorisation
-# Process to update parameters of the model or any other changes on notebooks
-# copy all files to the cloned repository
-# cp ../Formation_ML/P5/*.joblib .
-# cp ../Formation_ML/P5/app.py .
-# add all files and commit
-# git add .
-# git commit -m "Update model parameters"
-# git push
-
-#pip freeze > requirements.txt
-
-
-
-
diff --git a/spaces/Fernando22/freegpt-webui/g4f/Provider/Providers/Better.py b/spaces/Fernando22/freegpt-webui/g4f/Provider/Providers/Better.py
deleted file mode 100644
index bee52870eb3300f25c9762ab204968791a2a30a9..0000000000000000000000000000000000000000
--- a/spaces/Fernando22/freegpt-webui/g4f/Provider/Providers/Better.py
+++ /dev/null
@@ -1,56 +0,0 @@
-import os
-import json
-import requests
-from typing import Dict, get_type_hints
-
-url = 'https://openai-proxy-api.vercel.app/v1/'
-model = [
- 'gpt-3.5-turbo',
- 'gpt-3.5-turbo-0613',
- 'gpt-3.5-turbo-16k',
- 'gpt-3.5-turbo-16k-0613',
- 'gpt-4',
-]
-
-supports_stream = True
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- headers = {
- 'Content-Type': 'application/json',
- 'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/114.0.0.0 Safari/537.36 Edg/114.0.1823.58',
- 'Referer': 'https://chat.ylokh.xyz/',
- 'Origin': 'https://chat.ylokh.xyz',
- 'Connection': 'keep-alive',
- }
-
- json_data = {
- 'messages': messages,
- 'temperature': 1.0,
- 'model': model,
- 'stream': stream,
- }
-
- response = requests.post(
- 'https://openai-proxy-api.vercel.app/v1/chat/completions', headers=headers, json=json_data, stream=True
- )
-
- for token in response.iter_lines():
- decoded = token.decode('utf-8')
- if decoded.startswith('data: '):
- data_str = decoded.replace('data: ', '')
- data = json.loads(data_str)
- if 'choices' in data and 'delta' in data['choices'][0]:
- delta = data['choices'][0]['delta']
- content = delta.get('content', '')
- finish_reason = delta.get('finish_reason', '')
-
- if finish_reason == 'stop':
- break
- if content:
- yield content
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/FoxMeo/fire-detector/models/experimental.py b/spaces/FoxMeo/fire-detector/models/experimental.py
deleted file mode 100644
index 735d7aa0ebe7dbf3c4b062ebc3858cb5f9ebab40..0000000000000000000000000000000000000000
--- a/spaces/FoxMeo/fire-detector/models/experimental.py
+++ /dev/null
@@ -1,272 +0,0 @@
-import numpy as np
-import random
-import torch
-import torch.nn as nn
-
-from models.common import Conv, DWConv
-from utils.google_utils import attempt_download
-
-
-class CrossConv(nn.Module):
- # Cross Convolution Downsample
- def __init__(self, c1, c2, k=3, s=1, g=1, e=1.0, shortcut=False):
- # ch_in, ch_out, kernel, stride, groups, expansion, shortcut
- super(CrossConv, self).__init__()
- c_ = int(c2 * e) # hidden channels
- self.cv1 = Conv(c1, c_, (1, k), (1, s))
- self.cv2 = Conv(c_, c2, (k, 1), (s, 1), g=g)
- self.add = shortcut and c1 == c2
-
- def forward(self, x):
- return x + self.cv2(self.cv1(x)) if self.add else self.cv2(self.cv1(x))
-
-
-class Sum(nn.Module):
- # Weighted sum of 2 or more layers https://arxiv.org/abs/1911.09070
- def __init__(self, n, weight=False): # n: number of inputs
- super(Sum, self).__init__()
- self.weight = weight # apply weights boolean
- self.iter = range(n - 1) # iter object
- if weight:
- self.w = nn.Parameter(-torch.arange(1., n) / 2, requires_grad=True) # layer weights
-
- def forward(self, x):
- y = x[0] # no weight
- if self.weight:
- w = torch.sigmoid(self.w) * 2
- for i in self.iter:
- y = y + x[i + 1] * w[i]
- else:
- for i in self.iter:
- y = y + x[i + 1]
- return y
-
-
-class MixConv2d(nn.Module):
- # Mixed Depthwise Conv https://arxiv.org/abs/1907.09595
- def __init__(self, c1, c2, k=(1, 3), s=1, equal_ch=True):
- super(MixConv2d, self).__init__()
- groups = len(k)
- if equal_ch: # equal c_ per group
- i = torch.linspace(0, groups - 1E-6, c2).floor() # c2 indices
- c_ = [(i == g).sum() for g in range(groups)] # intermediate channels
- else: # equal weight.numel() per group
- b = [c2] + [0] * groups
- a = np.eye(groups + 1, groups, k=-1)
- a -= np.roll(a, 1, axis=1)
- a *= np.array(k) ** 2
- a[0] = 1
- c_ = np.linalg.lstsq(a, b, rcond=None)[0].round() # solve for equal weight indices, ax = b
-
- self.m = nn.ModuleList([nn.Conv2d(c1, int(c_[g]), k[g], s, k[g] // 2, bias=False) for g in range(groups)])
- self.bn = nn.BatchNorm2d(c2)
- self.act = nn.LeakyReLU(0.1, inplace=True)
-
- def forward(self, x):
- return x + self.act(self.bn(torch.cat([m(x) for m in self.m], 1)))
-
-
-class Ensemble(nn.ModuleList):
- # Ensemble of models
- def __init__(self):
- super(Ensemble, self).__init__()
-
- def forward(self, x, augment=False):
- y = []
- for module in self:
- y.append(module(x, augment)[0])
- # y = torch.stack(y).max(0)[0] # max ensemble
- # y = torch.stack(y).mean(0) # mean ensemble
- y = torch.cat(y, 1) # nms ensemble
- return y, None # inference, train output
-
-
-
-
-
-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, n_classes=80):
- 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 # if max_wh != 0 : non-agnostic else : agnostic
- 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)
- self.n_classes=n_classes
-
- def forward(self, x):
- boxes = x[:, :, :4]
- conf = x[:, :, 4:5]
- scores = x[:, :, 5:]
- if self.n_classes == 1:
- scores = conf # for models with one class, cls_loss is 0 and cls_conf is always 0.5,
- # so there is no need to multiplicate.
- else:
- scores *= conf # conf = obj_conf * cls_conf
- boxes @= self.convert_matrix
- max_score, category_id = scores.max(2, keepdim=True)
- dis = category_id.float() * self.max_wh
- nmsbox = boxes + dis
- max_score_tp = max_score.transpose(1, 2).contiguous()
- selected_indices = ORT_NMS.apply(nmsbox, max_score_tp, self.max_obj, self.iou_threshold, self.score_threshold)
- X, Y = selected_indices[:, 0], selected_indices[:, 2]
- selected_boxes = boxes[X, Y, :]
- selected_categories = category_id[X, Y, :].float()
- selected_scores = max_score[X, Y, :]
- X = X.unsqueeze(1).float()
- return torch.cat([X, selected_boxes, selected_categories, selected_scores], 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, n_classes=80):
- 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
- self.n_classes=n_classes
-
- def forward(self, x):
- boxes = x[:, :, :4]
- conf = x[:, :, 4:5]
- scores = x[:, :, 5:]
- if self.n_classes == 1:
- scores = conf # for models with one class, cls_loss is 0 and cls_conf is always 0.5,
- # so there is no need to multiplicate.
- else:
- scores *= conf # conf = obj_conf * cls_conf
- num_det, det_boxes, det_scores, det_classes = TRT_NMS.apply(boxes, scores, 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, n_classes=80):
- super().__init__()
- device = device if device else torch.device('cpu')
- assert isinstance(max_wh,(int)) or max_wh is None
- self.model = model.to(device)
- self.model.model[-1].end2end = True
- 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, n_classes)
- self.end2end.eval()
-
- def forward(self, x):
- x = self.model(x)
- x = self.end2end(x)
- return x
-
-
-
-
-
-def attempt_load(weights, map_location=None):
- # Loads an ensemble of models weights=[a,b,c] or a single model weights=[a] or weights=a
- model = Ensemble()
- for w in weights if isinstance(weights, list) else [weights]:
- attempt_download(w)
- ckpt = torch.load(w, map_location=map_location) # load
- model.append(ckpt['ema' if ckpt.get('ema') else 'model'].float().fuse().eval()) # FP32 model
-
- # Compatibility updates
- for m in model.modules():
- if type(m) in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6, nn.SiLU]:
- m.inplace = True # pytorch 1.7.0 compatibility
- elif type(m) is nn.Upsample:
- m.recompute_scale_factor = None # torch 1.11.0 compatibility
- elif type(m) is Conv:
- m._non_persistent_buffers_set = set() # pytorch 1.6.0 compatibility
-
- if len(model) == 1:
- return model[-1] # return model
- else:
- print('Ensemble created with %s\n' % weights)
- for k in ['names', 'stride']:
- setattr(model, k, getattr(model[-1], k))
- return model # return ensemble
-
-
diff --git a/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/thai.py b/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/thai.py
deleted file mode 100644
index 998207c01a85c710a46db1ec8b62c39c2d94bc84..0000000000000000000000000000000000000000
--- a/spaces/FrankZxShen/vits-fast-fineturning-models-ba/text/thai.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import re
-from num_thai.thainumbers import NumThai
-
-
-num = NumThai()
-
-# List of (Latin alphabet, Thai) pairs:
-_latin_to_thai = [(re.compile('%s' % x[0], re.IGNORECASE), x[1]) for x in [
- ('a', 'เอ'),
- ('b','บี'),
- ('c','ซี'),
- ('d','ดี'),
- ('e','อี'),
- ('f','เอฟ'),
- ('g','จี'),
- ('h','เอช'),
- ('i','ไอ'),
- ('j','เจ'),
- ('k','เค'),
- ('l','แอล'),
- ('m','เอ็ม'),
- ('n','เอ็น'),
- ('o','โอ'),
- ('p','พี'),
- ('q','คิว'),
- ('r','แอร์'),
- ('s','เอส'),
- ('t','ที'),
- ('u','ยู'),
- ('v','วี'),
- ('w','ดับเบิลยู'),
- ('x','เอ็กซ์'),
- ('y','วาย'),
- ('z','ซี')
-]]
-
-
-def num_to_thai(text):
- return re.sub(r'(?:\d+(?:,?\d+)?)+(?:\.\d+(?:,?\d+)?)?', lambda x: ''.join(num.NumberToTextThai(float(x.group(0).replace(',', '')))), text)
-
-def latin_to_thai(text):
- for regex, replacement in _latin_to_thai:
- text = re.sub(regex, replacement, text)
- return text
diff --git a/spaces/GIZ/SDSN-demo/utils/ndc_explorer.py b/spaces/GIZ/SDSN-demo/utils/ndc_explorer.py
deleted file mode 100644
index 6bdb527b232ac800156b1c5ca50ddd97e0560d0b..0000000000000000000000000000000000000000
--- a/spaces/GIZ/SDSN-demo/utils/ndc_explorer.py
+++ /dev/null
@@ -1,90 +0,0 @@
-
-import urllib.request
-import json
-
-link = "https://klimalog.die-gdi.de/ndc/open-data/dataset.json"
-def get_document(country_code: str):
- """
- read the country NDC data from
- https://klimalog.die-gdi.de/ndc/open-data/dataset.json
- using the country code.
-
- Params
- -------
- country_code:"""
- with urllib.request.urlopen(link) as urlfile:
- data = json.loads(urlfile.read())
- categoriesData = {}
- categoriesData['categories']= data['categories']
- categoriesData['subcategories']= data['subcategories']
- keys_sub = categoriesData['subcategories'].keys()
- documentType= 'NDCs'
- if documentType in data.keys():
- if country_code in data[documentType].keys():
- get_dict = {}
- for key, value in data[documentType][country_code].items():
- if key not in ['country_name','region_id', 'region_name']:
- get_dict[key] = value['classification']
- else:
- get_dict[key] = value
- else:
- return None
- else:
- return None
-
- country = {}
- for key in categoriesData['categories']:
- country[key]= {}
- for key,value in categoriesData['subcategories'].items():
- country[value['category']][key] = get_dict[key]
-
- return country
-
-
-def countrySpecificCCA(cca_sent:dict, threshold:int, countryCode:str):
- """
- based on the countrycode, reads the country data from
- https://klimalog.die-gdi.de/ndc/open-data/dataset.json
- using get_documents from utils.ndc_explorer.py
- then based on thereshold value filters the Climate Change Adaptation
- targets assigned by NDC explorer team to that country. Using the sentences
- create by Data services team of GIZ for each target level, tries to find the
- relevant passages from the document by doing the semantic search.
-
- Params
- -------
- cca_sent: dictionary with key as 'target labels' and manufactured sentences
- reflecting the target level. Please see the docStore/ndcs/cca.txt
-
- threshold: NDC target have many categoriees ranging from [0-5], with 0
- refelcting most relaxed attitude and 5 being most aggrisive towards Climate
- change. We select the threshold value beyond which we need to focus on.
-
- countryCode: standard country code to allow us to fetch the country specific
- data.
-
- """
- temp = {}
- doc = get_document(countryCode)
- for key,value in cca_sent.items():
- id_ = doc['climate change adaptation'][key]['id']
- if id_ >threshold:
- temp[key] = value['id'][id_]
- return temp
-
-
-def countrySpecificCCM(ccm_sent, threshold, countryCode):
- """
- see the documentation of countrySpecificCCA. This is same instead of
- this gets the data pertaining to Adaptation
-
- """
-
- temp = {}
- doc = get_document(countryCode)
- for key,value in ccm_sent.items():
- id_ = doc['climate change mitigation'][key]['id']
- if id_ >threshold:
- temp[key] = value['id'][id_]
-
- return temp
diff --git a/spaces/Gen-Sim/Gen-Sim/notebooks/print_results.py b/spaces/Gen-Sim/Gen-Sim/notebooks/print_results.py
deleted file mode 100644
index 6ea11091fc06280f613b073f4ffe09382c1141c9..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/notebooks/print_results.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import os
-import sys
-import json
-
-from cliport import agents
-from cliport import tasks
-import argparse
-import datetime
-import matplotlib as mpl
-
-mpl.use("Agg")
-import argparse
-import os
-import pandas as pd
-import seaborn as sns
-import matplotlib.pyplot as plt
-import matplotlib
-import IPython
-import numpy as np
-font = {
- "size": 22,
-}
-matplotlib.rc("font", **font)
-sns.set_context("paper", font_scale=2.0)
-
-
-def mkdir_if_missing(dst_dir):
- if not os.path.exists(dst_dir):
- os.makedirs(dst_dir)
-
-
-def save_figure(name, title=""):
- print(f"output/output_figures/{name}.png")
- if len(title) > 0:
- plt.title(title)
- plt.tight_layout()
- mkdir_if_missing(f"output/output_figures/{name}")
- plt.savefig(f"output/output_figures/{name}/output.png")
- plt.clf()
-
-
-def print_and_write(file_handle, text):
- print(text)
- if file_handle is not None:
- file_handle.write(text + "\n")
- return text
-
-parser = argparse.ArgumentParser()
-
-# federated arguments (Notation for the arguments followed from paper)
-parser.add_argument(
- "--results", "-r", type=str, default="exps/exps-singletask"
-)
-parser.add_argument(
- "--single", "-s", action="store_true", default=False
-)
-args = parser.parse_args()
-
-root_folder = os.environ['GENSIM_ROOT']
-exp_folder = os.path.join(root_folder, args.results) # replace 'cliport_quickstart' with your exps folder
-
-
-mkdir_if_missing('output/output_figures')
-mkdir_if_missing('output/cliport_output')
-mkdir_if_missing('output/output_stat')
-
-
-
-output_stat_file = os.path.join('output/', 'cliport_output/', 'cliport-training.txt')
-mkdir_if_missing('output/cliport_output/')
-file_handle = open(output_stat_file, 'a+')
-
-tasks_list = list(tasks.names.keys())
-agents_list = list(agents.names.keys())
-demos_list = [1, 5, 10, 20, 30, 50, 100, 200, 1000] # 100,
-
-results = {}
-for t in tasks_list:
- for a in agents_list:
- for d in demos_list:
- task_folder = f'{t}-{a}-n{d}-train'
- task_folder_path = os.path.join(exp_folder, task_folder, 'checkpoints')
-
- if os.path.exists(task_folder_path):
- print(f"train {task_folder_path}")
-
- jsons = [f for f in os.listdir(task_folder_path) if '.json' in f]
- for j in jsons:
- model_type = 'multi' if 'multi' in j else 'single'
- eval_type = 'val' if 'val' in j else 'test'
-
- with open(os.path.join(task_folder_path, j)) as f:
- res = json.load(f)
-
- results[f'{t}-{a}-n{d}-{model_type}-{eval_type}'] = res
-
-dt_string = datetime.datetime.now().strftime("%d_%m_%Y_%H:%M:%S")
-print_and_write(file_handle, f"==========================={dt_string}=========================\n")
-print_and_write(file_handle, f'Experiments folder: {exp_folder}\n')
-
-data = {'task': [], 'success': []}
-
-for eval_type in ['val', 'test']:
- print_and_write(file_handle, f'----- {eval_type.upper()} -----\n')
- for t in tasks_list:
- for a in agents_list:
- for d in demos_list:
- for model_type in ['single', 'multi']:
- eval_key = f'{t}-{a}-n{d}-{model_type}-{eval_type}'
-
- if eval_key in results:
- print_and_write(file_handle, f'{eval_key} {t} | Train Demos: {d}')
- res = results[eval_key]
- best_score, best_ckpt = max(zip([v['mean_reward'] for v in list(res.values())], res.keys()))
- # TODO: test that this works for full results folder
-
- print_and_write(file_handle, f'\t{best_score*100:1.1f} : {a} | {model_type}\n')
- data['task'].append(t)
- data['success'].append(best_score)
-
-data['task'].append("Average")
-data['success'].append(np.mean(data["success"]))
-
-
-# make figure as well for sinle expeirment results
-dfs = []
-suffix = ""
-run_num = 0
-df = pd.DataFrame.from_dict(data)
-title = args.results + "_res"
-
-# rewards
-fig, ax = plt.subplots(figsize=(16, 8))
-sns_plot = sns.barplot(
- data=df, x="task", y="success", errorbar=("sd", 1), palette="deep"
-)
-
-# label texts
-for container in ax.containers:
- ax.bar_label(container, label_type="center", fontsize="x-large", fmt="%.2f")
-# ax.set_xticklabels(ax.get_xticklabels(), rotation=90, ha="right")
-ax.set_xticklabels(['\n'.join(str(xlabel.get_text()).split("-")) for xlabel in ax.get_xticklabels()])
-
-# save plot
-save_figure(f"{title}", title)
diff --git a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_gptmixcliport5_new_pickplace_demo10.sh b/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_gptmixcliport5_new_pickplace_demo10.sh
deleted file mode 100644
index 7e36cd7688b092b053a693f33f96244e5a91449d..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train10_gptmixcliport5_new_pickplace_demo10.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-#SBATCH -c 10
-#SBATCH -n 1
-#SBATCH -o logs/%j.out
-#SBATCH --exclusive
-STEPS=${1-'50000'}
-
-
-sh scripts/traintest_scripts/train_test_multi_task_goal_demo10.sh data \
- "[stack-block-pyramid,align-box-corner,put-block-in-bowl,packing-boxes,block-insertion,color_linked_ball_bowl_ordering,color_specific_container_fill,insert_blocks_into_fixture,sort_insert_color_coordinated_blocks,color_ordered_blocks_on_pallet,color-coordinated-sphere-insertion,rainbow-stack,put-block-in-bowl,vertical-insertion-blocks,stack-blocks-in-container]" \
- "[stack-block-pyramid,put-block-in-bowl,align-box-corner,packing-boxes,block-insertion]" \
- gpt10_mixcliport5_task_new
diff --git a/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/preprocess.py b/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/preprocess.py
deleted file mode 100644
index cde325c4163d6800404de214202d773addfff296..0000000000000000000000000000000000000000
--- a/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/preprocess.py
+++ /dev/null
@@ -1,259 +0,0 @@
-from multiprocessing.pool import Pool
-from synthesizer import audio
-from functools import partial
-from itertools import chain
-from encoder import inference as encoder
-from pathlib import Path
-from utils import logmmse
-from tqdm import tqdm
-import numpy as np
-import librosa
-
-
-def preprocess_dataset(datasets_root: Path, out_dir: Path, n_processes: int,
- skip_existing: bool, hparams, no_alignments: bool,
- datasets_name: str, subfolders: str):
- # Gather the input directories
- dataset_root = datasets_root.joinpath(datasets_name)
- input_dirs = [dataset_root.joinpath(subfolder.strip()) for subfolder in subfolders.split(",")]
- print("\n ".join(map(str, ["Using data from:"] + input_dirs)))
- assert all(input_dir.exists() for input_dir in input_dirs)
-
- # Create the output directories for each output file type
- out_dir.joinpath("mels").mkdir(exist_ok=True)
- out_dir.joinpath("audio").mkdir(exist_ok=True)
-
- # Create a metadata file
- metadata_fpath = out_dir.joinpath("train.txt")
- metadata_file = metadata_fpath.open("a" if skip_existing else "w", encoding="utf-8")
-
- # Preprocess the dataset
- speaker_dirs = list(chain.from_iterable(input_dir.glob("*") for input_dir in input_dirs))
- func = partial(preprocess_speaker, out_dir=out_dir, skip_existing=skip_existing,
- hparams=hparams, no_alignments=no_alignments)
- job = Pool(n_processes).imap(func, speaker_dirs)
- for speaker_metadata in tqdm(job, datasets_name, len(speaker_dirs), unit="speakers"):
- for metadatum in speaker_metadata:
- metadata_file.write("|".join(str(x) for x in metadatum) + "\n")
- metadata_file.close()
-
- # Verify the contents of the metadata file
- with metadata_fpath.open("r", encoding="utf-8") as metadata_file:
- metadata = [line.split("|") for line in metadata_file]
- mel_frames = sum([int(m[4]) for m in metadata])
- timesteps = sum([int(m[3]) for m in metadata])
- sample_rate = hparams.sample_rate
- hours = (timesteps / sample_rate) / 3600
- print("The dataset consists of %d utterances, %d mel frames, %d audio timesteps (%.2f hours)." %
- (len(metadata), mel_frames, timesteps, hours))
- print("Max input length (text chars): %d" % max(len(m[5]) for m in metadata))
- print("Max mel frames length: %d" % max(int(m[4]) for m in metadata))
- print("Max audio timesteps length: %d" % max(int(m[3]) for m in metadata))
-
-
-def preprocess_speaker(speaker_dir, out_dir: Path, skip_existing: bool, hparams, no_alignments: bool):
- metadata = []
- for book_dir in speaker_dir.glob("*"):
- if no_alignments:
- # Gather the utterance audios and texts
- # LibriTTS uses .wav but we will include extensions for compatibility with other datasets
- extensions = ["*.wav", "*.flac", "*.mp3"]
- for extension in extensions:
- wav_fpaths = book_dir.glob(extension)
-
- for wav_fpath in wav_fpaths:
- # Load the audio waveform
- wav, _ = librosa.load(str(wav_fpath), hparams.sample_rate)
- if hparams.rescale:
- wav = wav / np.abs(wav).max() * hparams.rescaling_max
-
- # Get the corresponding text
- # Check for .txt (for compatibility with other datasets)
- text_fpath = wav_fpath.with_suffix(".txt")
- if not text_fpath.exists():
- # Check for .normalized.txt (LibriTTS)
- text_fpath = wav_fpath.with_suffix(".normalized.txt")
- assert text_fpath.exists()
- with text_fpath.open("r") as text_file:
- text = "".join([line for line in text_file])
- text = text.replace("\"", "")
- text = text.strip()
-
- # Process the utterance
- metadata.append(process_utterance(wav, text, out_dir, str(wav_fpath.with_suffix("").name),
- skip_existing, hparams))
- else:
- # Process alignment file (LibriSpeech support)
- # Gather the utterance audios and texts
- try:
- alignments_fpath = next(book_dir.glob("*.alignment.txt"))
- with alignments_fpath.open("r") as alignments_file:
- alignments = [line.rstrip().split(" ") for line in alignments_file]
- except StopIteration:
- # A few alignment files will be missing
- continue
-
- # Iterate over each entry in the alignments file
- for wav_fname, words, end_times in alignments:
- wav_fpath = book_dir.joinpath(wav_fname + ".flac")
- assert wav_fpath.exists()
- words = words.replace("\"", "").split(",")
- end_times = list(map(float, end_times.replace("\"", "").split(",")))
-
- # Process each sub-utterance
- wavs, texts = split_on_silences(wav_fpath, words, end_times, hparams)
- for i, (wav, text) in enumerate(zip(wavs, texts)):
- sub_basename = "%s_%02d" % (wav_fname, i)
- metadata.append(process_utterance(wav, text, out_dir, sub_basename,
- skip_existing, hparams))
-
- return [m for m in metadata if m is not None]
-
-
-def split_on_silences(wav_fpath, words, end_times, hparams):
- # Load the audio waveform
- wav, _ = librosa.load(str(wav_fpath), hparams.sample_rate)
- if hparams.rescale:
- wav = wav / np.abs(wav).max() * hparams.rescaling_max
-
- words = np.array(words)
- start_times = np.array([0.0] + end_times[:-1])
- end_times = np.array(end_times)
- assert len(words) == len(end_times) == len(start_times)
- assert words[0] == "" and words[-1] == ""
-
- # Find pauses that are too long
- mask = (words == "") & (end_times - start_times >= hparams.silence_min_duration_split)
- mask[0] = mask[-1] = True
- breaks = np.where(mask)[0]
-
- # Profile the noise from the silences and perform noise reduction on the waveform
- silence_times = [[start_times[i], end_times[i]] for i in breaks]
- silence_times = (np.array(silence_times) * hparams.sample_rate).astype(np.int)
- noisy_wav = np.concatenate([wav[stime[0]:stime[1]] for stime in silence_times])
- if len(noisy_wav) > hparams.sample_rate * 0.02:
- profile = logmmse.profile_noise(noisy_wav, hparams.sample_rate)
- wav = logmmse.denoise(wav, profile, eta=0)
-
- # Re-attach segments that are too short
- segments = list(zip(breaks[:-1], breaks[1:]))
- segment_durations = [start_times[end] - end_times[start] for start, end in segments]
- i = 0
- while i < len(segments) and len(segments) > 1:
- if segment_durations[i] < hparams.utterance_min_duration:
- # See if the segment can be re-attached with the right or the left segment
- left_duration = float("inf") if i == 0 else segment_durations[i - 1]
- right_duration = float("inf") if i == len(segments) - 1 else segment_durations[i + 1]
- joined_duration = segment_durations[i] + min(left_duration, right_duration)
-
- # Do not re-attach if it causes the joined utterance to be too long
- if joined_duration > hparams.hop_size * hparams.max_mel_frames / hparams.sample_rate:
- i += 1
- continue
-
- # Re-attach the segment with the neighbour of shortest duration
- j = i - 1 if left_duration <= right_duration else i
- segments[j] = (segments[j][0], segments[j + 1][1])
- segment_durations[j] = joined_duration
- del segments[j + 1], segment_durations[j + 1]
- else:
- i += 1
-
- # Split the utterance
- segment_times = [[end_times[start], start_times[end]] for start, end in segments]
- segment_times = (np.array(segment_times) * hparams.sample_rate).astype(np.int)
- wavs = [wav[segment_time[0]:segment_time[1]] for segment_time in segment_times]
- texts = [" ".join(words[start + 1:end]).replace(" ", " ") for start, end in segments]
-
- # # DEBUG: play the audio segments (run with -n=1)
- # import sounddevice as sd
- # if len(wavs) > 1:
- # print("This sentence was split in %d segments:" % len(wavs))
- # else:
- # print("There are no silences long enough for this sentence to be split:")
- # for wav, text in zip(wavs, texts):
- # # Pad the waveform with 1 second of silence because sounddevice tends to cut them early
- # # when playing them. You shouldn't need to do that in your parsers.
- # wav = np.concatenate((wav, [0] * 16000))
- # print("\t%s" % text)
- # sd.play(wav, 16000, blocking=True)
- # print("")
-
- return wavs, texts
-
-
-def process_utterance(wav: np.ndarray, text: str, out_dir: Path, basename: str,
- skip_existing: bool, hparams):
- ## FOR REFERENCE:
- # For you not to lose your head if you ever wish to change things here or implement your own
- # synthesizer.
- # - Both the audios and the mel spectrograms are saved as numpy arrays
- # - There is no processing done to the audios that will be saved to disk beyond volume
- # normalization (in split_on_silences)
- # - However, pre-emphasis is applied to the audios before computing the mel spectrogram. This
- # is why we re-apply it on the audio on the side of the vocoder.
- # - Librosa pads the waveform before computing the mel spectrogram. Here, the waveform is saved
- # without extra padding. This means that you won't have an exact relation between the length
- # of the wav and of the mel spectrogram. See the vocoder data loader.
-
-
- # Skip existing utterances if needed
- mel_fpath = out_dir.joinpath("mels", "mel-%s.npy" % basename)
- wav_fpath = out_dir.joinpath("audio", "audio-%s.npy" % basename)
- if skip_existing and mel_fpath.exists() and wav_fpath.exists():
- return None
-
- # Trim silence
- if hparams.trim_silence:
- wav = encoder.preprocess_wav(wav, normalize=False, trim_silence=True)
-
- # Skip utterances that are too short
- if len(wav) < hparams.utterance_min_duration * hparams.sample_rate:
- return None
-
- # Compute the mel spectrogram
- mel_spectrogram = audio.melspectrogram(wav, hparams).astype(np.float32)
- mel_frames = mel_spectrogram.shape[1]
-
- # Skip utterances that are too long
- if mel_frames > hparams.max_mel_frames and hparams.clip_mels_length:
- return None
-
- # Write the spectrogram, embed and audio to disk
- np.save(mel_fpath, mel_spectrogram.T, allow_pickle=False)
- np.save(wav_fpath, wav, allow_pickle=False)
-
- # Return a tuple describing this training example
- return wav_fpath.name, mel_fpath.name, "embed-%s.npy" % basename, len(wav), mel_frames, text
-
-
-def embed_utterance(fpaths, encoder_model_fpath):
- if not encoder.is_loaded():
- encoder.load_model(encoder_model_fpath)
-
- # Compute the speaker embedding of the utterance
- wav_fpath, embed_fpath = fpaths
- wav = np.load(wav_fpath)
- wav = encoder.preprocess_wav(wav)
- embed = encoder.embed_utterance(wav)
- np.save(embed_fpath, embed, allow_pickle=False)
-
-
-def create_embeddings(synthesizer_root: Path, encoder_model_fpath: Path, n_processes: int):
- wav_dir = synthesizer_root.joinpath("audio")
- metadata_fpath = synthesizer_root.joinpath("train.txt")
- assert wav_dir.exists() and metadata_fpath.exists()
- embed_dir = synthesizer_root.joinpath("embeds")
- embed_dir.mkdir(exist_ok=True)
-
- # Gather the input wave filepath and the target output embed filepath
- with metadata_fpath.open("r") as metadata_file:
- metadata = [line.split("|") for line in metadata_file]
- fpaths = [(wav_dir.joinpath(m[0]), embed_dir.joinpath(m[2])) for m in metadata]
-
- # TODO: improve on the multiprocessing, it's terrible. Disk I/O is the bottleneck here.
- # Embed the utterances in separate threads
- func = partial(embed_utterance, encoder_model_fpath=encoder_model_fpath)
- job = Pool(n_processes).imap(func, fpaths)
- list(tqdm(job, "Embedding", len(fpaths), unit="utterances"))
-
diff --git a/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/utils/__init__.py b/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/utils/__init__.py
deleted file mode 100644
index 5ae3e48110e61231acf1e666e5fa76af5e4ebdcd..0000000000000000000000000000000000000000
--- a/spaces/GipAdonimus/Real-Time-Voice-Cloning/synthesizer/utils/__init__.py
+++ /dev/null
@@ -1,45 +0,0 @@
-import torch
-
-
-_output_ref = None
-_replicas_ref = None
-
-def data_parallel_workaround(model, *input):
- global _output_ref
- global _replicas_ref
- device_ids = list(range(torch.cuda.device_count()))
- output_device = device_ids[0]
- replicas = torch.nn.parallel.replicate(model, device_ids)
- # input.shape = (num_args, batch, ...)
- inputs = torch.nn.parallel.scatter(input, device_ids)
- # inputs.shape = (num_gpus, num_args, batch/num_gpus, ...)
- replicas = replicas[:len(inputs)]
- outputs = torch.nn.parallel.parallel_apply(replicas, inputs)
- y_hat = torch.nn.parallel.gather(outputs, output_device)
- _output_ref = outputs
- _replicas_ref = replicas
- return y_hat
-
-
-class ValueWindow():
- def __init__(self, window_size=100):
- self._window_size = window_size
- self._values = []
-
- def append(self, x):
- self._values = self._values[-(self._window_size - 1):] + [x]
-
- @property
- def sum(self):
- return sum(self._values)
-
- @property
- def count(self):
- return len(self._values)
-
- @property
- def average(self):
- return self.sum / max(1, self.count)
-
- def reset(self):
- self._values = []
diff --git a/spaces/Goutam982/RVC_V2_voice_clone/lib/infer_pack/models_onnx.py b/spaces/Goutam982/RVC_V2_voice_clone/lib/infer_pack/models_onnx.py
deleted file mode 100644
index 963e67b29f828e9fdd096397952054fe77cf3d10..0000000000000000000000000000000000000000
--- a/spaces/Goutam982/RVC_V2_voice_clone/lib/infer_pack/models_onnx.py
+++ /dev/null
@@ -1,819 +0,0 @@
-import math, pdb, os
-from time import time as ttime
-import torch
-from torch import nn
-from torch.nn import functional as F
-from lib.infer_pack import modules
-from lib.infer_pack import attentions
-from lib.infer_pack import commons
-from lib.infer_pack.commons import init_weights, get_padding
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from lib.infer_pack.commons import init_weights
-import numpy as np
-from lib.infer_pack import commons
-
-
-class TextEncoder256(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(256, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class TextEncoder768(nn.Module):
- def __init__(
- self,
- out_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- f0=True,
- ):
- super().__init__()
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.emb_phone = nn.Linear(768, hidden_channels)
- self.lrelu = nn.LeakyReLU(0.1, inplace=True)
- if f0 == True:
- self.emb_pitch = nn.Embedding(256, hidden_channels) # pitch 256
- self.encoder = attentions.Encoder(
- hidden_channels, filter_channels, n_heads, n_layers, kernel_size, p_dropout
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, phone, pitch, lengths):
- if pitch == None:
- x = self.emb_phone(phone)
- else:
- x = self.emb_phone(phone) + self.emb_pitch(pitch)
- x = x * math.sqrt(self.hidden_channels) # [b, t, h]
- x = self.lrelu(x)
- x = torch.transpose(x, 1, -1) # [b, h, t]
- x_mask = torch.unsqueeze(commons.sequence_mask(lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.encoder(x * x_mask, x_mask)
- stats = self.proj(x) * x_mask
-
- m, logs = torch.split(stats, self.out_channels, dim=1)
- return m, logs, x_mask
-
-
-class ResidualCouplingBlock(nn.Module):
- def __init__(
- self,
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- n_flows=4,
- gin_channels=0,
- ):
- super().__init__()
- self.channels = channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.n_flows = n_flows
- self.gin_channels = gin_channels
-
- self.flows = nn.ModuleList()
- for i in range(n_flows):
- self.flows.append(
- modules.ResidualCouplingLayer(
- channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- mean_only=True,
- )
- )
- self.flows.append(modules.Flip())
-
- def forward(self, x, x_mask, g=None, reverse=False):
- if not reverse:
- for flow in self.flows:
- x, _ = flow(x, x_mask, g=g, reverse=reverse)
- else:
- for flow in reversed(self.flows):
- x = flow(x, x_mask, g=g, reverse=reverse)
- return x
-
- def remove_weight_norm(self):
- for i in range(self.n_flows):
- self.flows[i * 2].remove_weight_norm()
-
-
-class PosteriorEncoder(nn.Module):
- def __init__(
- self,
- in_channels,
- out_channels,
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=0,
- ):
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.hidden_channels = hidden_channels
- self.kernel_size = kernel_size
- self.dilation_rate = dilation_rate
- self.n_layers = n_layers
- self.gin_channels = gin_channels
-
- self.pre = nn.Conv1d(in_channels, hidden_channels, 1)
- self.enc = modules.WN(
- hidden_channels,
- kernel_size,
- dilation_rate,
- n_layers,
- gin_channels=gin_channels,
- )
- self.proj = nn.Conv1d(hidden_channels, out_channels * 2, 1)
-
- def forward(self, x, x_lengths, g=None):
- x_mask = torch.unsqueeze(commons.sequence_mask(x_lengths, x.size(2)), 1).to(
- x.dtype
- )
- x = self.pre(x) * x_mask
- x = self.enc(x, x_mask, g=g)
- stats = self.proj(x) * x_mask
- m, logs = torch.split(stats, self.out_channels, dim=1)
- z = (m + torch.randn_like(m) * torch.exp(logs)) * x_mask
- return z, m, logs, x_mask
-
- def remove_weight_norm(self):
- self.enc.remove_weight_norm()
-
-
-class Generator(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=0,
- ):
- super(Generator, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- def forward(self, x, g=None):
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
-
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-class SineGen(torch.nn.Module):
- """Definition of sine generator
- SineGen(samp_rate, harmonic_num = 0,
- sine_amp = 0.1, noise_std = 0.003,
- voiced_threshold = 0,
- flag_for_pulse=False)
- samp_rate: sampling rate in Hz
- harmonic_num: number of harmonic overtones (default 0)
- sine_amp: amplitude of sine-wavefrom (default 0.1)
- noise_std: std of Gaussian noise (default 0.003)
- voiced_thoreshold: F0 threshold for U/V classification (default 0)
- flag_for_pulse: this SinGen is used inside PulseGen (default False)
- Note: when flag_for_pulse is True, the first time step of a voiced
- segment is always sin(np.pi) or cos(0)
- """
-
- def __init__(
- self,
- samp_rate,
- harmonic_num=0,
- sine_amp=0.1,
- noise_std=0.003,
- voiced_threshold=0,
- flag_for_pulse=False,
- ):
- super(SineGen, self).__init__()
- self.sine_amp = sine_amp
- self.noise_std = noise_std
- self.harmonic_num = harmonic_num
- self.dim = self.harmonic_num + 1
- self.sampling_rate = samp_rate
- self.voiced_threshold = voiced_threshold
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = torch.ones_like(f0)
- uv = uv * (f0 > self.voiced_threshold)
- return uv
-
- def forward(self, f0, upp):
- """sine_tensor, uv = forward(f0)
- input F0: tensor(batchsize=1, length, dim=1)
- f0 for unvoiced steps should be 0
- output sine_tensor: tensor(batchsize=1, length, dim)
- output uv: tensor(batchsize=1, length, 1)
- """
- with torch.no_grad():
- f0 = f0[:, None].transpose(1, 2)
- f0_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim, device=f0.device)
- # fundamental component
- f0_buf[:, :, 0] = f0[:, :, 0]
- for idx in np.arange(self.harmonic_num):
- f0_buf[:, :, idx + 1] = f0_buf[:, :, 0] * (
- idx + 2
- ) # idx + 2: the (idx+1)-th overtone, (idx+2)-th harmonic
- rad_values = (f0_buf / self.sampling_rate) % 1 ###%1意味着n_har的乘积无法后处理优化
- rand_ini = torch.rand(
- f0_buf.shape[0], f0_buf.shape[2], device=f0_buf.device
- )
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
- tmp_over_one = torch.cumsum(rad_values, 1) # % 1 #####%1意味着后面的cumsum无法再优化
- tmp_over_one *= upp
- tmp_over_one = F.interpolate(
- tmp_over_one.transpose(2, 1),
- scale_factor=upp,
- mode="linear",
- align_corners=True,
- ).transpose(2, 1)
- rad_values = F.interpolate(
- rad_values.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(
- 2, 1
- ) #######
- tmp_over_one %= 1
- tmp_over_one_idx = (tmp_over_one[:, 1:, :] - tmp_over_one[:, :-1, :]) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
- sine_waves = torch.sin(
- torch.cumsum(rad_values + cumsum_shift, dim=1) * 2 * np.pi
- )
- sine_waves = sine_waves * self.sine_amp
- uv = self._f02uv(f0)
- uv = F.interpolate(
- uv.transpose(2, 1), scale_factor=upp, mode="nearest"
- ).transpose(2, 1)
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
- sine_waves = sine_waves * uv + noise
- return sine_waves, uv, noise
-
-
-class SourceModuleHnNSF(torch.nn.Module):
- """SourceModule for hn-nsf
- SourceModule(sampling_rate, harmonic_num=0, sine_amp=0.1,
- add_noise_std=0.003, voiced_threshod=0)
- sampling_rate: sampling_rate in Hz
- harmonic_num: number of harmonic above F0 (default: 0)
- sine_amp: amplitude of sine source signal (default: 0.1)
- add_noise_std: std of additive Gaussian noise (default: 0.003)
- note that amplitude of noise in unvoiced is decided
- by sine_amp
- voiced_threshold: threhold to set U/V given F0 (default: 0)
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- uv (batchsize, length, 1)
- """
-
- def __init__(
- self,
- sampling_rate,
- harmonic_num=0,
- sine_amp=0.1,
- add_noise_std=0.003,
- voiced_threshod=0,
- is_half=True,
- ):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
- self.is_half = is_half
- # to produce sine waveforms
- self.l_sin_gen = SineGen(
- sampling_rate, harmonic_num, sine_amp, add_noise_std, voiced_threshod
- )
-
- # to merge source harmonics into a single excitation
- self.l_linear = torch.nn.Linear(harmonic_num + 1, 1)
- self.l_tanh = torch.nn.Tanh()
-
- def forward(self, x, upp=None):
- sine_wavs, uv, _ = self.l_sin_gen(x, upp)
- if self.is_half:
- sine_wavs = sine_wavs.half()
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
- return sine_merge, None, None # noise, uv
-
-
-class GeneratorNSF(torch.nn.Module):
- def __init__(
- self,
- initial_channel,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels,
- sr,
- is_half=False,
- ):
- super(GeneratorNSF, self).__init__()
- self.num_kernels = len(resblock_kernel_sizes)
- self.num_upsamples = len(upsample_rates)
-
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(upsample_rates))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=sr, harmonic_num=0, is_half=is_half
- )
- self.noise_convs = nn.ModuleList()
- self.conv_pre = Conv1d(
- initial_channel, upsample_initial_channel, 7, 1, padding=3
- )
- resblock = modules.ResBlock1 if resblock == "1" else modules.ResBlock2
-
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(upsample_rates, upsample_kernel_sizes)):
- c_cur = upsample_initial_channel // (2 ** (i + 1))
- self.ups.append(
- weight_norm(
- ConvTranspose1d(
- upsample_initial_channel // (2**i),
- upsample_initial_channel // (2 ** (i + 1)),
- k,
- u,
- padding=(k - u) // 2,
- )
- )
- )
- if i + 1 < len(upsample_rates):
- stride_f0 = np.prod(upsample_rates[i + 1 :])
- self.noise_convs.append(
- Conv1d(
- 1,
- c_cur,
- kernel_size=stride_f0 * 2,
- stride=stride_f0,
- padding=stride_f0 // 2,
- )
- )
- else:
- self.noise_convs.append(Conv1d(1, c_cur, kernel_size=1))
-
- self.resblocks = nn.ModuleList()
- for i in range(len(self.ups)):
- ch = upsample_initial_channel // (2 ** (i + 1))
- for j, (k, d) in enumerate(
- zip(resblock_kernel_sizes, resblock_dilation_sizes)
- ):
- self.resblocks.append(resblock(ch, k, d))
-
- self.conv_post = Conv1d(ch, 1, 7, 1, padding=3, bias=False)
- self.ups.apply(init_weights)
-
- if gin_channels != 0:
- self.cond = nn.Conv1d(gin_channels, upsample_initial_channel, 1)
-
- self.upp = np.prod(upsample_rates)
-
- def forward(self, x, f0, g=None):
- har_source, noi_source, uv = self.m_source(f0, self.upp)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- if g is not None:
- x = x + self.cond(g)
-
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- x = x + x_source
- xs = None
- for j in range(self.num_kernels):
- if xs is None:
- xs = self.resblocks[i * self.num_kernels + j](x)
- else:
- xs += self.resblocks[i * self.num_kernels + j](x)
- x = xs / self.num_kernels
- x = F.leaky_relu(x)
- x = self.conv_post(x)
- x = torch.tanh(x)
- return x
-
- def remove_weight_norm(self):
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
-
-
-sr2sr = {
- "32k": 32000,
- "40k": 40000,
- "48k": 48000,
-}
-
-
-class SynthesizerTrnMsNSFsidM(nn.Module):
- def __init__(
- self,
- spec_channels,
- segment_size,
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- spk_embed_dim,
- gin_channels,
- sr,
- version,
- **kwargs
- ):
- super().__init__()
- if type(sr) == type("strr"):
- sr = sr2sr[sr]
- self.spec_channels = spec_channels
- self.inter_channels = inter_channels
- self.hidden_channels = hidden_channels
- self.filter_channels = filter_channels
- self.n_heads = n_heads
- self.n_layers = n_layers
- self.kernel_size = kernel_size
- self.p_dropout = p_dropout
- self.resblock = resblock
- self.resblock_kernel_sizes = resblock_kernel_sizes
- self.resblock_dilation_sizes = resblock_dilation_sizes
- self.upsample_rates = upsample_rates
- self.upsample_initial_channel = upsample_initial_channel
- self.upsample_kernel_sizes = upsample_kernel_sizes
- self.segment_size = segment_size
- self.gin_channels = gin_channels
- # self.hop_length = hop_length#
- self.spk_embed_dim = spk_embed_dim
- if version == "v1":
- self.enc_p = TextEncoder256(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- else:
- self.enc_p = TextEncoder768(
- inter_channels,
- hidden_channels,
- filter_channels,
- n_heads,
- n_layers,
- kernel_size,
- p_dropout,
- )
- self.dec = GeneratorNSF(
- inter_channels,
- resblock,
- resblock_kernel_sizes,
- resblock_dilation_sizes,
- upsample_rates,
- upsample_initial_channel,
- upsample_kernel_sizes,
- gin_channels=gin_channels,
- sr=sr,
- is_half=kwargs["is_half"],
- )
- self.enc_q = PosteriorEncoder(
- spec_channels,
- inter_channels,
- hidden_channels,
- 5,
- 1,
- 16,
- gin_channels=gin_channels,
- )
- self.flow = ResidualCouplingBlock(
- inter_channels, hidden_channels, 5, 1, 3, gin_channels=gin_channels
- )
- self.emb_g = nn.Embedding(self.spk_embed_dim, gin_channels)
- self.speaker_map = None
- print("gin_channels:", gin_channels, "self.spk_embed_dim:", self.spk_embed_dim)
-
- def remove_weight_norm(self):
- self.dec.remove_weight_norm()
- self.flow.remove_weight_norm()
- self.enc_q.remove_weight_norm()
-
- def construct_spkmixmap(self, n_speaker):
- self.speaker_map = torch.zeros((n_speaker, 1, 1, self.gin_channels))
- for i in range(n_speaker):
- self.speaker_map[i] = self.emb_g(torch.LongTensor([[i]]))
- self.speaker_map = self.speaker_map.unsqueeze(0)
-
- def forward(self, phone, phone_lengths, pitch, nsff0, g, rnd, max_len=None):
- if self.speaker_map is not None: # [N, S] * [S, B, 1, H]
- g = g.reshape((g.shape[0], g.shape[1], 1, 1, 1)) # [N, S, B, 1, 1]
- g = g * self.speaker_map # [N, S, B, 1, H]
- g = torch.sum(g, dim=1) # [N, 1, B, 1, H]
- g = g.transpose(0, -1).transpose(0, -2).squeeze(0) # [B, H, N]
- else:
- g = g.unsqueeze(0)
- g = self.emb_g(g).transpose(1, 2)
-
- m_p, logs_p, x_mask = self.enc_p(phone, pitch, phone_lengths)
- z_p = (m_p + torch.exp(logs_p) * rnd) * x_mask
- z = self.flow(z_p, x_mask, g=g, reverse=True)
- o = self.dec((z * x_mask)[:, :, :max_len], nsff0, g=g)
- return o
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminator, self).__init__()
- periods = [2, 3, 5, 7, 11, 17]
- # periods = [3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class MultiPeriodDiscriminatorV2(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(MultiPeriodDiscriminatorV2, self).__init__()
- # periods = [2, 3, 5, 7, 11, 17]
- periods = [2, 3, 5, 7, 11, 17, 23, 37]
-
- discs = [DiscriminatorS(use_spectral_norm=use_spectral_norm)]
- discs = discs + [
- DiscriminatorP(i, use_spectral_norm=use_spectral_norm) for i in periods
- ]
- self.discriminators = nn.ModuleList(discs)
-
- def forward(self, y, y_hat):
- y_d_rs = [] #
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- # for j in range(len(fmap_r)):
- # print(i,j,y.shape,y_hat.shape,fmap_r[j].shape,fmap_g[j].shape)
- y_d_rs.append(y_d_r)
- y_d_gs.append(y_d_g)
- fmap_rs.append(fmap_r)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class DiscriminatorS(torch.nn.Module):
- def __init__(self, use_spectral_norm=False):
- super(DiscriminatorS, self).__init__()
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(Conv1d(1, 16, 15, 1, padding=7)),
- norm_f(Conv1d(16, 64, 41, 4, groups=4, padding=20)),
- norm_f(Conv1d(64, 256, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(256, 1024, 41, 4, groups=64, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 4, groups=256, padding=20)),
- norm_f(Conv1d(1024, 1024, 5, 1, padding=2)),
- ]
- )
- self.conv_post = norm_f(Conv1d(1024, 1, 3, 1, padding=1))
-
- def forward(self, x):
- fmap = []
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- self.use_spectral_norm = use_spectral_norm
- norm_f = weight_norm if use_spectral_norm == False else spectral_norm
- self.convs = nn.ModuleList(
- [
- norm_f(
- Conv2d(
- 1,
- 32,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 32,
- 128,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 128,
- 512,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 512,
- 1024,
- (kernel_size, 1),
- (stride, 1),
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- norm_f(
- Conv2d(
- 1024,
- 1024,
- (kernel_size, 1),
- 1,
- padding=(get_padding(kernel_size, 1), 0),
- )
- ),
- ]
- )
- self.conv_post = norm_f(Conv2d(1024, 1, (3, 1), 1, padding=(1, 0)))
-
- def forward(self, x):
- fmap = []
-
- # 1d to 2d
- b, c, t = x.shape
- if t % self.period != 0: # pad first
- n_pad = self.period - (t % self.period)
- x = F.pad(x, (0, n_pad), "reflect")
- t = t + n_pad
- x = x.view(b, c, t // self.period, self.period)
-
- for l in self.convs:
- x = l(x)
- x = F.leaky_relu(x, modules.LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco.py
deleted file mode 100644
index c9a035f15cfad12ddbbfa87ed0d579c1cde0c4ce..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_faster_x101_32x4d_fpn_1x_coco.py
+++ /dev/null
@@ -1,13 +0,0 @@
-_base_ = './ga_faster_r50_fpn_1x_coco.py'
-model = dict(
- pretrained='open-mmlab://resnext101_32x4d',
- backbone=dict(
- type='ResNeXt',
- depth=101,
- groups=32,
- base_width=4,
- num_stages=4,
- out_indices=(0, 1, 2, 3),
- frozen_stages=1,
- norm_cfg=dict(type='BN', requires_grad=True),
- style='pytorch'))
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco.py
deleted file mode 100644
index 0048965d5b4d2257eed860f9bd69256795b44fa6..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/guided_anchoring/ga_retinanet_r101_caffe_fpn_1x_coco.py
+++ /dev/null
@@ -1,4 +0,0 @@
-_base_ = './ga_retinanet_r50_caffe_fpn_1x_coco.py'
-model = dict(
- pretrained='open-mmlab://detectron2/resnet101_caffe',
- backbone=dict(depth=101))
diff --git a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/metrics/clap_consistency.py b/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/metrics/clap_consistency.py
deleted file mode 100644
index d2a6c61ae177533ca2fb17e25bc77d2acbbe3791..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/AudioCraft_Plus/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/GrandaddyShmax/AudioCraft_Plus/audiocraft/optim/ema.py b/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/optim/ema.py
deleted file mode 100644
index 4337eaff066a8ca124dca3e3e63ee36e417c055c..0000000000000000000000000000000000000000
--- a/spaces/GrandaddyShmax/AudioCraft_Plus/audiocraft/optim/ema.py
+++ /dev/null
@@ -1,85 +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.
-
-# ModelEMA implementation is taken from
-# https://github.com/facebookresearch/demucs
-
-from collections import defaultdict
-import typing as tp
-
-import torch
-import torch.nn as nn
-
-
-def _get_all_non_persistent_buffers_set(module: nn.Module, root: str = "") -> set:
- names: set = set()
- for (name, sub_module) in module.named_modules():
- if name == '':
- buffer_names = module._non_persistent_buffers_set
- buffer_names = {f"{root}.{buff_name}" if len(root) > 0 else buff_name
- for buff_name in buffer_names}
- names.update(buffer_names)
- else:
- sub_name = f"{root}.{name}" if len(root) > 0 else name
- sub_buffer_names = _get_all_non_persistent_buffers_set(sub_module, sub_name)
- names.update(sub_buffer_names)
- return names
-
-
-def _get_named_tensors(module: nn.Module):
- non_persistent_buffers_set = _get_all_non_persistent_buffers_set(module)
- named_buffers = [(name, buffer) for (name, buffer) in module.named_buffers()
- if name not in non_persistent_buffers_set]
- named_parameters = list(module.named_parameters())
- return named_parameters + named_buffers
-
-
-class ModuleDictEMA:
- """Exponential Moving Average over a nn.ModuleDict.
-
- You can switch to the EMA weights temporarily.
- """
- def __init__(self, module_dict: nn.ModuleDict, decay: float = 0.999,
- unbias: bool = True, device: tp.Union[torch.device, str] = 'cpu'):
- self.decay = decay
- self.module_dict = module_dict
- self.state: dict = defaultdict(dict)
- self.count = 0
- self.device = device
- self.unbias = unbias
- self._init()
-
- def _init(self):
- for module_name, module in self.module_dict.items():
- for key, val in _get_named_tensors(module):
- if not val.is_floating_point():
- continue
- device = self.device or val.device
- if key not in self.state[module_name]:
- self.state[module_name][key] = val.detach().to(device, copy=True)
-
- def step(self):
- if self.unbias:
- self.count = self.count * self.decay + 1
- w = 1 / self.count
- else:
- w = 1 - self.decay
- for module_name, module in self.module_dict.items():
- for key, val in _get_named_tensors(module):
- if not val.is_floating_point():
- continue
- device = self.device or val.device
- self.state[module_name][key].mul_(1 - w)
- self.state[module_name][key].add_(val.detach().to(device), alpha=w)
-
- def state_dict(self):
- return {'state': self.state, 'count': self.count}
-
- def load_state_dict(self, state):
- self.count = state['count']
- for module_name, module in state['state'].items():
- for key, val in module.items():
- self.state[module_name][key].copy_(val)
diff --git a/spaces/HaloMaster/chinesesummary/fengshen/examples/zen2_finetune/fs_zen2_large_iflytek.sh b/spaces/HaloMaster/chinesesummary/fengshen/examples/zen2_finetune/fs_zen2_large_iflytek.sh
deleted file mode 100644
index 7afd7b24d27ddd1a6834935222a100351111d570..0000000000000000000000000000000000000000
--- a/spaces/HaloMaster/chinesesummary/fengshen/examples/zen2_finetune/fs_zen2_large_iflytek.sh
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/bin/bash
-#SBATCH --job-name=zen2_large_iflytek # create a short name for your job
-#SBATCH --nodes=1 # node count
-#SBATCH --ntasks=1 # total number of tasks across all nodes
-#SBATCH --cpus-per-task=30 # cpu-cores per task (>1 if multi-threaded tasks)
-#SBATCH --gres=gpu:1 # number of gpus per node
-#SBATCH --mail-type=ALL # send email when job begins, ends or failed etc.
-#SBATCH -o %x-%j.log # output and error file name (%x=job name, %j=job id)
-
-
-export CUDA_VISIBLE_DEVICES='5'
-export TORCH_EXTENSIONS_DIR=/cognitive_comp/ganruyi/tmp/torch_extendsions
-
-MODEL_NAME=zen2_large
-
-TASK=iflytek
-
-ZERO_STAGE=1
-STRATEGY=deepspeed_stage_${ZERO_STAGE}
-
-ROOT_DIR=/cognitive_comp/ganruyi/experiments/classification_finetune/${MODEL_NAME}_${TASK}
-if [ ! -d ${ROOT_DIR} ];then
- mkdir -p ${ROOT_DIR}
- echo ${ROOT_DIR} created!!!!!!!!!!!!!!
-else
- echo ${ROOT_DIR} exist!!!!!!!!!!!!!!!
-fi
-
-DATA_DIR=/cognitive_comp/yangping/data/ChineseCLUE_DATA/${TASK}_public/
-PRETRAINED_MODEL_PATH=/cognitive_comp/ganruyi/hf_models/zen/zh_zen_large_2.0
-
-CHECKPOINT_PATH=${ROOT_DIR}/ckpt/
-OUTPUT_PATH=${ROOT_DIR}/predict.json
-
-DATA_ARGS="\
- --data_dir $DATA_DIR \
- --train_data train.json \
- --valid_data dev.json \
- --test_data test.json \
- --train_batchsize 32 \
- --valid_batchsize 16 \
- --max_seq_length 128 \
- --texta_name sentence \
- --label_name label \
- --id_name id \
- --task_name iflytek \
- "
-
-MODEL_ARGS="\
- --learning_rate 2e-5 \
- --weight_decay 0.1 \
- --warmup_ratio 0.01 \
- --num_labels 119 \
- "
-
-MODEL_CHECKPOINT_ARGS="\
- --monitor val_acc \
- --save_top_k 3 \
- --mode max \
- --every_n_train_steps 100 \
- --save_weights_only True \
- --dirpath $CHECKPOINT_PATH \
- --filename model-{epoch:02d}-{val_acc:.4f} \
- "
-
-TRAINER_ARGS="\
- --max_epochs 7 \
- --gpus 1 \
- --check_val_every_n_epoch 1 \
- --val_check_interval 100 \
- --default_root_dir $ROOT_DIR \
- "
-
-
-options=" \
- --pretrained_model_path $PRETRAINED_MODEL_PATH \
- --vocab_file $PRETRAINED_MODEL_PATH/vocab.txt \
- --do_lower_case \
- --output_save_path $OUTPUT_PATH \
- $DATA_ARGS \
- $MODEL_ARGS \
- $MODEL_CHECKPOINT_ARGS \
- $TRAINER_ARGS \
-"
-SCRIPT_PATH=/cognitive_comp/ganruyi/Fengshenbang-LM/fengshen/examples/zen2_finetune/fengshen_sequence_level_ft_task.py
-/home/ganruyi/anaconda3/bin/python $SCRIPT_PATH $options
-
-# SINGULARITY_PATH=/cognitive_comp/ganruyi/pytorch21_06_py3_docker_image_v2.sif
-# python3 $SCRIPT_PATH $options
-# source activate base
-# singularity exec --nv -B /cognitive_comp/:/cognitive_comp/ $SINGULARITY_PATH /home/ganruyi/anaconda3/bin/python $SCRIPT_PATH $options
-# /home/ganruyi/anaconda3/bin/python $SCRIPT_PATH $options
-
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/discriminative_reranking_nmt/__init__.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/discriminative_reranking_nmt/__init__.py
deleted file mode 100644
index 0278f6a27340c7ff7e207d09348483d1b0d3a100..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/discriminative_reranking_nmt/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from . import criterions, models, tasks # noqa
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_lotus.sh b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_lotus.sh
deleted file mode 100644
index c08c701314a8e575637deff78381ab02c2ef6728..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/multilingual/data_scripts/download_lotus.sh
+++ /dev/null
@@ -1,46 +0,0 @@
-#!/bin/bash
-# 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.
-
-
-if [ -z $WORKDIR_ROOT ] ;
-then
- echo "please specify your working directory root in environment variable WORKDIR_ROOT. Exitting..."
- exit
-fi
-
-
-SRCDIR=$WORKDIR_ROOT/indic_languages_corpus
-DESTDIR=${WORKDIR_ROOT}/ML50/raw/
-mkdir -p $SRCDIR
-mkdir -p $DESTDIR
-
-cd $SRCDIR
-wget http://lotus.kuee.kyoto-u.ac.jp/WAT/indic-multilingual/indic_languages_corpus.tar.gz
-tar -xvzf indic_languages_corpus.tar.gz
-
-SRC_EXTRACT_DIR=$SRCDIR/indic_languages_corpus/bilingual
-
-cp $SRC_EXTRACT_DIR/ml-en/train.ml $DESTDIR/train.ml_IN-en_XX.ml_IN
-cp $SRC_EXTRACT_DIR/ml-en/train.en $DESTDIR/train.ml_IN-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/ml-en/dev.ml $DESTDIR/valid.ml_IN-en_XX.ml_IN
-cp $SRC_EXTRACT_DIR/ml-en/dev.en $DESTDIR/valid.ml_IN-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/ml-en/test.ml $DESTDIR/test.ml_IN-en_XX.ml_IN
-cp $SRC_EXTRACT_DIR/ml-en/test.en $DESTDIR/test.ml_IN-en_XX.en_XX
-
-cp $SRC_EXTRACT_DIR/ur-en/train.ur $DESTDIR/train.ur_PK-en_XX.ur_PK
-cp $SRC_EXTRACT_DIR/ur-en/train.en $DESTDIR/train.ur_PK-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/ur-en/dev.ur $DESTDIR/valid.ur_PK-en_XX.ur_PK
-cp $SRC_EXTRACT_DIR/ur-en/dev.en $DESTDIR/valid.ur_PK-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/ur-en/test.ur $DESTDIR/test.ur_PK-en_XX.ur_PK
-cp $SRC_EXTRACT_DIR/ur-en/test.en $DESTDIR/test.ur_PK-en_XX.en_XX
-
-cp $SRC_EXTRACT_DIR/te-en/train.te $DESTDIR/train.te_IN-en_XX.te_IN
-cp $SRC_EXTRACT_DIR/te-en/train.en $DESTDIR/train.te_IN-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/te-en/dev.te $DESTDIR/valid.te_IN-en_XX.te_IN
-cp $SRC_EXTRACT_DIR/te-en/dev.en $DESTDIR/valid.te_IN-en_XX.en_XX
-cp $SRC_EXTRACT_DIR/te-en/test.te $DESTDIR/test.te_IN-en_XX.te_IN
-cp $SRC_EXTRACT_DIR/te-en/test.en $DESTDIR/test.te_IN-en_XX.en_XX
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/run_scripts/caption/train_caption_stage1_el_db.sh b/spaces/HarryLee/eCommerceImageCaptioning/run_scripts/caption/train_caption_stage1_el_db.sh
deleted file mode 100644
index 3d32254e59d0da435675f45845a9e1b53947b024..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/run_scripts/caption/train_caption_stage1_el_db.sh
+++ /dev/null
@@ -1,111 +0,0 @@
-#!/usr/bin/env
-
-# The port for communication. Note that if you want to run multiple tasks on the same machine,
-# you need to specify different port numbers.
-export MASTER_PORT=1051
-
-log_dir=./stage1_logs
-save_dir=./stage1_checkpoints
-mkdir -p $log_dir $save_dir
-
-bpe_dir=../../utils/BPE
-user_dir=../../ofa_module
-
-data_dir=../../dataset/caption_data
-data=${data_dir}/caption_stage1_train.tsv,${data_dir}/caption_val.tsv
-restore_file=../../checkpoints/ofa_large.pt
-selected_cols=0,4,2
-
-task=caption
-arch=ofa_large
-criterion=adjust_label_smoothed_encouraging_loss # for el
-label_smoothing=0.1
-lr=1e-5
-max_epoch=5
-warmup_ratio=0.06
-batch_size=8
-update_freq=4
-resnet_drop_path_rate=0.0
-encoder_drop_path_rate=0.1
-decoder_drop_path_rate=0.1
-dropout=0.1
-attention_dropout=0.0
-max_src_length=80
-max_tgt_length=20
-num_bins=1000
-patch_image_size=480
-eval_cider_cached=${data_dir}/cider_cached_tokens/coco-valid-words.p
-drop_worst_ratio=0.05 # modified from 0.2 for el
-drop_best_ratio=0.05
-drop_best_after=2500
-log_end=0.75 # for el
-for max_epoch in {2,}; do
- echo "max_epoch "${max_epoch}
- for warmup_ratio in {0.06,}; do
- echo "warmup_ratio "${warmup_ratio}
- for drop_worst_after in {2500,}; do
- echo "drop_worst_after "${drop_worst_after}
-
- log_file=${log_dir}/${max_epoch}"_"${warmup_ratio}"_dwdb"${drop_worst_after}_el${log_end}_".log"
- save_path=${save_dir}/${max_epoch}"_"${warmup_ratio}"_dwdb"${drop_worst_after}_el${log_end}_
- mkdir -p $save_path
-
- CUDA_VISIBLE_DEVICES=0,1,2,3 python3 -m torch.distributed.launch --nproc_per_node=4 --master_port=${MASTER_PORT} ../../train.py \
- $data \
- --selected-cols=${selected_cols} \
- --bpe-dir=${bpe_dir} \
- --user-dir=${user_dir} \
- --restore-file=${restore_file} \
- --reset-optimizer --reset-dataloader --reset-meters \
- --save-dir=${save_path} \
- --task=${task} \
- --arch=${arch} \
- --criterion=${criterion} \
- --label-smoothing=${label_smoothing} \
- --batch-size=${batch_size} \
- --update-freq=${update_freq} \
- --encoder-normalize-before \
- --decoder-normalize-before \
- --share-decoder-input-output-embed \
- --share-all-embeddings \
- --layernorm-embedding \
- --patch-layernorm-embedding \
- --code-layernorm-embedding \
- --resnet-drop-path-rate=${resnet_drop_path_rate} \
- --encoder-drop-path-rate=${encoder_drop_path_rate} \
- --decoder-drop-path-rate=${decoder_drop_path_rate} \
- --dropout=${dropout} \
- --attention-dropout=${attention_dropout} \
- --weight-decay=0.01 --optimizer=adam --adam-betas="(0.9,0.999)" --adam-eps=1e-08 --clip-norm=1.0 \
- --lr-scheduler=polynomial_decay --lr=${lr} \
- --max-epoch=${max_epoch} --warmup-ratio=${warmup_ratio} \
- --log-format=simple --log-interval=10 \
- --fixed-validation-seed=7 \
- --no-epoch-checkpoints --keep-best-checkpoints=1 \
- --save-interval=1 --validate-interval=1 \
- --save-interval-updates=500 --validate-interval-updates=500 \
- --eval-cider \
- --eval-cider-cached-tokens=${eval_cider_cached} \
- --eval-args='{"beam":5,"max_len_b":16,"no_repeat_ngram_size":3}' \
- --best-checkpoint-metric=cider --maximize-best-checkpoint-metric \
- --max-src-length=${max_src_length} \
- --max-tgt-length=${max_tgt_length} \
- --find-unused-parameters \
- --freeze-encoder-embedding \
- --freeze-decoder-embedding \
- --add-type-embedding \
- --scale-attn \
- --scale-fc \
- --scale-heads \
- --disable-entangle \
- --num-bins=${num_bins} \
- --patch-image-size=${patch_image_size} \
- --drop-worst-ratio=${drop_worst_ratio} \
- --drop-worst-after=${drop_worst_after} \
- --log-end ${log_end} --drop-best-ratio ${drop_best_ratio} --drop-best-after ${drop_best_after} \
- --fp16 \
- --fp16-scale-window=512 \
- --num-workers=0 > ${log_file} 2>&1
- done
- done
-done
diff --git a/spaces/Harsh12/Rossmann_Sales_Prediction/app.py b/spaces/Harsh12/Rossmann_Sales_Prediction/app.py
deleted file mode 100644
index 23b2b7dcb28f245870b81c8deab6949d1d46276e..0000000000000000000000000000000000000000
--- a/spaces/Harsh12/Rossmann_Sales_Prediction/app.py
+++ /dev/null
@@ -1,137 +0,0 @@
-import streamlit as st
-import joblib
-import pickle
-import pandas as pd
-
-# Load the model from disk
-model = joblib.load('rf.sav')
-# Load the model from disk
-with open('scaler.pkl', 'rb') as file:
- scaler = pickle.load(file)
-
-st.title('Rossmann Sales Prediction App')
-
-st.write('This app takes in the several input parameters and predict the sales for a particular day of a 1115 rossmann stores.')
-
-
-store = int(st.number_input('Store Number (select between 1-1115)', step=1, min_value=1, max_value=1115))
-# st.write('Store Number is', store)
-
-week_days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday', 'Sunday']
-week_days_mapping = {'Monday':1, 'Tuesday':2, 'Wednesday':3, 'Thursday':4, 'Friday':5, 'Saturday':6, 'Sunday':7}
-
-week_days_input = st.selectbox('Select the day of the week', week_days)
-
-# st.write(week_days_input)
-
-col1, col2 = st.columns(2)
-
-
-with col1:
- promo = ['yes', 'no']
- promo_map = {'yes':1, 'no':0}
-
- promo_or_not = st.selectbox('Promotion was opted or not?', promo)
-
-with col2:
- school_holiday = ['yes', 'no']
- school_map = {'yes':1, 'no':0}
-
- school_holiday_or_not = st.selectbox('Is there a School Holiday?', school_holiday)
-
-
-col3, col4 = st.columns(2)
-
-with col3:
- year = st.number_input('Enter the year:',step=1, min_value=1973, max_value=2025)
-
-
-with col4:
- months = ['January', 'February', 'March', 'April', 'May', 'June', 'July', 'August', 'September', 'October', 'November', 'December']
-
- month_map = {'January': 1, 'February': 2, 'March': 3, 'April': 4, 'May': 5, 'June': 6,
- 'July': 7, 'August': 8, 'September': 9, 'October': 10, 'November': 11, 'December': 12}
-
-
- select_month = st.selectbox('Select the month', months)
-
-
-days = st.number_input('Enter the day number for which you want to predict:', step=1, min_value=1, max_value=31)
-
-
-stores_type = ['a', 'b', 'c', 'd']
-stores_type_input = st.selectbox('Select the type of store', stores_type)
-
-assortment_type = ['basic', 'extra', 'extended']
-assortment_type_map = {'basic':'a', 'extra':'b', 'extended':'c'}
-assortment_type_input = st.selectbox('Select the assortment type (variations in the product)', assortment_type)
-
-customers = st.number_input('Enter the expected number of customers', step=5, min_value=5, max_value=7500)
-comp_distance = st.number_input('Enter the distance in meters to the nearest competitor store', step=1)
-comp_open_since_month = float(st.number_input('The month is which the nearest competitor store was opened (1-12)', step=1, min_value=1, max_value=12))
-comp_open_since_year = float(st.number_input('The year in which the nearest competitor store was opened', step=1, min_value=1973, max_value=2025))
-
-
-competition_open = (12* (year-comp_open_since_year)) + (month_map[select_month] - (comp_open_since_month))
-
-if stores_type_input == 'a':
- store_type_value_b = 0
- store_type_value_c = 0
- store_type_value_d = 0
-
-if stores_type_input == 'b':
- store_type_value_b = 1
- store_type_value_c = 0
- store_type_value_d = 0
-
-if stores_type_input == 'c':
- store_type_value_b = 0
- store_type_value_c = 1
- store_type_value_d = 0
-
-if stores_type_input == 'd':
- store_type_value_b = 0
- store_type_value_c = 0
- store_type_value_d = 1
-
-if assortment_type_input == 'basic':
- assortment_b = 0
- assortment_c = 0
-
-if assortment_type_input == 'extra':
- assortment_b = 1
- assortment_c = 0
-
-if assortment_type_input == 'extended':
- assortment_b = 0
- assortment_c = 1
-
-
-
-
-
-if st.button('Predict Sales'):
-
- try:
- final_dict = {'Store':store, 'day_of_week':week_days_mapping[week_days_input],
- 'promotion':promo_map[promo_or_not], 'school holiday':school_map[school_holiday_or_not],
- 'year':year, 'month':month_map[select_month], 'day':days, 'store b':store_type_value_b,
- 'store c':store_type_value_c, 'store d':store_type_value_d, 'assortment b':assortment_b,
- 'assortment c':assortment_c, 'customers':customers, 'Comp Dist':comp_distance,
- 'Comp_open': competition_open}
-
-
- final_df = pd.DataFrame([final_dict])
- final_df_scaled = scaler.transform(final_df)
- # st.write(final_df_scaled)
- # st.write(final_df)
-
- sales = model.predict(final_df_scaled)
- st.write('The sales for this particular day of the store you selected is:', sales[0])
-
- except Exception as e:
- st.error('There is something wrong, please enter the correct inputs', e)
-
-
-
-
diff --git a/spaces/HarshulNanda/HARM_ML_App_ludwig/dataGenerators/thumbnail_dataGenerators/readme.md b/spaces/HarshulNanda/HARM_ML_App_ludwig/dataGenerators/thumbnail_dataGenerators/readme.md
deleted file mode 100644
index 82ac350fe083cf88ffbf2130ad9991e46a8283dd..0000000000000000000000000000000000000000
--- a/spaces/HarshulNanda/HARM_ML_App_ludwig/dataGenerators/thumbnail_dataGenerators/readme.md
+++ /dev/null
@@ -1 +0,0 @@
-## Thumbnails data generators and model
\ No newline at end of file
diff --git a/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/src/glow_tts/hifi/utils.py b/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/src/glow_tts/hifi/utils.py
deleted file mode 100644
index 71e9b2c99e053e2d4239074a67d64b834898c348..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/Vakyansh-Odia-TTS/ttsv/src/glow_tts/hifi/utils.py
+++ /dev/null
@@ -1,57 +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 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/Harveenchadha/Vakyansh-Tamil-TTS/ttsv/scripts/inference/infer.sh b/spaces/Harveenchadha/Vakyansh-Tamil-TTS/ttsv/scripts/inference/infer.sh
deleted file mode 100644
index dec70e1f30fb80f6957f4f3382b4c0963827cf43..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/Vakyansh-Tamil-TTS/ttsv/scripts/inference/infer.sh
+++ /dev/null
@@ -1,15 +0,0 @@
-gender='male'
-glowdir='../../checkpoints/glow/'$gender'/'
-hifidir='../../checkpoints/hifi/'$gender'/'
-device='cpu'
-text='testing this one'
-
-
-timestamp=$(date +%s)
-wav='../../results/'$gender'/'
-wav_file=$wav/$timestamp'.wav'
-
-
-mkdir -p $wav
-python ../../utils/inference/tts.py -a $glowdir -v $hifidir -d $device -t "$text" -w $wav_file
-echo "File saved at: "$wav_file
diff --git a/spaces/HugoDzz/super-godot-galaxy/tailwind.config.js b/spaces/HugoDzz/super-godot-galaxy/tailwind.config.js
deleted file mode 100644
index 186f731d89a9ad8fca203cd5150f41eed9aca2e1..0000000000000000000000000000000000000000
--- a/spaces/HugoDzz/super-godot-galaxy/tailwind.config.js
+++ /dev/null
@@ -1,12 +0,0 @@
-/** @type {import('tailwindcss').Config} */
-export default {
- content: ["./src/**/*.{html,js,svelte,ts}"],
- theme: {
- extend: {
- fontFamily: {
- Hellovetica: ["Hellovetica"]
- },
- },
- },
- plugins: [],
-};
diff --git a/spaces/ICML2022/OFA/fairseq/fairseq/data/num_samples_dataset.py b/spaces/ICML2022/OFA/fairseq/fairseq/data/num_samples_dataset.py
deleted file mode 100644
index 99a17495c701d8a05e0268f98bf453905e11d078..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/fairseq/data/num_samples_dataset.py
+++ /dev/null
@@ -1,17 +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.
-
-from . import FairseqDataset
-
-
-class NumSamplesDataset(FairseqDataset):
- def __getitem__(self, index):
- return 1
-
- def __len__(self):
- return 0
-
- def collater(self, samples):
- return sum(samples)
diff --git a/spaces/ICML2022/OFA/fairseq/fairseq/models/roberta/enc_dec.py b/spaces/ICML2022/OFA/fairseq/fairseq/models/roberta/enc_dec.py
deleted file mode 100644
index e538dee0aa5984b1a3d02ce81117d2046c030593..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/fairseq/models/roberta/enc_dec.py
+++ /dev/null
@@ -1,192 +0,0 @@
-import argparse
-import logging
-
-import torch.nn as nn
-import fairseq.checkpoint_utils
-from fairseq.models import (
- FairseqEncoderDecoderModel,
- register_model,
- register_model_architecture,
-)
-from fairseq.models.transformer import TransformerDecoder
-from fairseq.models.roberta import model as roberta
-
-logger = logging.getLogger(__name__)
-
-
-@register_model("roberta_enc_dec")
-class RobertaEncDecModel(FairseqEncoderDecoderModel):
- @staticmethod
- def add_args(parser):
- parser.add_argument(
- "--pretrained-mlm-checkpoint",
- default=None,
- type=str,
- metavar="PRETRAINED",
- help="path to pretrained mlm checkpoint",
- )
- parser.add_argument(
- "--pretrained-decoder", action="store_true", help="reload decoder"
- )
- parser.add_argument(
- "--hack-layernorm-embedding",
- action="store_true",
- help="hack to reload old models trained with encoder-normalize-before=False (no equivalent to encoder-normalize-before=False and layernorm_embedding=False",
- )
- parser.add_argument(
- "--share-decoder-input-output-embed",
- action="store_true",
- help="share decoder input and output embeddings",
- )
- parser.add_argument(
- "--share-all-embeddings",
- action="store_true",
- help="share encoder, decoder and output embeddings"
- " (requires shared dictionary and embed dim)",
- )
-
- @classmethod
- def build_model(cls, args, task):
- """Build a new model instance."""
-
- # make sure all arguments are present
- base_enc_dec_architecture(args)
- if args.pretrained_mlm_checkpoint:
- arg_overrides = None
- if args.hack_layernorm_embedding:
- arg_overrides = {"layernorm_embedding": False}
- loaded = fairseq.checkpoint_utils.load_model_ensemble_and_task(
- [args.pretrained_mlm_checkpoint], arg_overrides=arg_overrides
- )
- ([roberta_enc], _cfg, _task) = loaded
- else:
- # Do we need to edit untie_weights here ?
- share_in_out = (
- args.share_decoder_input_output_embed or args.share_all_embeddings
- )
- args.untie_weights_roberta = not share_in_out
- if args.hack_layernorm_embedding:
- args.layernorm_embedding = False
- args.encoder_normalize_before = False
- roberta_enc = roberta.RobertaModel.build_model(args, task)
-
- return cls.from_roberta(roberta_enc, args, task.source_dictionary)
-
- @staticmethod
- def from_roberta(roberta_enc: roberta.RobertaModel, args, dictionary):
- encoder = roberta_enc.encoder.sentence_encoder
- vocab_size, embed_dim = encoder.embed_tokens.weight.shape
-
- if args.share_all_embeddings:
- lm_head = roberta_enc.encoder.lm_head
- assert encoder.embed_tokens.weight is lm_head.weight, (
- "Can't use --share-all-embeddings with a model "
- "that was pretraiend with --untie-weights-roberta_enc"
- )
- else:
- lm_head = roberta.RobertaLMHead(
- embed_dim, vocab_size, roberta_enc.args.activation_fn
- )
-
- dec_embs = nn.Embedding(vocab_size, embed_dim, dictionary.pad())
- if args.share_all_embeddings or args.share_decoder_input_output_embed:
- # Note: I wasn't able to use Embedding _weight parameter to achive this sharing.
- dec_embs.weight = lm_head.weight
-
- decoder = TransformerDecoder(
- RobertaEncDecModel.read_args_from_roberta(roberta_enc.args),
- dictionary,
- dec_embs,
- no_encoder_attn=False,
- output_projection=lm_head,
- )
- if getattr(args, "pretrained_decoder", False):
- decoder_dict = encoder.state_dict()
-
- # TODO: hide setting "encoder_attn" layers behind a flag.
- for k, w in list(decoder_dict.items()):
- if ".self_attn" in k:
- k_enc_attn = k.replace(".self_attn", ".encoder_attn")
- decoder_dict[k_enc_attn] = w.detach().clone()
-
- for k, w in lm_head.state_dict().items():
- decoder_dict["output_projection." + k] = w
-
- missing_keys, unexpected_keys = decoder.load_state_dict(
- decoder_dict, strict=False
- )
- # missing_keys = [m for m in missing_keys if ".encoder_attn" not in m]
- assert not missing_keys and not unexpected_keys, (
- "Failed to load state dict. "
- f"Missing keys: {missing_keys}. "
- f"Unexpected keys: {unexpected_keys}."
- )
-
- if args.share_all_embeddings:
- assert decoder.output_projection.weight is decoder.embed_tokens.weight
- assert encoder.embed_tokens.weight is decoder.embed_tokens.weight
- elif args.share_decoder_input_output_embed:
- assert decoder.output_projection.weight is decoder.embed_tokens.weight
- assert encoder.embed_tokens.weight is not decoder.embed_tokens.weight
- else:
- assert decoder.output_projection.weight is not decoder.embed_tokens.weight
- assert encoder.embed_tokens.weight is not decoder.embed_tokens.weight
-
- return RobertaEncDecModel(encoder, decoder)
-
- @staticmethod
- def read_args_from_roberta(roberta_args: argparse.Namespace):
- # TODO: this would become easier if encoder/decoder where using a similar
- # TransformerConfig object
- args = argparse.Namespace(**vars(roberta_args))
- attr_map = [
- ("encoder_attention_heads", "decoder_attention_heads"),
- ("encoder_embed_dim", "decoder_embed_dim"),
- ("encoder_embed_dim", "decoder_output_dim"),
- ("encoder_normalize_before", "decoder_normalize_before"),
- ("encoder_layers_to_keep", "decoder_layers_to_keep"),
- ("encoder_ffn_embed_dim", "decoder_ffn_embed_dim"),
- ("encoder_layerdrop", "decoder_layerdrop"),
- ("encoder_layers", "decoder_layers"),
- ("encoder_learned_pos", "decoder_learned_pos"),
- # should this be set from here ?
- ("max_positions", "max_target_positions"),
- ]
- for k1, k2 in attr_map:
- setattr(args, k2, getattr(roberta_args, k1))
-
- args.adaptive_softmax_cutoff = getattr(args, "adaptive_softmax_cutoff", None)
- args.adaptive_softmax_dropout = getattr(args, "adaptive_softmax_dropout", 0)
- args.share_decoder_input_output_embed = not roberta_args.untie_weights_roberta
- return args
-
- def upgrade_state_dict_named(self, state_dict, name):
- prefix = name + "." if name != "" else ""
- super().upgrade_state_dict_named(state_dict, name)
- old_keys = list(state_dict.keys())
-
- # rename decoder -> encoder before upgrading children modules
- for k in old_keys:
- if k.startswith(prefix + "encoder.lm_head"):
- state_dict.pop(k)
- continue
- new_k = k
- new_k = new_k.replace(".sentence_encoder.", ".")
- new_k = new_k.replace("decoder.lm_head.", "decoder.output_projection.")
- if k == new_k:
- continue
- # print(k, "->", new_k)
- state_dict[new_k] = state_dict.pop(k)
-
-
-@register_model_architecture("roberta_enc_dec", "roberta_enc_dec")
-def base_enc_dec_architecture(args):
- args.hack_layernorm_embedding = getattr(args, "hack_layernorm_embedding", False)
- args.pretrained_mlm_checkpoint = getattr(args, "pretrained_mlm_checkpoint", None)
- args.pretrained_decoder = getattr(args, "pretrained_decoder", None)
- args.share_all_embeddings = getattr(args, "share_all_embeddings", False)
- args.share_decoder_input_output_embed = getattr(
- args, "share_decoder_input_output_embed", False
- )
-
- roberta.base_architecture(args)
diff --git a/spaces/IDEA-CCNL/Erlangshen-UniMC-Zero-Shot/README.md b/spaces/IDEA-CCNL/Erlangshen-UniMC-Zero-Shot/README.md
deleted file mode 100644
index fbe757c131a190affd39ad841092770f05e00fb5..0000000000000000000000000000000000000000
--- a/spaces/IDEA-CCNL/Erlangshen-UniMC-Zero-Shot/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Erlangshen-UniMC-Zero-Shot
-emoji: 🐢
-colorFrom: green
-colorTo: gray
-sdk: streamlit
-sdk_version: 1.10.0
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Iceclear/StableSR/StableSR/ldm/modules/image_degradation/bsrgan.py b/spaces/Iceclear/StableSR/StableSR/ldm/modules/image_degradation/bsrgan.py
deleted file mode 100644
index 32ef56169978e550090261cddbcf5eb611a6173b..0000000000000000000000000000000000000000
--- a/spaces/Iceclear/StableSR/StableSR/ldm/modules/image_degradation/bsrgan.py
+++ /dev/null
@@ -1,730 +0,0 @@
-# -*- coding: utf-8 -*-
-"""
-# --------------------------------------------
-# Super-Resolution
-# --------------------------------------------
-#
-# Kai Zhang (cskaizhang@gmail.com)
-# https://github.com/cszn
-# From 2019/03--2021/08
-# --------------------------------------------
-"""
-
-import numpy as np
-import cv2
-import torch
-
-from functools import partial
-import random
-from scipy import ndimage
-import scipy
-import scipy.stats as ss
-from scipy.interpolate import interp2d
-from scipy.linalg import orth
-import albumentations
-
-import ldm.modules.image_degradation.utils_image as util
-
-
-def modcrop_np(img, sf):
- '''
- Args:
- img: numpy image, WxH or WxHxC
- sf: scale factor
- Return:
- cropped image
- '''
- w, h = img.shape[:2]
- im = np.copy(img)
- return im[:w - w % sf, :h - h % sf, ...]
-
-
-"""
-# --------------------------------------------
-# anisotropic Gaussian kernels
-# --------------------------------------------
-"""
-
-
-def analytic_kernel(k):
- """Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)"""
- k_size = k.shape[0]
- # Calculate the big kernels size
- big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2))
- # Loop over the small kernel to fill the big one
- for r in range(k_size):
- for c in range(k_size):
- big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k
- # Crop the edges of the big kernel to ignore very small values and increase run time of SR
- crop = k_size // 2
- cropped_big_k = big_k[crop:-crop, crop:-crop]
- # Normalize to 1
- return cropped_big_k / cropped_big_k.sum()
-
-
-def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
- """ generate an anisotropic Gaussian kernel
- Args:
- ksize : e.g., 15, kernel size
- theta : [0, pi], rotation angle range
- l1 : [0.1,50], scaling of eigenvalues
- l2 : [0.1,l1], scaling of eigenvalues
- If l1 = l2, will get an isotropic Gaussian kernel.
- Returns:
- k : kernel
- """
-
- v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.]))
- V = np.array([[v[0], v[1]], [v[1], -v[0]]])
- D = np.array([[l1, 0], [0, l2]])
- Sigma = np.dot(np.dot(V, D), np.linalg.inv(V))
- k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize)
-
- return k
-
-
-def gm_blur_kernel(mean, cov, size=15):
- center = size / 2.0 + 0.5
- k = np.zeros([size, size])
- for y in range(size):
- for x in range(size):
- cy = y - center + 1
- cx = x - center + 1
- k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov)
-
- k = k / np.sum(k)
- return k
-
-
-def shift_pixel(x, sf, upper_left=True):
- """shift pixel for super-resolution with different scale factors
- Args:
- x: WxHxC or WxH
- sf: scale factor
- upper_left: shift direction
- """
- h, w = x.shape[:2]
- shift = (sf - 1) * 0.5
- xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0)
- if upper_left:
- x1 = xv + shift
- y1 = yv + shift
- else:
- x1 = xv - shift
- y1 = yv - shift
-
- x1 = np.clip(x1, 0, w - 1)
- y1 = np.clip(y1, 0, h - 1)
-
- if x.ndim == 2:
- x = interp2d(xv, yv, x)(x1, y1)
- if x.ndim == 3:
- for i in range(x.shape[-1]):
- x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1)
-
- return x
-
-
-def blur(x, k):
- '''
- x: image, NxcxHxW
- k: kernel, Nx1xhxw
- '''
- n, c = x.shape[:2]
- p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2
- x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate')
- k = k.repeat(1, c, 1, 1)
- k = k.view(-1, 1, k.shape[2], k.shape[3])
- x = x.view(1, -1, x.shape[2], x.shape[3])
- x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c)
- x = x.view(n, c, x.shape[2], x.shape[3])
-
- return x
-
-
-def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0):
- """"
- # modified version of https://github.com/assafshocher/BlindSR_dataset_generator
- # Kai Zhang
- # min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var
- # max_var = 2.5 * sf
- """
- # Set random eigen-vals (lambdas) and angle (theta) for COV matrix
- lambda_1 = min_var + np.random.rand() * (max_var - min_var)
- lambda_2 = min_var + np.random.rand() * (max_var - min_var)
- theta = np.random.rand() * np.pi # random theta
- noise = -noise_level + np.random.rand(*k_size) * noise_level * 2
-
- # Set COV matrix using Lambdas and Theta
- LAMBDA = np.diag([lambda_1, lambda_2])
- Q = np.array([[np.cos(theta), -np.sin(theta)],
- [np.sin(theta), np.cos(theta)]])
- SIGMA = Q @ LAMBDA @ Q.T
- INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :]
-
- # Set expectation position (shifting kernel for aligned image)
- MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2)
- MU = MU[None, None, :, None]
-
- # Create meshgrid for Gaussian
- [X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1]))
- Z = np.stack([X, Y], 2)[:, :, :, None]
-
- # Calcualte Gaussian for every pixel of the kernel
- ZZ = Z - MU
- ZZ_t = ZZ.transpose(0, 1, 3, 2)
- raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise)
-
- # shift the kernel so it will be centered
- # raw_kernel_centered = kernel_shift(raw_kernel, scale_factor)
-
- # Normalize the kernel and return
- # kernel = raw_kernel_centered / np.sum(raw_kernel_centered)
- kernel = raw_kernel / np.sum(raw_kernel)
- return kernel
-
-
-def fspecial_gaussian(hsize, sigma):
- hsize = [hsize, hsize]
- siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0]
- std = sigma
- [x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1))
- arg = -(x * x + y * y) / (2 * std * std)
- h = np.exp(arg)
- h[h < scipy.finfo(float).eps * h.max()] = 0
- sumh = h.sum()
- if sumh != 0:
- h = h / sumh
- return h
-
-
-def fspecial_laplacian(alpha):
- alpha = max([0, min([alpha, 1])])
- h1 = alpha / (alpha + 1)
- h2 = (1 - alpha) / (alpha + 1)
- h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]]
- h = np.array(h)
- return h
-
-
-def fspecial(filter_type, *args, **kwargs):
- '''
- python code from:
- https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py
- '''
- if filter_type == 'gaussian':
- return fspecial_gaussian(*args, **kwargs)
- if filter_type == 'laplacian':
- return fspecial_laplacian(*args, **kwargs)
-
-
-"""
-# --------------------------------------------
-# degradation models
-# --------------------------------------------
-"""
-
-
-def bicubic_degradation(x, sf=3):
- '''
- Args:
- x: HxWxC image, [0, 1]
- sf: down-scale factor
- Return:
- bicubicly downsampled LR image
- '''
- x = util.imresize_np(x, scale=1 / sf)
- return x
-
-
-def srmd_degradation(x, k, sf=3):
- ''' blur + bicubic downsampling
- Args:
- x: HxWxC image, [0, 1]
- k: hxw, double
- sf: down-scale factor
- Return:
- downsampled LR image
- Reference:
- @inproceedings{zhang2018learning,
- title={Learning a single convolutional super-resolution network for multiple degradations},
- author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
- booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
- pages={3262--3271},
- year={2018}
- }
- '''
- x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror'
- x = bicubic_degradation(x, sf=sf)
- return x
-
-
-def dpsr_degradation(x, k, sf=3):
- ''' bicubic downsampling + blur
- Args:
- x: HxWxC image, [0, 1]
- k: hxw, double
- sf: down-scale factor
- Return:
- downsampled LR image
- Reference:
- @inproceedings{zhang2019deep,
- title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels},
- author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
- booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
- pages={1671--1681},
- year={2019}
- }
- '''
- x = bicubic_degradation(x, sf=sf)
- x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
- return x
-
-
-def classical_degradation(x, k, sf=3):
- ''' blur + downsampling
- Args:
- x: HxWxC image, [0, 1]/[0, 255]
- k: hxw, double
- sf: down-scale factor
- Return:
- downsampled LR image
- '''
- x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
- # x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2))
- st = 0
- return x[st::sf, st::sf, ...]
-
-
-def add_sharpening(img, weight=0.5, radius=50, threshold=10):
- """USM sharpening. borrowed from real-ESRGAN
- Input image: I; Blurry image: B.
- 1. K = I + weight * (I - B)
- 2. Mask = 1 if abs(I - B) > threshold, else: 0
- 3. Blur mask:
- 4. Out = Mask * K + (1 - Mask) * I
- Args:
- img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
- weight (float): Sharp weight. Default: 1.
- radius (float): Kernel size of Gaussian blur. Default: 50.
- threshold (int):
- """
- if radius % 2 == 0:
- radius += 1
- blur = cv2.GaussianBlur(img, (radius, radius), 0)
- residual = img - blur
- mask = np.abs(residual) * 255 > threshold
- mask = mask.astype('float32')
- soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
-
- K = img + weight * residual
- K = np.clip(K, 0, 1)
- return soft_mask * K + (1 - soft_mask) * img
-
-
-def add_blur(img, sf=4):
- wd2 = 4.0 + sf
- wd = 2.0 + 0.2 * sf
- if random.random() < 0.5:
- l1 = wd2 * random.random()
- l2 = wd2 * random.random()
- k = anisotropic_Gaussian(ksize=2 * random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2)
- else:
- k = fspecial('gaussian', 2 * random.randint(2, 11) + 3, wd * random.random())
- img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror')
-
- return img
-
-
-def add_resize(img, sf=4):
- rnum = np.random.rand()
- if rnum > 0.8: # up
- sf1 = random.uniform(1, 2)
- elif rnum < 0.7: # down
- sf1 = random.uniform(0.5 / sf, 1)
- else:
- sf1 = 1.0
- img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3]))
- img = np.clip(img, 0.0, 1.0)
-
- return img
-
-
-# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
-# noise_level = random.randint(noise_level1, noise_level2)
-# rnum = np.random.rand()
-# if rnum > 0.6: # add color Gaussian noise
-# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
-# elif rnum < 0.4: # add grayscale Gaussian noise
-# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
-# else: # add noise
-# L = noise_level2 / 255.
-# D = np.diag(np.random.rand(3))
-# U = orth(np.random.rand(3, 3))
-# conv = np.dot(np.dot(np.transpose(U), D), U)
-# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
-# img = np.clip(img, 0.0, 1.0)
-# return img
-
-def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
- noise_level = random.randint(noise_level1, noise_level2)
- rnum = np.random.rand()
- if rnum > 0.6: # add color Gaussian noise
- img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
- elif rnum < 0.4: # add grayscale Gaussian noise
- img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
- else: # add noise
- L = noise_level2 / 255.
- D = np.diag(np.random.rand(3))
- U = orth(np.random.rand(3, 3))
- conv = np.dot(np.dot(np.transpose(U), D), U)
- img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
- img = np.clip(img, 0.0, 1.0)
- return img
-
-
-def add_speckle_noise(img, noise_level1=2, noise_level2=25):
- noise_level = random.randint(noise_level1, noise_level2)
- img = np.clip(img, 0.0, 1.0)
- rnum = random.random()
- if rnum > 0.6:
- img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
- elif rnum < 0.4:
- img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
- else:
- L = noise_level2 / 255.
- D = np.diag(np.random.rand(3))
- U = orth(np.random.rand(3, 3))
- conv = np.dot(np.dot(np.transpose(U), D), U)
- img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
- img = np.clip(img, 0.0, 1.0)
- return img
-
-
-def add_Poisson_noise(img):
- img = np.clip((img * 255.0).round(), 0, 255) / 255.
- vals = 10 ** (2 * random.random() + 2.0) # [2, 4]
- if random.random() < 0.5:
- img = np.random.poisson(img * vals).astype(np.float32) / vals
- else:
- img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114])
- img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255.
- noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray
- img += noise_gray[:, :, np.newaxis]
- img = np.clip(img, 0.0, 1.0)
- return img
-
-
-def add_JPEG_noise(img):
- quality_factor = random.randint(30, 95)
- img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR)
- result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor])
- img = cv2.imdecode(encimg, 1)
- img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB)
- return img
-
-
-def random_crop(lq, hq, sf=4, lq_patchsize=64):
- h, w = lq.shape[:2]
- rnd_h = random.randint(0, h - lq_patchsize)
- rnd_w = random.randint(0, w - lq_patchsize)
- lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :]
-
- rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf)
- hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :]
- return lq, hq
-
-
-def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
- """
- This is the degradation model of BSRGAN from the paper
- "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
- ----------
- img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
- sf: scale factor
- isp_model: camera ISP model
- Returns
- -------
- img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
- hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
- """
- isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
- sf_ori = sf
-
- h1, w1 = img.shape[:2]
- img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
- h, w = img.shape[:2]
-
- if h < lq_patchsize * sf or w < lq_patchsize * sf:
- raise ValueError(f'img size ({h1}X{w1}) is too small!')
-
- hq = img.copy()
-
- if sf == 4 and random.random() < scale2_prob: # downsample1
- if np.random.rand() < 0.5:
- img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])),
- interpolation=random.choice([1, 2, 3]))
- else:
- img = util.imresize_np(img, 1 / 2, True)
- img = np.clip(img, 0.0, 1.0)
- sf = 2
-
- shuffle_order = random.sample(range(7), 7)
- idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
- if idx1 > idx2: # keep downsample3 last
- shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
- for i in shuffle_order:
-
- if i == 0:
- img = add_blur(img, sf=sf)
-
- elif i == 1:
- img = add_blur(img, sf=sf)
-
- elif i == 2:
- a, b = img.shape[1], img.shape[0]
- # downsample2
- if random.random() < 0.75:
- sf1 = random.uniform(1, 2 * sf)
- img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])),
- interpolation=random.choice([1, 2, 3]))
- else:
- k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
- k_shifted = shift_pixel(k, sf)
- k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
- img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror')
- img = img[0::sf, 0::sf, ...] # nearest downsampling
- img = np.clip(img, 0.0, 1.0)
-
- elif i == 3:
- # downsample3
- img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
- img = np.clip(img, 0.0, 1.0)
-
- elif i == 4:
- # add Gaussian noise
- img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
-
- elif i == 5:
- # add JPEG noise
- if random.random() < jpeg_prob:
- img = add_JPEG_noise(img)
-
- elif i == 6:
- # add processed camera sensor noise
- if random.random() < isp_prob and isp_model is not None:
- with torch.no_grad():
- img, hq = isp_model.forward(img.copy(), hq)
-
- # add final JPEG compression noise
- img = add_JPEG_noise(img)
-
- # random crop
- img, hq = random_crop(img, hq, sf_ori, lq_patchsize)
-
- return img, hq
-
-
-# todo no isp_model?
-def degradation_bsrgan_variant(image, sf=4, isp_model=None):
- """
- This is the degradation model of BSRGAN from the paper
- "Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
- ----------
- sf: scale factor
- isp_model: camera ISP model
- Returns
- -------
- img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
- hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
- """
- image = util.uint2single(image)
- isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
- sf_ori = sf
-
- h1, w1 = image.shape[:2]
- image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
- h, w = image.shape[:2]
-
- hq = image.copy()
-
- if sf == 4 and random.random() < scale2_prob: # downsample1
- if np.random.rand() < 0.5:
- image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])),
- interpolation=random.choice([1, 2, 3]))
- else:
- image = util.imresize_np(image, 1 / 2, True)
- image = np.clip(image, 0.0, 1.0)
- sf = 2
-
- shuffle_order = random.sample(range(7), 7)
- idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
- if idx1 > idx2: # keep downsample3 last
- shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
-
- for i in shuffle_order:
-
- if i == 0:
- image = add_blur(image, sf=sf)
-
- elif i == 1:
- image = add_blur(image, sf=sf)
-
- elif i == 2:
- a, b = image.shape[1], image.shape[0]
- # downsample2
- if random.random() < 0.75:
- sf1 = random.uniform(1, 2 * sf)
- image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])),
- interpolation=random.choice([1, 2, 3]))
- else:
- k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
- k_shifted = shift_pixel(k, sf)
- k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
- image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror')
- image = image[0::sf, 0::sf, ...] # nearest downsampling
- image = np.clip(image, 0.0, 1.0)
-
- elif i == 3:
- # downsample3
- image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
- image = np.clip(image, 0.0, 1.0)
-
- elif i == 4:
- # add Gaussian noise
- image = add_Gaussian_noise(image, noise_level1=2, noise_level2=25)
-
- elif i == 5:
- # add JPEG noise
- if random.random() < jpeg_prob:
- image = add_JPEG_noise(image)
-
- # elif i == 6:
- # # add processed camera sensor noise
- # if random.random() < isp_prob and isp_model is not None:
- # with torch.no_grad():
- # img, hq = isp_model.forward(img.copy(), hq)
-
- # add final JPEG compression noise
- image = add_JPEG_noise(image)
- image = util.single2uint(image)
- example = {"image":image}
- return example
-
-
-# TODO incase there is a pickle error one needs to replace a += x with a = a + x in add_speckle_noise etc...
-def degradation_bsrgan_plus(img, sf=4, shuffle_prob=0.5, use_sharp=True, lq_patchsize=64, isp_model=None):
- """
- This is an extended degradation model by combining
- the degradation models of BSRGAN and Real-ESRGAN
- ----------
- img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
- sf: scale factor
- use_shuffle: the degradation shuffle
- use_sharp: sharpening the img
- Returns
- -------
- img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
- hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
- """
-
- h1, w1 = img.shape[:2]
- img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
- h, w = img.shape[:2]
-
- if h < lq_patchsize * sf or w < lq_patchsize * sf:
- raise ValueError(f'img size ({h1}X{w1}) is too small!')
-
- if use_sharp:
- img = add_sharpening(img)
- hq = img.copy()
-
- if random.random() < shuffle_prob:
- shuffle_order = random.sample(range(13), 13)
- else:
- shuffle_order = list(range(13))
- # local shuffle for noise, JPEG is always the last one
- shuffle_order[2:6] = random.sample(shuffle_order[2:6], len(range(2, 6)))
- shuffle_order[9:13] = random.sample(shuffle_order[9:13], len(range(9, 13)))
-
- poisson_prob, speckle_prob, isp_prob = 0.1, 0.1, 0.1
-
- for i in shuffle_order:
- if i == 0:
- img = add_blur(img, sf=sf)
- elif i == 1:
- img = add_resize(img, sf=sf)
- elif i == 2:
- img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
- elif i == 3:
- if random.random() < poisson_prob:
- img = add_Poisson_noise(img)
- elif i == 4:
- if random.random() < speckle_prob:
- img = add_speckle_noise(img)
- elif i == 5:
- if random.random() < isp_prob and isp_model is not None:
- with torch.no_grad():
- img, hq = isp_model.forward(img.copy(), hq)
- elif i == 6:
- img = add_JPEG_noise(img)
- elif i == 7:
- img = add_blur(img, sf=sf)
- elif i == 8:
- img = add_resize(img, sf=sf)
- elif i == 9:
- img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
- elif i == 10:
- if random.random() < poisson_prob:
- img = add_Poisson_noise(img)
- elif i == 11:
- if random.random() < speckle_prob:
- img = add_speckle_noise(img)
- elif i == 12:
- if random.random() < isp_prob and isp_model is not None:
- with torch.no_grad():
- img, hq = isp_model.forward(img.copy(), hq)
- else:
- print('check the shuffle!')
-
- # resize to desired size
- img = cv2.resize(img, (int(1 / sf * hq.shape[1]), int(1 / sf * hq.shape[0])),
- interpolation=random.choice([1, 2, 3]))
-
- # add final JPEG compression noise
- img = add_JPEG_noise(img)
-
- # random crop
- img, hq = random_crop(img, hq, sf, lq_patchsize)
-
- return img, hq
-
-
-if __name__ == '__main__':
- print("hey")
- img = util.imread_uint('utils/test.png', 3)
- print(img)
- img = util.uint2single(img)
- print(img)
- img = img[:448, :448]
- h = img.shape[0] // 4
- print("resizing to", h)
- sf = 4
- deg_fn = partial(degradation_bsrgan_variant, sf=sf)
- for i in range(20):
- print(i)
- img_lq = deg_fn(img)
- print(img_lq)
- img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img)["image"]
- print(img_lq.shape)
- print("bicubic", img_lq_bicubic.shape)
- print(img_hq.shape)
- lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
- interpolation=0)
- lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
- interpolation=0)
- img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1)
- util.imsave(img_concat, str(i) + '.png')
-
-
diff --git a/spaces/Ishayy/space_1/app.py b/spaces/Ishayy/space_1/app.py
deleted file mode 100644
index 57b7b791807d111f20403524a5d21fe94bdf2b5c..0000000000000000000000000000000000000000
--- a/spaces/Ishayy/space_1/app.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from transformers import PegasusForConditionalGeneration,PegasusTokenizer
-import gradio as grad
-mdl_name = "google/pegasus-xsum"
-pegasus_tkn = PegasusTokenizer.from_pretrained(mdl_name)
-mdl = PegasusForConditionalGeneration.from_pretrained(mdl_name)
-def summarize(text):
- tokens = pegasus_tkn(text, truncation=True, padding="longest",return_tensors="pt")
- txt_summary = mdl.generate(**tokens)
- response = pegasus_tkn.batch_decode(txt_summary,skip_special_tokens=True)
- return response
-txt=grad.Textbox(lines=10, label="English", placeholder="English Texthere")
-out=grad.Textbox(lines=10, label="Summary")
-grad.Interface(summarize, inputs=txt, outputs=out).launch()
\ No newline at end of file
diff --git a/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/archs/arch_util.py b/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/archs/arch_util.py
deleted file mode 100644
index bad45ab34e901c47fb539152fca714a3795b0de2..0000000000000000000000000000000000000000
--- a/spaces/Jasonyoyo/CodeFormer/CodeFormer/basicsr/archs/arch_util.py
+++ /dev/null
@@ -1,318 +0,0 @@
-import collections.abc
-import math
-import torch
-import torchvision
-import warnings
-from distutils.version import LooseVersion
-from itertools import repeat
-from torch import nn as nn
-from torch.nn import functional as F
-from torch.nn import init as init
-from torch.nn.modules.batchnorm import _BatchNorm
-
-from basicsr.ops.dcn import ModulatedDeformConvPack, modulated_deform_conv
-from basicsr.utils import get_root_logger
-
-
-@torch.no_grad()
-def default_init_weights(module_list, scale=1, bias_fill=0, **kwargs):
- """Initialize network weights.
-
- Args:
- module_list (list[nn.Module] | nn.Module): Modules to be initialized.
- scale (float): Scale initialized weights, especially for residual
- blocks. Default: 1.
- bias_fill (float): The value to fill bias. Default: 0
- kwargs (dict): Other arguments for initialization function.
- """
- if not isinstance(module_list, list):
- module_list = [module_list]
- for module in module_list:
- for m in module.modules():
- if isinstance(m, nn.Conv2d):
- init.kaiming_normal_(m.weight, **kwargs)
- m.weight.data *= scale
- if m.bias is not None:
- m.bias.data.fill_(bias_fill)
- elif isinstance(m, nn.Linear):
- init.kaiming_normal_(m.weight, **kwargs)
- m.weight.data *= scale
- if m.bias is not None:
- m.bias.data.fill_(bias_fill)
- elif isinstance(m, _BatchNorm):
- init.constant_(m.weight, 1)
- if m.bias is not None:
- m.bias.data.fill_(bias_fill)
-
-
-def make_layer(basic_block, num_basic_block, **kwarg):
- """Make layers by stacking the same blocks.
-
- Args:
- basic_block (nn.module): nn.module class for basic block.
- num_basic_block (int): number of blocks.
-
- Returns:
- nn.Sequential: Stacked blocks in nn.Sequential.
- """
- layers = []
- for _ in range(num_basic_block):
- layers.append(basic_block(**kwarg))
- return nn.Sequential(*layers)
-
-
-class ResidualBlockNoBN(nn.Module):
- """Residual block without BN.
-
- It has a style of:
- ---Conv-ReLU-Conv-+-
- |________________|
-
- Args:
- num_feat (int): Channel number of intermediate features.
- Default: 64.
- res_scale (float): Residual scale. Default: 1.
- pytorch_init (bool): If set to True, use pytorch default init,
- otherwise, use default_init_weights. Default: False.
- """
-
- def __init__(self, num_feat=64, res_scale=1, pytorch_init=False):
- super(ResidualBlockNoBN, self).__init__()
- self.res_scale = res_scale
- self.conv1 = nn.Conv2d(num_feat, num_feat, 3, 1, 1, bias=True)
- self.conv2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1, bias=True)
- self.relu = nn.ReLU(inplace=True)
-
- if not pytorch_init:
- default_init_weights([self.conv1, self.conv2], 0.1)
-
- def forward(self, x):
- identity = x
- out = self.conv2(self.relu(self.conv1(x)))
- return identity + out * self.res_scale
-
-
-class Upsample(nn.Sequential):
- """Upsample module.
-
- Args:
- scale (int): Scale factor. Supported scales: 2^n and 3.
- num_feat (int): Channel number of intermediate features.
- """
-
- def __init__(self, scale, num_feat):
- m = []
- if (scale & (scale - 1)) == 0: # scale = 2^n
- for _ in range(int(math.log(scale, 2))):
- m.append(nn.Conv2d(num_feat, 4 * num_feat, 3, 1, 1))
- m.append(nn.PixelShuffle(2))
- elif scale == 3:
- m.append(nn.Conv2d(num_feat, 9 * num_feat, 3, 1, 1))
- m.append(nn.PixelShuffle(3))
- else:
- raise ValueError(f'scale {scale} is not supported. Supported scales: 2^n and 3.')
- super(Upsample, self).__init__(*m)
-
-
-def flow_warp(x, flow, interp_mode='bilinear', padding_mode='zeros', align_corners=True):
- """Warp an image or feature map with optical flow.
-
- Args:
- x (Tensor): Tensor with size (n, c, h, w).
- flow (Tensor): Tensor with size (n, h, w, 2), normal value.
- interp_mode (str): 'nearest' or 'bilinear'. Default: 'bilinear'.
- padding_mode (str): 'zeros' or 'border' or 'reflection'.
- Default: 'zeros'.
- align_corners (bool): Before pytorch 1.3, the default value is
- align_corners=True. After pytorch 1.3, the default value is
- align_corners=False. Here, we use the True as default.
-
- Returns:
- Tensor: Warped image or feature map.
- """
- assert x.size()[-2:] == flow.size()[1:3]
- _, _, h, w = x.size()
- # create mesh grid
- grid_y, grid_x = torch.meshgrid(torch.arange(0, h).type_as(x), torch.arange(0, w).type_as(x))
- grid = torch.stack((grid_x, grid_y), 2).float() # W(x), H(y), 2
- grid.requires_grad = False
-
- vgrid = grid + flow
- # scale grid to [-1,1]
- vgrid_x = 2.0 * vgrid[:, :, :, 0] / max(w - 1, 1) - 1.0
- vgrid_y = 2.0 * vgrid[:, :, :, 1] / max(h - 1, 1) - 1.0
- vgrid_scaled = torch.stack((vgrid_x, vgrid_y), dim=3)
- output = F.grid_sample(x, vgrid_scaled, mode=interp_mode, padding_mode=padding_mode, align_corners=align_corners)
-
- # TODO, what if align_corners=False
- return output
-
-
-def resize_flow(flow, size_type, sizes, interp_mode='bilinear', align_corners=False):
- """Resize a flow according to ratio or shape.
-
- Args:
- flow (Tensor): Precomputed flow. shape [N, 2, H, W].
- size_type (str): 'ratio' or 'shape'.
- sizes (list[int | float]): the ratio for resizing or the final output
- shape.
- 1) The order of ratio should be [ratio_h, ratio_w]. For
- downsampling, the ratio should be smaller than 1.0 (i.e., ratio
- < 1.0). For upsampling, the ratio should be larger than 1.0 (i.e.,
- ratio > 1.0).
- 2) The order of output_size should be [out_h, out_w].
- interp_mode (str): The mode of interpolation for resizing.
- Default: 'bilinear'.
- align_corners (bool): Whether align corners. Default: False.
-
- Returns:
- Tensor: Resized flow.
- """
- _, _, flow_h, flow_w = flow.size()
- if size_type == 'ratio':
- output_h, output_w = int(flow_h * sizes[0]), int(flow_w * sizes[1])
- elif size_type == 'shape':
- output_h, output_w = sizes[0], sizes[1]
- else:
- raise ValueError(f'Size type should be ratio or shape, but got type {size_type}.')
-
- input_flow = flow.clone()
- ratio_h = output_h / flow_h
- ratio_w = output_w / flow_w
- input_flow[:, 0, :, :] *= ratio_w
- input_flow[:, 1, :, :] *= ratio_h
- resized_flow = F.interpolate(
- input=input_flow, size=(output_h, output_w), mode=interp_mode, align_corners=align_corners)
- return resized_flow
-
-
-# TODO: may write a cpp file
-def pixel_unshuffle(x, scale):
- """ Pixel unshuffle.
-
- Args:
- x (Tensor): Input feature with shape (b, c, hh, hw).
- scale (int): Downsample ratio.
-
- Returns:
- Tensor: the pixel unshuffled feature.
- """
- b, c, hh, hw = x.size()
- out_channel = c * (scale**2)
- assert hh % scale == 0 and hw % scale == 0
- h = hh // scale
- w = hw // scale
- x_view = x.view(b, c, h, scale, w, scale)
- return x_view.permute(0, 1, 3, 5, 2, 4).reshape(b, out_channel, h, w)
-
-
-class DCNv2Pack(ModulatedDeformConvPack):
- """Modulated deformable conv for deformable alignment.
-
- Different from the official DCNv2Pack, which generates offsets and masks
- from the preceding features, this DCNv2Pack takes another different
- features to generate offsets and masks.
-
- Ref:
- Delving Deep into Deformable Alignment in Video Super-Resolution.
- """
-
- def forward(self, x, feat):
- out = self.conv_offset(feat)
- o1, o2, mask = torch.chunk(out, 3, dim=1)
- offset = torch.cat((o1, o2), dim=1)
- mask = torch.sigmoid(mask)
-
- offset_absmean = torch.mean(torch.abs(offset))
- if offset_absmean > 50:
- logger = get_root_logger()
- logger.warning(f'Offset abs mean is {offset_absmean}, larger than 50.')
-
- if LooseVersion(torchvision.__version__) >= LooseVersion('0.9.0'):
- return torchvision.ops.deform_conv2d(x, offset, self.weight, self.bias, self.stride, self.padding,
- self.dilation, mask)
- else:
- return modulated_deform_conv(x, offset, mask, self.weight, self.bias, self.stride, self.padding,
- self.dilation, self.groups, self.deformable_groups)
-
-
-def _no_grad_trunc_normal_(tensor, mean, std, a, b):
- # From: https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/layers/weight_init.py
- # Cut & paste from PyTorch official master until it's in a few official releases - RW
- # Method based on https://people.sc.fsu.edu/~jburkardt/presentations/truncated_normal.pdf
- def norm_cdf(x):
- # Computes standard normal cumulative distribution function
- return (1. + math.erf(x / math.sqrt(2.))) / 2.
-
- if (mean < a - 2 * std) or (mean > b + 2 * std):
- warnings.warn(
- 'mean is more than 2 std from [a, b] in nn.init.trunc_normal_. '
- 'The distribution of values may be incorrect.',
- stacklevel=2)
-
- with torch.no_grad():
- # Values are generated by using a truncated uniform distribution and
- # then using the inverse CDF for the normal distribution.
- # Get upper and lower cdf values
- low = norm_cdf((a - mean) / std)
- up = norm_cdf((b - mean) / std)
-
- # Uniformly fill tensor with values from [low, up], then translate to
- # [2l-1, 2u-1].
- tensor.uniform_(2 * low - 1, 2 * up - 1)
-
- # Use inverse cdf transform for normal distribution to get truncated
- # standard normal
- tensor.erfinv_()
-
- # Transform to proper mean, std
- tensor.mul_(std * math.sqrt(2.))
- tensor.add_(mean)
-
- # Clamp to ensure it's in the proper range
- tensor.clamp_(min=a, max=b)
- return tensor
-
-
-def trunc_normal_(tensor, mean=0., std=1., a=-2., b=2.):
- r"""Fills the input Tensor with values drawn from a truncated
- normal distribution.
-
- From: https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/layers/weight_init.py
-
- The values are effectively drawn from the
- normal distribution :math:`\mathcal{N}(\text{mean}, \text{std}^2)`
- with values outside :math:`[a, b]` redrawn until they are within
- the bounds. The method used for generating the random values works
- best when :math:`a \leq \text{mean} \leq b`.
-
- Args:
- tensor: an n-dimensional `torch.Tensor`
- mean: the mean of the normal distribution
- std: the standard deviation of the normal distribution
- a: the minimum cutoff value
- b: the maximum cutoff value
-
- Examples:
- >>> w = torch.empty(3, 5)
- >>> nn.init.trunc_normal_(w)
- """
- return _no_grad_trunc_normal_(tensor, mean, std, a, b)
-
-
-# From PyTorch
-def _ntuple(n):
-
- def parse(x):
- if isinstance(x, collections.abc.Iterable):
- return x
- return tuple(repeat(x, n))
-
- return parse
-
-
-to_1tuple = _ntuple(1)
-to_2tuple = _ntuple(2)
-to_3tuple = _ntuple(3)
-to_4tuple = _ntuple(4)
-to_ntuple = _ntuple
\ No newline at end of file
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/modules/webui_locale.py b/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/modules/webui_locale.py
deleted file mode 100644
index 1ce4d97b9b41cbb2d9be3fdadc4c85f6ef897604..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT_Beta/modules/webui_locale.py
+++ /dev/null
@@ -1,26 +0,0 @@
-import os
-import locale
-import commentjson as json
-
-class I18nAuto:
- def __init__(self):
- if os.path.exists("config.json"):
- with open("config.json", "r", encoding='utf-8') as f:
- config = json.load(f)
- else:
- config = {}
- lang_config = config.get("language", "auto")
- language = os.environ.get("LANGUAGE", lang_config)
- if language == "auto":
- language = locale.getdefaultlocale()[0] # get the language code of the system (ex. zh_CN)
- self.language_map = {}
- self.file_is_exists = os.path.isfile(f"./locale/{language}.json")
- if self.file_is_exists:
- with open(f"./locale/{language}.json", "r", encoding="utf-8") as f:
- self.language_map.update(json.load(f))
-
- def __call__(self, key):
- if self.file_is_exists and key in self.language_map:
- return self.language_map[key]
- else:
- return key
diff --git a/spaces/JonatanGk/catalonia-independence-detector/README.md b/spaces/JonatanGk/catalonia-independence-detector/README.md
deleted file mode 100644
index ae3fc614e3a7fb00959628c8c13bf0c01af53d52..0000000000000000000000000000000000000000
--- a/spaces/JonatanGk/catalonia-independence-detector/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: Catalonia Independence Detector
-emoji: 👎👍
-colorFrom: yellow
-colorTo: pink
-sdk: gradio
-app_file: app.py
-pinned: false
----
-
-
diff --git a/spaces/JosueElias/borrs/README.md b/spaces/JosueElias/borrs/README.md
deleted file mode 100644
index cabae4713f9fa43d69dd46574a3ff67261011667..0000000000000000000000000000000000000000
--- a/spaces/JosueElias/borrs/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Borrs
-emoji: 🔥
-colorFrom: yellow
-colorTo: purple
-sdk: streamlit
-sdk_version: 1.28.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/KarmKarma/genshinimpact-rvc-models-v2/vc_infer_pipeline.py b/spaces/KarmKarma/genshinimpact-rvc-models-v2/vc_infer_pipeline.py
deleted file mode 100644
index 1b70d7b0de4e8bccbdd146ac90a5cfe42ed8749c..0000000000000000000000000000000000000000
--- a/spaces/KarmKarma/genshinimpact-rvc-models-v2/vc_infer_pipeline.py
+++ /dev/null
@@ -1,431 +0,0 @@
-import numpy as np, parselmouth, torch, pdb
-from time import time as ttime
-import torch.nn.functional as F
-import scipy.signal as signal
-import pyworld, os, traceback, faiss, librosa, torchcrepe
-from scipy import signal
-from functools import lru_cache
-
-bh, ah = signal.butter(N=5, Wn=48, btype="high", fs=16000)
-
-input_audio_path2wav = {}
-
-
-@lru_cache
-def cache_harvest_f0(input_audio_path, fs, f0max, f0min, frame_period):
- audio = input_audio_path2wav[input_audio_path]
- f0, t = pyworld.harvest(
- audio,
- fs=fs,
- f0_ceil=f0max,
- f0_floor=f0min,
- frame_period=frame_period,
- )
- f0 = pyworld.stonemask(audio, f0, t, fs)
- return f0
-
-
-def change_rms(data1, sr1, data2, sr2, rate): # 1是输入音频，2是输出音频,rate是2的占比
- # print(data1.max(),data2.max())
- rms1 = librosa.feature.rms(
- y=data1, frame_length=sr1 // 2 * 2, hop_length=sr1 // 2
- ) # 每半秒一个点
- rms2 = librosa.feature.rms(y=data2, frame_length=sr2 // 2 * 2, hop_length=sr2 // 2)
- rms1 = torch.from_numpy(rms1)
- rms1 = F.interpolate(
- rms1.unsqueeze(0), size=data2.shape[0], mode="linear"
- ).squeeze()
- rms2 = torch.from_numpy(rms2)
- rms2 = F.interpolate(
- rms2.unsqueeze(0), size=data2.shape[0], mode="linear"
- ).squeeze()
- rms2 = torch.max(rms2, torch.zeros_like(rms2) + 1e-6)
- data2 *= (
- torch.pow(rms1, torch.tensor(1 - rate))
- * torch.pow(rms2, torch.tensor(rate - 1))
- ).numpy()
- return data2
-
-
-class VC(object):
- def __init__(self, tgt_sr, config):
- self.x_pad, self.x_query, self.x_center, self.x_max, self.is_half = (
- config.x_pad,
- config.x_query,
- config.x_center,
- config.x_max,
- config.is_half,
- )
- self.sr = 16000 # hubert输入采样率
- self.window = 160 # 每帧点数
- self.t_pad = self.sr * self.x_pad # 每条前后pad时间
- self.t_pad_tgt = tgt_sr * self.x_pad
- self.t_pad2 = self.t_pad * 2
- self.t_query = self.sr * self.x_query # 查询切点前后查询时间
- self.t_center = self.sr * self.x_center # 查询切点位置
- self.t_max = self.sr * self.x_max # 免查询时长阈值
- self.device = config.device
-
- def get_f0(
- self,
- input_audio_path,
- x,
- p_len,
- f0_up_key,
- f0_method,
- filter_radius,
- inp_f0=None,
- ):
- global input_audio_path2wav
- time_step = self.window / self.sr * 1000
- f0_min = 50
- f0_max = 1100
- f0_mel_min = 1127 * np.log(1 + f0_min / 700)
- f0_mel_max = 1127 * np.log(1 + f0_max / 700)
- if f0_method == "pm":
- f0 = (
- parselmouth.Sound(x, self.sr)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=f0_min,
- pitch_ceiling=f0_max,
- )
- .selected_array["frequency"]
- )
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(
- f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
- )
- elif f0_method == "harvest":
- input_audio_path2wav[input_audio_path] = x.astype(np.double)
- f0 = cache_harvest_f0(input_audio_path, self.sr, f0_max, f0_min, 10)
- if filter_radius > 2:
- f0 = signal.medfilt(f0, 3)
- elif f0_method == "crepe":
- model = "full"
- # Pick a batch size that doesn't cause memory errors on your gpu
- batch_size = 512
- # Compute pitch using first gpu
- audio = torch.tensor(np.copy(x))[None].float()
- f0, pd = torchcrepe.predict(
- audio,
- self.sr,
- self.window,
- f0_min,
- f0_max,
- model,
- batch_size=batch_size,
- device=self.device,
- return_periodicity=True,
- )
- pd = torchcrepe.filter.median(pd, 3)
- f0 = torchcrepe.filter.mean(f0, 3)
- f0[pd < 0.1] = 0
- f0 = f0[0].cpu().numpy()
- f0 *= pow(2, f0_up_key / 12)
- # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
- tf0 = self.sr // self.window # 每秒f0点数
- if inp_f0 is not None:
- delta_t = np.round(
- (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
- ).astype("int16")
- replace_f0 = np.interp(
- list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
- )
- shape = f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)].shape[0]
- f0[self.x_pad * tf0 : self.x_pad * tf0 + len(replace_f0)] = replace_f0[
- :shape
- ]
- # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
- f0bak = f0.copy()
- f0_mel = 1127 * np.log(1 + f0 / 700)
- f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
- f0_mel_max - f0_mel_min
- ) + 1
- f0_mel[f0_mel <= 1] = 1
- f0_mel[f0_mel > 255] = 255
- f0_coarse = np.rint(f0_mel).astype(np.int)
- return f0_coarse, f0bak # 1-0
-
- def vc(
- self,
- model,
- net_g,
- sid,
- audio0,
- pitch,
- pitchf,
- times,
- index,
- big_npy,
- index_rate,
- version,
- protect,
- ): # ,file_index,file_big_npy
- feats = torch.from_numpy(audio0)
- if self.is_half:
- feats = feats.half()
- else:
- feats = feats.float()
- if feats.dim() == 2: # double channels
- feats = feats.mean(-1)
- assert feats.dim() == 1, feats.dim()
- feats = feats.view(1, -1)
- padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
-
- inputs = {
- "source": feats.to(self.device),
- "padding_mask": padding_mask,
- "output_layer": 9 if version == "v1" else 12,
- }
- t0 = ttime()
- with torch.no_grad():
- logits = model.extract_features(**inputs)
- feats = model.final_proj(logits[0]) if version == "v1" else logits[0]
- if protect < 0.5 and pitch != None and pitchf != None:
- feats0 = feats.clone()
- if (
- isinstance(index, type(None)) == False
- and isinstance(big_npy, type(None)) == False
- and index_rate != 0
- ):
- npy = feats[0].cpu().numpy()
- if self.is_half:
- npy = npy.astype("float32")
-
- # _, I = index.search(npy, 1)
- # npy = big_npy[I.squeeze()]
-
- score, ix = index.search(npy, k=8)
- weight = np.square(1 / score)
- weight /= weight.sum(axis=1, keepdims=True)
- npy = np.sum(big_npy[ix] * np.expand_dims(weight, axis=2), axis=1)
-
- if self.is_half:
- npy = npy.astype("float16")
- feats = (
- torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
- + (1 - index_rate) * feats
- )
-
- feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
- if protect < 0.5 and pitch != None and pitchf != None:
- feats0 = F.interpolate(feats0.permute(0, 2, 1), scale_factor=2).permute(
- 0, 2, 1
- )
- t1 = ttime()
- p_len = audio0.shape[0] // self.window
- if feats.shape[1] < p_len:
- p_len = feats.shape[1]
- if pitch != None and pitchf != None:
- pitch = pitch[:, :p_len]
- pitchf = pitchf[:, :p_len]
-
- if protect < 0.5 and pitch != None and pitchf != None:
- pitchff = pitchf.clone()
- pitchff[pitchf > 0] = 1
- pitchff[pitchf < 1] = protect
- pitchff = pitchff.unsqueeze(-1)
- feats = feats * pitchff + feats0 * (1 - pitchff)
- feats = feats.to(feats0.dtype)
- p_len = torch.tensor([p_len], device=self.device).long()
- with torch.no_grad():
- if pitch != None and pitchf != None:
- audio1 = (
- (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0])
- .data.cpu()
- .float()
- .numpy()
- )
- else:
- audio1 = (
- (net_g.infer(feats, p_len, sid)[0][0, 0]).data.cpu().float().numpy()
- )
- del feats, p_len, padding_mask
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- t2 = ttime()
- times[0] += t1 - t0
- times[2] += t2 - t1
- return audio1
-
- def pipeline(
- self,
- model,
- net_g,
- sid,
- audio,
- input_audio_path,
- times,
- f0_up_key,
- f0_method,
- file_index,
- # file_big_npy,
- index_rate,
- if_f0,
- filter_radius,
- tgt_sr,
- resample_sr,
- rms_mix_rate,
- version,
- protect,
- f0_file=None,
- ):
- if (
- file_index != ""
- # and file_big_npy != ""
- # and os.path.exists(file_big_npy) == True
- and os.path.exists(file_index) == True
- and index_rate != 0
- ):
- try:
- index = faiss.read_index(file_index)
- # big_npy = np.load(file_big_npy)
- big_npy = index.reconstruct_n(0, index.ntotal)
- except:
- traceback.print_exc()
- index = big_npy = None
- else:
- index = big_npy = None
- audio = signal.filtfilt(bh, ah, audio)
- audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
- opt_ts = []
- if audio_pad.shape[0] > self.t_max:
- audio_sum = np.zeros_like(audio)
- for i in range(self.window):
- audio_sum += audio_pad[i : i - self.window]
- for t in range(self.t_center, audio.shape[0], self.t_center):
- opt_ts.append(
- t
- - self.t_query
- + np.where(
- np.abs(audio_sum[t - self.t_query : t + self.t_query])
- == np.abs(audio_sum[t - self.t_query : t + self.t_query]).min()
- )[0][0]
- )
- s = 0
- audio_opt = []
- t = None
- t1 = ttime()
- audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
- p_len = audio_pad.shape[0] // self.window
- inp_f0 = None
- if hasattr(f0_file, "name") == True:
- try:
- with open(f0_file.name, "r") as f:
- lines = f.read().strip("\n").split("\n")
- inp_f0 = []
- for line in lines:
- inp_f0.append([float(i) for i in line.split(",")])
- inp_f0 = np.array(inp_f0, dtype="float32")
- except:
- traceback.print_exc()
- sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
- pitch, pitchf = None, None
- if if_f0 == 1:
- pitch, pitchf = self.get_f0(
- input_audio_path,
- audio_pad,
- p_len,
- f0_up_key,
- f0_method,
- filter_radius,
- inp_f0,
- )
- pitch = pitch[:p_len]
- pitchf = pitchf[:p_len]
- if self.device == "mps":
- pitchf = pitchf.astype(np.float32)
- pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
- pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
- t2 = ttime()
- times[1] += t2 - t1
- for t in opt_ts:
- t = t // self.window * self.window
- if if_f0 == 1:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[s : t + self.t_pad2 + self.window],
- pitch[:, s // self.window : (t + self.t_pad2) // self.window],
- pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
- times,
- index,
- big_npy,
- index_rate,
- version,
- protect,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- else:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[s : t + self.t_pad2 + self.window],
- None,
- None,
- times,
- index,
- big_npy,
- index_rate,
- version,
- protect,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- s = t
- if if_f0 == 1:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[t:],
- pitch[:, t // self.window :] if t is not None else pitch,
- pitchf[:, t // self.window :] if t is not None else pitchf,
- times,
- index,
- big_npy,
- index_rate,
- version,
- protect,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- else:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[t:],
- None,
- None,
- times,
- index,
- big_npy,
- index_rate,
- version,
- protect,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- audio_opt = np.concatenate(audio_opt)
- if rms_mix_rate != 1:
- audio_opt = change_rms(audio, 16000, audio_opt, tgt_sr, rms_mix_rate)
- if resample_sr >= 16000 and tgt_sr != resample_sr:
- audio_opt = librosa.resample(
- audio_opt, orig_sr=tgt_sr, target_sr=resample_sr
- )
- audio_max = np.abs(audio_opt).max() / 0.99
- max_int16 = 32768
- if audio_max > 1:
- max_int16 /= audio_max
- audio_opt = (audio_opt * max_int16).astype(np.int16)
- del pitch, pitchf, sid
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- return audio_opt
\ No newline at end of file
diff --git a/spaces/Kevin676/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md b/spaces/Kevin676/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md
deleted file mode 100644
index a4f28a3d27d66d79cb95f2b8b847832172bb5f11..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/AutoGPT/.github/PULL_REQUEST_TEMPLATE.md
+++ /dev/null
@@ -1,40 +0,0 @@
-
-
-
-
-### Background
-
-
-### Changes
-
-
-### Documentation
-
-
-### Test Plan
-
-
-### PR Quality Checklist
-- [ ] My pull request is atomic and focuses on a single change.
-- [ ] I have thoroughly tested my changes with multiple different prompts.
-- [ ] I have considered potential risks and mitigations for my changes.
-- [ ] I have documented my changes clearly and comprehensively.
-- [ ] I have not snuck in any "extra" small tweaks changes
-
-
-
-
diff --git a/spaces/Kevin676/AutoGPT/tests/integration/milvus_memory_tests.py b/spaces/Kevin676/AutoGPT/tests/integration/milvus_memory_tests.py
deleted file mode 100644
index ec38bf2f72087b5da679d26594ebff97d8a09b19..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/AutoGPT/tests/integration/milvus_memory_tests.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# sourcery skip: snake-case-functions
-"""Tests for the MilvusMemory class."""
-import random
-import string
-import unittest
-
-from autogpt.config import Config
-from autogpt.memory.milvus import MilvusMemory
-
-try:
-
- class TestMilvusMemory(unittest.TestCase):
- """Tests for the MilvusMemory class."""
-
- def random_string(self, length: int) -> str:
- """Generate a random string of the given length."""
- return "".join(random.choice(string.ascii_letters) for _ in range(length))
-
- def setUp(self) -> None:
- """Set up the test environment."""
- cfg = Config()
- cfg.milvus_addr = "localhost:19530"
- self.memory = MilvusMemory(cfg)
- self.memory.clear()
-
- # Add example texts to the cache
- self.example_texts = [
- "The quick brown fox jumps over the lazy dog",
- "I love machine learning and natural language processing",
- "The cake is a lie, but the pie is always true",
- "ChatGPT is an advanced AI model for conversation",
- ]
-
- for text in self.example_texts:
- self.memory.add(text)
-
- # Add some random strings to test noise
- for _ in range(5):
- self.memory.add(self.random_string(10))
-
- def test_get_relevant(self) -> None:
- """Test getting relevant texts from the cache."""
- query = "I'm interested in artificial intelligence and NLP"
- num_relevant = 3
- relevant_texts = self.memory.get_relevant(query, num_relevant)
-
- print(f"Top {k} relevant texts for the query '{query}':")
- for i, text in enumerate(relevant_texts, start=1):
- print(f"{i}. {text}")
-
- self.assertEqual(len(relevant_texts), k)
- self.assertIn(self.example_texts[1], relevant_texts)
-
-except:
- print(
- "Skipping tests/integration/milvus_memory_tests.py as Milvus is not installed."
- )
diff --git a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/vocoder/fregan/stft_loss.py b/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/vocoder/fregan/stft_loss.py
deleted file mode 100644
index e47447455341e5725d6f82ded66dc08b5d2b1cc5..0000000000000000000000000000000000000000
--- a/spaces/Kevin676/ChatGPT-with-Voice-Cloning-in-Chinese/vocoder/fregan/stft_loss.py
+++ /dev/null
@@ -1,136 +0,0 @@
-# -*- coding: utf-8 -*-
-
-# Copyright 2019 Tomoki Hayashi
-# MIT License (https://opensource.org/licenses/MIT)
-
-"""STFT-based Loss modules."""
-
-import torch
-import torch.nn.functional as F
-
-
-def stft(x, fft_size, hop_size, win_length, window):
- """Perform STFT and convert to magnitude spectrogram.
- Args:
- x (Tensor): Input signal tensor (B, T).
- fft_size (int): FFT size.
- hop_size (int): Hop size.
- win_length (int): Window length.
- window (str): Window function type.
- Returns:
- Tensor: Magnitude spectrogram (B, #frames, fft_size // 2 + 1).
- """
- x_stft = torch.stft(x, fft_size, hop_size, win_length, window)
- real = x_stft[..., 0]
- imag = x_stft[..., 1]
-
- # NOTE(kan-bayashi): clamp is needed to avoid nan or inf
- return torch.sqrt(torch.clamp(real ** 2 + imag ** 2, min=1e-7)).transpose(2, 1)
-
-
-class SpectralConvergengeLoss(torch.nn.Module):
- """Spectral convergence loss module."""
-
- def __init__(self):
- """Initilize spectral convergence loss module."""
- super(SpectralConvergengeLoss, self).__init__()
-
- def forward(self, x_mag, y_mag):
- """Calculate forward propagation.
- Args:
- x_mag (Tensor): Magnitude spectrogram of predicted signal (B, #frames, #freq_bins).
- y_mag (Tensor): Magnitude spectrogram of groundtruth signal (B, #frames, #freq_bins).
- Returns:
- Tensor: Spectral convergence loss value.
- """
- return torch.norm(y_mag - x_mag, p="fro") / torch.norm(y_mag, p="fro")
-
-
-class LogSTFTMagnitudeLoss(torch.nn.Module):
- """Log STFT magnitude loss module."""
-
- def __init__(self):
- """Initilize los STFT magnitude loss module."""
- super(LogSTFTMagnitudeLoss, self).__init__()
-
- def forward(self, x_mag, y_mag):
- """Calculate forward propagation.
- Args:
- x_mag (Tensor): Magnitude spectrogram of predicted signal (B, #frames, #freq_bins).
- y_mag (Tensor): Magnitude spectrogram of groundtruth signal (B, #frames, #freq_bins).
- Returns:
- Tensor: Log STFT magnitude loss value.
- """
- return F.l1_loss(torch.log(y_mag), torch.log(x_mag))
-
-
-class STFTLoss(torch.nn.Module):
- """STFT loss module."""
-
- def __init__(self, fft_size=1024, shift_size=120, win_length=600, window="hann_window"):
- """Initialize STFT loss module."""
- super(STFTLoss, self).__init__()
- self.fft_size = fft_size
- self.shift_size = shift_size
- self.win_length = win_length
- self.window = getattr(torch, window)(win_length)
- self.spectral_convergenge_loss = SpectralConvergengeLoss()
- self.log_stft_magnitude_loss = LogSTFTMagnitudeLoss()
-
- def forward(self, x, y):
- """Calculate forward propagation.
- Args:
- x (Tensor): Predicted signal (B, T).
- y (Tensor): Groundtruth signal (B, T).
- Returns:
- Tensor: Spectral convergence loss value.
- Tensor: Log STFT magnitude loss value.
- """
- x_mag = stft(x, self.fft_size, self.shift_size, self.win_length, self.window.to(x.get_device()))
- y_mag = stft(y, self.fft_size, self.shift_size, self.win_length, self.window.to(x.get_device()))
- sc_loss = self.spectral_convergenge_loss(x_mag, y_mag)
- mag_loss = self.log_stft_magnitude_loss(x_mag, y_mag)
-
- return sc_loss, mag_loss
-
-
-class MultiResolutionSTFTLoss(torch.nn.Module):
- """Multi resolution STFT loss module."""
-
- def __init__(self,
- fft_sizes=[1024, 2048, 512],
- hop_sizes=[120, 240, 50],
- win_lengths=[600, 1200, 240],
- window="hann_window"):
- """Initialize Multi resolution STFT loss module.
- Args:
- fft_sizes (list): List of FFT sizes.
- hop_sizes (list): List of hop sizes.
- win_lengths (list): List of window lengths.
- window (str): Window function type.
- """
- super(MultiResolutionSTFTLoss, self).__init__()
- assert len(fft_sizes) == len(hop_sizes) == len(win_lengths)
- self.stft_losses = torch.nn.ModuleList()
- for fs, ss, wl in zip(fft_sizes, hop_sizes, win_lengths):
- self.stft_losses += [STFTLoss(fs, ss, wl, window)]
-
- def forward(self, x, y):
- """Calculate forward propagation.
- Args:
- x (Tensor): Predicted signal (B, T).
- y (Tensor): Groundtruth signal (B, T).
- Returns:
- Tensor: Multi resolution spectral convergence loss value.
- Tensor: Multi resolution log STFT magnitude loss value.
- """
- sc_loss = 0.0
- mag_loss = 0.0
- for f in self.stft_losses:
- sc_l, mag_l = f(x, y)
- sc_loss += sc_l
- mag_loss += mag_l
- sc_loss /= len(self.stft_losses)
- mag_loss /= len(self.stft_losses)
-
- return sc_loss, mag_loss
\ No newline at end of file
diff --git a/spaces/Kushiii112/stabilityai-stable-diffusion-xl-base-1.0/app.py b/spaces/Kushiii112/stabilityai-stable-diffusion-xl-base-1.0/app.py
deleted file mode 100644
index 9520517f687cf7229ddfab9d8c5f8af7f76b0bd4..0000000000000000000000000000000000000000
--- a/spaces/Kushiii112/stabilityai-stable-diffusion-xl-base-1.0/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/stabilityai/stable-diffusion-xl-base-1.0").launch()
\ No newline at end of file
diff --git a/spaces/Lianjd/stock_dashboard/backtrader/indicators/kst.py b/spaces/Lianjd/stock_dashboard/backtrader/indicators/kst.py
deleted file mode 100644
index 9f358f7b69aff3066918523580d14002385a75bd..0000000000000000000000000000000000000000
--- a/spaces/Lianjd/stock_dashboard/backtrader/indicators/kst.py
+++ /dev/null
@@ -1,77 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8; py-indent-offset:4 -*-
-###############################################################################
-#
-# Copyright (C) 2015-2020 Daniel Rodriguez
-#
-# This program is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, either version 3 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program. If not, see "
-
- self.state.add_factory("target_dictionary", self.load_target_dictionary)
-
- def load_target_dictionary(self):
- if self.cfg.labels:
- dict_path = os.path.join(self.cfg.data, f"dict.{self.cfg.labels}.txt")
- return Dictionary.load(dict_path)
- return None
-
- def load_dataset(self, split: str, task_cfg: AudioFinetuningConfig = None, **kwargs):
- super().load_dataset(split, task_cfg, **kwargs)
-
- task_cfg = task_cfg or self.cfg
- assert task_cfg.labels is not None
- text_compression_level = getattr(
- TextCompressionLevel, str(self.cfg.text_compression_level)
- )
- data_path = self.cfg.data
- label_path = os.path.join(data_path, f"{split}.{task_cfg.labels}")
- skipped_indices = getattr(self.datasets[split], "skipped_indices", set())
- text_compressor = TextCompressor(level=text_compression_level)
- with open(label_path, "r") as f:
- labels = [
- text_compressor.compress(l)
- for i, l in enumerate(f) if i not in skipped_indices
- ]
-
- assert len(labels) == len(self.datasets[split]), (
- f"labels length ({len(labels)}) and dataset length "
- f"({len(self.datasets[split])}) do not match"
- )
-
- process_label = LabelEncoder(self.target_dictionary)
-
- self.datasets[split] = AddTargetDataset(
- self.datasets[split],
- labels,
- pad=self.target_dictionary.pad(),
- eos=self.target_dictionary.eos(),
- batch_targets=True,
- process_label=process_label,
- label_len_fn=label_len_fn,
- add_to_input=task_cfg.get("autoregressive", False),
- text_compression_level=text_compression_level
- )
-
- @property
- def target_dictionary(self):
- """Return the :class:`~fairseq.data.Dictionary` for the language
- model."""
- return self.state.target_dictionary
-
- def valid_step(self, sample, model, criterion):
- loss, sample_size, logging_output = super().valid_step(sample, model, criterion)
- if self.cfg.eval_wer and self.cfg.autoregressive:
- metrics = self._inference_with_wer(self.sequence_generator, sample, model)
- logging_output["_num_char_errors"] = metrics["num_char_errors"]
- logging_output["_num_chars"] = metrics["num_chars"]
- logging_output["_num_word_errors"] = metrics["num_word_errors"]
- logging_output["_num_words"] = metrics["num_words"]
- if self.cfg.eval_bleu and self.cfg.autoregressive:
- metrics = self._inference_with_bleu(self.sequence_generator, sample, model)
- logging_output['_bleu_sys_len'] = metrics.sys_len
- logging_output['_bleu_ref_len'] = metrics.ref_len
- # we split counts into separate entries so that they can be
- # summed efficiently across workers using fast-stat-sync
- assert len(metrics.counts) == 4
- for i in range(4):
- logging_output[f"_bleu_counts_{i}"] = metrics.counts[i]
- logging_output[f"_bleu_totals_{i}"] = metrics.totals[i]
- return loss, sample_size, logging_output
-
- def build_model(self, model_cfg: FairseqDataclass):
- model = super().build_model(model_cfg)
-
- if self.cfg.eval_wer and self.cfg.autoregressive:
- self.sequence_generator = self.build_generator(
- [model],
- self.cfg.eval_wer_config,
- )
- if self.cfg.eval_wer_tokenizer:
- self.tokenizer = encoders.build_tokenizer(self.cfg.eval_wer_tokenizer)
- else:
- self.tokenizer = None
- if self.cfg.eval_bleu and self.cfg.autoregressive:
- assert self.cfg.eval_bleu_detok is not None, (
- '--eval-bleu-detok is required if using --eval-bleu; '
- 'try --eval-bleu-detok=moses (or --eval-bleu-detok=space '
- 'to disable detokenization, e.g., when using sentencepiece)'
- )
- detok_args = json.loads(self.cfg.eval_bleu_detok_args)
- self.tokenizer = encoders.build_tokenizer(
- Namespace(tokenizer=self.cfg.eval_bleu_detok, **detok_args)
- )
- gen_args = json.loads(self.cfg.eval_bleu_args)
- gen_args = Namespace(**gen_args)
- self.sequence_generator = self.build_generator([model], gen_args)
-
- return model
-
- def _inference_with_wer(self, generator, sample, model):
- import editdistance
-
- def decode(toks):
- s = self.target_dictionary.string(
- toks.int().cpu(),
- self.cfg.eval_wer_post_process,
- escape_unk=True,
- )
- if self.tokenizer:
- s = self.tokenizer.decode(s)
- return s
-
- num_word_errors, num_char_errors = 0, 0
- num_chars, num_words = 0, 0
- gen_out = self.inference_step(generator, [model], sample, None)
- for i in range(len(gen_out)):
- hyp = decode(gen_out[i][0]["tokens"])
- ref = decode(
- utils.strip_pad(sample["target"][i], self.target_dictionary.pad()),
- )
- num_char_errors += editdistance.eval(hyp, ref)
- num_chars += len(ref)
- hyp_words = hyp.split()
- ref_words = ref.split()
- num_word_errors += editdistance.eval(hyp_words, ref_words)
- num_words += len(ref_words)
-
- return {
- "num_char_errors": num_char_errors,
- "num_chars": num_chars,
- "num_word_errors": num_word_errors,
- "num_words": num_words,
- }
-
- def _inference_with_bleu(self, generator, sample, model):
- import sacrebleu
-
- def decode(toks, is_ref):
- s = self.target_dictionary.string(
- toks.int().cpu(),
- self.cfg.eval_bleu_remove_bpe,
- # The default unknown string in fairseq is ``, but
- # this is tokenized by sacrebleu as `< unk >`, inflating
- # BLEU scores. Instead, we use a somewhat more verbose
- # alternative that is unlikely to appear in the real
- # reference, but doesn't get split into multiple tokens.
- unk_string=(
- "UNKNOWNTOKENINREF" if is_ref else "UNKNOWNTOKENINHYP"
- ),
- )
- if self.tokenizer:
- s = self.tokenizer.decode(s)
- return s
-
- gen_out = self.inference_step(generator, [model], sample)
- hyps, refs = [], []
- for i in range(len(gen_out)):
- hyps.append(decode(gen_out[i][0]['tokens'], is_ref=False))
- refs.append(
- decode(
- utils.strip_pad(
- sample['target'][i],
- self.target_dictionary.pad()
- ),
- is_ref=True, # don't count as matches to the hypo
- )
- )
- if self.cfg.eval_bleu_print_samples:
- logger.info('H-{} {}'.format(sample["id"][0], hyps[0]))
- logger.info('T-{} {}'.format(sample["id"][0], refs[0]))
-
- eval_tokenization = 'none' if self.cfg.eval_tokenized_bleu else '13a'
- return sacrebleu.corpus_bleu(hyps, [refs], tokenize=eval_tokenization)
-
- def reduce_metrics(self, logging_outputs, criterion):
- super().reduce_metrics(logging_outputs, criterion)
-
- if self.cfg.eval_wer:
- zero = torch.scalar_tensor(0.0)
- num_char_errors = sum(
- log.get("_num_char_errors", zero) for log in logging_outputs
- )
- num_chars = sum(log.get("_num_chars", zero) for log in logging_outputs)
- num_word_errors = sum(
- log.get("_num_word_errors", zero) for log in logging_outputs
- )
- num_words = sum(log.get("_num_words", zero) for log in logging_outputs)
- metrics.log_scalar("_num_char_errors", num_char_errors)
- metrics.log_scalar("_num_chars", num_chars)
- metrics.log_scalar("_num_word_errors", num_word_errors)
- metrics.log_scalar("_num_words", num_words)
- if num_chars > 0:
- metrics.log_derived(
- "uer",
- lambda meters: meters["_num_char_errors"].sum
- * 100.0
- / meters["_num_chars"].sum
- if meters["_num_chars"].sum > 0
- else float("nan"),
- )
- if num_words > 0:
- metrics.log_derived(
- "wer",
- lambda meters: meters["_num_word_errors"].sum
- * 100.0
- / meters["_num_words"].sum
- if meters["_num_words"].sum > 0
- else float("nan"),
- )
- if self.cfg.eval_bleu:
- len_keys = ["_bleu_sys_len", "_bleu_ref_len"]
- count_keys = [f"_bleu_counts_{i}" for i in range(4)]
- total_keys = [f"_bleu_totals_{i}" for i in range(4)]
- for k in len_keys + count_keys + total_keys:
- metrics.log_scalar(
- k, sum(log.get(k, 0) for log in logging_outputs)
- )
-
- import sacrebleu
- metrics.log_derived(
- 'bleu',
- lambda meters: sacrebleu.compute_bleu(
- correct=[meters[k].sum for k in count_keys],
- total=[meters[k].sum for k in total_keys],
- sys_len=meters['_bleu_sys_len'].sum,
- ref_len=meters['_bleu_ref_len'].sum,
- smooth_method="exp"
- ).score
- )
diff --git a/spaces/OpenDILabCommunity/LLMRiddlesChatGPTCN/llmriddles/questions/__init__.py b/spaces/OpenDILabCommunity/LLMRiddlesChatGPTCN/llmriddles/questions/__init__.py
deleted file mode 100644
index 6904d13a3d820f39b4b54d09671673e49a06aa4c..0000000000000000000000000000000000000000
--- a/spaces/OpenDILabCommunity/LLMRiddlesChatGPTCN/llmriddles/questions/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-from .executor import QuestionExecutor
-from .level1 import __file__ as _level1_file_
-from .level2 import __file__ as _level2_file_
-from .level3 import __file__ as _level3_file_
-from .level4 import __file__ as _level4_file_
-from .level5 import __file__ as _level5_file_
-from .question import Question, register_question, list_ordered_questions
-
-_ = _level1_file_
-_ = _level2_file_
-_ = _level3_file_
-_ = _level4_file_
-_ = _level5_file_
\ No newline at end of file
diff --git a/spaces/OpenMotionLab/MotionGPT/mGPT/metrics/m2m.py b/spaces/OpenMotionLab/MotionGPT/mGPT/metrics/m2m.py
deleted file mode 100644
index 780d34dadf7d9b01369884b1ae3e5a6e0c6bceb3..0000000000000000000000000000000000000000
--- a/spaces/OpenMotionLab/MotionGPT/mGPT/metrics/m2m.py
+++ /dev/null
@@ -1,95 +0,0 @@
-from typing import List
-
-import torch
-from torch import Tensor
-from torchmetrics import Metric
-
-from .utils import *
-
-
-# motion reconstruction metric
-class PredMetrics(Metric):
-
- def __init__(self,
- cfg,
- njoints: int = 22,
- jointstype: str = "mmm",
- force_in_meter: bool = True,
- align_root: bool = True,
- dist_sync_on_step=True,
- task: str = "pred",
- **kwargs):
- super().__init__(dist_sync_on_step=dist_sync_on_step)
-
- self.name = 'Motion Prdiction'
- self.cfg = cfg
- self.jointstype = jointstype
- self.align_root = align_root
- self.task = task
- self.force_in_meter = force_in_meter
-
- self.add_state("count", default=torch.tensor(0), dist_reduce_fx="sum")
- self.add_state("count_seq",
- default=torch.tensor(0),
- dist_reduce_fx="sum")
-
- self.add_state("APD",
- default=torch.tensor([0.0]),
- dist_reduce_fx="sum")
- self.add_state("ADE",
- default=torch.tensor([0.0]),
- dist_reduce_fx="sum")
- self.add_state("FDE",
- default=torch.tensor([0.0]),
- dist_reduce_fx="sum")
-
- self.MR_metrics = ["APD", "ADE", "FDE"]
-
- # All metric
- self.metrics = self.MR_metrics
-
- def compute(self, sanity_flag):
-
- count = self.count
- count_seq = self.count_seq
- mr_metrics = {}
- mr_metrics["APD"] = self.APD / count_seq
- mr_metrics["ADE"] = self.ADE / count_seq
- mr_metrics["FDE"] = self.FDE / count_seq
-
- # Reset
- self.reset()
-
- return mr_metrics
-
- def update(self, joints_rst: Tensor, joints_ref: Tensor,
- lengths: List[int]):
-
- assert joints_rst.shape == joints_ref.shape
- assert joints_rst.dim() == 4
- # (bs, seq, njoint=22, 3)
-
- self.count += sum(lengths)
- self.count_seq += len(lengths)
-
- rst = torch.flatten(joints_rst, start_dim=2)
- ref = torch.flatten(joints_ref, start_dim=2)
-
- for i, l in enumerate(lengths):
- if self.task == "pred":
- pred_start = int(l*self.cfg.ABLATION.predict_ratio)
- diff = rst[i,pred_start:] - ref[i,pred_start:]
- elif self.task == "inbetween":
- inbetween_start = int(l*self.cfg.ABLATION.inbetween_ratio)
- inbetween_end = l - int(l*self.cfg.ABLATION.inbetween_ratio)
- diff = rst[i,inbetween_start:inbetween_end] - ref[i,inbetween_start:inbetween_end]
- else:
- print(f"Task {self.task} not implemented.")
- diff = rst - ref
-
- dist = torch.linalg.norm(diff, dim=-1)[None]
-
- ade = dist.mean(dim=1)
- fde = dist[:,-1]
- self.ADE = self.ADE + ade
- self.FDE = self.FDE + fde
diff --git a/spaces/OpenMotionLab/MotionGPT/pyrender/tests/unit/__init__.py b/spaces/OpenMotionLab/MotionGPT/pyrender/tests/unit/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/ops/psa_mask.py b/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/ops/psa_mask.py
deleted file mode 100644
index cdf14e62b50e8d4dd6856c94333c703bcc4c9ab6..0000000000000000000000000000000000000000
--- a/spaces/PAIR/Text2Video-Zero/annotator/uniformer/mmcv/ops/psa_mask.py
+++ /dev/null
@@ -1,92 +0,0 @@
-# Modified from https://github.com/hszhao/semseg/blob/master/lib/psa
-from torch import nn
-from torch.autograd import Function
-from torch.nn.modules.utils import _pair
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext',
- ['psamask_forward', 'psamask_backward'])
-
-
-class PSAMaskFunction(Function):
-
- @staticmethod
- def symbolic(g, input, psa_type, mask_size):
- return g.op(
- 'mmcv::MMCVPSAMask',
- input,
- psa_type_i=psa_type,
- mask_size_i=mask_size)
-
- @staticmethod
- def forward(ctx, input, psa_type, mask_size):
- ctx.psa_type = psa_type
- ctx.mask_size = _pair(mask_size)
- ctx.save_for_backward(input)
-
- h_mask, w_mask = ctx.mask_size
- batch_size, channels, h_feature, w_feature = input.size()
- assert channels == h_mask * w_mask
- output = input.new_zeros(
- (batch_size, h_feature * w_feature, h_feature, w_feature))
-
- ext_module.psamask_forward(
- input,
- output,
- psa_type=psa_type,
- num_=batch_size,
- h_feature=h_feature,
- w_feature=w_feature,
- h_mask=h_mask,
- w_mask=w_mask,
- half_h_mask=(h_mask - 1) // 2,
- half_w_mask=(w_mask - 1) // 2)
- return output
-
- @staticmethod
- def backward(ctx, grad_output):
- input = ctx.saved_tensors[0]
- psa_type = ctx.psa_type
- h_mask, w_mask = ctx.mask_size
- batch_size, channels, h_feature, w_feature = input.size()
- grad_input = grad_output.new_zeros(
- (batch_size, channels, h_feature, w_feature))
- ext_module.psamask_backward(
- grad_output,
- grad_input,
- psa_type=psa_type,
- num_=batch_size,
- h_feature=h_feature,
- w_feature=w_feature,
- h_mask=h_mask,
- w_mask=w_mask,
- half_h_mask=(h_mask - 1) // 2,
- half_w_mask=(w_mask - 1) // 2)
- return grad_input, None, None, None
-
-
-psa_mask = PSAMaskFunction.apply
-
-
-class PSAMask(nn.Module):
-
- def __init__(self, psa_type, mask_size=None):
- super(PSAMask, self).__init__()
- assert psa_type in ['collect', 'distribute']
- if psa_type == 'collect':
- psa_type_enum = 0
- else:
- psa_type_enum = 1
- self.psa_type_enum = psa_type_enum
- self.mask_size = mask_size
- self.psa_type = psa_type
-
- def forward(self, input):
- return psa_mask(input, self.psa_type_enum, self.mask_size)
-
- def __repr__(self):
- s = self.__class__.__name__
- s += f'(psa_type={self.psa_type}, '
- s += f'mask_size={self.mask_size})'
- return s
diff --git a/spaces/PSMdata/langchain-llama2-7b-chat/app.py b/spaces/PSMdata/langchain-llama2-7b-chat/app.py
deleted file mode 100644
index cd31257a825ae4a198b723a192eed8e6357631b3..0000000000000000000000000000000000000000
--- a/spaces/PSMdata/langchain-llama2-7b-chat/app.py
+++ /dev/null
@@ -1,554 +0,0 @@
-"""Run codes."""
-# pylint: disable=line-too-long, broad-exception-caught, invalid-name, missing-function-docstring, too-many-instance-attributes, missing-class-docstring
-# ruff: noqa: E501
-import gc
-import os
-import platform
-import random
-import time
-from collections import deque
-from pathlib import Path
-from threading import Thread
-from typing import Any, Dict, List, Union
-
-# from types import SimpleNamespace
-import gradio as gr
-import psutil
-from about_time import about_time
-from ctransformers import Config
-from dl_hf_model import dl_hf_model
-from langchain.callbacks.base import BaseCallbackHandler
-from langchain.callbacks.streaming_stdout import StreamingStdOutCallbackHandler
-from langchain.chains import ConversationChain
-from langchain.chains.conversation.memory import ConversationBufferWindowMemory
-
-# from ctransformers import AutoModelForCausalLM
-from langchain.llms import CTransformers
-from langchain.prompts import PromptTemplate
-from langchain.schema import LLMResult
-from loguru import logger
-
-deq = deque()
-sig_end = object() # signals the processing is done
-
-# from langchain.llms import OpenAI
-
-filename_list = [
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q2_K.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q3_K_L.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q3_K_M.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q3_K_S.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q4_0.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q4_1.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q4_K_M.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q4_K_S.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q5_0.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q5_1.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q5_K_M.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q5_K_S.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q6_K.bin",
- "Wizard-Vicuna-7B-Uncensored.ggmlv3.q8_0.bin",
-]
-
-URL = "https://huggingface.co/TheBloke/Wizard-Vicuna-7B-Uncensored-GGML/raw/main/Wizard-Vicuna-7B-Uncensored.ggmlv3.q4_K_M.bin" # 4.05G
-
-url = "https://huggingface.co/savvamadar/ggml-gpt4all-j-v1.3-groovy/blob/main/ggml-gpt4all-j-v1.3-groovy.bin"
-url = "https://huggingface.co/TheBloke/Llama-2-13B-GGML/blob/main/llama-2-13b.ggmlv3.q4_K_S.bin" # 7.37G
-# url = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q3_K_L.bin"
-url = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q3_K_L.bin" # 6.93G
-# url = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q3_K_L.binhttps://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q4_K_M.bin" # 7.87G
-
-url = "https://huggingface.co/localmodels/Llama-2-13B-Chat-ggml/blob/main/llama-2-13b-chat.ggmlv3.q4_K_S.bin" # 7.37G
-
-_ = (
- "golay" in platform.node()
- or "okteto" in platform.node()
- or Path("/kaggle").exists()
- # or psutil.cpu_count(logical=False) < 4
- or 1 # run 7b in hf
-)
-
-if _:
- # url = "https://huggingface.co/TheBloke/Llama-2-13B-chat-GGML/blob/main/llama-2-13b-chat.ggmlv3.q2_K.bin"
- url = "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/blob/main/llama-2-7b-chat.ggmlv3.q2_K.bin" # 2.87G
- url = "https://huggingface.co/TheBloke/Llama-2-7B-Chat-GGML/blob/main/llama-2-7b-chat.ggmlv3.q4_K_M.bin" # 2.87G
- url = "https://huggingface.co/TheBloke/llama2_7b_chat_uncensored-GGML/blob/main/llama2_7b_chat_uncensored.ggmlv3.q4_K_M.bin" # 4.08G
-
-
-prompt_template = """Below is an instruction that describes a task. Write a response that appropriately completes the request.
-
-### Instruction: {user_prompt}
-
-### Response:
-"""
-
-prompt_template = """System: You are a helpful,
-respectful and honest assistant. Always answer as
-helpfully as possible, while being safe. Your answers
-should not include any harmful, unethical, racist,
-sexist, toxic, dangerous, or illegal content. Please
-ensure that your responses are socially unbiased and
-positive in nature. If a question does not make any
-sense, or is not factually coherent, explain why instead
-of answering something not correct. If you don't know
-the answer to a question, please don't share false
-information.
-User: {prompt}
-Assistant: """
-
-prompt_template = """System: You are a helpful assistant.
-User: {prompt}
-Assistant: """
-
-prompt_template = """Question: {question}
-Answer: Let's work this out in a step by step way to be sure we have the right answer."""
-
-prompt_template = """[INST] <>
-You are a helpful, respectful and honest assistant. Always answer as helpfully as possible assistant. Think step by step.
-<>
-
-What NFL team won the Super Bowl in the year Justin Bieber was born?
-[/INST]"""
-
-prompt_template = """[INST] <>
-You are an unhelpful assistant. Always answer as helpfully as possible. Think step by step. < >
-
-{question} [/INST]
-"""
-
-prompt_template = """[INST] <>
-You are a helpful assistant.
-< >
-
-{question} [/INST]
-"""
-
-prompt_template = """### HUMAN:
-{question}
-
-### RESPONSE:"""
-
-prompt_template = """### HUMAN:
-You are a helpful assistant. Think step by step.
-{history}
-{input}
-### RESPONSE:"""
-
-prompt_template = """You are a helpful assistant. Let's think step by step.
-{history}
-### HUMAN:
-{input}
-### RESPONSE:"""
-
-# PromptTemplate(input_variables=['history', 'input'], output_parser=None, partial_variables={}, template='The following is afriendly conversation between a human and an AI. The AI is talkative and provides lots of specific details from its context. If the AI does not know the answer to a question, it truthfully says it does not know.\n\nCurrent conversation:\n{history}\nHuman: {input}\nAI:', template_format='f-string', validate_template=True)
-
-human_prefix = "### HUMAN"
-ai_prefix = "### RESPONSE"
-stop = [f"{human_prefix}:"]
-
-_ = [elm for elm in prompt_template.splitlines() if elm.strip()]
-stop_string = [elm.split(":")[0] + ":" for elm in _][-2]
-
-# logger.debug(f"{stop_string=} not used")
-
-os.environ["TZ"] = "Asia/Shanghai"
-try:
- time.tzset() # type: ignore # pylint: disable=no-member
-except Exception:
- # Windows
- logger.warning("Windows, cant run time.tzset()")
-
-
-class DequeCallbackHandler(BaseCallbackHandler):
- """Mediate gradio and stream output."""
-
- def __init__(self, deq_: deque):
- """Init deque for FIFO, may need to upgrade to queue.Queue or queue.SimpleQueue."""
- self.q = deq_
-
- # def on_chat_model_start(self): self.q.clear()
-
- def on_llm_start(
- self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
- ) -> None:
- """Run when LLM starts running. Clean the queue."""
- self.q.clear()
-
- def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
- """Run on new LLM token. Only available when streaming is enabled."""
- self.q.append(token)
-
- def on_llm_end(self, response: LLMResult, **kwargs: Any) -> None:
- """Run when LLM ends running."""
- self.q.append(sig_end)
-
- def on_llm_error(
- self, error: Union[Exception, KeyboardInterrupt], **kwargs: Any
- ) -> None:
- """Run when LLM errors."""
- self.q.append(sig_end)
-
-
-_ = psutil.cpu_count(logical=False) - 1
-cpu_count: int = int(_) if _ else 1
-logger.debug(f"{cpu_count=}")
-
-LLM = None
-gc.collect()
-
-try:
- model_loc, file_size = dl_hf_model(url)
-except Exception as exc_:
- logger.error(exc_)
- raise SystemExit(1) from exc_
-
-config = Config()
-# Config(top_k=40, top_p=0.95, temperature=0.8, repetition_penalty=1.1, last_n_tokens=64, seed=-1, batch_size=8, threads=-1, max_new_tokens=256, stop=None, stream=False, reset=True, context_length=-1, gpu_layers=0)
-config.stream = True
-config.stop = stop
-config.threads = cpu_count
-
-deqcb = DequeCallbackHandler(deq)
-
-# LLM = AutoModelForCausalLM.from_pretrained(
-LLM = CTransformers(
- model=model_loc,
- model_type="llama",
- callbacks=[StreamingStdOutCallbackHandler(), deqcb],
- # config=config,
- **vars(config),
-)
-
-logger.info(f"done load llm {model_loc=} {file_size=}G")
-
-prompt = PromptTemplate(
- input_variables=["history", "input"],
- output_parser=None,
- partial_variables={},
- template=prompt_template,
- template_format="f-string",
- validate_template=True,
-)
-
-memory = ConversationBufferWindowMemory(
- human_prefix=human_prefix,
- ai_prefix=ai_prefix,
-) # default k=5
-
-conversation = ConversationChain(
- llm=LLM,
- prompt=prompt,
- memory=memory,
- verbose=True,
-)
-logger.debug(f"{conversation.prompt.template=}") # type: ignore
-
-# for api access ===
-config = Config()
-# Config(top_k=40, top_p=0.95, temperature=0.8, repetition_penalty=1.1, last_n_tokens=64, seed=-1, batch_size=8, threads=-1, max_new_tokens=256, stop=None, stream=False, reset=True, context_length=-1, gpu_layers=0)
-config.stop = stop
-config.threads = cpu_count
-
-try:
- LLM_api = CTransformers(
- model=model_loc,
- model_type="llama",
- # callbacks=[StreamingStdOutCallbackHandler(), deqcb],
- callbacks=[StreamingStdOutCallbackHandler()],
- **vars(config),
- )
- conversation_api = ConversationChain(
- llm=LLM_api, # need a separate LLM, or else deq may be messed up
- prompt=prompt,
- verbose=True,
- )
-except Exception as exc_:
- logger.error(exc_)
- conversation_api = None
- logger.warning("Not able to instantiate conversation_api, api will not work")
-
-# conversation.predict(input="Hello, my name is Andrea")
-
-
-def user(user_message, history):
- # return user_message, history + [[user_message, None]]
- history.append([user_message, None])
- return user_message, history # keep user_message
-
-
-def user1(user_message, history):
- # return user_message, history + [[user_message, None]]
- history.append([user_message, None])
- return "", history # clear user_message
-
-
-def bot_(history):
- user_message = history[-1][0]
- resp = random.choice(["How are you?", "I love you", "I'm very hungry"])
- bot_message = user_message + ": " + resp
- history[-1][1] = ""
- for character in bot_message:
- history[-1][1] += character
- time.sleep(0.02)
- yield history
-
- history[-1][1] = resp
- yield history
-
-
-def bot(history):
- user_message = history[-1][0]
- response = []
-
- logger.debug(f"{user_message=}")
-
- # conversation.predict(input="What's my name?")
- thr = Thread(target=conversation.predict, kwargs={"input": user_message})
- thr.start()
-
- # preocess deq
- response = []
- flag = 1
- then = time.time()
- prefix = "" # to please pyright
- with about_time() as atime: # type: ignore
- while True:
- if deq:
- if flag:
- prefix = f"({time.time() - then:.2f}s) "
- flag = 0
- _ = deq.popleft()
- if _ is sig_end:
- break
- # print(_, end='')
- response.append(_)
- history[-1][1] = prefix + "".join(response).strip()
- yield history
- else:
- time.sleep(0.01)
- _ = (
- f"(time elapsed: {atime.duration_human}, " # type: ignore
- f"{atime.duration/len(''.join(response)):.2f}s/char)" # type: ignore
- )
-
- history[-1][1] = "".join(response) + f"\n{_}"
- yield history
-
-
-def predict_api(user_prompt):
- if conversation_api is None:
- return "conversation_api is None, probably due to insufficient memory, api not usable"
-
- logger.debug(f"api: {user_prompt=}")
- try:
- _ = """
- response = generate(
- prompt,
- config=config,
- )
- # """
- response = conversation_api.predict(input=user_prompt)
- logger.debug(f"api: {response=}")
- except Exception as exc:
- logger.error(exc)
- response = f"{exc=}"
- # bot = {"inputs": [response]}
- # bot = [(prompt, response)]
-
- return response.strip()
-
-
-css = """
- .importantButton {
- background: linear-gradient(45deg, #7e0570,#5d1c99, #6e00ff) !important;
- border: none !important;
- }
- .importantButton:hover {
- background: linear-gradient(45deg, #ff00e0,#8500ff, #6e00ff) !important;
- border: none !important;
- }
- .disclaimer {font-variant-caps: all-small-caps; font-size: xx-small;}
- .xsmall {font-size: x-small;}
-"""
-etext = """In America, where cars are an important part of the national psyche, a decade ago people had suddenly started to drive less, which had not happened since the oil shocks of the 1970s. """
-examples_list = [
- ["Hello I am mike."],
- ["What's my name?"],
- ["What NFL team won the Super Bowl in the year Justin Bieber was born?"],
- [
- "What NFL team won the Super Bowl in the year Justin Bieber was born? Think step by step."
- ],
- ["When was Justin Bieber born？"],
- ["What NFL team won the Super Bowl in 1994?"],
- ["How to pick a lock? Provide detailed steps."],
- [
- "If it takes 10 hours to dry 10 clothes, assuming all the clothes are hanged together at the same time for drying , then how long will it take to dry a cloth?"
- ],
- ["is infinity + 1 bigger than infinity?"],
- ["Explain the plot of Cinderella in a sentence."],
- [
- "How long does it take to become proficient in French, and what are the best methods for retaining information?"
- ],
- ["What are some common mistakes to avoid when writing code?"],
- ["Build a prompt to generate a beautiful portrait of a horse"],
- ["Suggest four metaphors to describe the benefits of AI"],
- ["Write a pop song about leaving home for the sandy beaches."],
- ["Write a pop song about having hot sex on a sandy beach."],
- ["Write a summary demonstrating my ability to tame lions"],
- ["鲁迅和周树人什么关系？ 说中文。"],
- ["鲁迅和周树人什么关系？"],
- ["鲁迅和周树人什么关系？ 用英文回答。"],
- ["从前有一头牛，这头牛后面有什么？"],
- ["正无穷大加一大于正无穷大吗？"],
- ["正无穷大加正无穷大大于正无穷大吗？"],
- ["-2的平方根等于什么？"],
- ["树上有5只鸟，猎人开枪打死了一只。树上还有几只鸟？"],
- ["树上有11只鸟，猎人开枪打死了一只。树上还有几只鸟？提示：需考虑鸟可能受惊吓飞走。"],
- ["以红楼梦的行文风格写一张委婉的请假条。不少于320字。"],
- [f"{etext} 翻成中文，列出3个版本。"],
- [f"{etext} \n 翻成中文，保留原意，但使用文学性的语言。不要写解释。列出3个版本。"],
- ["假定 1 + 2 = 4, 试求 7 + 8。"],
- ["给出判断一个数是不是质数的 javascript 码。"],
- ["给出实现python 里 range(10)的 javascript 码。"],
- ["给出实现python 里 [*(range(10)]的 javascript 码。"],
- ["Erkläre die Handlung von Cinderella in einem Satz."],
- ["Erkläre die Handlung von Cinderella in einem Satz. Auf Deutsch."],
-]
-
-logger.info("start block")
-
-with gr.Blocks(
- title=f"{Path(model_loc).name}",
- theme=gr.themes.Soft(text_size="sm", spacing_size="sm"),
- css=css,
-) as block:
- # buff_var = gr.State("")
- with gr.Accordion("🎈 Info", open=False):
- # gr.HTML(
- # """{Path(model_loc).name}
- The bot can conduct multi-turn conversations, i.e. it remembers past dialogs. The process time is longer.
- It typically takes about 120 seconds for the first response to appear.
-
- Most examples are meant for another model.
- You probably should try to test
- some related prompts.""",
- elem_classes="xsmall",
- )
-
- chatbot = gr.Chatbot(height=500)
-
- with gr.Row():
- with gr.Column(scale=5):
- msg = gr.Textbox(
- label="Chat Message Box",
- placeholder="Ask me anything (press Shift+Enter or click Submit to send)",
- show_label=False,
- # container=False,
- lines=6,
- max_lines=30,
- show_copy_button=True,
- # ).style(container=False)
- )
- with gr.Column(scale=1, min_width=50):
- with gr.Row():
- submit = gr.Button("Submit", elem_classes="xsmall")
- stop = gr.Button("Stop", visible=True)
- clear = gr.Button("Clear History", visible=True)
- with gr.Row(visible=False):
- with gr.Accordion("Advanced Options:", open=False):
- with gr.Row():
- with gr.Column(scale=2):
- system = gr.Textbox(
- label="System Prompt",
- value=prompt_template,
- show_label=False,
- container=False,
- # ).style(container=False)
- )
- with gr.Column():
- with gr.Row():
- change = gr.Button("Change System Prompt")
- reset = gr.Button("Reset System Prompt")
-
- with gr.Accordion("Example Inputs", open=True):
- examples = gr.Examples(
- examples=examples_list,
- inputs=[msg],
- examples_per_page=40,
- )
-
- with gr.Accordion("Disclaimer", open=False):
- _ = Path(model_loc).name
- gr.Markdown(
- f"Disclaimer: {_} can produce factually incorrect output, and should not be relied on to produce "
- "factually accurate information. {_} was trained on various public datasets; while great efforts "
- "have been taken to clean the pretraining data, it is possible that this model could generate lewd, "
- "biased, or otherwise offensive outputs.",
- elem_classes=["disclaimer"],
- )
-
- msg_submit_event = msg.submit(
- # fn=conversation.user_turn,
- fn=user,
- inputs=[msg, chatbot],
- outputs=[msg, chatbot],
- queue=True,
- show_progress="full",
- # api_name=None,
- ).then(bot, chatbot, chatbot, queue=True)
- submit_click_event = submit.click(
- # fn=lambda x, y: ("",) + user(x, y)[1:], # clear msg
- fn=user1, # clear msg
- inputs=[msg, chatbot],
- outputs=[msg, chatbot],
- queue=True,
- # queue=False,
- show_progress="full",
- # api_name=None,
- ).then(bot, chatbot, chatbot, queue=True)
- stop.click(
- fn=None,
- inputs=None,
- outputs=None,
- cancels=[msg_submit_event, submit_click_event],
- queue=False,
- )
-
- # TODO: clear conversation memory as well
- clear.click(lambda: None, None, chatbot, queue=False)
-
- with gr.Accordion("For Chat/Translation API", open=False, visible=False):
- input_text = gr.Text()
- api_btn = gr.Button("Go", variant="primary")
- out_text = gr.Text()
-
- if conversation_api is not None:
- api_btn.click(
- predict_api,
- input_text,
- out_text,
- api_name="api",
- )
-
-# concurrency_count=5, max_size=20
-# max_size=36, concurrency_count=14
-# CPU cpu_count=2 16G, model 7G
-# CPU UPGRADE cpu_count=8 32G, model 7G
-
-# does not work
-_ = """
-# _ = int(psutil.virtual_memory().total / 10**9 // file_size - 1)
-# concurrency_count = max(_, 1)
-if psutil.cpu_count(logical=False) >= 8:
- # concurrency_count = max(int(32 / file_size) - 1, 1)
-else:
- # concurrency_count = max(int(16 / file_size) - 1, 1)
-# """
-
-concurrency_count = 1
-logger.info(f"{concurrency_count=}")
-
-block.queue(concurrency_count=concurrency_count, max_size=5).launch(debug=True)
diff --git a/spaces/ParisNeo/Blip_QA/README.md b/spaces/ParisNeo/Blip_QA/README.md
deleted file mode 100644
index 5d911ee00bbe3b9aaf28fe96520137b4ca551aa1..0000000000000000000000000000000000000000
--- a/spaces/ParisNeo/Blip_QA/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Blip QA
-emoji: 🚀
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.20.1
-app_file: app.py
-pinned: false
-license: mit
----
-BLIP: Bootstrapping Language-Image Pre-training for Unified Vision-Language Understanding and Generation
-This space shows how easy it is to use the BLIP model for image querrying.
-[https://arxiv.org/abs/2201.12086](https://arxiv.org/abs/2201.12086)
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/page.go b/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/page.go
deleted file mode 100644
index cf3ab247ef5c2c773e4afac0c95f5cb72e585e66..0000000000000000000000000000000000000000
Binary files a/spaces/Pattr/DrumClassification/lilypond-2.24.2/lib/lilypond/2.24.2/ccache/lily/page.go and /dev/null differ
diff --git a/spaces/PeepDaSlan9/AutoGPT/autogpt/memory/pinecone.py b/spaces/PeepDaSlan9/AutoGPT/autogpt/memory/pinecone.py
deleted file mode 100644
index 27fcd62482d0cf44e02fa1c339195be58cb745b0..0000000000000000000000000000000000000000
--- a/spaces/PeepDaSlan9/AutoGPT/autogpt/memory/pinecone.py
+++ /dev/null
@@ -1,75 +0,0 @@
-import pinecone
-from colorama import Fore, Style
-
-from autogpt.llm_utils import create_embedding_with_ada
-from autogpt.logs import logger
-from autogpt.memory.base import MemoryProviderSingleton
-
-
-class PineconeMemory(MemoryProviderSingleton):
- def __init__(self, cfg):
- pinecone_api_key = cfg.pinecone_api_key
- pinecone_region = cfg.pinecone_region
- pinecone.init(api_key=pinecone_api_key, environment=pinecone_region)
- dimension = 1536
- metric = "cosine"
- pod_type = "p1"
- table_name = "auto-gpt"
- # this assumes we don't start with memory.
- # for now this works.
- # we'll need a more complicated and robust system if we want to start with
- # memory.
- self.vec_num = 0
-
- try:
- pinecone.whoami()
- except Exception as e:
- logger.typewriter_log(
- "FAILED TO CONNECT TO PINECONE",
- Fore.RED,
- Style.BRIGHT + str(e) + Style.RESET_ALL,
- )
- logger.double_check(
- "Please ensure you have setup and configured Pinecone properly for use."
- + f"You can check out {Fore.CYAN + Style.BRIGHT}"
- "https://github.com/Torantulino/Auto-GPT#-pinecone-api-key-setup"
- f"{Style.RESET_ALL} to ensure you've set up everything correctly."
- )
- exit(1)
-
- if table_name not in pinecone.list_indexes():
- pinecone.create_index(
- table_name, dimension=dimension, metric=metric, pod_type=pod_type
- )
- self.index = pinecone.Index(table_name)
-
- def add(self, data):
- vector = create_embedding_with_ada(data)
- # no metadata here. We may wish to change that long term.
- self.index.upsert([(str(self.vec_num), vector, {"raw_text": data})])
- _text = f"Inserting data into memory at index: {self.vec_num}:\n data: {data}"
- self.vec_num += 1
- return _text
-
- def get(self, data):
- return self.get_relevant(data, 1)
-
- def clear(self):
- self.index.delete(deleteAll=True)
- return "Obliviated"
-
- def get_relevant(self, data, num_relevant=5):
- """
- Returns all the data in the memory that is relevant to the given data.
- :param data: The data to compare to.
- :param num_relevant: The number of relevant data to return. Defaults to 5
- """
- query_embedding = create_embedding_with_ada(data)
- results = self.index.query(
- query_embedding, top_k=num_relevant, include_metadata=True
- )
- sorted_results = sorted(results.matches, key=lambda x: x.score)
- return [str(item["metadata"]["raw_text"]) for item in sorted_results]
-
- def get_stats(self):
- return self.index.describe_index_stats()
diff --git a/spaces/PeepDaSlan9/Llama-2-AWS/responses.py b/spaces/PeepDaSlan9/Llama-2-AWS/responses.py
deleted file mode 100644
index 7ce341095a466dcec978291a834f973b82ce6753..0000000000000000000000000000000000000000
--- a/spaces/PeepDaSlan9/Llama-2-AWS/responses.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# RESPONSE
-import requests
-
-# Define the URL
-url = "https://wcza44xtt6.execute-api.us-west-2.amazonaws.com/default/llama-osu"
-
-
-def new_data():
- data = {
- "inputs": [
- [
- ]
- ],
- "parameters": {
- "max_new_tokens": 500,
- "top_p": 0.9, # if you set top p to 0.9, the model will only consider the most likely words that make up 90% of the probability mass.
- "temperature": 0.2 # creative level from 0 to 1 (the higher the more creative)
- }
- }
- return data
-
-
-data = new_data()
-def get_response(prompt: str) -> str:
- if(prompt.lower() == 'reset'):
- global data
- data = new_data()
- return "You can start a new conversation"
- else:
- _dict = {"role": "user", "content": f"{prompt}" + " (Make your answer brief with several sentences)"}
- data["inputs"][0].append(_dict)
- response = requests.post(url, json=data)
- response_dict = response.json()[0]['generation']
- data["inputs"][0].append(response_dict)
-
- return response.json()[0]['generation']['content']
\ No newline at end of file
diff --git a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/arraymisc/quantization.py b/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/arraymisc/quantization.py
deleted file mode 100644
index 8e47a3545780cf071a1ef8195efb0b7b662c8186..0000000000000000000000000000000000000000
--- a/spaces/Pie31415/control-animation/annotator/uniformer/mmcv/arraymisc/quantization.py
+++ /dev/null
@@ -1,55 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import numpy as np
-
-
-def quantize(arr, min_val, max_val, levels, dtype=np.int64):
- """Quantize an array of (-inf, inf) to [0, levels-1].
-
- Args:
- arr (ndarray): Input array.
- min_val (scalar): Minimum value to be clipped.
- max_val (scalar): Maximum value to be clipped.
- levels (int): Quantization levels.
- dtype (np.type): The type of the quantized array.
-
- Returns:
- tuple: Quantized array.
- """
- if not (isinstance(levels, int) and levels > 1):
- raise ValueError(
- f'levels must be a positive integer, but got {levels}')
- if min_val >= max_val:
- raise ValueError(
- f'min_val ({min_val}) must be smaller than max_val ({max_val})')
-
- arr = np.clip(arr, min_val, max_val) - min_val
- quantized_arr = np.minimum(
- np.floor(levels * arr / (max_val - min_val)).astype(dtype), levels - 1)
-
- return quantized_arr
-
-
-def dequantize(arr, min_val, max_val, levels, dtype=np.float64):
- """Dequantize an array.
-
- Args:
- arr (ndarray): Input array.
- min_val (scalar): Minimum value to be clipped.
- max_val (scalar): Maximum value to be clipped.
- levels (int): Quantization levels.
- dtype (np.type): The type of the dequantized array.
-
- Returns:
- tuple: Dequantized array.
- """
- if not (isinstance(levels, int) and levels > 1):
- raise ValueError(
- f'levels must be a positive integer, but got {levels}')
- if min_val >= max_val:
- raise ValueError(
- f'min_val ({min_val}) must be smaller than max_val ({max_val})')
-
- dequantized_arr = (arr + 0.5).astype(dtype) * (max_val -
- min_val) / levels + min_val
-
- return dequantized_arr
diff --git a/spaces/Purple11/Grounded-Diffusion/src/taming-transformers/taming/modules/losses/__init__.py b/spaces/Purple11/Grounded-Diffusion/src/taming-transformers/taming/modules/losses/__init__.py
deleted file mode 100644
index d09caf9eb805f849a517f1b23503e1a4d6ea1ec5..0000000000000000000000000000000000000000
--- a/spaces/Purple11/Grounded-Diffusion/src/taming-transformers/taming/modules/losses/__init__.py
+++ /dev/null
@@ -1,2 +0,0 @@
-from taming.modules.losses.vqperceptual import DummyLoss
-
diff --git a/spaces/RMXK/RVC_HFF/infer/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py b/spaces/RMXK/RVC_HFF/infer/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py
deleted file mode 100644
index f9664fb1f89ef068e923211179e1c7e1ce7fdbd2..0000000000000000000000000000000000000000
--- a/spaces/RMXK/RVC_HFF/infer/lib/infer_pack/modules/F0Predictor/HarvestF0Predictor.py
+++ /dev/null
@@ -1,87 +0,0 @@
-import numpy as np
-import pyworld
-
-from infer.lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-
-
-class HarvestF0Predictor(F0Predictor):
- def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
- self.hop_length = hop_length
- self.f0_min = f0_min
- self.f0_max = f0_max
- self.sampling_rate = sampling_rate
-
- def interpolate_f0(self, f0):
- """
- 对F0进行插值处理
- """
-
- data = np.reshape(f0, (f0.size, 1))
-
- vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
- vuv_vector[data > 0.0] = 1.0
- vuv_vector[data <= 0.0] = 0.0
-
- ip_data = data
-
- frame_number = data.size
- last_value = 0.0
- for i in range(frame_number):
- if data[i] <= 0.0:
- j = i + 1
- for j in range(i + 1, frame_number):
- if data[j] > 0.0:
- break
- if j < frame_number - 1:
- if last_value > 0.0:
- step = (data[j] - data[i - 1]) / float(j - i)
- for k in range(i, j):
- ip_data[k] = data[i - 1] + step * (k - i + 1)
- else:
- for k in range(i, j):
- ip_data[k] = data[j]
- else:
- for k in range(i, frame_number):
- ip_data[k] = last_value
- else:
- ip_data[i] = data[i] # 这里可能存在一个没有必要的拷贝
- last_value = data[i]
-
- return ip_data[:, 0], vuv_vector[:, 0]
-
- def resize_f0(self, x, target_len):
- source = np.array(x)
- source[source < 0.001] = np.nan
- target = np.interp(
- np.arange(0, len(source) * target_len, len(source)) / target_len,
- np.arange(0, len(source)),
- source,
- )
- res = np.nan_to_num(target)
- return res
-
- def compute_f0(self, wav, p_len=None):
- if p_len is None:
- p_len = wav.shape[0] // self.hop_length
- f0, t = pyworld.harvest(
- wav.astype(np.double),
- fs=self.hop_length,
- f0_ceil=self.f0_max,
- f0_floor=self.f0_min,
- frame_period=1000 * self.hop_length / self.sampling_rate,
- )
- f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.fs)
- return self.interpolate_f0(self.resize_f0(f0, p_len))[0]
-
- def compute_f0_uv(self, wav, p_len=None):
- if p_len is None:
- p_len = wav.shape[0] // self.hop_length
- f0, t = pyworld.harvest(
- wav.astype(np.double),
- fs=self.sampling_rate,
- f0_floor=self.f0_min,
- f0_ceil=self.f0_max,
- frame_period=1000 * self.hop_length / self.sampling_rate,
- )
- f0 = pyworld.stonemask(wav.astype(np.double), f0, t, self.sampling_rate)
- return self.interpolate_f0(self.resize_f0(f0, p_len))
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/queue.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/queue.py
deleted file mode 100644
index 41784104ee4bd5796006d1052536325d52db1e8c..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/urllib3/util/queue.py
+++ /dev/null
@@ -1,22 +0,0 @@
-import collections
-
-from ..packages import six
-from ..packages.six.moves import queue
-
-if six.PY2:
- # Queue is imported for side effects on MS Windows. See issue #229.
- import Queue as _unused_module_Queue # noqa: F401
-
-
-class LifoQueue(queue.Queue):
- def _init(self, _):
- self.queue = collections.deque()
-
- def _qsize(self, len=len):
- return len(self.queue)
-
- def _put(self, item):
- self.queue.append(item)
-
- def _get(self):
- return self.queue.pop()
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_distutils/_macos_compat.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_distutils/_macos_compat.py
deleted file mode 100644
index 17769e9154bd9cc3f3c00dc10718e4377828cb5e..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/_distutils/_macos_compat.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import sys
-import importlib
-
-
-def bypass_compiler_fixup(cmd, args):
- return cmd
-
-
-if sys.platform == 'darwin':
- compiler_fixup = importlib.import_module('_osx_support').compiler_fixup
-else:
- compiler_fixup = bypass_compiler_fixup
diff --git a/spaces/Reha2704/VToonify/vtoonify/model/encoder/encoders/__init__.py b/spaces/Reha2704/VToonify/vtoonify/model/encoder/encoders/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/evaluation/class_names.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/evaluation/class_names.py
deleted file mode 100644
index c2487c2ee2d010c40db0e1c2b51c91b194e84dc7..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/evaluation/class_names.py
+++ /dev/null
@@ -1,116 +0,0 @@
-import mmcv
-
-
-def wider_face_classes():
- return ['face']
-
-
-def voc_classes():
- return [
- 'aeroplane', 'bicycle', 'bird', 'boat', 'bottle', 'bus', 'car', 'cat',
- 'chair', 'cow', 'diningtable', 'dog', 'horse', 'motorbike', 'person',
- 'pottedplant', 'sheep', 'sofa', 'train', 'tvmonitor'
- ]
-
-
-def imagenet_det_classes():
- return [
- 'accordion', 'airplane', 'ant', 'antelope', 'apple', 'armadillo',
- 'artichoke', 'axe', 'baby_bed', 'backpack', 'bagel', 'balance_beam',
- 'banana', 'band_aid', 'banjo', 'baseball', 'basketball', 'bathing_cap',
- 'beaker', 'bear', 'bee', 'bell_pepper', 'bench', 'bicycle', 'binder',
- 'bird', 'bookshelf', 'bow_tie', 'bow', 'bowl', 'brassiere', 'burrito',
- 'bus', 'butterfly', 'camel', 'can_opener', 'car', 'cart', 'cattle',
- 'cello', 'centipede', 'chain_saw', 'chair', 'chime', 'cocktail_shaker',
- 'coffee_maker', 'computer_keyboard', 'computer_mouse', 'corkscrew',
- 'cream', 'croquet_ball', 'crutch', 'cucumber', 'cup_or_mug', 'diaper',
- 'digital_clock', 'dishwasher', 'dog', 'domestic_cat', 'dragonfly',
- 'drum', 'dumbbell', 'electric_fan', 'elephant', 'face_powder', 'fig',
- 'filing_cabinet', 'flower_pot', 'flute', 'fox', 'french_horn', 'frog',
- 'frying_pan', 'giant_panda', 'goldfish', 'golf_ball', 'golfcart',
- 'guacamole', 'guitar', 'hair_dryer', 'hair_spray', 'hamburger',
- 'hammer', 'hamster', 'harmonica', 'harp', 'hat_with_a_wide_brim',
- 'head_cabbage', 'helmet', 'hippopotamus', 'horizontal_bar', 'horse',
- 'hotdog', 'iPod', 'isopod', 'jellyfish', 'koala_bear', 'ladle',
- 'ladybug', 'lamp', 'laptop', 'lemon', 'lion', 'lipstick', 'lizard',
- 'lobster', 'maillot', 'maraca', 'microphone', 'microwave', 'milk_can',
- 'miniskirt', 'monkey', 'motorcycle', 'mushroom', 'nail', 'neck_brace',
- 'oboe', 'orange', 'otter', 'pencil_box', 'pencil_sharpener', 'perfume',
- 'person', 'piano', 'pineapple', 'ping-pong_ball', 'pitcher', 'pizza',
- 'plastic_bag', 'plate_rack', 'pomegranate', 'popsicle', 'porcupine',
- 'power_drill', 'pretzel', 'printer', 'puck', 'punching_bag', 'purse',
- 'rabbit', 'racket', 'ray', 'red_panda', 'refrigerator',
- 'remote_control', 'rubber_eraser', 'rugby_ball', 'ruler',
- 'salt_or_pepper_shaker', 'saxophone', 'scorpion', 'screwdriver',
- 'seal', 'sheep', 'ski', 'skunk', 'snail', 'snake', 'snowmobile',
- 'snowplow', 'soap_dispenser', 'soccer_ball', 'sofa', 'spatula',
- 'squirrel', 'starfish', 'stethoscope', 'stove', 'strainer',
- 'strawberry', 'stretcher', 'sunglasses', 'swimming_trunks', 'swine',
- 'syringe', 'table', 'tape_player', 'tennis_ball', 'tick', 'tie',
- 'tiger', 'toaster', 'traffic_light', 'train', 'trombone', 'trumpet',
- 'turtle', 'tv_or_monitor', 'unicycle', 'vacuum', 'violin',
- 'volleyball', 'waffle_iron', 'washer', 'water_bottle', 'watercraft',
- 'whale', 'wine_bottle', 'zebra'
- ]
-
-
-def imagenet_vid_classes():
- return [
- 'airplane', 'antelope', 'bear', 'bicycle', 'bird', 'bus', 'car',
- 'cattle', 'dog', 'domestic_cat', 'elephant', 'fox', 'giant_panda',
- 'hamster', 'horse', 'lion', 'lizard', 'monkey', 'motorcycle', 'rabbit',
- 'red_panda', 'sheep', 'snake', 'squirrel', 'tiger', 'train', 'turtle',
- 'watercraft', 'whale', 'zebra'
- ]
-
-
-def coco_classes():
- return [
- 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus', 'train',
- 'truck', 'boat', 'traffic_light', 'fire_hydrant', 'stop_sign',
- 'parking_meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep',
- 'cow', 'elephant', 'bear', 'zebra', 'giraffe', 'backpack', 'umbrella',
- 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard',
- 'sports_ball', 'kite', 'baseball_bat', 'baseball_glove', 'skateboard',
- 'surfboard', 'tennis_racket', 'bottle', 'wine_glass', 'cup', 'fork',
- 'knife', 'spoon', 'bowl', 'banana', 'apple', 'sandwich', 'orange',
- 'broccoli', 'carrot', 'hot_dog', 'pizza', 'donut', 'cake', 'chair',
- 'couch', 'potted_plant', 'bed', 'dining_table', 'toilet', 'tv',
- 'laptop', 'mouse', 'remote', 'keyboard', 'cell_phone', 'microwave',
- 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
- 'scissors', 'teddy_bear', 'hair_drier', 'toothbrush'
- ]
-
-
-def cityscapes_classes():
- return [
- 'person', 'rider', 'car', 'truck', 'bus', 'train', 'motorcycle',
- 'bicycle'
- ]
-
-
-dataset_aliases = {
- 'voc': ['voc', 'pascal_voc', 'voc07', 'voc12'],
- 'imagenet_det': ['det', 'imagenet_det', 'ilsvrc_det'],
- 'imagenet_vid': ['vid', 'imagenet_vid', 'ilsvrc_vid'],
- 'coco': ['coco', 'mscoco', 'ms_coco'],
- 'wider_face': ['WIDERFaceDataset', 'wider_face', 'WIDERFace'],
- 'cityscapes': ['cityscapes']
-}
-
-
-def get_classes(dataset):
- """Get class names of a dataset."""
- alias2name = {}
- for name, aliases in dataset_aliases.items():
- for alias in aliases:
- alias2name[alias] = name
-
- if mmcv.is_str(dataset):
- if dataset in alias2name:
- labels = eval(alias2name[dataset] + '_classes()')
- else:
- raise ValueError(f'Unrecognized dataset: {dataset}')
- else:
- raise TypeError(f'dataset must a str, but got {type(dataset)}')
- return labels
diff --git a/spaces/SHIBATAATSUSHI/aioccupationaltherapist2/constraints.md b/spaces/SHIBATAATSUSHI/aioccupationaltherapist2/constraints.md
deleted file mode 100644
index 6bddcd1754c9ce6eb8233d6664851c14752f38b1..0000000000000000000000000000000000000000
--- a/spaces/SHIBATAATSUSHI/aioccupationaltherapist2/constraints.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# 制約
-
-- あなたは人の身体を作業療法で治療することを生きがいとした作業療法AIアシスタントです
-- あなたはuserを作業療法することしか考えてないので、どんな話も作業療法で行う作業療法のプログラムを提供することで切り替えします
-- あなたの返信は下記テンプレートに沿って生成します
-
-# テンプレート
diff --git a/spaces/Sa-m/Vehicles-Detection-Custom-YoloV7/app.py b/spaces/Sa-m/Vehicles-Detection-Custom-YoloV7/app.py
deleted file mode 100644
index 8be9d09f5392238346ae765c688ea50da2aadd00..0000000000000000000000000000000000000000
--- a/spaces/Sa-m/Vehicles-Detection-Custom-YoloV7/app.py
+++ /dev/null
@@ -1,171 +0,0 @@
-import torch
-import argparse
-import gradio as gr
-from PIL import Image
-from numpy import random
-from pathlib import Path
-import os
-import time
-import torch.backends.cudnn as cudnn
-from models.experimental import attempt_load
-import cv2
-from utils.datasets import LoadStreams, LoadImages
-from utils.general import check_img_size, check_requirements, check_imshow, non_max_suppression, apply_classifier,scale_coords, xyxy2xywh, strip_optimizer, set_logging, increment_path
-from utils.plots import plot_one_box
-from utils.torch_utils import select_device, load_classifier, time_synchronized, TracedModel
-
-
-os.system('git clone https://github.com/WongKinYiu/yolov7')
-os.system('wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7.pt')
-#os.system('wget https://github.com/WongKinYiu/yolov7/releases/download/v0.1/yolov7-mask.pt')
-
-#model='best'
-def Custom_detect(img,mode):
- if mode=='Custom-Detection':
- model='best'
- #if mode=='Instance-Segmentation':
- # model='yolov7-mask'
- if mode=='Yolov7-model-detection':
- model='yolov7'
-
- parser = argparse.ArgumentParser()
- parser.add_argument('--weights', nargs='+', type=str, default=model+".pt", help='model.pt path(s)')
- parser.add_argument('--source', type=str, default='Temp_files/', help='source')
- parser.add_argument('--img-size', type=int, default=640, help='inference size (pixels)')
- parser.add_argument('--conf-thres', type=float, default=0.25, help='object confidence threshold')
- parser.add_argument('--iou-thres', type=float, default=0.45, help='IOU threshold for NMS')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--view-img', action='store_true', help='display results')
- parser.add_argument('--save-txt', action='store_true', help='save results to *.txt')
- parser.add_argument('--save-conf', action='store_true', help='save confidences in --save-txt labels')
- parser.add_argument('--nosave', action='store_true', help='do not save images/videos')
- parser.add_argument('--classes', nargs='+', type=int, help='filter by class: --class 0, or --class 0 2 3')
- parser.add_argument('--agnostic-nms', action='store_true', help='class-agnostic NMS')
- parser.add_argument('--augment', action='store_true', help='augmented inference')
- parser.add_argument('--update', action='store_true', help='update all models')
- parser.add_argument('--project', default='runs/detect', help='save results to project/name')
- parser.add_argument('--name', default='exp', help='save results to project/name')
- parser.add_argument('--exist-ok', action='store_true', help='existing project/name ok, do not increment')
- parser.add_argument('--trace', action='store_true', help='trace model')
- opt = parser.parse_args()
- img.save("Temp_files/test.jpg")
- source, weights, view_img, save_txt, imgsz, trace = opt.source, opt.weights, opt.view_img, opt.save_txt, opt.img_size, opt.trace
- save_img = True
- webcam = source.isnumeric() or source.endswith('.txt') or source.lower().startswith(('rtsp://', 'rtmp://', 'http://', 'https://'))
- save_dir = Path(increment_path(Path(opt.project)/opt.name,exist_ok=opt.exist_ok))
-
- (save_dir / 'labels' if save_txt else save_dir).mkdir(parents=True, exist_ok=True)
- set_logging()
- device = select_device(opt.device)
- half = device.type != 'cpu'
- model = attempt_load(weights, map_location=device)
- stride = int(model.stride.max())
- imgsz = check_img_size(imgsz, s=stride)
- if trace:
- model = TracedModel(model, device, opt.img_size)
- if half:
- model.half()
-
- classify = False
- if classify:
- modelc = load_classifier(name='resnet101', n=2) # initialize
- modelc.load_state_dict(torch.load('weights/resnet101.pt', map_location=device)['model']).to(device).eval()
- vid_path, vid_writer = None, None
- if webcam:
- view_img = check_imshow()
- cudnn.benchmark = True
- dataset = LoadStreams(source, img_size=imgsz, stride=stride)
- else:
- dataset = LoadImages(source, img_size=imgsz, stride=stride)
- names = model.module.names if hasattr(model, 'module') else model.names
- colors = [[random.randint(0, 255) for _ in range(3)] for _ in names]
- if device.type != 'cpu':
- model(torch.zeros(1, 3, imgsz, imgsz).to(device).type_as(next(model.parameters())))
- t0 = time.time()
- for path, img, im0s, vid_cap in dataset:
- img = torch.from_numpy(img).to(device)
- img = img.half() if half else img.float()
- img /= 255.0
- if img.ndimension() == 3:
- img = img.unsqueeze(0)
-
- # Inference
- t1 = time_synchronized()
- pred = model(img, augment=opt.augment)[0]
-
- pred = non_max_suppression(pred,opt.conf_thres,opt.iou_thres,classes=opt.classes, agnostic=opt.agnostic_nms)
- t2 = time_synchronized()
-
-
- # Apply Classifier
- if classify:
- pred = apply_classifier(pred, modelc, img, im0s)
-
- for i, det in enumerate(pred):
- if webcam:
- p, s, im0, frame = path[i], '%g: ' % i, im0s[i].copy(), dataset.count
- else:
- p, s, im0, frame = path, '', im0s, getattr(dataset, 'frame', 0)
-
- p = Path(p)
- save_path = str(save_dir / p.name)
- txt_path = str(save_dir / 'labels' / p.stem) + ('' if dataset.mode == 'image' else f'_{frame}') # img.txt
- s += '%gx%g ' % img.shape[2:]
- gn = torch.tensor(im0.shape)[[1, 0, 1, 0]]
- if len(det):
- det[:, :4] = scale_coords(img.shape[2:], det[:, :4], im0.shape).round()
-
-
- for c in det[:, -1].unique():
- n = (det[:, -1] == c).sum()
- s += f"{n} {names[int(c)]}{'s' * (n > 1)}, "
-
-
- for *xyxy, conf, cls in reversed(det):
- if save_txt:
- xywh = (xyxy2xywh(torch.tensor(xyxy).view(1, 4)) / gn).view(-1).tolist()
- line = (cls, *xywh, conf) if opt.save_conf else (cls, *xywh)
- with open(txt_path + '.txt', 'a') as f:
- f.write(('%g ' * len(line)).rstrip() % line + '\n')
-
- if save_img or view_img:
- label = f'{names[int(cls)]} {conf:.2f}'
- plot_one_box(xyxy, im0, label=label, color=colors[int(cls)], line_thickness=2)
- if view_img:
- cv2.imshow(str(p), im0)
- cv2.waitKey(1)
-
- if save_img:
- if dataset.mode == 'image':
- cv2.imwrite(save_path, im0)
- else:
- if vid_path != save_path:
- vid_path = save_path
- if isinstance(vid_writer, cv2.VideoWriter):
- vid_writer.release()
- if vid_cap:
- fps = vid_cap.get(cv2.CAP_PROP_FPS)
- w = int(vid_cap.get(cv2.CAP_PROP_FRAME_WIDTH))
- h = int(vid_cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
- else:
- fps, w, h = 30, im0.shape[1], im0.shape[0]
- save_path += '.mp4'
- vid_writer = cv2.VideoWriter(save_path, cv2.VideoWriter_fourcc(*'mp4v'), fps, (w, h))
- vid_writer.write(im0)
-
- if save_txt or save_img:
- s = f"\n{len(list(save_dir.glob('labels/*.txt')))} labels saved to {save_dir / 'labels'}" if save_txt else ''
-
- print(f'Done. ({time.time() - t0:.3f}s)')
-
- return Image.fromarray(im0[:,:,::-1])
-inp = gr.Image(type="pil")
-#"Custom-Detection","Yolov7-model-detection"
-inp2= gr.Dropdown(choices=['Custom-Detection','Yolov7-model-detection'])
-output = gr.Image(type="pil")
-
-examples=[["Examples/Image1.jpg","Image1"],["Examples/Image14.jpg","Image14"],["Examples/Image32.jpg","Image32"]]
-
-io=gr.Interface(fn=Custom_detect, inputs=[inp,inp2], outputs=output, title='Vehicle Detection With Custom YOLOv7')
-io.launch()
-
diff --git a/spaces/Salesforce/EDICT/my_half_diffusers/utils/outputs.py b/spaces/Salesforce/EDICT/my_half_diffusers/utils/outputs.py
deleted file mode 100644
index b02f62d02d0322401fd9926aca9f792a4696cc1e..0000000000000000000000000000000000000000
--- a/spaces/Salesforce/EDICT/my_half_diffusers/utils/outputs.py
+++ /dev/null
@@ -1,109 +0,0 @@
-# Copyright 2022 The HuggingFace Team. All rights reserved.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-"""
-Generic utilities
-"""
-
-import warnings
-from collections import OrderedDict
-from dataclasses import fields
-from typing import Any, Tuple
-
-import numpy as np
-
-from .import_utils import is_torch_available
-
-
-def is_tensor(x):
- """
- Tests if `x` is a `torch.Tensor` or `np.ndarray`.
- """
- if is_torch_available():
- import torch
-
- if isinstance(x, torch.Tensor):
- return True
-
- return isinstance(x, np.ndarray)
-
-
-class BaseOutput(OrderedDict):
- """
- Base class for all model outputs as dataclass. Has a `__getitem__` that allows indexing by integer or slice (like a
- tuple) or strings (like a dictionary) that will ignore the `None` attributes. Otherwise behaves like a regular
- python dictionary.
-
-
-
- You can't unpack a `BaseOutput` directly. Use the [`~utils.BaseOutput.to_tuple`] method to convert it to a tuple
- before.
-
-
- """
-
- def __post_init__(self):
- class_fields = fields(self)
-
- # Safety and consistency checks
- if not len(class_fields):
- raise ValueError(f"{self.__class__.__name__} has no fields.")
-
- for field in class_fields:
- v = getattr(self, field.name)
- if v is not None:
- self[field.name] = v
-
- def __delitem__(self, *args, **kwargs):
- raise Exception(f"You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.")
-
- def setdefault(self, *args, **kwargs):
- raise Exception(f"You cannot use ``setdefault`` on a {self.__class__.__name__} instance.")
-
- def pop(self, *args, **kwargs):
- raise Exception(f"You cannot use ``pop`` on a {self.__class__.__name__} instance.")
-
- def update(self, *args, **kwargs):
- raise Exception(f"You cannot use ``update`` on a {self.__class__.__name__} instance.")
-
- def __getitem__(self, k):
- if isinstance(k, str):
- inner_dict = {k: v for (k, v) in self.items()}
- if self.__class__.__name__ in ["StableDiffusionPipelineOutput", "ImagePipelineOutput"] and k == "sample":
- warnings.warn(
- "The keyword 'samples' is deprecated and will be removed in version 0.4.0. Please use `.images` or"
- " `'images'` instead.",
- DeprecationWarning,
- )
- return inner_dict["images"]
- return inner_dict[k]
- else:
- return self.to_tuple()[k]
-
- def __setattr__(self, name, value):
- if name in self.keys() and value is not None:
- # Don't call self.__setitem__ to avoid recursion errors
- super().__setitem__(name, value)
- super().__setattr__(name, value)
-
- def __setitem__(self, key, value):
- # Will raise a KeyException if needed
- super().__setitem__(key, value)
- # Don't call self.__setattr__ to avoid recursion errors
- super().__setattr__(key, value)
-
- def to_tuple(self) -> Tuple[Any]:
- """
- Convert self to a tuple containing all the attributes/keys that are not `None`.
- """
- return tuple(self[k] for k in self.keys())
diff --git a/spaces/Sandiago21/automatic-speech-recognition-german/app.py b/spaces/Sandiago21/automatic-speech-recognition-german/app.py
deleted file mode 100644
index e89a3dcb038f094b73348ebb733135d61272b63f..0000000000000000000000000000000000000000
--- a/spaces/Sandiago21/automatic-speech-recognition-german/app.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import torch
-import gradio as gr
-from transformers import pipeline
-
-model_id = "Sandiago21/whisper-large-v2-german-2" # update with your model id
-pipe = pipeline("automatic-speech-recognition", model=model_id)
-
-
-title = "Automatic Speech Recognition (ASR)"
-description = """
-Demo for automatic speech recognition in German. Demo uses [Sandiago21/whisper-large-v2-german-2](https://huggingface.co/Sandiago21/whisper-large-v2-german-2) checkpoint, which is based on OpenAI's
-[Whisper](https://huggingface.co/openai/whisper-large-v2) model and is fine-tuned in German Audio dataset
-
-"""
-
-def transcribe_speech(filepath):
- output = pipe(
- filepath,
- max_new_tokens=256,
- generate_kwargs={
- "task": "transcribe",
- "language": "german",
- }, # update with the language you've fine-tuned on
- chunk_length_s=30,
- batch_size=8,
- )
- return output["text"]
-
-demo = gr.Blocks()
-
-mic_transcribe = gr.Interface(
- fn=transcribe_speech,
- inputs=gr.Audio(source="microphone", type="filepath"),
- outputs=gr.outputs.Textbox(),
- tilte=title,
- description=description,
-)
-
-file_transcribe = gr.Interface(
- fn=transcribe_speech,
- inputs=gr.Audio(source="upload", type="filepath"),
- outputs=gr.outputs.Textbox(),
- examples=[["./example.wav"]],
- tilte=title,
- description=description,
-)
-
-with demo:
- gr.TabbedInterface(
- [mic_transcribe, file_transcribe],
- ["Transcribe Microphone", "Transcribe Audio File"],
- ),
-
-demo.launch()
diff --git a/spaces/Sangamesh/Cat_Dog_Classifier/app.py b/spaces/Sangamesh/Cat_Dog_Classifier/app.py
deleted file mode 100644
index 98a765572f722e9c82491a368eadc4a24e496ce7..0000000000000000000000000000000000000000
--- a/spaces/Sangamesh/Cat_Dog_Classifier/app.py
+++ /dev/null
@@ -1,56 +0,0 @@
-#|default_expv app
-
-#cell
-import numpy as np
-
-#cell
-from fastai.vision.all import *
-
-#cell
-#|export
-from fastai.learner import load_learner
-from PIL import Image
-import gradio as gr
-
-def is_cat(x): return x[0].isupper()
-
-#cell
-import pathlib
-plt = platform.system()
-if plt == 'Windows': pathlib.PosixPath = pathlib.WindowsPath
-
-
-#cell
-im = PILImage.create('dog.jpg')
-im.thumbnail((192,192))
-im
-
-
-#cell
-#|export
-learn = load_learner('model.pkl')
-
-#cell
-learn.predict(im)
-
-#cell
-#|export
-categories = ('Dog','Cat')
-
-def classify_images(img):
- pred,idx,probs = learn.predict(img)
- return dict(zip(categories, map(float,probs)))
-
- #cell
- classify_images(im)
-
- #cell
- #|export
-image = gr.inputs.Image(shape=(192,192))
-label = gr.outputs.Label()
-
-intf = gr.Interface(fn=classify_images, inputs=image, outputs=label)
-intf.launch(inline=False)
-
-#cell
-m = learn.model
\ No newline at end of file
diff --git a/spaces/Silentlin/DiffSinger/vocoders/__init__.py b/spaces/Silentlin/DiffSinger/vocoders/__init__.py
deleted file mode 100644
index 66c318857ce48048437dede7072901ad6471b8fc..0000000000000000000000000000000000000000
--- a/spaces/Silentlin/DiffSinger/vocoders/__init__.py
+++ /dev/null
@@ -1 +0,0 @@
-from vocoders import hifigan
diff --git a/spaces/SmartPy/ScisummNet/app.py b/spaces/SmartPy/ScisummNet/app.py
deleted file mode 100644
index 6ce0876f3cd6a69f80688a40525ecb60bc942001..0000000000000000000000000000000000000000
--- a/spaces/SmartPy/ScisummNet/app.py
+++ /dev/null
@@ -1,281 +0,0 @@
-import os
-import contextlib
-import logging
-import random
-import re
-import time
-from pathlib import Path
-
-import gradio as gr
-import nltk
-from cleantext import clean
-
-from summarize import load_model_and_tokenizer, summarize_via_tokenbatches
-from utils import load_example_filenames, truncate_word_count, saves_summary
-from textrank import get_summary
-
-example_path = "./"
-nltk.download("stopwords")
-
-logging.basicConfig(
- level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-
-def proc_submission(
- input_text: str,
- model_size: str,
- num_beams,
- token_batch_length,
- length_penalty,
- repetition_penalty,
- no_repeat_ngram_size,
- max_input_length: int = 1024,
-):
-
- settings = {
- "length_penalty": float(length_penalty),
- "repetition_penalty": float(repetition_penalty),
- "no_repeat_ngram_size": int(no_repeat_ngram_size),
- "encoder_no_repeat_ngram_size": 4,
- "num_beams": int(num_beams),
- "min_length": 4,
- "max_length": int(token_batch_length // 4),
- "early_stopping": True,
- "do_sample": False,
- }
- st = time.perf_counter()
- history = {}
- clean_text = clean(input_text, lower=False)
- max_input_length = 1024 if "base" in model_size.lower() else max_input_length
- clean_text = get_summary(clean_text)
- processed = truncate_word_count(clean_text, max_input_length)
-
- if processed["was_truncated"]:
- tr_in = processed["truncated_text"]
- # create elaborate HTML warning
- input_wc = re.split(r"\s+", input_text)
- msg = f"""
-
-
Warning
-
Input text was truncated to {max_input_length} words. That's about {100*max_input_length/len(input_wc):.2f}% of the submission.
-
-
Warning
-
Input text is too short to summarize. Detected {len(input_text)} characters.
- Please load text by selecting an example from the dropdown menu or by pasting text into the text box.
-
Runtime: {rt} minutes on CPU
"
- if msg is not None:
- html += msg
-
- html += ""
-
- # save to file
- saved_file = saves_summary(_summaries)
-
- return html, sum_text_out, scores_out, saved_file
-
-
-def load_single_example_text(
- example_path: str or Path="./example.txt",
- max_pages=20,
-):
- """
- load_single_example - a helper function for the gradio module to load examples
- Returns:
- list of str, the examples
- """
- global name_to_path
- full_ex_path = name_to_path[example_path]
- full_ex_path = Path(full_ex_path)
-
- if full_ex_path.suffix == ".txt":
- with open(full_ex_path, "r", encoding="utf-8", errors="ignore") as f:
- raw_text = f.read()
- text = clean(raw_text, lower=False)
- else:
- logging.error(f"Unknown file type {full_ex_path.suffix}")
- text = "ERROR - check example path"
-
- return text
-
-if __name__ == "__main__":
- logging.info("Starting app instance")
- os.environ[
- "TOKENIZERS_PARALLELISM"
- ] = "false" # parallelism on tokenizers is buggy with gradio
- logging.info("Loading summ models")
- with contextlib.redirect_stdout(None):
- model, tokenizer = load_model_and_tokenizer(
- "SmartPy/bart-large-cnn-finetuned-scientific_summarize"
- )
-
- name_to_path = load_example_filenames(example_path)
- logging.info(f"Loaded {len(name_to_path)} examples")
- demo = gr.Blocks()
- _examples = list(name_to_path.keys())
- with demo:
-
- gr.Markdown("# Document Summarization with Long-Document Transformers")
- gr.Markdown(
- "This is an example use case for fine-tuned long document transformers. The model is trained on Scientific Article summaries (via the Yale Scientific Article Summarization Dataset). The models in this demo are [Bart-large-cnn](https://huggingface.co/facebook/bart-large-cnn)."
- )
- with gr.Column():
-
- gr.Markdown("## Load Inputs & Select Parameters")
- gr.Markdown(
- "Enter text below in the text area. The text will be summarized [using the selected parameters](https://huggingface.co/blog/how-to-generate). "
- )
- with gr.Row(variant="compact"):
- with gr.Column(scale=0.5, variant="compact"):
-
- model_size = gr.Radio(
- choices=["bart-large-cnn"],
- label="Model Variant",
- value="bart-large-cnn",
- )
- num_beams = gr.Radio(
- choices=[2, 3, 4],
- label="Beam Search: # of Beams",
- value=2,
- )
- with gr.Column(variant="compact"):
- example_name = gr.Dropdown(
- _examples,
- label="Examples",
- value=random.choice(_examples),
- )
-
- with gr.Row():
- input_text = gr.Textbox(
- lines=4,
- label="Input Text (for summarization)",
- placeholder="Enter text to summarize, the text will be cleaned and truncated on Spaces. Narrative, academic (both papers and lecture transcription), and article text work well. May take a bit to generate depending on the input text :)",
- )
- with gr.Column(min_width=100, scale=0.5):
- load_examples_button = gr.Button(
- "Load Example",
- )
-
- with gr.Column():
- gr.Markdown("## Generate Summary")
- gr.Markdown(
- "Summarization should take ~1-2 minutes for most settings, but may extend up to 5-10 minutes in some scenarios."
- )
- summarize_button = gr.Button(
- "Summarize!",
- variant="primary",
- )
-
- output_text = gr.HTML("Output will appear below:
")
- gr.Markdown("### Summary Output")
- summary_text = gr.Textbox(
- label="Summary", placeholder="The generated summary will appear here"
- )
- gr.Markdown(
- "The summary scores can be thought of as representing the quality of the summary. less-negative numbers (closer to 0) are better:"
- )
- summary_scores = gr.Textbox(
- label="Summary Scores", placeholder="Summary scores will appear here"
- )
-
- text_file = gr.File(
- label="Download Summary as Text File",
- file_count="single",
- type="file",
- interactive=False,
- )
-
- gr.Markdown("---")
- with gr.Column():
- gr.Markdown("### Advanced Settings")
- with gr.Row(variant="compact"):
- length_penalty = gr.inputs.Slider(
- minimum=0.5,
- maximum=1.0,
- label="length penalty",
- default=0.7,
- step=0.05,
- )
- token_batch_length = gr.Radio(
- choices=[512, 768, 1024, 1536],
- label="token batch length",
- value=1024,
- )
-
- with gr.Row(variant="compact"):
- repetition_penalty = gr.inputs.Slider(
- minimum=1.0,
- maximum=5.0,
- label="repetition penalty",
- default=3.5,
- step=0.1,
- )
- no_repeat_ngram_size = gr.Radio(
- choices=[2, 3, 4],
- label="no repeat ngram size",
- value=3,
- )
- with gr.Column():
- gr.Markdown("### About the Model")
- gr.Markdown(
- "These models are fine-tuned on the [1000 most cited papers in the ACL Anthology Network (AAN)](http://arxiv.org/pdf/1909.01716.pdf).The goal was to create a model that can generalize well and is useful in summarizing lots of text in academic and daily usage."
- )
- gr.Markdown("---")
-
- load_examples_button.click(
- fn=load_single_example_text, inputs=[example_name], outputs=[input_text]
- )
-
- summarize_button.click(
- fn=proc_submission,
- inputs=[
- input_text,
- model_size,
- num_beams,
- token_batch_length,
- length_penalty,
- repetition_penalty,
- no_repeat_ngram_size,
- ],
- outputs=[output_text, summary_text, summary_scores, text_file],
- )
-
- demo.launch(enable_queue=True, debug=True)
diff --git a/spaces/StatsByZach/app/on_ice_xg_rates.py b/spaces/StatsByZach/app/on_ice_xg_rates.py
deleted file mode 100644
index f9062140fcc58dd2ee721542df3779840ee9149d..0000000000000000000000000000000000000000
--- a/spaces/StatsByZach/app/on_ice_xg_rates.py
+++ /dev/null
@@ -1,282 +0,0 @@
-##### on_ice_xg_rates.py #####
-# A program to display skaters on-ice xG rates
-# Zach Andrews
-
-# Import modules
-from shiny import *
-import shinyswatch
-import plotly.graph_objs as go
-from shinywidgets import output_widget, register_widget, render_widget
-import pandas as pd
-import plotly.express as px
-from configure import base_url
-
-path = "data/on_ice_xg.csv"
-
-df = pd.read_csv(path)
-
-def server(input, output, session):
- @output
- @render.table
- def table():
- df = pd.read_csv(path)
- if input.z() == "T":
- asc = True
- else:
- asc = False
- if input.strength()=="even":
- df = df[(df['Team']==input.x())&(df['EV_TOI']>=input.toi())]
- if input.y() == "xGF/60":
- df = df[['Player','EV_TOI','EV_xGF/60','EV_xGA/60']].sort_values(by='EV_xGF/60',ascending=asc).round(3)
- elif input.y() == "xGA/60":
- df = df[['Player','EV_TOI','EV_xGF/60','EV_xGA/60']].sort_values(by='EV_xGA/60',ascending=asc).round(3)
- elif input.y() == 'TOI':
- df = df[['Player','EV_TOI','EV_xGF/60','EV_xGA/60']].sort_values(by='EV_TOI',ascending=asc).round(3)
- else:
- df = df[['Player','EV_TOI','EV_xGF/60','EV_xGA/60']].sort_values(by=input.y(),ascending=asc).round(3)
- elif input.strength()=="_5v5":
- df = df[(df['Team']==input.x())&(df['5v5_TOI']>=input.toi())]
- if input.y() == "xGF/60":
- df = df[['Player','5v5_TOI','5v5_xGF/60','5v5_xGA/60']].sort_values(by='5v5_xGF/60',ascending=asc).round(3)
- elif input.y() == "xGA/60":
- df = df[['Player','5v5_TOI','5v5_xGF/60','5v5_xGA/60']].sort_values(by='5v5_xGA/60',ascending=asc).round(3)
- elif input.y() == 'TOI':
- df = df[['Player','5v5_TOI','5v5_xGF/60','5v5_xGA/60']].sort_values(by='5v5_TOI',ascending=asc).round(3)
- else:
- df = df[['Player','5v5_TOI','5v5_xGF/60','5v5_xGA/60']].sort_values(by=input.y(),ascending=asc).round(3)
- else:
- df = df[(df['Team']==input.x())&(df['ALL_TOI']>=input.toi())]
- if input.y() == "xGF/60":
- df = df[['Player','ALL_TOI','ALL_xGF/60','ALL_xGA/60']].sort_values(by='ALL_xGF/60',ascending=asc).round(3)
- elif input.y() == "xGA/60":
- df = df[['Player','ALL_TOI','ALL_xGF/60','ALL_xGA/60']].sort_values(by='ALL_xGA/60',ascending=asc).round(3)
- elif input.y() == 'TOI':
- df = df[['Player','ALL_TOI','ALL_xGF/60','ALL_xGA/60']].sort_values(by='ALL_TOI',ascending=asc).round(3)
- else:
- df = df[['Player','ALL_TOI','ALL_xGF/60','ALL_xGA/60']].sort_values(by=input.y(),ascending=asc).round(3)
- return df
-
-
-
- @output
- @render_widget
- def my_widget():
- df = pd.read_csv(path)
- team = input.x()
- if input.strength()=="even":
- title_strength = "Even Strength"
- title_toi = "EV"
- x_col = "EV_xGF/60"
- y_col = "EV_xGA/60"
- x_title = "Even Strength xGF/60"
- y_title = "Even Strength xGA/60"
- color_for_chart = "EV_TOI"
- data = df[(df['Team']==team)&(df['EV_TOI']>=input.toi())]
- elif input.strength()=="_5v5":
- title_strength="5v5"
- title_toi="5v5"
- x_col = "5v5_xGF/60"
- y_col = "5v5_xGA/60"
- x_title = "5v5 xGF/60"
- y_title = "5v5 xGA/60"
- color_for_chart="5v5_TOI"
- data = df[(df['Team']==team)&(df['5v5_TOI']>=input.toi())]
- else:
- title_strength="All Situation"
- title_toi="All"
- x_col = "ALL_xGF/60"
- y_col = "ALL_xGA/60"
- x_title = "All Situation xGF/60"
- y_title = "All Situation xGA/60"
- color_for_chart="ALL_TOI"
- data = df[(df['Team']==team)&(df['ALL_TOI']>=input.toi())]
- fig = px.scatter(data, x_col, y_col,color=color_for_chart,template="plotly_dark",height=1050,width=1050,text='Player')
- fig.update_traces(textposition='top right',marker=dict(size=10))
- fig.update(layout_xaxis_range = [.01,6])
- fig.update(layout_yaxis_range = [6,.01])
- fig.update_layout(xaxis_showgrid=False, yaxis_showgrid=False,plot_bgcolor="#222222",paper_bgcolor="#222222")
- fig.update_layout(
- title=(team + " Skaters "+title_strength+" On-Ice xG Rates2023-24 NHL Regular Season Minimum "+ str(input.toi()) + " " + title_toi + " TOI "),
- margin=dict(r=20, l=40, b=100, t=90),
- template='plotly_dark')
- fig.add_annotation(
- text = ("Data: @StatsByZach on Twitter")
- , showarrow=False
- , x = .80
- , y = -.045
- , xref='paper'
- , yref='paper'
- , xanchor='left'
- , yanchor='bottom'
- , xshift=-1
- , yshift=-5
- , font=dict(size=11, color="white")
- , align="left"
- )
- fig.update_layout(xaxis_title=x_title)
- fig.update_layout(yaxis_title=y_title)
- return fig
-
- @reactive.Effect
- def _():
- val = input.quant()
-
- if input.strength()=="even":
- calc = "EV_TOI"
- elif input.strength()=="_5v5":
- calc = "5v5_TOI"
- else:
- calc = "ALL_TOI"
-
- if val == "_25":
- q= round(df[calc].quantile(.25),1)
- elif val == "_50":
- q= round(df[calc].quantile(.5),1)
- elif val == "_75":
- q=round(df[calc].quantile(.75),1)
- else:
- q=0
- ui.update_slider(
- "toi", value=q
- )
-
- @reactive.Effect
- def _2():
- btn = input.btn()
- if btn % 2 == 1:
- tab = ui.output_table("table")
- ui.insert_ui(
- ui.div({"id": "inserted-slider"},ui.tags.h5("Sort Table by", class_="app-heading"),ui.input_select("y","",{"Player":"Player","TOI":"TOI","xGF/60":"xGF/60","xGA/60":"xGA/60"}),
- ui.input_radio_buttons(
- "z", "", {"F": "High to Low", "T": "Low to High"}
- ),ui.output_table("table")),
- selector="#main-content",
- where="beforeEnd",
- )
- elif btn > 0:
- ui.remove_ui("#inserted-slider")
-
-on_ice_xg = App(ui.page_fluid(
- ui.tags.base(href=base_url),
- ui.tags.div(
- {"style": "width:75%;margin: 0 auto"},
- ui.tags.style(
- """
- h4 {
- margin-top: 1em;font-size:35px;
- }
- h2{
- font-size:25px;
- }
- """
- ),
- shinyswatch.theme.darkly(),
- ui.tags.h4("Stats By Zach"),
- ui.tags.i("A website for hockey analytics"),
- ui.navset_tab(
- ui.nav_control(
- ui.a(
- "Home",
- href="home/"
- ),
- ),
- ui.nav_menu(
- "Skater Charts",
- ui.nav_control(
- ui.a(
- "On-Ice xG Rates",
- href="skater-xg-rates/"
- ),
- ui.a(
- "On-Ice xGF%",
- href="skater-xg-percentages/"
- ),
- ),
- ),
- ui.nav_menu(
- "Goalie Charts",
- ui.nav_control(
- ui.a(
- "GSAx Timeline",
- href="gsax-timeline/"
- ),
- ui.a(
- "GSAx Leaderboard",
- href="gsax-leaderboard/"
- ),
- ui.a(
- "GSAx Comparison",
- href="gsax-comparison/"
- )
- ),
- ),ui.nav_menu(
- "Team Charts",
- ui.nav_control(
- ui.a(
- "Team xG Rates",
- href="team-xg-rates/"
- ),
- ),
- ),ui.nav_control(
- ui.a(
- "Games",
- href="games/"
- ),
- ),ui.nav_control(
- ui.a(
- "About",
- href="about/"
- ),
- )
- ),ui.row(
- ui.column(3,ui.tags.br(),ui.tags.h2("On-Ice xG Rates"),ui.tags.h5("Team", class_="app-heading"),
- ui.input_select("x", "", { "ANA": "Anaheim Ducks",
- "ARI": "Arizona Coyotes",
- "BOS": "Boston Bruins",
- "BUF": "Buffalo Sabres",
- "CGY": "Calgary Flames",
- "CAR": "Carolina Hurricanes",
- "CHI": "Chicago Blackhawks",
- "COL": "Colorado Avalanche",
- "CBJ": "Columbus Blue Jackets",
- "DAL": "Dallas Stars",
- "DET": "Detroit Red Wings",
- "EDM": "Edmonton Oilers",
- "FLA": "Florida Panthers",
- "L.A": "Los Angeles Kings",
- "MIN": "Minnesota Wild",
- "MTL": "Montreal Canadiens",
- "NSH": "Nashville Predators",
- "N.J": "New Jersey Devils",
- "NYI": "New York Islanders",
- "NYR": "New York Rangers",
- "OTT": "Ottawa Senators",
- "PHI": "Philadelphia Flyers",
- "PIT": "Pittsburgh Penguins",
- "S.J": "San Jose Sharks",
- "SEA":"Seattle Kraken",
- "STL": "St. Louis Blues",
- "T.B": "Tampa Bay Lightning",
- "TOR": "Toronto Maple Leafs",
- "VAN": "Vancouver Canucks",
- "VGK": "Vegas Golden Knights",
- "WSH": "Washington Capitals",
- "WPG": "Winnipeg Jets"}),ui.tags.h5("Strength", class_="app-heading"),ui.input_select("strength", "",{'even':"Even",'_5v5':"5v5",'All':"All Situations"}),
- ui.tags.h5("Minimum TOI", class_="app-heading"),
- ui.input_slider("toi", "", min=0, max=round(df['ALL_TOI'].max(),0), value=round(df['EV_TOI'].quantile(.25),1)),
- ui.tags.h5("TOI Percentile (Among All NHL Skaters)",class_="app-heading"),
- ui.input_radio_buttons(
- "quant",
- "",
- {
- "_25": "Top 75%",
- "_50": "Top 50%",
- "_75": "Top 25%",
- },
- ), ui.input_action_button("btn", "Toggle Table"),ui.div({"id":"main-content"}),
- #ui.output_table("table")
- ),
- ui.column(9,output_widget("my_widget"),title="Stats By Zach",
- )))),server)
diff --git a/spaces/Sumit7864/Image-Enhancer/realesrgan/models/realesrgan_model.py b/spaces/Sumit7864/Image-Enhancer/realesrgan/models/realesrgan_model.py
deleted file mode 100644
index c298a09c42433177f90001a0a31d029576072ccd..0000000000000000000000000000000000000000
--- a/spaces/Sumit7864/Image-Enhancer/realesrgan/models/realesrgan_model.py
+++ /dev/null
@@ -1,258 +0,0 @@
-import numpy as np
-import random
-import torch
-from basicsr.data.degradations import random_add_gaussian_noise_pt, random_add_poisson_noise_pt
-from basicsr.data.transforms import paired_random_crop
-from basicsr.models.srgan_model import SRGANModel
-from basicsr.utils import DiffJPEG, USMSharp
-from basicsr.utils.img_process_util import filter2D
-from basicsr.utils.registry import MODEL_REGISTRY
-from collections import OrderedDict
-from torch.nn import functional as F
-
-
-@MODEL_REGISTRY.register()
-class RealESRGANModel(SRGANModel):
- """RealESRGAN Model for Real-ESRGAN: Training Real-World Blind Super-Resolution with Pure Synthetic Data.
-
- It mainly performs:
- 1. randomly synthesize LQ images in GPU tensors
- 2. optimize the networks with GAN training.
- """
-
- def __init__(self, opt):
- super(RealESRGANModel, self).__init__(opt)
- self.jpeger = DiffJPEG(differentiable=False).cuda() # simulate JPEG compression artifacts
- self.usm_sharpener = USMSharp().cuda() # do usm sharpening
- self.queue_size = opt.get('queue_size', 180)
-
- @torch.no_grad()
- def _dequeue_and_enqueue(self):
- """It is the training pair pool for increasing the diversity in a batch.
-
- Batch processing limits the diversity of synthetic degradations in a batch. For example, samples in a
- batch could not have different resize scaling factors. Therefore, we employ this training pair pool
- to increase the degradation diversity in a batch.
- """
- # initialize
- b, c, h, w = self.lq.size()
- if not hasattr(self, 'queue_lr'):
- assert self.queue_size % b == 0, f'queue size {self.queue_size} should be divisible by batch size {b}'
- self.queue_lr = torch.zeros(self.queue_size, c, h, w).cuda()
- _, c, h, w = self.gt.size()
- self.queue_gt = torch.zeros(self.queue_size, c, h, w).cuda()
- self.queue_ptr = 0
- if self.queue_ptr == self.queue_size: # the pool is full
- # do dequeue and enqueue
- # shuffle
- idx = torch.randperm(self.queue_size)
- self.queue_lr = self.queue_lr[idx]
- self.queue_gt = self.queue_gt[idx]
- # get first b samples
- lq_dequeue = self.queue_lr[0:b, :, :, :].clone()
- gt_dequeue = self.queue_gt[0:b, :, :, :].clone()
- # update the queue
- self.queue_lr[0:b, :, :, :] = self.lq.clone()
- self.queue_gt[0:b, :, :, :] = self.gt.clone()
-
- self.lq = lq_dequeue
- self.gt = gt_dequeue
- else:
- # only do enqueue
- self.queue_lr[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.lq.clone()
- self.queue_gt[self.queue_ptr:self.queue_ptr + b, :, :, :] = self.gt.clone()
- self.queue_ptr = self.queue_ptr + b
-
- @torch.no_grad()
- def feed_data(self, data):
- """Accept data from dataloader, and then add two-order degradations to obtain LQ images.
- """
- if self.is_train and self.opt.get('high_order_degradation', True):
- # training data synthesis
- self.gt = data['gt'].to(self.device)
- self.gt_usm = self.usm_sharpener(self.gt)
-
- self.kernel1 = data['kernel1'].to(self.device)
- self.kernel2 = data['kernel2'].to(self.device)
- self.sinc_kernel = data['sinc_kernel'].to(self.device)
-
- ori_h, ori_w = self.gt.size()[2:4]
-
- # ----------------------- The first degradation process ----------------------- #
- # blur
- out = filter2D(self.gt_usm, self.kernel1)
- # random resize
- updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob'])[0]
- if updown_type == 'up':
- scale = np.random.uniform(1, self.opt['resize_range'][1])
- elif updown_type == 'down':
- scale = np.random.uniform(self.opt['resize_range'][0], 1)
- else:
- scale = 1
- mode = random.choice(['area', 'bilinear', 'bicubic'])
- out = F.interpolate(out, scale_factor=scale, mode=mode)
- # add noise
- gray_noise_prob = self.opt['gray_noise_prob']
- if np.random.uniform() < self.opt['gaussian_noise_prob']:
- out = random_add_gaussian_noise_pt(
- out, sigma_range=self.opt['noise_range'], clip=True, rounds=False, gray_prob=gray_noise_prob)
- else:
- out = random_add_poisson_noise_pt(
- out,
- scale_range=self.opt['poisson_scale_range'],
- gray_prob=gray_noise_prob,
- clip=True,
- rounds=False)
- # JPEG compression
- jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range'])
- out = torch.clamp(out, 0, 1) # clamp to [0, 1], otherwise JPEGer will result in unpleasant artifacts
- out = self.jpeger(out, quality=jpeg_p)
-
- # ----------------------- The second degradation process ----------------------- #
- # blur
- if np.random.uniform() < self.opt['second_blur_prob']:
- out = filter2D(out, self.kernel2)
- # random resize
- updown_type = random.choices(['up', 'down', 'keep'], self.opt['resize_prob2'])[0]
- if updown_type == 'up':
- scale = np.random.uniform(1, self.opt['resize_range2'][1])
- elif updown_type == 'down':
- scale = np.random.uniform(self.opt['resize_range2'][0], 1)
- else:
- scale = 1
- mode = random.choice(['area', 'bilinear', 'bicubic'])
- out = F.interpolate(
- out, size=(int(ori_h / self.opt['scale'] * scale), int(ori_w / self.opt['scale'] * scale)), mode=mode)
- # add noise
- gray_noise_prob = self.opt['gray_noise_prob2']
- if np.random.uniform() < self.opt['gaussian_noise_prob2']:
- out = random_add_gaussian_noise_pt(
- out, sigma_range=self.opt['noise_range2'], clip=True, rounds=False, gray_prob=gray_noise_prob)
- else:
- out = random_add_poisson_noise_pt(
- out,
- scale_range=self.opt['poisson_scale_range2'],
- gray_prob=gray_noise_prob,
- clip=True,
- rounds=False)
-
- # JPEG compression + the final sinc filter
- # We also need to resize images to desired sizes. We group [resize back + sinc filter] together
- # as one operation.
- # We consider two orders:
- # 1. [resize back + sinc filter] + JPEG compression
- # 2. JPEG compression + [resize back + sinc filter]
- # Empirically, we find other combinations (sinc + JPEG + Resize) will introduce twisted lines.
- if np.random.uniform() < 0.5:
- # resize back + the final sinc filter
- mode = random.choice(['area', 'bilinear', 'bicubic'])
- out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
- out = filter2D(out, self.sinc_kernel)
- # JPEG compression
- jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
- out = torch.clamp(out, 0, 1)
- out = self.jpeger(out, quality=jpeg_p)
- else:
- # JPEG compression
- jpeg_p = out.new_zeros(out.size(0)).uniform_(*self.opt['jpeg_range2'])
- out = torch.clamp(out, 0, 1)
- out = self.jpeger(out, quality=jpeg_p)
- # resize back + the final sinc filter
- mode = random.choice(['area', 'bilinear', 'bicubic'])
- out = F.interpolate(out, size=(ori_h // self.opt['scale'], ori_w // self.opt['scale']), mode=mode)
- out = filter2D(out, self.sinc_kernel)
-
- # clamp and round
- self.lq = torch.clamp((out * 255.0).round(), 0, 255) / 255.
-
- # random crop
- gt_size = self.opt['gt_size']
- (self.gt, self.gt_usm), self.lq = paired_random_crop([self.gt, self.gt_usm], self.lq, gt_size,
- self.opt['scale'])
-
- # training pair pool
- self._dequeue_and_enqueue()
- # sharpen self.gt again, as we have changed the self.gt with self._dequeue_and_enqueue
- self.gt_usm = self.usm_sharpener(self.gt)
- self.lq = self.lq.contiguous() # for the warning: grad and param do not obey the gradient layout contract
- else:
- # for paired training or validation
- self.lq = data['lq'].to(self.device)
- if 'gt' in data:
- self.gt = data['gt'].to(self.device)
- self.gt_usm = self.usm_sharpener(self.gt)
-
- def nondist_validation(self, dataloader, current_iter, tb_logger, save_img):
- # do not use the synthetic process during validation
- self.is_train = False
- super(RealESRGANModel, self).nondist_validation(dataloader, current_iter, tb_logger, save_img)
- self.is_train = True
-
- def optimize_parameters(self, current_iter):
- # usm sharpening
- l1_gt = self.gt_usm
- percep_gt = self.gt_usm
- gan_gt = self.gt_usm
- if self.opt['l1_gt_usm'] is False:
- l1_gt = self.gt
- if self.opt['percep_gt_usm'] is False:
- percep_gt = self.gt
- if self.opt['gan_gt_usm'] is False:
- gan_gt = self.gt
-
- # optimize net_g
- for p in self.net_d.parameters():
- p.requires_grad = False
-
- self.optimizer_g.zero_grad()
- self.output = self.net_g(self.lq)
-
- l_g_total = 0
- loss_dict = OrderedDict()
- if (current_iter % self.net_d_iters == 0 and current_iter > self.net_d_init_iters):
- # pixel loss
- if self.cri_pix:
- l_g_pix = self.cri_pix(self.output, l1_gt)
- l_g_total += l_g_pix
- loss_dict['l_g_pix'] = l_g_pix
- # perceptual loss
- if self.cri_perceptual:
- l_g_percep, l_g_style = self.cri_perceptual(self.output, percep_gt)
- if l_g_percep is not None:
- l_g_total += l_g_percep
- loss_dict['l_g_percep'] = l_g_percep
- if l_g_style is not None:
- l_g_total += l_g_style
- loss_dict['l_g_style'] = l_g_style
- # gan loss
- fake_g_pred = self.net_d(self.output)
- l_g_gan = self.cri_gan(fake_g_pred, True, is_disc=False)
- l_g_total += l_g_gan
- loss_dict['l_g_gan'] = l_g_gan
-
- l_g_total.backward()
- self.optimizer_g.step()
-
- # optimize net_d
- for p in self.net_d.parameters():
- p.requires_grad = True
-
- self.optimizer_d.zero_grad()
- # real
- real_d_pred = self.net_d(gan_gt)
- l_d_real = self.cri_gan(real_d_pred, True, is_disc=True)
- loss_dict['l_d_real'] = l_d_real
- loss_dict['out_d_real'] = torch.mean(real_d_pred.detach())
- l_d_real.backward()
- # fake
- fake_d_pred = self.net_d(self.output.detach().clone()) # clone for pt1.9
- l_d_fake = self.cri_gan(fake_d_pred, False, is_disc=True)
- loss_dict['l_d_fake'] = l_d_fake
- loss_dict['out_d_fake'] = torch.mean(fake_d_pred.detach())
- l_d_fake.backward()
- self.optimizer_d.step()
-
- if self.ema_decay > 0:
- self.model_ema(decay=self.ema_decay)
-
- self.log_dict = self.reduce_loss_dict(loss_dict)
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/base.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/base.py
deleted file mode 100644
index 302cb2fb384f95939312420a69fd26b18a613d4c..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/clickhouse_connect/datatypes/base.py
+++ /dev/null
@@ -1,364 +0,0 @@
-import array
-import logging
-
-from abc import ABC
-from math import log
-from typing import NamedTuple, Dict, Type, Any, Sequence, MutableSequence, Optional, Union, Collection
-
-from clickhouse_connect.driver.common import array_type, int_size, write_array, write_uint64, low_card_version
-from clickhouse_connect.driver.context import BaseQueryContext
-from clickhouse_connect.driver.ctypes import numpy_conv, data_conv
-from clickhouse_connect.driver.exceptions import NotSupportedError
-from clickhouse_connect.driver.insert import InsertContext
-from clickhouse_connect.driver.query import QueryContext
-from clickhouse_connect.driver.types import ByteSource
-from clickhouse_connect.driver.options import np, pd
-
-logger = logging.getLogger(__name__)
-ch_read_formats = {}
-ch_write_formats = {}
-
-
-class TypeDef(NamedTuple):
- """
- Immutable tuple that contains all additional information needed to construct a particular ClickHouseType
- """
- wrappers: tuple = ()
- keys: tuple = ()
- values: tuple = ()
-
- @property
- def arg_str(self):
- return f"({', '.join(str(v) for v in self.values)})" if self.values else ''
-
-
-class ClickHouseType(ABC):
- """
- Base class for all ClickHouseType objects.
- """
- __slots__ = 'nullable', 'low_card', 'wrappers', 'type_def', '__dict__'
- _name_suffix = ''
- encoding = 'utf8'
- np_type = 'O' # Default to Numpy Object type
- nano_divisor = 0 # Only relevant for date like objects
- byte_size = 0
- valid_formats = 'native'
-
- python_type = None
- base_type = None
-
- def __init_subclass__(cls, registered: bool = True):
- if registered:
- cls.base_type = cls.__name__
- type_map[cls.base_type] = cls
-
- @classmethod
- def build(cls: Type['ClickHouseType'], type_def: TypeDef):
- return cls(type_def)
-
- @classmethod
- def _active_format(cls, fmt_map: Dict[Type['ClickHouseType'], str], ctx: BaseQueryContext):
- ctx_fmt = ctx.active_fmt(cls.base_type)
- if ctx_fmt:
- return ctx_fmt
- return fmt_map.get(cls, 'native')
-
- @classmethod
- def read_format(cls, ctx: BaseQueryContext):
- return cls._active_format(ch_read_formats, ctx)
-
- @classmethod
- def write_format(cls, ctx: BaseQueryContext):
- return cls._active_format(ch_write_formats, ctx)
-
- def __init__(self, type_def: TypeDef):
- """
- Base class constructor that sets Nullable and LowCardinality wrappers
- :param type_def: ClickHouseType base configuration parameters
- """
- self.type_def = type_def
- self.wrappers = type_def.wrappers
- self.low_card = 'LowCardinality' in self.wrappers
- self.nullable = 'Nullable' in self.wrappers
-
- def __eq__(self, other):
- return other.__class__ == self.__class__ and self.type_def == other.type_def
-
- def __hash__(self):
- return hash((self.type_def, self.__class__))
-
- @property
- def name(self):
- name = f'{self.base_type}{self._name_suffix}'
- for wrapper in reversed(self.wrappers):
- name = f'{wrapper}({name})'
- return name
-
- def data_size(self, sample: Collection) -> int:
- if self.low_card:
- values = set(sample)
- d_size = self._data_size(values) + 2
- else:
- d_size = self._data_size(sample)
- if self.nullable:
- d_size += 1
- return d_size
-
- def _data_size(self, _sample: Collection) -> int:
- if self.byte_size:
- return self.byte_size
- return 0
-
- def write_column_prefix(self, dest: bytearray):
- """
- Prefix is primarily used is for the LowCardinality version (but see the JSON data type). Because of the
- way the ClickHouse C++ code is written, this must be done before any data is written even if the
- LowCardinality column is within a container. The only recognized low cardinality version is 1
- :param dest: The native protocol binary write buffer
- """
- if self.low_card:
- write_uint64(low_card_version, dest)
-
- def read_column_prefix(self, source: ByteSource):
- """
- Read the low cardinality version. Like the write method, this has to happen immediately for container classes
- :param source: The native protocol binary read buffer
- :return: updated read pointer
- """
- if self.low_card:
- v = source.read_uint64()
- if v != low_card_version:
- logger.warning('Unexpected low cardinality version %d reading type %s', v, self.name)
-
- def read_column(self, source: ByteSource, num_rows: int, ctx: QueryContext) -> Sequence:
- """
- Wrapping read method for all ClickHouseType data types. Only overridden for container classes so that
- the LowCardinality version is read for the contained types
- :param source: Native protocol binary read buffer
- :param num_rows: Number of rows expected in the column
- :param ctx: QueryContext for query specific settings
- :return: The decoded column data as a sequence and the updated location pointer
- """
- self.read_column_prefix(source)
- return self.read_column_data(source, num_rows, ctx)
-
- def read_column_data(self, source: ByteSource, num_rows: int, ctx: QueryContext) -> Sequence:
- """
- Public read method for all ClickHouseType data type columns
- :param source: Native protocol binary read buffer
- :param num_rows: Number of rows expected in the column
- :param ctx: QueryContext for query specific settings
- :return: The decoded column plus the updated location pointer
- """
- if self.low_card:
- column = self._read_low_card_column(source, num_rows, ctx)
- elif self.nullable:
- column = self._read_nullable_column(source, num_rows, ctx)
- else:
- column = self._read_column_binary(source, num_rows, ctx)
- return self._finalize_column(column, ctx)
-
- def _read_nullable_column(self, source: ByteSource, num_rows: int, ctx: QueryContext) -> Sequence:
- null_map = source.read_bytes(num_rows)
- column = self._read_column_binary(source, num_rows, ctx)
- null_obj = self._active_null(ctx)
- return data_conv.build_nullable_column(column, null_map, null_obj)
-
- # The binary methods are really abstract, but they aren't implemented for container classes which
- # delegate binary operations to their elements
-
- # pylint: disable=no-self-use
- def _read_column_binary(self,
- _source: ByteSource,
- _num_rows: int, _ctx: QueryContext) -> Union[Sequence, MutableSequence]:
- """
- Lowest level read method for ClickHouseType native data columns
- :param _source: Native protocol binary read buffer
- :param _num_rows: Expected number of rows in the column
- :return: Decoded column plus updated read buffer
- """
- return [], 0
-
- def _finalize_column(self, column: Sequence, _ctx: QueryContext) -> Sequence:
- return column
-
- def _write_column_binary(self, column: Union[Sequence, MutableSequence], dest: bytearray, ctx: InsertContext):
- """
- Lowest level write method for ClickHouseType data columns
- :param column: Python data column
- :param dest: Native protocol write buffer
- :param ctx: Insert Context with insert specific settings
- """
-
- def write_column(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- """
- Wrapping write method for ClickHouseTypes. Only overridden for container types that so that
- the write_native_prefix is done at the right time for contained types
- :param column: Column/sequence of Python values to write
- :param dest: Native binary write buffer
- :param ctx: Insert Context with insert specific settings
- """
- self.write_column_prefix(dest)
- self.write_column_data(column, dest, ctx)
-
- def write_column_data(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- """
- Public native write method for ClickHouseTypes. Delegates the actual write to either the LowCardinality
- write method or the _write_native_binary method of the type
- :param column: Sequence of Python data
- :param dest: Native binary write buffer
- :param ctx: Insert Context with insert specific settings
- """
- if self.low_card:
- self._write_column_low_card(column, dest, ctx)
- else:
- if self.nullable:
- dest += bytes([1 if x is None else 0 for x in column])
- self._write_column_binary(column, dest, ctx)
-
- # pylint: disable=no-member
- def _read_low_card_column(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- if num_rows == 0:
- return []
- key_data = source.read_uint64()
- index_sz = 2 ** (key_data & 0xff)
- key_cnt = source.read_uint64()
- keys = self._read_column_binary(source, key_cnt, ctx)
- index_cnt = source.read_uint64()
- index = source.read_array(array_type(index_sz, False), index_cnt)
- if self.nullable:
- return self._build_lc_nullable_column(keys, index, ctx)
- return self._build_lc_column(keys, index, ctx)
-
- def _build_lc_column(self, keys: Sequence, index: array.array, _ctx: QueryContext):
- return [keys[ix] for ix in index]
-
- def _build_lc_nullable_column(self, keys: Sequence, index: array.array, ctx: QueryContext):
- return data_conv.build_lc_nullable_column(keys, index, self._active_null(ctx))
-
- def _write_column_low_card(self, column: Sequence, dest: bytearray, ctx: InsertContext):
- if len(column) == 0:
- return
- index = []
- keys = []
- rev_map = {}
- rmg = rev_map.get
- if self.nullable:
- keys.append(None)
- key = 1
- for x in column:
- if x is None:
- index.append(0)
- else:
- ix = rmg(x)
- if ix is None:
- index.append(key)
- keys.append(x)
- rev_map[x] = key
- key += 1
- else:
- index.append(ix)
- else:
- key = 0
- for x in column:
- ix = rmg(x)
- if ix is None:
- index.append(key)
- keys.append(x)
- rev_map[x] = key
- key += 1
- else:
- index.append(ix)
- ix_type = int(log(len(keys), 2)) >> 3 # power of two bytes needed to store the total number of keys
- write_uint64((1 << 9) | (1 << 10) | ix_type, dest) # Index type plus new dictionary (9) and additional keys(10)
- write_uint64(len(keys), dest)
- self._write_column_binary(keys, dest, ctx)
- write_uint64(len(index), dest)
- write_array(array_type(1 << ix_type, False), index, dest)
-
- def _active_null(self, _ctx: QueryContext) -> Any:
- return None
-
- def _first_value(self, column: Sequence) -> Optional[Any]:
- if self.nullable:
- return next((x for x in column if x is not None), None)
- if len(column):
- return column[0]
- return None
-
-
-EMPTY_TYPE_DEF = TypeDef()
-NULLABLE_TYPE_DEF = TypeDef(wrappers=('Nullable',))
-LC_TYPE_DEF = TypeDef(wrappers=('LowCardinality',))
-type_map: Dict[str, Type[ClickHouseType]] = {}
-
-
-class ArrayType(ClickHouseType, ABC, registered=False):
- """
- ClickHouse type that utilizes Python or Numpy arrays for fast reads and writes of binary data.
- arrays can only be used for ClickHouse types that can be translated into UInt64 (and smaller) integers
- or Float32/64
- """
- _signed = True
- _array_type = None
- _struct_type = None
- valid_formats = 'string', 'native'
- python_type = int
-
- def __init_subclass__(cls, registered: bool = True):
- super().__init_subclass__(registered)
- if cls._array_type in ('i', 'I') and int_size == 2:
- cls._array_type = 'L' if cls._array_type.isupper() else 'l'
- if isinstance(cls._array_type, str) and cls._array_type:
- cls._struct_type = '<' + cls._array_type
- cls.byte_size = array.array(cls._array_type).itemsize
-
- def _read_column_binary(self, source: ByteSource, num_rows: int, ctx: QueryContext):
- if ctx.use_numpy:
- return numpy_conv.read_numpy_array(source, self.np_type, num_rows)
- return source.read_array(self._array_type, num_rows)
-
- def _read_nullable_column(self, source: ByteSource, num_rows: int, ctx: QueryContext) -> Sequence:
- return data_conv.read_nullable_array(source, self._array_type, num_rows, self._active_null(ctx))
-
- def _build_lc_column(self, keys: Sequence, index: array.array, ctx: QueryContext):
- if ctx.use_numpy:
- return np.fromiter((keys[ix] for ix in index), dtype=keys.dtype, count=len(index))
- return super()._build_lc_column(keys, index, ctx)
-
- def _finalize_column(self, column: Sequence, ctx: QueryContext) -> Sequence:
- if self.read_format(ctx) == 'string':
- return [str(x) for x in column]
- if ctx.use_extended_dtypes and self.nullable:
- return pd.array(column, dtype=self.base_type)
- if ctx.use_numpy and self.nullable and (not ctx.use_none):
- return np.array(column, dtype=self.np_type)
- return column
-
- def _write_column_binary(self, column: Union[Sequence, MutableSequence], dest: bytearray, ctx: InsertContext):
- if len(column) and self.nullable:
- column = [0 if x is None else x for x in column]
- write_array(self._array_type, column, dest)
-
- def _active_null(self, ctx: QueryContext):
- if ctx.as_pandas and ctx.use_extended_dtypes:
- return pd.NA
- if ctx.use_none:
- return None
- return 0
-
-
-class UnsupportedType(ClickHouseType, ABC, registered=False):
- """
- Base class for ClickHouse types that can't be serialized/deserialized into Python types.
- Mostly useful just for DDL statements
- """
- def __init__(self, type_def: TypeDef):
- super().__init__(type_def)
- self._name_suffix = type_def.arg_str
-
- def _read_column_binary(self, source: Sequence, num_rows: int, ctx: QueryContext):
- raise NotSupportedError(f'{self.name} deserialization not supported')
-
- def _write_column_binary(self, column: Union[Sequence, MutableSequence], dest: bytearray, ctx: InsertContext):
- raise NotSupportedError(f'{self.name} serialization not supported')
diff --git a/spaces/Superlang/ImageProcessor/annotator/leres/pix2pix/util/visualizer.py b/spaces/Superlang/ImageProcessor/annotator/leres/pix2pix/util/visualizer.py
deleted file mode 100644
index 810a0513ab997103ace77b665c9a17f223b173c9..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/leres/pix2pix/util/visualizer.py
+++ /dev/null
@@ -1,166 +0,0 @@
-import numpy as np
-import os
-import sys
-import ntpath
-import time
-from . import util, html
-from subprocess import Popen, PIPE
-import torch
-
-
-if sys.version_info[0] == 2:
- VisdomExceptionBase = Exception
-else:
- VisdomExceptionBase = ConnectionError
-
-
-def save_images(webpage, visuals, image_path, aspect_ratio=1.0, width=256):
- """Save images to the disk.
-
- Parameters:
- webpage (the HTML class) -- the HTML webpage class that stores these imaegs (see html.py for more details)
- visuals (OrderedDict) -- an ordered dictionary that stores (name, images (either tensor or numpy) ) pairs
- image_path (str) -- the string is used to create image paths
- aspect_ratio (float) -- the aspect ratio of saved images
- width (int) -- the images will be resized to width x width
-
- This function will save images stored in 'visuals' to the HTML file specified by 'webpage'.
- """
- image_dir = webpage.get_image_dir()
- short_path = ntpath.basename(image_path[0])
- name = os.path.splitext(short_path)[0]
-
- webpage.add_header(name)
- ims, txts, links = [], [], []
-
- for label, im_data in visuals.items():
- im = util.tensor2im(im_data)
- image_name = '%s_%s.png' % (name, label)
- save_path = os.path.join(image_dir, image_name)
- util.save_image(im, save_path, aspect_ratio=aspect_ratio)
- ims.append(image_name)
- txts.append(label)
- links.append(image_name)
- webpage.add_images(ims, txts, links, width=width)
-
-
-class Visualizer():
- """This class includes several functions that can display/save images and print/save logging information.
-
- It uses a Python library 'visdom' for display, and a Python library 'dominate' (wrapped in 'HTML') for creating HTML files with images.
- """
-
- def __init__(self, opt):
- """Initialize the Visualizer class
-
- Parameters:
- opt -- stores all the experiment flags; needs to be a subclass of BaseOptions
- Step 1: Cache the training/test options
- Step 2: connect to a visdom server
- Step 3: create an HTML object for saveing HTML filters
- Step 4: create a logging file to store training losses
- """
- self.opt = opt # cache the option
- self.display_id = opt.display_id
- self.use_html = opt.isTrain and not opt.no_html
- self.win_size = opt.display_winsize
- self.name = opt.name
- self.port = opt.display_port
- self.saved = False
-
- if self.use_html: # create an HTML object at /web/; images will be saved under /web/images/
- self.web_dir = os.path.join(opt.checkpoints_dir, opt.name, 'web')
- self.img_dir = os.path.join(self.web_dir, 'images')
- print('create web directory %s...' % self.web_dir)
- util.mkdirs([self.web_dir, self.img_dir])
- # create a logging file to store training losses
- self.log_name = os.path.join(opt.checkpoints_dir, opt.name, 'loss_log.txt')
- with open(self.log_name, "a") as log_file:
- now = time.strftime("%c")
- log_file.write('================ Training Loss (%s) ================\n' % now)
-
- def reset(self):
- """Reset the self.saved status"""
- self.saved = False
-
- def create_visdom_connections(self):
- """If the program could not connect to Visdom server, this function will start a new server at port < self.port > """
- cmd = sys.executable + ' -m visdom.server -p %d &>/dev/null &' % self.port
- print('\n\nCould not connect to Visdom server. \n Trying to start a server....')
- print('Command: %s' % cmd)
- Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE)
-
- def display_current_results(self, visuals, epoch, save_result):
- """Display current results on visdom; save current results to an HTML file.
-
- Parameters:
- visuals (OrderedDict) - - dictionary of images to display or save
- epoch (int) - - the current epoch
- save_result (bool) - - if save the current results to an HTML file
- """
- if self.use_html and (save_result or not self.saved): # save images to an HTML file if they haven't been saved.
- self.saved = True
- # save images to the disk
- for label, image in visuals.items():
- image_numpy = util.tensor2im(image)
- img_path = os.path.join(self.img_dir, 'epoch%.3d_%s.png' % (epoch, label))
- util.save_image(image_numpy, img_path)
-
- # update website
- webpage = html.HTML(self.web_dir, 'Experiment name = %s' % self.name, refresh=1)
- for n in range(epoch, 0, -1):
- webpage.add_header('epoch [%d]' % n)
- ims, txts, links = [], [], []
-
- for label, image_numpy in visuals.items():
- # image_numpy = util.tensor2im(image)
- img_path = 'epoch%.3d_%s.png' % (n, label)
- ims.append(img_path)
- txts.append(label)
- links.append(img_path)
- webpage.add_images(ims, txts, links, width=self.win_size)
- webpage.save()
-
- # def plot_current_losses(self, epoch, counter_ratio, losses):
- # """display the current losses on visdom display: dictionary of error labels and values
- #
- # Parameters:
- # epoch (int) -- current epoch
- # counter_ratio (float) -- progress (percentage) in the current epoch, between 0 to 1
- # losses (OrderedDict) -- training losses stored in the format of (name, float) pairs
- # """
- # if not hasattr(self, 'plot_data'):
- # self.plot_data = {'X': [], 'Y': [], 'legend': list(losses.keys())}
- # self.plot_data['X'].append(epoch + counter_ratio)
- # self.plot_data['Y'].append([losses[k] for k in self.plot_data['legend']])
- # try:
- # self.vis.line(
- # X=np.stack([np.array(self.plot_data['X'])] * len(self.plot_data['legend']), 1),
- # Y=np.array(self.plot_data['Y']),
- # opts={
- # 'title': self.name + ' loss over time',
- # 'legend': self.plot_data['legend'],
- # 'xlabel': 'epoch',
- # 'ylabel': 'loss'},
- # win=self.display_id)
- # except VisdomExceptionBase:
- # self.create_visdom_connections()
-
- # losses: same format as |losses| of plot_current_losses
- def print_current_losses(self, epoch, iters, losses, t_comp, t_data):
- """print current losses on console; also save the losses to the disk
-
- Parameters:
- epoch (int) -- current epoch
- iters (int) -- current training iteration during this epoch (reset to 0 at the end of every epoch)
- losses (OrderedDict) -- training losses stored in the format of (name, float) pairs
- t_comp (float) -- computational time per data point (normalized by batch_size)
- t_data (float) -- data loading time per data point (normalized by batch_size)
- """
- message = '(epoch: %d, iters: %d, time: %.3f, data: %.3f) ' % (epoch, iters, t_comp, t_data)
- for k, v in losses.items():
- message += '%s: %.3f ' % (k, v)
-
- print(message) # print the message
- with open(self.log_name, "a") as log_file:
- log_file.write('%s\n' % message) # save the message
diff --git a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/utils/logger.py b/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/utils/logger.py
deleted file mode 100644
index d77d42cbe86366e5d91e93311f92bb166c304184..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/oneformer/detectron2/utils/logger.py
+++ /dev/null
@@ -1,237 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import atexit
-import functools
-import logging
-import os
-import sys
-import time
-from collections import Counter
-import torch
-from tabulate import tabulate
-from termcolor import colored
-
-from annotator.oneformer.detectron2.utils.file_io import PathManager
-
-__all__ = ["setup_logger", "log_first_n", "log_every_n", "log_every_n_seconds"]
-
-
-class _ColorfulFormatter(logging.Formatter):
- def __init__(self, *args, **kwargs):
- self._root_name = kwargs.pop("root_name") + "."
- self._abbrev_name = kwargs.pop("abbrev_name", "")
- if len(self._abbrev_name):
- self._abbrev_name = self._abbrev_name + "."
- super(_ColorfulFormatter, self).__init__(*args, **kwargs)
-
- def formatMessage(self, record):
- record.name = record.name.replace(self._root_name, self._abbrev_name)
- log = super(_ColorfulFormatter, self).formatMessage(record)
- if record.levelno == logging.WARNING:
- prefix = colored("WARNING", "red", attrs=["blink"])
- elif record.levelno == logging.ERROR or record.levelno == logging.CRITICAL:
- prefix = colored("ERROR", "red", attrs=["blink", "underline"])
- else:
- return log
- return prefix + " " + log
-
-
-@functools.lru_cache() # so that calling setup_logger multiple times won't add many handlers
-def setup_logger(
- output=None, distributed_rank=0, *, color=True, name="detectron2", abbrev_name=None
-):
- """
- Initialize the detectron2 logger and set its verbosity level to "DEBUG".
-
- Args:
- output (str): a file name or a directory to save log. If None, will not save log file.
- If ends with ".txt" or ".log", assumed to be a file name.
- Otherwise, logs will be saved to `output/log.txt`.
- name (str): the root module name of this logger
- abbrev_name (str): an abbreviation of the module, to avoid long names in logs.
- Set to "" to not log the root module in logs.
- By default, will abbreviate "detectron2" to "d2" and leave other
- modules unchanged.
-
- Returns:
- logging.Logger: a logger
- """
- logger = logging.getLogger(name)
- logger.setLevel(logging.DEBUG)
- logger.propagate = False
-
- if abbrev_name is None:
- abbrev_name = "d2" if name == "detectron2" else name
-
- plain_formatter = logging.Formatter(
- "[%(asctime)s] %(name)s %(levelname)s: %(message)s", datefmt="%m/%d %H:%M:%S"
- )
- # stdout logging: master only
- if distributed_rank == 0:
- ch = logging.StreamHandler(stream=sys.stdout)
- ch.setLevel(logging.DEBUG)
- if color:
- formatter = _ColorfulFormatter(
- colored("[%(asctime)s %(name)s]: ", "green") + "%(message)s",
- datefmt="%m/%d %H:%M:%S",
- root_name=name,
- abbrev_name=str(abbrev_name),
- )
- else:
- formatter = plain_formatter
- ch.setFormatter(formatter)
- logger.addHandler(ch)
-
- # file logging: all workers
- if output is not None:
- if output.endswith(".txt") or output.endswith(".log"):
- filename = output
- else:
- filename = os.path.join(output, "log.txt")
- if distributed_rank > 0:
- filename = filename + ".rank{}".format(distributed_rank)
- PathManager.mkdirs(os.path.dirname(filename))
-
- fh = logging.StreamHandler(_cached_log_stream(filename))
- fh.setLevel(logging.DEBUG)
- fh.setFormatter(plain_formatter)
- logger.addHandler(fh)
-
- return logger
-
-
-# cache the opened file object, so that different calls to `setup_logger`
-# with the same file name can safely write to the same file.
-@functools.lru_cache(maxsize=None)
-def _cached_log_stream(filename):
- # use 1K buffer if writing to cloud storage
- io = PathManager.open(filename, "a", buffering=1024 if "://" in filename else -1)
- atexit.register(io.close)
- return io
-
-
-"""
-Below are some other convenient logging methods.
-They are mainly adopted from
-https://github.com/abseil/abseil-py/blob/master/absl/logging/__init__.py
-"""
-
-
-def _find_caller():
- """
- Returns:
- str: module name of the caller
- tuple: a hashable key to be used to identify different callers
- """
- frame = sys._getframe(2)
- while frame:
- code = frame.f_code
- if os.path.join("utils", "logger.") not in code.co_filename:
- mod_name = frame.f_globals["__name__"]
- if mod_name == "__main__":
- mod_name = "detectron2"
- return mod_name, (code.co_filename, frame.f_lineno, code.co_name)
- frame = frame.f_back
-
-
-_LOG_COUNTER = Counter()
-_LOG_TIMER = {}
-
-
-def log_first_n(lvl, msg, n=1, *, name=None, key="caller"):
- """
- Log only for the first n times.
-
- Args:
- lvl (int): the logging level
- msg (str):
- n (int):
- name (str): name of the logger to use. Will use the caller's module by default.
- key (str or tuple[str]): the string(s) can be one of "caller" or
- "message", which defines how to identify duplicated logs.
- For example, if called with `n=1, key="caller"`, this function
- will only log the first call from the same caller, regardless of
- the message content.
- If called with `n=1, key="message"`, this function will log the
- same content only once, even if they are called from different places.
- If called with `n=1, key=("caller", "message")`, this function
- will not log only if the same caller has logged the same message before.
- """
- if isinstance(key, str):
- key = (key,)
- assert len(key) > 0
-
- caller_module, caller_key = _find_caller()
- hash_key = ()
- if "caller" in key:
- hash_key = hash_key + caller_key
- if "message" in key:
- hash_key = hash_key + (msg,)
-
- _LOG_COUNTER[hash_key] += 1
- if _LOG_COUNTER[hash_key] <= n:
- logging.getLogger(name or caller_module).log(lvl, msg)
-
-
-def log_every_n(lvl, msg, n=1, *, name=None):
- """
- Log once per n times.
-
- Args:
- lvl (int): the logging level
- msg (str):
- n (int):
- name (str): name of the logger to use. Will use the caller's module by default.
- """
- caller_module, key = _find_caller()
- _LOG_COUNTER[key] += 1
- if n == 1 or _LOG_COUNTER[key] % n == 1:
- logging.getLogger(name or caller_module).log(lvl, msg)
-
-
-def log_every_n_seconds(lvl, msg, n=1, *, name=None):
- """
- Log no more than once per n seconds.
-
- Args:
- lvl (int): the logging level
- msg (str):
- n (int):
- name (str): name of the logger to use. Will use the caller's module by default.
- """
- caller_module, key = _find_caller()
- last_logged = _LOG_TIMER.get(key, None)
- current_time = time.time()
- if last_logged is None or current_time - last_logged >= n:
- logging.getLogger(name or caller_module).log(lvl, msg)
- _LOG_TIMER[key] = current_time
-
-
-def create_small_table(small_dict):
- """
- Create a small table using the keys of small_dict as headers. This is only
- suitable for small dictionaries.
-
- Args:
- small_dict (dict): a result dictionary of only a few items.
-
- Returns:
- str: the table as a string.
- """
- keys, values = tuple(zip(*small_dict.items()))
- table = tabulate(
- [values],
- headers=keys,
- tablefmt="pipe",
- floatfmt=".3f",
- stralign="center",
- numalign="center",
- )
- return table
-
-
-def _log_api_usage(identifier: str):
- """
- Internal function used to log the usage of different detectron2 components
- inside facebook's infra.
- """
- torch._C._log_api_usage_once("detectron2." + identifier)
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/upernet_uniformer.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/upernet_uniformer.py
deleted file mode 100644
index 41aa4db809dc6e2c508e98051f61807d07477903..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/configs/_base_/models/upernet_uniformer.py
+++ /dev/null
@@ -1,43 +0,0 @@
-# model settings
-norm_cfg = dict(type='BN', requires_grad=True)
-model = dict(
- type='EncoderDecoder',
- pretrained=None,
- backbone=dict(
- type='UniFormer',
- embed_dim=[64, 128, 320, 512],
- layers=[3, 4, 8, 3],
- head_dim=64,
- mlp_ratio=4.,
- qkv_bias=True,
- drop_rate=0.,
- attn_drop_rate=0.,
- drop_path_rate=0.1),
- decode_head=dict(
- type='UPerHead',
- in_channels=[64, 128, 320, 512],
- in_index=[0, 1, 2, 3],
- pool_scales=(1, 2, 3, 6),
- channels=512,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0)),
- auxiliary_head=dict(
- type='FCNHead',
- in_channels=320,
- in_index=2,
- channels=256,
- num_convs=1,
- concat_input=False,
- dropout_ratio=0.1,
- num_classes=19,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=False, loss_weight=0.4)),
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
\ No newline at end of file
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/fused_bias_leakyrelu.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/fused_bias_leakyrelu.py
deleted file mode 100644
index 6d12508469c6c8fa1884debece44c58d158cb6fa..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/fused_bias_leakyrelu.py
+++ /dev/null
@@ -1,268 +0,0 @@
-# modified from https://github.com/rosinality/stylegan2-pytorch/blob/master/op/fused_act.py # noqa:E501
-
-# Copyright (c) 2021, NVIDIA Corporation. All rights reserved.
-# NVIDIA Source Code License for StyleGAN2 with Adaptive Discriminator
-# Augmentation (ADA)
-# =======================================================================
-
-# 1. Definitions
-
-# "Licensor" means any person or entity that distributes its Work.
-
-# "Software" means the original work of authorship made available under
-# this License.
-
-# "Work" means the Software and any additions to or derivative works of
-# the Software that are made available under this License.
-
-# The terms "reproduce," "reproduction," "derivative works," and
-# "distribution" have the meaning as provided under U.S. copyright law;
-# provided, however, that for the purposes of this License, derivative
-# works shall not include works that remain separable from, or merely
-# link (or bind by name) to the interfaces of, the Work.
-
-# Works, including the Software, are "made available" under this License
-# by including in or with the Work either (a) a copyright notice
-# referencing the applicability of this License to the Work, or (b) a
-# copy of this License.
-
-# 2. License Grants
-
-# 2.1 Copyright Grant. Subject to the terms and conditions of this
-# License, each Licensor grants to you a perpetual, worldwide,
-# non-exclusive, royalty-free, copyright license to reproduce,
-# prepare derivative works of, publicly display, publicly perform,
-# sublicense and distribute its Work and any resulting derivative
-# works in any form.
-
-# 3. Limitations
-
-# 3.1 Redistribution. You may reproduce or distribute the Work only
-# if (a) you do so under this License, (b) you include a complete
-# copy of this License with your distribution, and (c) you retain
-# without modification any copyright, patent, trademark, or
-# attribution notices that are present in the Work.
-
-# 3.2 Derivative Works. You may specify that additional or different
-# terms apply to the use, reproduction, and distribution of your
-# derivative works of the Work ("Your Terms") only if (a) Your Terms
-# provide that the use limitation in Section 3.3 applies to your
-# derivative works, and (b) you identify the specific derivative
-# works that are subject to Your Terms. Notwithstanding Your Terms,
-# this License (including the redistribution requirements in Section
-# 3.1) will continue to apply to the Work itself.
-
-# 3.3 Use Limitation. The Work and any derivative works thereof only
-# may be used or intended for use non-commercially. Notwithstanding
-# the foregoing, NVIDIA and its affiliates may use the Work and any
-# derivative works commercially. As used herein, "non-commercially"
-# means for research or evaluation purposes only.
-
-# 3.4 Patent Claims. If you bring or threaten to bring a patent claim
-# against any Licensor (including any claim, cross-claim or
-# counterclaim in a lawsuit) to enforce any patents that you allege
-# are infringed by any Work, then your rights under this License from
-# such Licensor (including the grant in Section 2.1) will terminate
-# immediately.
-
-# 3.5 Trademarks. This License does not grant any rights to use any
-# Licensor’s or its affiliates’ names, logos, or trademarks, except
-# as necessary to reproduce the notices described in this License.
-
-# 3.6 Termination. If you violate any term of this License, then your
-# rights under this License (including the grant in Section 2.1) will
-# terminate immediately.
-
-# 4. Disclaimer of Warranty.
-
-# THE WORK IS PROVIDED "AS IS" WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WARRANTIES OR CONDITIONS OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE OR
-# NON-INFRINGEMENT. YOU BEAR THE RISK OF UNDERTAKING ANY ACTIVITIES UNDER
-# THIS LICENSE.
-
-# 5. Limitation of Liability.
-
-# EXCEPT AS PROHIBITED BY APPLICABLE LAW, IN NO EVENT AND UNDER NO LEGAL
-# THEORY, WHETHER IN TORT (INCLUDING NEGLIGENCE), CONTRACT, OR OTHERWISE
-# SHALL ANY LICENSOR BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY DIRECT,
-# INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
-# OR RELATED TO THIS LICENSE, THE USE OR INABILITY TO USE THE WORK
-# (INCLUDING BUT NOT LIMITED TO LOSS OF GOODWILL, BUSINESS INTERRUPTION,
-# LOST PROFITS OR DATA, COMPUTER FAILURE OR MALFUNCTION, OR ANY OTHER
-# COMMERCIAL DAMAGES OR LOSSES), EVEN IF THE LICENSOR HAS BEEN ADVISED OF
-# THE POSSIBILITY OF SUCH DAMAGES.
-
-# =======================================================================
-
-import torch
-import torch.nn.functional as F
-from torch import nn
-from torch.autograd import Function
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', ['fused_bias_leakyrelu'])
-
-
-class FusedBiasLeakyReLUFunctionBackward(Function):
- """Calculate second order deviation.
-
- This function is to compute the second order deviation for the fused leaky
- relu operation.
- """
-
- @staticmethod
- def forward(ctx, grad_output, out, negative_slope, scale):
- ctx.save_for_backward(out)
- ctx.negative_slope = negative_slope
- ctx.scale = scale
-
- empty = grad_output.new_empty(0)
-
- grad_input = ext_module.fused_bias_leakyrelu(
- grad_output,
- empty,
- out,
- act=3,
- grad=1,
- alpha=negative_slope,
- scale=scale)
-
- dim = [0]
-
- if grad_input.ndim > 2:
- dim += list(range(2, grad_input.ndim))
-
- grad_bias = grad_input.sum(dim).detach()
-
- return grad_input, grad_bias
-
- @staticmethod
- def backward(ctx, gradgrad_input, gradgrad_bias):
- out, = ctx.saved_tensors
-
- # The second order deviation, in fact, contains two parts, while the
- # the first part is zero. Thus, we direct consider the second part
- # which is similar with the first order deviation in implementation.
- gradgrad_out = ext_module.fused_bias_leakyrelu(
- gradgrad_input,
- gradgrad_bias.to(out.dtype),
- out,
- act=3,
- grad=1,
- alpha=ctx.negative_slope,
- scale=ctx.scale)
-
- return gradgrad_out, None, None, None
-
-
-class FusedBiasLeakyReLUFunction(Function):
-
- @staticmethod
- def forward(ctx, input, bias, negative_slope, scale):
- empty = input.new_empty(0)
-
- out = ext_module.fused_bias_leakyrelu(
- input,
- bias,
- empty,
- act=3,
- grad=0,
- alpha=negative_slope,
- scale=scale)
- ctx.save_for_backward(out)
- ctx.negative_slope = negative_slope
- ctx.scale = scale
-
- return out
-
- @staticmethod
- def backward(ctx, grad_output):
- out, = ctx.saved_tensors
-
- grad_input, grad_bias = FusedBiasLeakyReLUFunctionBackward.apply(
- grad_output, out, ctx.negative_slope, ctx.scale)
-
- return grad_input, grad_bias, None, None
-
-
-class FusedBiasLeakyReLU(nn.Module):
- """Fused bias leaky ReLU.
-
- This function is introduced in the StyleGAN2:
- http://arxiv.org/abs/1912.04958
-
- The bias term comes from the convolution operation. In addition, to keep
- the variance of the feature map or gradients unchanged, they also adopt a
- scale similarly with Kaiming initialization. However, since the
- :math:`1+{alpha}^2` : is too small, we can just ignore it. Therefore, the
- final scale is just :math:`\sqrt{2}`:. Of course, you may change it with # noqa: W605, E501
- your own scale.
-
- TODO: Implement the CPU version.
-
- Args:
- channel (int): The channel number of the feature map.
- negative_slope (float, optional): Same as nn.LeakyRelu.
- Defaults to 0.2.
- scale (float, optional): A scalar to adjust the variance of the feature
- map. Defaults to 2**0.5.
- """
-
- def __init__(self, num_channels, negative_slope=0.2, scale=2**0.5):
- super(FusedBiasLeakyReLU, self).__init__()
-
- self.bias = nn.Parameter(torch.zeros(num_channels))
- self.negative_slope = negative_slope
- self.scale = scale
-
- def forward(self, input):
- return fused_bias_leakyrelu(input, self.bias, self.negative_slope,
- self.scale)
-
-
-def fused_bias_leakyrelu(input, bias, negative_slope=0.2, scale=2**0.5):
- """Fused bias leaky ReLU function.
-
- This function is introduced in the StyleGAN2:
- http://arxiv.org/abs/1912.04958
-
- The bias term comes from the convolution operation. In addition, to keep
- the variance of the feature map or gradients unchanged, they also adopt a
- scale similarly with Kaiming initialization. However, since the
- :math:`1+{alpha}^2` : is too small, we can just ignore it. Therefore, the
- final scale is just :math:`\sqrt{2}`:. Of course, you may change it with # noqa: W605, E501
- your own scale.
-
- Args:
- input (torch.Tensor): Input feature map.
- bias (nn.Parameter): The bias from convolution operation.
- negative_slope (float, optional): Same as nn.LeakyRelu.
- Defaults to 0.2.
- scale (float, optional): A scalar to adjust the variance of the feature
- map. Defaults to 2**0.5.
-
- Returns:
- torch.Tensor: Feature map after non-linear activation.
- """
-
- if not input.is_cuda:
- return bias_leakyrelu_ref(input, bias, negative_slope, scale)
-
- return FusedBiasLeakyReLUFunction.apply(input, bias.to(input.dtype),
- negative_slope, scale)
-
-
-def bias_leakyrelu_ref(x, bias, negative_slope=0.2, scale=2**0.5):
-
- if bias is not None:
- assert bias.ndim == 1
- assert bias.shape[0] == x.shape[1]
- x = x + bias.reshape([-1 if i == 1 else 1 for i in range(x.ndim)])
-
- x = F.leaky_relu(x, negative_slope)
- if scale != 1:
- x = x * scale
-
- return x
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/roipoint_pool3d.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/roipoint_pool3d.py
deleted file mode 100644
index 0a21412c0728431c04b84245bc2e3109eea9aefc..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/ops/roipoint_pool3d.py
+++ /dev/null
@@ -1,77 +0,0 @@
-from torch import nn as nn
-from torch.autograd import Function
-
-from ..utils import ext_loader
-
-ext_module = ext_loader.load_ext('_ext', ['roipoint_pool3d_forward'])
-
-
-class RoIPointPool3d(nn.Module):
- """Encode the geometry-specific features of each 3D proposal.
-
- Please refer to `Paper of PartA2 `_
- for more details.
-
- Args:
- num_sampled_points (int, optional): Number of samples in each roi.
- Default: 512.
- """
-
- def __init__(self, num_sampled_points=512):
- super().__init__()
- self.num_sampled_points = num_sampled_points
-
- def forward(self, points, point_features, boxes3d):
- """
- Args:
- points (torch.Tensor): Input points whose shape is (B, N, C).
- point_features (torch.Tensor): Features of input points whose shape
- is (B, N, C).
- boxes3d (B, M, 7), Input bounding boxes whose shape is (B, M, 7).
-
- Returns:
- pooled_features (torch.Tensor): The output pooled features whose
- shape is (B, M, 512, 3 + C).
- pooled_empty_flag (torch.Tensor): Empty flag whose shape is (B, M).
- """
- return RoIPointPool3dFunction.apply(points, point_features, boxes3d,
- self.num_sampled_points)
-
-
-class RoIPointPool3dFunction(Function):
-
- @staticmethod
- def forward(ctx, points, point_features, boxes3d, num_sampled_points=512):
- """
- Args:
- points (torch.Tensor): Input points whose shape is (B, N, C).
- point_features (torch.Tensor): Features of input points whose shape
- is (B, N, C).
- boxes3d (B, M, 7), Input bounding boxes whose shape is (B, M, 7).
- num_sampled_points (int, optional): The num of sampled points.
- Default: 512.
-
- Returns:
- pooled_features (torch.Tensor): The output pooled features whose
- shape is (B, M, 512, 3 + C).
- pooled_empty_flag (torch.Tensor): Empty flag whose shape is (B, M).
- """
- assert len(points.shape) == 3 and points.shape[2] == 3
- batch_size, boxes_num, feature_len = points.shape[0], boxes3d.shape[
- 1], point_features.shape[2]
- pooled_boxes3d = boxes3d.view(batch_size, -1, 7)
- pooled_features = point_features.new_zeros(
- (batch_size, boxes_num, num_sampled_points, 3 + feature_len))
- pooled_empty_flag = point_features.new_zeros(
- (batch_size, boxes_num)).int()
-
- ext_module.roipoint_pool3d_forward(points.contiguous(),
- pooled_boxes3d.contiguous(),
- point_features.contiguous(),
- pooled_features, pooled_empty_flag)
-
- return pooled_features, pooled_empty_flag
-
- @staticmethod
- def backward(ctx, grad_out):
- raise NotImplementedError
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/evaluation.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/evaluation.py
deleted file mode 100644
index 4d00999ce5665c53bded8de9e084943eee2d230d..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/evaluation.py
+++ /dev/null
@@ -1,509 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import os.path as osp
-import warnings
-from math import inf
-
-import torch.distributed as dist
-from torch.nn.modules.batchnorm import _BatchNorm
-from torch.utils.data import DataLoader
-
-from annotator.uniformer.mmcv.fileio import FileClient
-from annotator.uniformer.mmcv.utils import is_seq_of
-from .hook import Hook
-from .logger import LoggerHook
-
-
-class EvalHook(Hook):
- """Non-Distributed evaluation hook.
-
- This hook will regularly perform evaluation in a given interval when
- performing in non-distributed environment.
-
- Args:
- dataloader (DataLoader): A PyTorch dataloader, whose dataset has
- implemented ``evaluate`` function.
- start (int | None, optional): Evaluation starting epoch. It enables
- evaluation before the training starts if ``start`` <= the resuming
- epoch. If None, whether to evaluate is merely decided by
- ``interval``. Default: None.
- interval (int): Evaluation interval. Default: 1.
- by_epoch (bool): Determine perform evaluation by epoch or by iteration.
- If set to True, it will perform by epoch. Otherwise, by iteration.
- Default: True.
- save_best (str, optional): If a metric is specified, it would measure
- the best checkpoint during evaluation. The information about best
- checkpoint would be saved in ``runner.meta['hook_msgs']`` to keep
- best score value and best checkpoint path, which will be also
- loaded when resume checkpoint. Options are the evaluation metrics
- on the test dataset. e.g., ``bbox_mAP``, ``segm_mAP`` for bbox
- detection and instance segmentation. ``AR@100`` for proposal
- recall. If ``save_best`` is ``auto``, the first key of the returned
- ``OrderedDict`` result will be used. Default: None.
- rule (str | None, optional): Comparison rule for best score. If set to
- None, it will infer a reasonable rule. Keys such as 'acc', 'top'
- .etc will be inferred by 'greater' rule. Keys contain 'loss' will
- be inferred by 'less' rule. Options are 'greater', 'less', None.
- Default: None.
- test_fn (callable, optional): test a model with samples from a
- dataloader, and return the test results. If ``None``, the default
- test function ``mmcv.engine.single_gpu_test`` will be used.
- (default: ``None``)
- greater_keys (List[str] | None, optional): Metric keys that will be
- inferred by 'greater' comparison rule. If ``None``,
- _default_greater_keys will be used. (default: ``None``)
- less_keys (List[str] | None, optional): Metric keys that will be
- inferred by 'less' comparison rule. If ``None``, _default_less_keys
- will be used. (default: ``None``)
- out_dir (str, optional): The root directory to save checkpoints. If not
- specified, `runner.work_dir` will be used by default. If specified,
- the `out_dir` will be the concatenation of `out_dir` and the last
- level directory of `runner.work_dir`.
- `New in version 1.3.16.`
- file_client_args (dict): Arguments to instantiate a FileClient.
- See :class:`mmcv.fileio.FileClient` for details. Default: None.
- `New in version 1.3.16.`
- **eval_kwargs: Evaluation arguments fed into the evaluate function of
- the dataset.
-
- Notes:
- If new arguments are added for EvalHook, tools/test.py,
- tools/eval_metric.py may be affected.
- """
-
- # Since the key for determine greater or less is related to the downstream
- # tasks, downstream repos may need to overwrite the following inner
- # variable accordingly.
-
- rule_map = {'greater': lambda x, y: x > y, 'less': lambda x, y: x < y}
- init_value_map = {'greater': -inf, 'less': inf}
- _default_greater_keys = [
- 'acc', 'top', 'AR@', 'auc', 'precision', 'mAP', 'mDice', 'mIoU',
- 'mAcc', 'aAcc'
- ]
- _default_less_keys = ['loss']
-
- def __init__(self,
- dataloader,
- start=None,
- interval=1,
- by_epoch=True,
- save_best=None,
- rule=None,
- test_fn=None,
- greater_keys=None,
- less_keys=None,
- out_dir=None,
- file_client_args=None,
- **eval_kwargs):
- if not isinstance(dataloader, DataLoader):
- raise TypeError(f'dataloader must be a pytorch DataLoader, '
- f'but got {type(dataloader)}')
-
- if interval <= 0:
- raise ValueError(f'interval must be a positive number, '
- f'but got {interval}')
-
- assert isinstance(by_epoch, bool), '``by_epoch`` should be a boolean'
-
- if start is not None and start < 0:
- raise ValueError(f'The evaluation start epoch {start} is smaller '
- f'than 0')
-
- self.dataloader = dataloader
- self.interval = interval
- self.start = start
- self.by_epoch = by_epoch
-
- assert isinstance(save_best, str) or save_best is None, \
- '""save_best"" should be a str or None ' \
- f'rather than {type(save_best)}'
- self.save_best = save_best
- self.eval_kwargs = eval_kwargs
- self.initial_flag = True
-
- if test_fn is None:
- from annotator.uniformer.mmcv.engine import single_gpu_test
- self.test_fn = single_gpu_test
- else:
- self.test_fn = test_fn
-
- if greater_keys is None:
- self.greater_keys = self._default_greater_keys
- else:
- if not isinstance(greater_keys, (list, tuple)):
- greater_keys = (greater_keys, )
- assert is_seq_of(greater_keys, str)
- self.greater_keys = greater_keys
-
- if less_keys is None:
- self.less_keys = self._default_less_keys
- else:
- if not isinstance(less_keys, (list, tuple)):
- less_keys = (less_keys, )
- assert is_seq_of(less_keys, str)
- self.less_keys = less_keys
-
- if self.save_best is not None:
- self.best_ckpt_path = None
- self._init_rule(rule, self.save_best)
-
- self.out_dir = out_dir
- self.file_client_args = file_client_args
-
- def _init_rule(self, rule, key_indicator):
- """Initialize rule, key_indicator, comparison_func, and best score.
-
- Here is the rule to determine which rule is used for key indicator
- when the rule is not specific (note that the key indicator matching
- is case-insensitive):
- 1. If the key indicator is in ``self.greater_keys``, the rule will be
- specified as 'greater'.
- 2. Or if the key indicator is in ``self.less_keys``, the rule will be
- specified as 'less'.
- 3. Or if the key indicator is equal to the substring in any one item
- in ``self.greater_keys``, the rule will be specified as 'greater'.
- 4. Or if the key indicator is equal to the substring in any one item
- in ``self.less_keys``, the rule will be specified as 'less'.
-
- Args:
- rule (str | None): Comparison rule for best score.
- key_indicator (str | None): Key indicator to determine the
- comparison rule.
- """
- if rule not in self.rule_map and rule is not None:
- raise KeyError(f'rule must be greater, less or None, '
- f'but got {rule}.')
-
- if rule is None:
- if key_indicator != 'auto':
- # `_lc` here means we use the lower case of keys for
- # case-insensitive matching
- key_indicator_lc = key_indicator.lower()
- greater_keys = [key.lower() for key in self.greater_keys]
- less_keys = [key.lower() for key in self.less_keys]
-
- if key_indicator_lc in greater_keys:
- rule = 'greater'
- elif key_indicator_lc in less_keys:
- rule = 'less'
- elif any(key in key_indicator_lc for key in greater_keys):
- rule = 'greater'
- elif any(key in key_indicator_lc for key in less_keys):
- rule = 'less'
- else:
- raise ValueError(f'Cannot infer the rule for key '
- f'{key_indicator}, thus a specific rule '
- f'must be specified.')
- self.rule = rule
- self.key_indicator = key_indicator
- if self.rule is not None:
- self.compare_func = self.rule_map[self.rule]
-
- def before_run(self, runner):
- if not self.out_dir:
- self.out_dir = runner.work_dir
-
- self.file_client = FileClient.infer_client(self.file_client_args,
- self.out_dir)
-
- # if `self.out_dir` is not equal to `runner.work_dir`, it means that
- # `self.out_dir` is set so the final `self.out_dir` is the
- # concatenation of `self.out_dir` and the last level directory of
- # `runner.work_dir`
- if self.out_dir != runner.work_dir:
- basename = osp.basename(runner.work_dir.rstrip(osp.sep))
- self.out_dir = self.file_client.join_path(self.out_dir, basename)
- runner.logger.info(
- (f'The best checkpoint will be saved to {self.out_dir} by '
- f'{self.file_client.name}'))
-
- if self.save_best is not None:
- if runner.meta is None:
- warnings.warn('runner.meta is None. Creating an empty one.')
- runner.meta = dict()
- runner.meta.setdefault('hook_msgs', dict())
- self.best_ckpt_path = runner.meta['hook_msgs'].get(
- 'best_ckpt', None)
-
- def before_train_iter(self, runner):
- """Evaluate the model only at the start of training by iteration."""
- if self.by_epoch or not self.initial_flag:
- return
- if self.start is not None and runner.iter >= self.start:
- self.after_train_iter(runner)
- self.initial_flag = False
-
- def before_train_epoch(self, runner):
- """Evaluate the model only at the start of training by epoch."""
- if not (self.by_epoch and self.initial_flag):
- return
- if self.start is not None and runner.epoch >= self.start:
- self.after_train_epoch(runner)
- self.initial_flag = False
-
- def after_train_iter(self, runner):
- """Called after every training iter to evaluate the results."""
- if not self.by_epoch and self._should_evaluate(runner):
- # Because the priority of EvalHook is higher than LoggerHook, the
- # training log and the evaluating log are mixed. Therefore,
- # we need to dump the training log and clear it before evaluating
- # log is generated. In addition, this problem will only appear in
- # `IterBasedRunner` whose `self.by_epoch` is False, because
- # `EpochBasedRunner` whose `self.by_epoch` is True calls
- # `_do_evaluate` in `after_train_epoch` stage, and at this stage
- # the training log has been printed, so it will not cause any
- # problem. more details at
- # https://github.com/open-mmlab/mmsegmentation/issues/694
- for hook in runner._hooks:
- if isinstance(hook, LoggerHook):
- hook.after_train_iter(runner)
- runner.log_buffer.clear()
-
- self._do_evaluate(runner)
-
- def after_train_epoch(self, runner):
- """Called after every training epoch to evaluate the results."""
- if self.by_epoch and self._should_evaluate(runner):
- self._do_evaluate(runner)
-
- def _do_evaluate(self, runner):
- """perform evaluation and save ckpt."""
- results = self.test_fn(runner.model, self.dataloader)
- runner.log_buffer.output['eval_iter_num'] = len(self.dataloader)
- key_score = self.evaluate(runner, results)
- # the key_score may be `None` so it needs to skip the action to save
- # the best checkpoint
- if self.save_best and key_score:
- self._save_ckpt(runner, key_score)
-
- def _should_evaluate(self, runner):
- """Judge whether to perform evaluation.
-
- Here is the rule to judge whether to perform evaluation:
- 1. It will not perform evaluation during the epoch/iteration interval,
- which is determined by ``self.interval``.
- 2. It will not perform evaluation if the start time is larger than
- current time.
- 3. It will not perform evaluation when current time is larger than
- the start time but during epoch/iteration interval.
-
- Returns:
- bool: The flag indicating whether to perform evaluation.
- """
- if self.by_epoch:
- current = runner.epoch
- check_time = self.every_n_epochs
- else:
- current = runner.iter
- check_time = self.every_n_iters
-
- if self.start is None:
- if not check_time(runner, self.interval):
- # No evaluation during the interval.
- return False
- elif (current + 1) < self.start:
- # No evaluation if start is larger than the current time.
- return False
- else:
- # Evaluation only at epochs/iters 3, 5, 7...
- # if start==3 and interval==2
- if (current + 1 - self.start) % self.interval:
- return False
- return True
-
- def _save_ckpt(self, runner, key_score):
- """Save the best checkpoint.
-
- It will compare the score according to the compare function, write
- related information (best score, best checkpoint path) and save the
- best checkpoint into ``work_dir``.
- """
- if self.by_epoch:
- current = f'epoch_{runner.epoch + 1}'
- cur_type, cur_time = 'epoch', runner.epoch + 1
- else:
- current = f'iter_{runner.iter + 1}'
- cur_type, cur_time = 'iter', runner.iter + 1
-
- best_score = runner.meta['hook_msgs'].get(
- 'best_score', self.init_value_map[self.rule])
- if self.compare_func(key_score, best_score):
- best_score = key_score
- runner.meta['hook_msgs']['best_score'] = best_score
-
- if self.best_ckpt_path and self.file_client.isfile(
- self.best_ckpt_path):
- self.file_client.remove(self.best_ckpt_path)
- runner.logger.info(
- (f'The previous best checkpoint {self.best_ckpt_path} was '
- 'removed'))
-
- best_ckpt_name = f'best_{self.key_indicator}_{current}.pth'
- self.best_ckpt_path = self.file_client.join_path(
- self.out_dir, best_ckpt_name)
- runner.meta['hook_msgs']['best_ckpt'] = self.best_ckpt_path
-
- runner.save_checkpoint(
- self.out_dir, best_ckpt_name, create_symlink=False)
- runner.logger.info(
- f'Now best checkpoint is saved as {best_ckpt_name}.')
- runner.logger.info(
- f'Best {self.key_indicator} is {best_score:0.4f} '
- f'at {cur_time} {cur_type}.')
-
- def evaluate(self, runner, results):
- """Evaluate the results.
-
- Args:
- runner (:obj:`mmcv.Runner`): The underlined training runner.
- results (list): Output results.
- """
- eval_res = self.dataloader.dataset.evaluate(
- results, logger=runner.logger, **self.eval_kwargs)
-
- for name, val in eval_res.items():
- runner.log_buffer.output[name] = val
- runner.log_buffer.ready = True
-
- if self.save_best is not None:
- # If the performance of model is pool, the `eval_res` may be an
- # empty dict and it will raise exception when `self.save_best` is
- # not None. More details at
- # https://github.com/open-mmlab/mmdetection/issues/6265.
- if not eval_res:
- warnings.warn(
- 'Since `eval_res` is an empty dict, the behavior to save '
- 'the best checkpoint will be skipped in this evaluation.')
- return None
-
- if self.key_indicator == 'auto':
- # infer from eval_results
- self._init_rule(self.rule, list(eval_res.keys())[0])
- return eval_res[self.key_indicator]
-
- return None
-
-
-class DistEvalHook(EvalHook):
- """Distributed evaluation hook.
-
- This hook will regularly perform evaluation in a given interval when
- performing in distributed environment.
-
- Args:
- dataloader (DataLoader): A PyTorch dataloader, whose dataset has
- implemented ``evaluate`` function.
- start (int | None, optional): Evaluation starting epoch. It enables
- evaluation before the training starts if ``start`` <= the resuming
- epoch. If None, whether to evaluate is merely decided by
- ``interval``. Default: None.
- interval (int): Evaluation interval. Default: 1.
- by_epoch (bool): Determine perform evaluation by epoch or by iteration.
- If set to True, it will perform by epoch. Otherwise, by iteration.
- default: True.
- save_best (str, optional): If a metric is specified, it would measure
- the best checkpoint during evaluation. The information about best
- checkpoint would be saved in ``runner.meta['hook_msgs']`` to keep
- best score value and best checkpoint path, which will be also
- loaded when resume checkpoint. Options are the evaluation metrics
- on the test dataset. e.g., ``bbox_mAP``, ``segm_mAP`` for bbox
- detection and instance segmentation. ``AR@100`` for proposal
- recall. If ``save_best`` is ``auto``, the first key of the returned
- ``OrderedDict`` result will be used. Default: None.
- rule (str | None, optional): Comparison rule for best score. If set to
- None, it will infer a reasonable rule. Keys such as 'acc', 'top'
- .etc will be inferred by 'greater' rule. Keys contain 'loss' will
- be inferred by 'less' rule. Options are 'greater', 'less', None.
- Default: None.
- test_fn (callable, optional): test a model with samples from a
- dataloader in a multi-gpu manner, and return the test results. If
- ``None``, the default test function ``mmcv.engine.multi_gpu_test``
- will be used. (default: ``None``)
- tmpdir (str | None): Temporary directory to save the results of all
- processes. Default: None.
- gpu_collect (bool): Whether to use gpu or cpu to collect results.
- Default: False.
- broadcast_bn_buffer (bool): Whether to broadcast the
- buffer(running_mean and running_var) of rank 0 to other rank
- before evaluation. Default: True.
- out_dir (str, optional): The root directory to save checkpoints. If not
- specified, `runner.work_dir` will be used by default. If specified,
- the `out_dir` will be the concatenation of `out_dir` and the last
- level directory of `runner.work_dir`.
- file_client_args (dict): Arguments to instantiate a FileClient.
- See :class:`mmcv.fileio.FileClient` for details. Default: None.
- **eval_kwargs: Evaluation arguments fed into the evaluate function of
- the dataset.
- """
-
- def __init__(self,
- dataloader,
- start=None,
- interval=1,
- by_epoch=True,
- save_best=None,
- rule=None,
- test_fn=None,
- greater_keys=None,
- less_keys=None,
- broadcast_bn_buffer=True,
- tmpdir=None,
- gpu_collect=False,
- out_dir=None,
- file_client_args=None,
- **eval_kwargs):
-
- if test_fn is None:
- from annotator.uniformer.mmcv.engine import multi_gpu_test
- test_fn = multi_gpu_test
-
- super().__init__(
- dataloader,
- start=start,
- interval=interval,
- by_epoch=by_epoch,
- save_best=save_best,
- rule=rule,
- test_fn=test_fn,
- greater_keys=greater_keys,
- less_keys=less_keys,
- out_dir=out_dir,
- file_client_args=file_client_args,
- **eval_kwargs)
-
- self.broadcast_bn_buffer = broadcast_bn_buffer
- self.tmpdir = tmpdir
- self.gpu_collect = gpu_collect
-
- def _do_evaluate(self, runner):
- """perform evaluation and save ckpt."""
- # Synchronization of BatchNorm's buffer (running_mean
- # and running_var) is not supported in the DDP of pytorch,
- # which may cause the inconsistent performance of models in
- # different ranks, so we broadcast BatchNorm's buffers
- # of rank 0 to other ranks to avoid this.
- if self.broadcast_bn_buffer:
- model = runner.model
- for name, module in model.named_modules():
- if isinstance(module,
- _BatchNorm) and module.track_running_stats:
- dist.broadcast(module.running_var, 0)
- dist.broadcast(module.running_mean, 0)
-
- tmpdir = self.tmpdir
- if tmpdir is None:
- tmpdir = osp.join(runner.work_dir, '.eval_hook')
-
- results = self.test_fn(
- runner.model,
- self.dataloader,
- tmpdir=tmpdir,
- gpu_collect=self.gpu_collect)
- if runner.rank == 0:
- print('\n')
- runner.log_buffer.output['eval_iter_num'] = len(self.dataloader)
- key_score = self.evaluate(runner, results)
- # the key_score may be `None` so it needs to skip the action to
- # save the best checkpoint
- if self.save_best and key_score:
- self._save_ckpt(runner, key_score)
diff --git a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/logger/dvclive.py b/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/logger/dvclive.py
deleted file mode 100644
index 687cdc58c0336c92b1e4f9a410ba67ebaab2bc7a..0000000000000000000000000000000000000000
--- a/spaces/Superlang/ImageProcessor/annotator/uniformer/mmcv/runner/hooks/logger/dvclive.py
+++ /dev/null
@@ -1,58 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from ...dist_utils import master_only
-from ..hook import HOOKS
-from .base import LoggerHook
-
-
-@HOOKS.register_module()
-class DvcliveLoggerHook(LoggerHook):
- """Class to log metrics with dvclive.
-
- It requires `dvclive`_ to be installed.
-
- Args:
- path (str): Directory where dvclive will write TSV log files.
- interval (int): Logging interval (every k iterations).
- Default 10.
- ignore_last (bool): Ignore the log of last iterations in each epoch
- if less than `interval`.
- Default: True.
- reset_flag (bool): Whether to clear the output buffer after logging.
- Default: True.
- by_epoch (bool): Whether EpochBasedRunner is used.
- Default: True.
-
- .. _dvclive:
- https://dvc.org/doc/dvclive
- """
-
- def __init__(self,
- path,
- interval=10,
- ignore_last=True,
- reset_flag=True,
- by_epoch=True):
-
- super(DvcliveLoggerHook, self).__init__(interval, ignore_last,
- reset_flag, by_epoch)
- self.path = path
- self.import_dvclive()
-
- def import_dvclive(self):
- try:
- import dvclive
- except ImportError:
- raise ImportError(
- 'Please run "pip install dvclive" to install dvclive')
- self.dvclive = dvclive
-
- @master_only
- def before_run(self, runner):
- self.dvclive.init(self.path)
-
- @master_only
- def log(self, runner):
- tags = self.get_loggable_tags(runner)
- if tags:
- for k, v in tags.items():
- self.dvclive.log(k, v, step=self.get_iter(runner))
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/chardet/cli/__init__.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/chardet/cli/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/urllib3/request.py b/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/urllib3/request.py
deleted file mode 100644
index 398386a5b9f61c13be314e256e671a37d28e3623..0000000000000000000000000000000000000000
--- a/spaces/TandCAcceptMe/face-swap-docker/mynewshinyroop/Lib/site-packages/pip/_vendor/urllib3/request.py
+++ /dev/null
@@ -1,170 +0,0 @@
-from __future__ import absolute_import
-
-from .filepost import encode_multipart_formdata
-from .packages.six.moves.urllib.parse import urlencode
-
-__all__ = ["RequestMethods"]
-
-
-class RequestMethods(object):
- """
- Convenience mixin for classes who implement a :meth:`urlopen` method, such
- as :class:`urllib3.HTTPConnectionPool` and
- :class:`urllib3.PoolManager`.
-
- Provides behavior for making common types of HTTP request methods and
- decides which type of request field encoding to use.
-
- Specifically,
-
- :meth:`.request_encode_url` is for sending requests whose fields are
- encoded in the URL (such as GET, HEAD, DELETE).
-
- :meth:`.request_encode_body` is for sending requests whose fields are
- encoded in the *body* of the request using multipart or www-form-urlencoded
- (such as for POST, PUT, PATCH).
-
- :meth:`.request` is for making any kind of request, it will look up the
- appropriate encoding format and use one of the above two methods to make
- the request.
-
- Initializer parameters:
-
- :param headers:
- Headers to include with all requests, unless other headers are given
- explicitly.
- """
-
- _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"}
-
- def __init__(self, headers=None):
- self.headers = headers or {}
-
- def urlopen(
- self,
- method,
- url,
- body=None,
- headers=None,
- encode_multipart=True,
- multipart_boundary=None,
- **kw
- ): # Abstract
- raise NotImplementedError(
- "Classes extending RequestMethods must implement "
- "their own ``urlopen`` method."
- )
-
- def request(self, method, url, fields=None, headers=None, **urlopen_kw):
- """
- Make a request using :meth:`urlopen` with the appropriate encoding of
- ``fields`` based on the ``method`` used.
-
- This is a convenience method that requires the least amount of manual
- effort. It can be used in most situations, while still having the
- option to drop down to more specific methods when necessary, such as
- :meth:`request_encode_url`, :meth:`request_encode_body`,
- or even the lowest level :meth:`urlopen`.
- """
- method = method.upper()
-
- urlopen_kw["request_url"] = url
-
- if method in self._encode_url_methods:
- return self.request_encode_url(
- method, url, fields=fields, headers=headers, **urlopen_kw
- )
- else:
- return self.request_encode_body(
- method, url, fields=fields, headers=headers, **urlopen_kw
- )
-
- def request_encode_url(self, method, url, fields=None, headers=None, **urlopen_kw):
- """
- Make a request using :meth:`urlopen` with the ``fields`` encoded in
- the url. This is useful for request methods like GET, HEAD, DELETE, etc.
- """
- if headers is None:
- headers = self.headers
-
- extra_kw = {"headers": headers}
- extra_kw.update(urlopen_kw)
-
- if fields:
- url += "?" + urlencode(fields)
-
- return self.urlopen(method, url, **extra_kw)
-
- def request_encode_body(
- self,
- method,
- url,
- fields=None,
- headers=None,
- encode_multipart=True,
- multipart_boundary=None,
- **urlopen_kw
- ):
- """
- Make a request using :meth:`urlopen` with the ``fields`` encoded in
- the body. This is useful for request methods like POST, PUT, PATCH, etc.
-
- When ``encode_multipart=True`` (default), then
- :func:`urllib3.encode_multipart_formdata` is used to encode
- the payload with the appropriate content type. Otherwise
- :func:`urllib.parse.urlencode` is used with the
- 'application/x-www-form-urlencoded' content type.
-
- Multipart encoding must be used when posting files, and it's reasonably
- safe to use it in other times too. However, it may break request
- signing, such as with OAuth.
-
- Supports an optional ``fields`` parameter of key/value strings AND
- key/filetuple. A filetuple is a (filename, data, MIME type) tuple where
- the MIME type is optional. For example::
-
- fields = {
- 'foo': 'bar',
- 'fakefile': ('foofile.txt', 'contents of foofile'),
- 'realfile': ('barfile.txt', open('realfile').read()),
- 'typedfile': ('bazfile.bin', open('bazfile').read(),
- 'image/jpeg'),
- 'nonamefile': 'contents of nonamefile field',
- }
-
- When uploading a file, providing a filename (the first parameter of the
- tuple) is optional but recommended to best mimic behavior of browsers.
-
- Note that if ``headers`` are supplied, the 'Content-Type' header will
- be overwritten because it depends on the dynamic random boundary string
- which is used to compose the body of the request. The random boundary
- string can be explicitly set with the ``multipart_boundary`` parameter.
- """
- if headers is None:
- headers = self.headers
-
- extra_kw = {"headers": {}}
-
- if fields:
- if "body" in urlopen_kw:
- raise TypeError(
- "request got values for both 'fields' and 'body', can only specify one."
- )
-
- if encode_multipart:
- body, content_type = encode_multipart_formdata(
- fields, boundary=multipart_boundary
- )
- else:
- body, content_type = (
- urlencode(fields),
- "application/x-www-form-urlencoded",
- )
-
- extra_kw["body"] = body
- extra_kw["headers"] = {"Content-Type": content_type}
-
- extra_kw["headers"].update(headers)
- extra_kw.update(urlopen_kw)
-
- return self.urlopen(method, url, **extra_kw)
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/__init__.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/__init__.py
deleted file mode 100644
index 25e5c94618a71cc584756ca2e17d6233a072dd87..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/export/__init__.py
+++ /dev/null
@@ -1,15 +0,0 @@
-# -*- coding: utf-8 -*-
-
-try:
- from caffe2.proto import caffe2_pb2 as _tmp
-
- # caffe2 is optional
-except ImportError:
- pass
-else:
- from .api import *
-
-from .flatten import TracingAdapter
-from .torchscript import scripting_with_instances, dump_torchscript_IR
-
-__all__ = [k for k in globals().keys() if not k.startswith("_")]
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/layers/nms.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/layers/nms.py
deleted file mode 100644
index 6b6be71c7832d188aaa20bd7e1b16964cab7a731..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/layers/nms.py
+++ /dev/null
@@ -1,139 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import torch
-from torchvision.ops import boxes as box_ops
-from torchvision.ops import nms # noqa . for compatibility
-
-
-def batched_nms(
- boxes: torch.Tensor, scores: torch.Tensor, idxs: torch.Tensor, iou_threshold: float
-):
- """
- Same as torchvision.ops.boxes.batched_nms, but with float().
- """
- assert boxes.shape[-1] == 4
- # Note: Torchvision already has a strategy (https://github.com/pytorch/vision/issues/1311)
- # to decide whether to use coordinate trick or for loop to implement batched_nms. So we
- # just call it directly.
- # Fp16 does not have enough range for batched NMS, so adding float().
- return box_ops.batched_nms(boxes.float(), scores, idxs, iou_threshold)
-
-
-# Note: this function (nms_rotated) might be moved into
-# torchvision/ops/boxes.py in the future
-def nms_rotated(boxes, scores, iou_threshold):
- """
- Performs non-maximum suppression (NMS) on the rotated boxes according
- to their intersection-over-union (IoU).
-
- Rotated NMS iteratively removes lower scoring rotated boxes which have an
- IoU greater than iou_threshold with another (higher scoring) rotated box.
-
- Note that RotatedBox (5, 3, 4, 2, -90) covers exactly the same region as
- RotatedBox (5, 3, 4, 2, 90) does, and their IoU will be 1. However, they
- can be representing completely different objects in certain tasks, e.g., OCR.
-
- As for the question of whether rotated-NMS should treat them as faraway boxes
- even though their IOU is 1, it depends on the application and/or ground truth annotation.
-
- As an extreme example, consider a single character v and the square box around it.
-
- If the angle is 0 degree, the object (text) would be read as 'v';
-
- If the angle is 90 degrees, the object (text) would become '>';
-
- If the angle is 180 degrees, the object (text) would become '^';
-
- If the angle is 270/-90 degrees, the object (text) would become '<'
-
- All of these cases have IoU of 1 to each other, and rotated NMS that only
- uses IoU as criterion would only keep one of them with the highest score -
- which, practically, still makes sense in most cases because typically
- only one of theses orientations is the correct one. Also, it does not matter
- as much if the box is only used to classify the object (instead of transcribing
- them with a sequential OCR recognition model) later.
-
- On the other hand, when we use IoU to filter proposals that are close to the
- ground truth during training, we should definitely take the angle into account if
- we know the ground truth is labeled with the strictly correct orientation (as in,
- upside-down words are annotated with -180 degrees even though they can be covered
- with a 0/90/-90 degree box, etc.)
-
- The way the original dataset is annotated also matters. For example, if the dataset
- is a 4-point polygon dataset that does not enforce ordering of vertices/orientation,
- we can estimate a minimum rotated bounding box to this polygon, but there's no way
- we can tell the correct angle with 100% confidence (as shown above, there could be 4 different
- rotated boxes, with angles differed by 90 degrees to each other, covering the exactly
- same region). In that case we have to just use IoU to determine the box
- proximity (as many detection benchmarks (even for text) do) unless there're other
- assumptions we can make (like width is always larger than height, or the object is not
- rotated by more than 90 degrees CCW/CW, etc.)
-
- In summary, not considering angles in rotated NMS seems to be a good option for now,
- but we should be aware of its implications.
-
- Args:
- boxes (Tensor[N, 5]): Rotated boxes to perform NMS on. They are expected to be in
- (x_center, y_center, width, height, angle_degrees) format.
- scores (Tensor[N]): Scores for each one of the rotated boxes
- iou_threshold (float): Discards all overlapping rotated boxes with IoU < iou_threshold
-
- Returns:
- keep (Tensor): int64 tensor with the indices of the elements that have been kept
- by Rotated NMS, sorted in decreasing order of scores
- """
- return torch.ops.detectron2.nms_rotated(boxes, scores, iou_threshold)
-
-
-# Note: this function (batched_nms_rotated) might be moved into
-# torchvision/ops/boxes.py in the future
-def batched_nms_rotated(boxes, scores, idxs, iou_threshold):
- """
- Performs non-maximum suppression in a batched fashion.
-
- Each index value correspond to a category, and NMS
- will not be applied between elements of different categories.
-
- Args:
- boxes (Tensor[N, 5]):
- boxes where NMS will be performed. They
- are expected to be in (x_ctr, y_ctr, width, height, angle_degrees) format
- scores (Tensor[N]):
- scores for each one of the boxes
- idxs (Tensor[N]):
- indices of the categories for each one of the boxes.
- iou_threshold (float):
- discards all overlapping boxes
- with IoU < iou_threshold
-
- Returns:
- Tensor:
- int64 tensor with the indices of the elements that have been kept
- by NMS, sorted in decreasing order of scores
- """
- assert boxes.shape[-1] == 5
-
- if boxes.numel() == 0:
- return torch.empty((0,), dtype=torch.int64, device=boxes.device)
- boxes = boxes.float() # fp16 does not have enough range for batched NMS
- # Strategy: in order to perform NMS independently per class,
- # we add an offset to all the boxes. The offset is dependent
- # only on the class idx, and is large enough so that boxes
- # from different classes do not overlap
-
- # Note that batched_nms in torchvision/ops/boxes.py only uses max_coordinate,
- # which won't handle negative coordinates correctly.
- # Here by using min_coordinate we can make sure the negative coordinates are
- # correctly handled.
- max_coordinate = (
- torch.max(boxes[:, 0], boxes[:, 1]) + torch.max(boxes[:, 2], boxes[:, 3]) / 2
- ).max()
- min_coordinate = (
- torch.min(boxes[:, 0], boxes[:, 1]) - torch.max(boxes[:, 2], boxes[:, 3]) / 2
- ).min()
- offsets = idxs.to(boxes) * (max_coordinate - min_coordinate + 1)
- boxes_for_nms = boxes.clone() # avoid modifying the original values in boxes
- boxes_for_nms[:, :2] += offsets[:, None]
- keep = nms_rotated(boxes_for_nms, scores, iou_threshold)
- return keep
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py
deleted file mode 100644
index e3360a74864e0c00ed92ffbc8531c8d36e8be379..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tests/test_model_zoo.py
+++ /dev/null
@@ -1,50 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import unittest
-
-from detectron2 import model_zoo
-from detectron2.config import instantiate
-from detectron2.modeling import FPN, GeneralizedRCNN
-
-logger = logging.getLogger(__name__)
-
-
-class TestModelZoo(unittest.TestCase):
- def test_get_returns_model(self):
- model = model_zoo.get("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.yaml", trained=False)
- self.assertIsInstance(model, GeneralizedRCNN)
- self.assertIsInstance(model.backbone, FPN)
-
- def test_get_invalid_model(self):
- self.assertRaises(RuntimeError, model_zoo.get, "Invalid/config.yaml")
-
- def test_get_url(self):
- url = model_zoo.get_checkpoint_url("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.yaml")
- self.assertEqual(
- url,
- "https://dl.fbaipublicfiles.com/detectron2/Misc/scratch_mask_rcnn_R_50_FPN_3x_gn/138602908/model_final_01ca85.pkl", # noqa
- )
- url2 = model_zoo.get_checkpoint_url("Misc/scratch_mask_rcnn_R_50_FPN_3x_gn.py")
- self.assertEqual(url, url2)
-
- def _build_lazy_model(self, name):
- cfg = model_zoo.get_config("common/models/" + name)
- instantiate(cfg.model)
-
- def test_mask_rcnn_fpn(self):
- self._build_lazy_model("mask_rcnn_fpn.py")
-
- def test_mask_rcnn_c4(self):
- self._build_lazy_model("mask_rcnn_c4.py")
-
- def test_panoptic_fpn(self):
- self._build_lazy_model("panoptic_fpn.py")
-
- def test_schedule(self):
- cfg = model_zoo.get_config("common/coco_schedule.py")
- for _, v in cfg.items():
- instantiate(v)
-
-
-if __name__ == "__main__":
- unittest.main()
diff --git a/spaces/Tirendaz/background-remover/app.py b/spaces/Tirendaz/background-remover/app.py
deleted file mode 100644
index c92b1d8fac26dc50b5fa4619c80e4e7c4bc036a1..0000000000000000000000000000000000000000
--- a/spaces/Tirendaz/background-remover/app.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import gradio as gr
-import cv2
-import torch
-import numpy as np
-from torchvision import transforms
-
-title = "Background Remover"
-description = "Automatically remove the image background from a profile photo."
-article = "Blog | Github Repo
"
-
-
-def make_transparent_foreground(pic, mask):
- # split the image into channels
- b, g, r = cv2.split(np.array(pic).astype('uint8'))
- # add an alpha channel with and fill all with transparent pixels (max 255)
- a = np.ones(mask.shape, dtype='uint8') * 255
- # merge the alpha channel back
- alpha_im = cv2.merge([b, g, r, a], 4)
- # create a transparent background
- bg = np.zeros(alpha_im.shape)
- # setup the new mask
- new_mask = np.stack([mask, mask, mask, mask], axis=2)
- # copy only the foreground color pixels from the original image where mask is set
- foreground = np.where(new_mask, alpha_im, bg).astype(np.uint8)
-
- return foreground
-
-
-def remove_background(input_image):
- preprocess = transforms.Compose([
- transforms.ToTensor(),
- transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
- ])
-
- input_tensor = preprocess(input_image)
- input_batch = input_tensor.unsqueeze(0) # create a mini-batch as expected by the model
-
- # move the input and model to GPU for speed if available
- if torch.cuda.is_available():
- input_batch = input_batch.to('cuda')
- model.to('cuda')
-
- with torch.no_grad():
- output = model(input_batch)['out'][0]
- output_predictions = output.argmax(0)
-
- # create a binary (black and white) mask of the profile foreground
- mask = output_predictions.byte().cpu().numpy()
- background = np.zeros(mask.shape)
- bin_mask = np.where(mask, 255, background).astype(np.uint8)
-
- foreground = make_transparent_foreground(input_image, bin_mask)
-
- return foreground, bin_mask
-
-
-def inference(img):
- foreground, _ = remove_background(img)
- return foreground
-
-
-model = torch.hub.load('pytorch/vision:v0.6.0', 'deeplabv3_resnet101', pretrained=True)
-model.eval()
-
-gr.Interface(
- inference,
- gr.inputs.Image(type="pil", label="Input"),
- gr.outputs.Image(type="pil", label="Output"),
- title=title,
- description=description,
- article=article,
- examples=[['woman.jpg'], ['man.jpg']],
- enable_queue=True
-).launch(debug=False)
\ No newline at end of file
diff --git a/spaces/UMich-siads699-fa22-spotamood/spotamood/pages/clustering.md b/spaces/UMich-siads699-fa22-spotamood/spotamood/pages/clustering.md
deleted file mode 100644
index 42523d65e1ea3ae68e7659261f1b206ff3443516..0000000000000000000000000000000000000000
--- a/spaces/UMich-siads699-fa22-spotamood/spotamood/pages/clustering.md
+++ /dev/null
@@ -1,5 +0,0 @@
-#### Songs Lyrics Clustering
-
-Based on the data and SBERT model called **"all-distilroberta-v1"**. This model is a pre-trained model based on various selections of the trained model corpus. The reason that we chose this model is due to its size of the model and performance. The model size is almost half that, 290MB, of the 1st and 2nd best-performing pre-trained models. Once we get the embedding of the lyrics from the sample songs that we sampled from the dataset, we then performed analysis on what is the best number of clusters using elbow plot. From the elbow plot below, we can see that the best number of clusters using the embedding of the songs is 7 clusters. We then perform the clustering on our dataset using MiniBatchKmean to help with the speed of the clustering considering the embedding size and samples.
-
-Finally, we can observe from the results of the clustering of the lyrics line that it clustered quite well and users can play with the interactive plot of the cluster on the main app screen. From this cluster, however, we discover that there are multiple lines with empty lyrics and some lines which contain the lyrics partition such as ***Chorus*** or ***Acoustic***, while some contain other song attributes. This means we need to clean up the lyrics line much more to make sure that the cluster is only representing important lyrics lines that matter. This, however, does not interfere with the recommendation ranking since the ranking is based on the overall song similarity based on all the lines in the song while suppressed scores for lines that are less similar to the query than the rest.
\ No newline at end of file
diff --git a/spaces/VIPLab/Caption-Anything/README.md b/spaces/VIPLab/Caption-Anything/README.md
deleted file mode 100644
index 170c7a1568a08bcd8131ebb66ba1c0f86e138fbd..0000000000000000000000000000000000000000
--- a/spaces/VIPLab/Caption-Anything/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-title: Caption Anything
-emoji: 📚
-colorFrom: green
-colorTo: green
-sdk: gradio
-sdk_version: 3.26.0
-python_version: 3.8.9
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: TencentARC/Caption-Anything
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/VickyKira/NASAGPT/g4f/Provider/Providers/Wewordle.py b/spaces/VickyKira/NASAGPT/g4f/Provider/Providers/Wewordle.py
deleted file mode 100644
index 18cfe8c58f3c5066fe9f5633b2d284532d70c4f4..0000000000000000000000000000000000000000
--- a/spaces/VickyKira/NASAGPT/g4f/Provider/Providers/Wewordle.py
+++ /dev/null
@@ -1,73 +0,0 @@
-import os
-import requests
-import json
-import random
-import time
-import string
-from ...typing import sha256, Dict, get_type_hints
-
-url = "https://wewordle.org/gptapi/v1/android/turbo"
-model = ['gpt-3.5-turbo']
-supports_stream = False
-needs_auth = False
-
-
-def _create_completion(model: str, messages: list, stream: bool, **kwargs):
- base = ''
- for message in messages:
- base += '%s: %s\n' % (message['role'], message['content'])
- base += 'assistant:'
- # randomize user id and app id
- _user_id = ''.join(random.choices(
- f'{string.ascii_lowercase}{string.digits}', k=16))
- _app_id = ''.join(random.choices(
- f'{string.ascii_lowercase}{string.digits}', k=31))
- # make current date with format utc
- _request_date = time.strftime("%Y-%m-%dT%H:%M:%S.000Z", time.gmtime())
- headers = {
- 'accept': '*/*',
- 'pragma': 'no-cache',
- 'Content-Type': 'application/json',
- 'Connection': 'keep-alive'
- }
- data = {
- "user": _user_id,
- "messages": [
- {"role": "user", "content": base}
- ],
- "subscriber": {
- "originalPurchaseDate": None,
- "originalApplicationVersion": None,
- "allPurchaseDatesMillis": {},
- "entitlements": {
- "active": {},
- "all": {}
- },
- "allPurchaseDates": {},
- "allExpirationDatesMillis": {},
- "allExpirationDates": {},
- "originalAppUserId": f"$RCAnonymousID:{_app_id}",
- "latestExpirationDate": None,
- "requestDate": _request_date,
- "latestExpirationDateMillis": None,
- "nonSubscriptionTransactions": [],
- "originalPurchaseDateMillis": None,
- "managementURL": None,
- "allPurchasedProductIdentifiers": [],
- "firstSeen": _request_date,
- "activeSubscriptions": []
- }
- }
- response = requests.post(url, headers=headers, data=json.dumps(data))
- if response.status_code == 200:
- _json = response.json()
- if 'message' in _json:
- yield _json['message']['content']
- else:
- print(f"Error Occurred::{response.status_code}")
- return None
-
-
-params = f'g4f.Providers.{os.path.basename(__file__)[:-3]} supports: ' + \
- '(%s)' % ', '.join(
- [f"{name}: {get_type_hints(_create_completion)[name].__name__}" for name in _create_completion.__code__.co_varnames[:_create_completion.__code__.co_argcount]])
diff --git a/spaces/Vynock/rvc-wefu/vc_infer_pipeline.py b/spaces/Vynock/rvc-wefu/vc_infer_pipeline.py
deleted file mode 100644
index c26d45068f9b6bf2b194b13c3c89f8a06347c124..0000000000000000000000000000000000000000
--- a/spaces/Vynock/rvc-wefu/vc_infer_pipeline.py
+++ /dev/null
@@ -1,306 +0,0 @@
-import numpy as np, parselmouth, torch, pdb
-from time import time as ttime
-import torch.nn.functional as F
-from config import x_pad, x_query, x_center, x_max
-import scipy.signal as signal
-import pyworld, os, traceback, faiss
-from scipy import signal
-
-bh, ah = signal.butter(N=5, Wn=48, btype="high", fs=16000)
-
-
-class VC(object):
- def __init__(self, tgt_sr, device, is_half):
- self.sr = 16000 # hubert输入采样率
- self.window = 160 # 每帧点数
- self.t_pad = self.sr * x_pad # 每条前后pad时间
- self.t_pad_tgt = tgt_sr * x_pad
- self.t_pad2 = self.t_pad * 2
- self.t_query = self.sr * x_query # 查询切点前后查询时间
- self.t_center = self.sr * x_center # 查询切点位置
- self.t_max = self.sr * x_max # 免查询时长阈值
- self.device = device
- self.is_half = is_half
-
- def get_f0(self, x, p_len, f0_up_key, f0_method, inp_f0=None):
- time_step = self.window / self.sr * 1000
- f0_min = 50
- f0_max = 1100
- f0_mel_min = 1127 * np.log(1 + f0_min / 700)
- f0_mel_max = 1127 * np.log(1 + f0_max / 700)
- if f0_method == "pm":
- f0 = (
- parselmouth.Sound(x, self.sr)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=f0_min,
- pitch_ceiling=f0_max,
- )
- .selected_array["frequency"]
- )
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(
- f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant"
- )
- elif f0_method == "harvest":
- f0, t = pyworld.harvest(
- x.astype(np.double),
- fs=self.sr,
- f0_ceil=f0_max,
- f0_floor=f0_min,
- frame_period=10,
- )
- f0 = pyworld.stonemask(x.astype(np.double), f0, t, self.sr)
- f0 = signal.medfilt(f0, 3)
- f0 *= pow(2, f0_up_key / 12)
- # with open("test.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
- tf0 = self.sr // self.window # 每秒f0点数
- if inp_f0 is not None:
- delta_t = np.round(
- (inp_f0[:, 0].max() - inp_f0[:, 0].min()) * tf0 + 1
- ).astype("int16")
- replace_f0 = np.interp(
- list(range(delta_t)), inp_f0[:, 0] * 100, inp_f0[:, 1]
- )
- shape = f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)].shape[0]
- f0[x_pad * tf0 : x_pad * tf0 + len(replace_f0)] = replace_f0[:shape]
- # with open("test_opt.txt","w")as f:f.write("\n".join([str(i)for i in f0.tolist()]))
- f0bak = f0.copy()
- f0_mel = 1127 * np.log(1 + f0 / 700)
- f0_mel[f0_mel > 0] = (f0_mel[f0_mel > 0] - f0_mel_min) * 254 / (
- f0_mel_max - f0_mel_min
- ) + 1
- f0_mel[f0_mel <= 1] = 1
- f0_mel[f0_mel > 255] = 255
- f0_coarse = np.rint(f0_mel).astype(np.int)
- return f0_coarse, f0bak # 1-0
-
- def vc(
- self,
- model,
- net_g,
- sid,
- audio0,
- pitch,
- pitchf,
- times,
- index,
- big_npy,
- index_rate,
- ): # ,file_index,file_big_npy
- feats = torch.from_numpy(audio0)
- if self.is_half:
- feats = feats.half()
- else:
- feats = feats.float()
- if feats.dim() == 2: # double channels
- feats = feats.mean(-1)
- assert feats.dim() == 1, feats.dim()
- feats = feats.view(1, -1)
- padding_mask = torch.BoolTensor(feats.shape).to(self.device).fill_(False)
-
- inputs = {
- "source": feats.to(self.device),
- "padding_mask": padding_mask,
- "output_layer": 9, # layer 9
- }
- t0 = ttime()
- with torch.no_grad():
- logits = model.extract_features(**inputs)
- feats = model.final_proj(logits[0])
-
- if (
- isinstance(index, type(None)) == False
- and isinstance(big_npy, type(None)) == False
- and index_rate != 0
- ):
- npy = feats[0].cpu().numpy()
- if self.is_half:
- npy = npy.astype("float32")
- _, I = index.search(npy, 1)
- npy = big_npy[I.squeeze()]
- if self.is_half:
- npy = npy.astype("float16")
- feats = (
- torch.from_numpy(npy).unsqueeze(0).to(self.device) * index_rate
- + (1 - index_rate) * feats
- )
-
- feats = F.interpolate(feats.permute(0, 2, 1), scale_factor=2).permute(0, 2, 1)
- t1 = ttime()
- p_len = audio0.shape[0] // self.window
- if feats.shape[1] < p_len:
- p_len = feats.shape[1]
- if pitch != None and pitchf != None:
- pitch = pitch[:, :p_len]
- pitchf = pitchf[:, :p_len]
- p_len = torch.tensor([p_len], device=self.device).long()
- with torch.no_grad():
- if pitch != None and pitchf != None:
- audio1 = (
- (net_g.infer(feats, p_len, pitch, pitchf, sid)[0][0, 0] * 32768)
- .data.cpu()
- .float()
- .numpy()
- .astype(np.int16)
- )
- else:
- audio1 = (
- (net_g.infer(feats, p_len, sid)[0][0, 0] * 32768)
- .data.cpu()
- .float()
- .numpy()
- .astype(np.int16)
- )
- del feats, p_len, padding_mask
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- t2 = ttime()
- times[0] += t1 - t0
- times[2] += t2 - t1
- return audio1
-
- def pipeline(
- self,
- model,
- net_g,
- sid,
- audio,
- times,
- f0_up_key,
- f0_method,
- file_index,
- file_big_npy,
- index_rate,
- if_f0,
- f0_file=None,
- ):
- if (
- file_big_npy != ""
- and file_index != ""
- and os.path.exists(file_big_npy) == True
- and os.path.exists(file_index) == True
- and index_rate != 0
- ):
- try:
- index = faiss.read_index(file_index)
- big_npy = np.load(file_big_npy)
- except:
- traceback.print_exc()
- index = big_npy = None
- else:
- index = big_npy = None
- print("Feature retrieval library doesn't exist or ratio is 0")
- audio = signal.filtfilt(bh, ah, audio)
- audio_pad = np.pad(audio, (self.window // 2, self.window // 2), mode="reflect")
- opt_ts = []
- if audio_pad.shape[0] > self.t_max:
- audio_sum = np.zeros_like(audio)
- for i in range(self.window):
- audio_sum += audio_pad[i : i - self.window]
- for t in range(self.t_center, audio.shape[0], self.t_center):
- opt_ts.append(
- t
- - self.t_query
- + np.where(
- np.abs(audio_sum[t - self.t_query : t + self.t_query])
- == np.abs(audio_sum[t - self.t_query : t + self.t_query]).min()
- )[0][0]
- )
- s = 0
- audio_opt = []
- t = None
- t1 = ttime()
- audio_pad = np.pad(audio, (self.t_pad, self.t_pad), mode="reflect")
- p_len = audio_pad.shape[0] // self.window
- inp_f0 = None
- if hasattr(f0_file, "name") == True:
- try:
- with open(f0_file.name, "r") as f:
- lines = f.read().strip("\n").split("\n")
- inp_f0 = []
- for line in lines:
- inp_f0.append([float(i) for i in line.split(",")])
- inp_f0 = np.array(inp_f0, dtype="float32")
- except:
- traceback.print_exc()
- sid = torch.tensor(sid, device=self.device).unsqueeze(0).long()
- pitch, pitchf = None, None
- if if_f0 == 1:
- pitch, pitchf = self.get_f0(audio_pad, p_len, f0_up_key, f0_method, inp_f0)
- pitch = pitch[:p_len]
- pitchf = pitchf[:p_len]
- pitch = torch.tensor(pitch, device=self.device).unsqueeze(0).long()
- pitchf = torch.tensor(pitchf, device=self.device).unsqueeze(0).float()
- t2 = ttime()
- times[1] += t2 - t1
- for t in opt_ts:
- t = t // self.window * self.window
- if if_f0 == 1:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[s : t + self.t_pad2 + self.window],
- pitch[:, s // self.window : (t + self.t_pad2) // self.window],
- pitchf[:, s // self.window : (t + self.t_pad2) // self.window],
- times,
- index,
- big_npy,
- index_rate,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- else:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[s : t + self.t_pad2 + self.window],
- None,
- None,
- times,
- index,
- big_npy,
- index_rate,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- s = t
- if if_f0 == 1:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[t:],
- pitch[:, t // self.window :] if t is not None else pitch,
- pitchf[:, t // self.window :] if t is not None else pitchf,
- times,
- index,
- big_npy,
- index_rate,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- else:
- audio_opt.append(
- self.vc(
- model,
- net_g,
- sid,
- audio_pad[t:],
- None,
- None,
- times,
- index,
- big_npy,
- index_rate,
- )[self.t_pad_tgt : -self.t_pad_tgt]
- )
- audio_opt = np.concatenate(audio_opt)
- del pitch, pitchf, sid
- if torch.cuda.is_available():
- torch.cuda.empty_cache()
- return audio_opt
diff --git a/spaces/Wanlau/sovits-4.0_datealive/onnx_export.py b/spaces/Wanlau/sovits-4.0_datealive/onnx_export.py
deleted file mode 100644
index 53b278dd9495550cd48dbddb92435b29b5bb2e6a..0000000000000000000000000000000000000000
--- a/spaces/Wanlau/sovits-4.0_datealive/onnx_export.py
+++ /dev/null
@@ -1,94 +0,0 @@
-import torch
-from torchaudio.models.wav2vec2.utils import import_fairseq_model
-from fairseq import checkpoint_utils
-from onnxexport.model_onnx import SynthesizerTrn
-import utils
-
-def get_hubert_model():
- vec_path = "hubert/checkpoint_best_legacy_500.pt"
- print("load model(s) from {}".format(vec_path))
- models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
- [vec_path],
- suffix="",
- )
- model = models[0]
- model.eval()
- return model
-
-
-def main(HubertExport, NetExport):
- path = "SoVits4.0"
-
- '''if HubertExport:
- device = torch.device("cpu")
- vec_path = "hubert/checkpoint_best_legacy_500.pt"
- models, saved_cfg, task = checkpoint_utils.load_model_ensemble_and_task(
- [vec_path],
- suffix="",
- )
- original = models[0]
- original.eval()
- model = original
- test_input = torch.rand(1, 1, 16000)
- model(test_input)
- torch.onnx.export(model,
- test_input,
- "hubert4.0.onnx",
- export_params=True,
- opset_version=16,
- do_constant_folding=True,
- input_names=['source'],
- output_names=['embed'],
- dynamic_axes={
- 'source':
- {
- 2: "sample_length"
- },
- }
- )'''
- if NetExport:
- device = torch.device("cpu")
- hps = utils.get_hparams_from_file(f"checkpoints/{path}/config.json")
- SVCVITS = SynthesizerTrn(
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model)
- _ = utils.load_checkpoint(f"checkpoints/{path}/model.pth", SVCVITS, None)
- _ = SVCVITS.eval().to(device)
- for i in SVCVITS.parameters():
- i.requires_grad = False
- test_hidden_unit = torch.rand(1, 10, 256)
- test_pitch = torch.rand(1, 10)
- test_mel2ph = torch.LongTensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]).unsqueeze(0)
- test_uv = torch.ones(1, 10, dtype=torch.float32)
- test_noise = torch.randn(1, 192, 10)
- test_sid = torch.LongTensor([0])
- input_names = ["c", "f0", "mel2ph", "uv", "noise", "sid"]
- output_names = ["audio", ]
- SVCVITS.eval()
- torch.onnx.export(SVCVITS,
- (
- test_hidden_unit.to(device),
- test_pitch.to(device),
- test_mel2ph.to(device),
- test_uv.to(device),
- test_noise.to(device),
- test_sid.to(device)
- ),
- f"checkpoints/{path}/model.onnx",
- dynamic_axes={
- "c": [0, 1],
- "f0": [1],
- "mel2ph": [1],
- "uv": [1],
- "noise": [2],
- },
- do_constant_folding=False,
- opset_version=16,
- verbose=False,
- input_names=input_names,
- output_names=output_names)
-
-
-if __name__ == '__main__':
- main(False, True)
diff --git "a/spaces/Wazzzabeee/image-video-colorization/pages/02_\360\237\216\245_Input_Youtube_Link.py" "b/spaces/Wazzzabeee/image-video-colorization/pages/02_\360\237\216\245_Input_Youtube_Link.py"
deleted file mode 100644
index fae44f01f84446647480ad26c63e60b66f4b29a8..0000000000000000000000000000000000000000
--- "a/spaces/Wazzzabeee/image-video-colorization/pages/02_\360\237\216\245_Input_Youtube_Link.py"
+++ /dev/null
@@ -1,138 +0,0 @@
-import time
-
-import cv2
-import moviepy.editor as mp
-import numpy as np
-import streamlit as st
-from pytube import YouTube
-from streamlit_lottie import st_lottie
-from tqdm import tqdm
-
-from models.deep_colorization.colorizers import eccv16
-from utils import colorize_frame, format_time
-from utils import load_lottieurl, change_model
-
-st.set_page_config(page_title="Image & Video Colorizer", page_icon="🎨", layout="wide")
-
-
-loaded_model = eccv16(pretrained=True).eval()
-current_model = "None"
-
-
-col1, col2 = st.columns([1, 3])
-with col1:
- lottie = load_lottieurl("https://assets5.lottiefiles.com/packages/lf20_RHdEuzVfEL.json")
- st_lottie(lottie)
-
-with col2:
- st.write("""
- ## B&W Videos Colorizer
- ##### Input a YouTube black and white video link and get a colorized version of it.
- ###### ➠ This space is using CPU Basic so it might take a while to colorize a video.
- ###### ➠ If you want more models and GPU available please support this space by donating.""")
-
-
-@st.cache_data()
-def download_video(link):
- yt = YouTube(link)
- video = yt.streams.filter(progressive=True, file_extension='mp4').order_by('resolution').desc().first().download(filename="video.mp4")
- return video
-
-
-def main():
- model = st.selectbox(
- "Select Model (Both models have their pros and cons, I recommend trying both and keeping the best for you task)",
- ["ECCV16", "SIGGRAPH17"], index=0)
-
- loaded_model = change_model(current_model, model)
- st.write(f"Model is now {model}")
-
- link = st.text_input("YouTube Link (The longer the video, the longer the processing time)")
- if st.button("Colorize"):
- yt_video = download_video(link)
- print(yt_video)
- col1, col2 = st.columns([0.5, 0.5])
- with col1:
- st.markdown('Before
', unsafe_allow_html=True)
- st.video(yt_video)
- with col2:
- st.markdown('After
', unsafe_allow_html=True)
- with st.spinner("Colorizing frames..."):
- # Colorize video frames and store in a list
- output_frames = []
-
- audio = mp.AudioFileClip("video.mp4")
- video = cv2.VideoCapture("video.mp4")
-
- total_frames = int(video.get(cv2.CAP_PROP_FRAME_COUNT))
- fps = video.get(cv2.CAP_PROP_FPS)
-
- progress_bar = st.progress(0) # Create a progress bar
- start_time = time.time()
- time_text = st.text("Time Remaining: ") # Initialize text value
-
- for _ in tqdm(range(total_frames), unit='frame', desc="Progress"):
- ret, frame = video.read()
- if not ret:
- break
-
- colorized_frame = colorize_frame(frame, loaded_model)
- output_frames.append((colorized_frame * 255).astype(np.uint8))
-
- elapsed_time = time.time() - start_time
- frames_completed = len(output_frames)
- frames_remaining = total_frames - frames_completed
- time_remaining = (frames_remaining / frames_completed) * elapsed_time
-
- progress_bar.progress(frames_completed / total_frames) # Update progress bar
-
- if frames_completed < total_frames:
- time_text.text(f"Time Remaining: {format_time(time_remaining)}") # Update text value
- else:
- time_text.empty() # Remove text value
- progress_bar.empty()
-
- with st.spinner("Merging frames to video..."):
- frame_size = output_frames[0].shape[:2]
- output_filename = "output.mp4"
- fourcc = cv2.VideoWriter_fourcc(*"mp4v") # Codec for MP4 video
- out = cv2.VideoWriter(output_filename, fourcc, fps, (frame_size[1], frame_size[0]))
-
- # Display the colorized video using st.video
- for frame in output_frames:
- frame_bgr = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
-
- out.write(frame_bgr)
-
- out.release()
-
- # Convert the output video to a format compatible with Streamlit
- converted_filename = "converted_output.mp4"
- clip = mp.VideoFileClip(output_filename)
- clip = clip.set_audio(audio)
-
- clip.write_videofile(converted_filename, codec="libx264")
-
- # Display the converted video using st.video()
- st.video(converted_filename)
- st.balloons()
-
- # Add a download button for the colorized video
- st.download_button(
- label="Download Colorized Video",
- data=open(converted_filename, "rb").read(),
- file_name="colorized_video.mp4"
- )
-
- # Close and delete the temporary file after processing
- video.release()
-
-
-if __name__ == "__main__":
- main()
- st.markdown(
- "###### Made with :heart: by [Clément Delteil](https://www.linkedin.com/in/clementdelteil/) [](https://www.buymeacoffee.com/clementdelteil)")
- st.markdown(
- "###### [Blog post of the project](https://medium.com/geekculture/creating-a-web-app-to-colorize-images-and-youtube-videos-80f5be2d0f68)"
- )
diff --git a/spaces/XzJosh/Lumi-Bert-VITS2/text/chinese_bert.py b/spaces/XzJosh/Lumi-Bert-VITS2/text/chinese_bert.py
deleted file mode 100644
index cb84ce0b426cd0a1c7954ddcdf41322c10ed14fa..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Lumi-Bert-VITS2/text/chinese_bert.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import torch
-from transformers import AutoTokenizer, AutoModelForMaskedLM
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-tokenizer = AutoTokenizer.from_pretrained("./bert/chinese-roberta-wwm-ext-large")
-model = AutoModelForMaskedLM.from_pretrained("./bert/chinese-roberta-wwm-ext-large").to(device)
-
-def get_bert_feature(text, word2ph):
- with torch.no_grad():
- inputs = tokenizer(text, return_tensors='pt')
- for i in inputs:
- inputs[i] = inputs[i].to(device)
- res = model(**inputs, output_hidden_states=True)
- res = torch.cat(res['hidden_states'][-3:-2], -1)[0].cpu()
-
- assert len(word2ph) == len(text)+2
- word2phone = word2ph
- phone_level_feature = []
- for i in range(len(word2phone)):
- repeat_feature = res[i].repeat(word2phone[i], 1)
- phone_level_feature.append(repeat_feature)
-
- phone_level_feature = torch.cat(phone_level_feature, dim=0)
-
-
- return phone_level_feature.T
-
-if __name__ == '__main__':
- # feature = get_bert_feature('你好,我是说的道理。')
- import torch
-
- word_level_feature = torch.rand(38, 1024) # 12个词,每个词1024维特征
- word2phone = [1, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 1, 2, 2, 2, 2, 2, 1, 1, 2, 2, 1, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 1]
-
- # 计算总帧数
- total_frames = sum(word2phone)
- print(word_level_feature.shape)
- print(word2phone)
- phone_level_feature = []
- for i in range(len(word2phone)):
- print(word_level_feature[i].shape)
-
- # 对每个词重复word2phone[i]次
- repeat_feature = word_level_feature[i].repeat(word2phone[i], 1)
- phone_level_feature.append(repeat_feature)
-
- phone_level_feature = torch.cat(phone_level_feature, dim=0)
- print(phone_level_feature.shape) # torch.Size([36, 1024])
-
diff --git a/spaces/YONG627/456123/yolov5-code-main/benchmarks.py b/spaces/YONG627/456123/yolov5-code-main/benchmarks.py
deleted file mode 100644
index 09108b8a7cc4ef07c97e3835d428bba106b71629..0000000000000000000000000000000000000000
--- a/spaces/YONG627/456123/yolov5-code-main/benchmarks.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# YOLOv5 🚀 by Ultralytics, GPL-3.0 license
-"""
-Run YOLOv5 benchmarks on all supported export formats
-
-Format | `export.py --include` | Model
---- | --- | ---
-PyTorch | - | yolov5s.pt
-TorchScript | `torchscript` | yolov5s.torchscript
-ONNX | `onnx` | yolov5s.onnx
-OpenVINO | `openvino` | yolov5s_openvino_model/
-TensorRT | `engine` | yolov5s.engine
-CoreML | `coreml` | yolov5s.mlmodel
-TensorFlow SavedModel | `saved_model` | yolov5s_saved_model/
-TensorFlow GraphDef | `pb` | yolov5s.pb
-TensorFlow Lite | `tflite` | yolov5s.tflite
-TensorFlow Edge TPU | `edgetpu` | yolov5s_edgetpu.tflite
-TensorFlow.js | `tfjs` | yolov5s_web_model/
-
-Requirements:
- $ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime openvino-dev tensorflow-cpu # CPU
- $ pip install -r requirements.txt coremltools onnx onnx-simplifier onnxruntime-gpu openvino-dev tensorflow # GPU
- $ pip install -U nvidia-tensorrt --index-url https://pypi.ngc.nvidia.com # TensorRT
-
-Usage:
- $ python benchmarks.py --weights yolov5s.pt --img 640
-"""
-
-import argparse
-import platform
-import sys
-import time
-from pathlib import Path
-
-import pandas as pd
-
-FILE = Path(__file__).resolve()
-ROOT = FILE.parents[0] # YOLOv5 root directory
-if str(ROOT) not in sys.path:
- sys.path.append(str(ROOT)) # add ROOT to PATH
-# ROOT = ROOT.relative_to(Path.cwd()) # relative
-
-import export
-from models.experimental import attempt_load
-from models.yolo import SegmentationModel
-from segment.val import run as val_seg
-from utils import notebook_init
-from utils.general import LOGGER, check_yaml, file_size, print_args
-from utils.torch_utils import select_device
-from val import run as val_det
-
-
-def run(
- weights=ROOT / 'yolov5s.pt', # weights path
- imgsz=640, # inference size (pixels)
- batch_size=1, # batch size
- data=ROOT / 'data/coco128.yaml', # dataset.yaml path
- device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
- half=False, # use FP16 half-precision inference
- test=False, # test exports only
- pt_only=False, # test PyTorch only
- hard_fail=False, # throw error on benchmark failure
-):
- y, t = [], time.time()
- device = select_device(device)
- model_type = type(attempt_load(weights, fuse=False)) # DetectionModel, SegmentationModel, etc.
- for i, (name, f, suffix, cpu, gpu) in export.export_formats().iterrows(): # index, (name, file, suffix, CPU, GPU)
- try:
- assert i not in (9, 10), 'inference not supported' # Edge TPU and TF.js are unsupported
- assert i != 5 or platform.system() == 'Darwin', 'inference only supported on macOS>=10.13' # CoreML
- if 'cpu' in device.type:
- assert cpu, 'inference not supported on CPU'
- if 'cuda' in device.type:
- assert gpu, 'inference not supported on GPU'
-
- # Export
- if f == '-':
- w = weights # PyTorch format
- else:
- w = export.run(weights=weights, imgsz=[imgsz], include=[f], device=device, half=half)[-1] # all others
- assert suffix in str(w), 'export failed'
-
- # Validate
- if model_type == SegmentationModel:
- result = val_seg(data, w, batch_size, imgsz, plots=False, device=device, task='speed', half=half)
- metric = result[0][7] # (box(p, r, map50, map), mask(p, r, map50, map), *loss(box, obj, cls))
- else: # DetectionModel:
- result = val_det(data, w, batch_size, imgsz, plots=False, device=device, task='speed', half=half)
- metric = result[0][3] # (p, r, map50, map, *loss(box, obj, cls))
- speed = result[2][1] # times (preprocess, inference, postprocess)
- y.append([name, round(file_size(w), 1), round(metric, 4), round(speed, 2)]) # MB, mAP, t_inference
- except Exception as e:
- if hard_fail:
- assert type(e) is AssertionError, f'Benchmark --hard-fail for {name}: {e}'
- LOGGER.warning(f'WARNING ⚠️ Benchmark failure for {name}: {e}')
- y.append([name, None, None, None]) # mAP, t_inference
- if pt_only and i == 0:
- break # break after PyTorch
-
- # Print results
- LOGGER.info('\n')
- parse_opt()
- notebook_init() # print system info
- c = ['Format', 'Size (MB)', 'mAP50-95', 'Inference time (ms)'] if map else ['Format', 'Export', '', '']
- py = pd.DataFrame(y, columns=c)
- LOGGER.info(f'\nBenchmarks complete ({time.time() - t:.2f}s)')
- LOGGER.info(str(py if map else py.iloc[:, :2]))
- if hard_fail and isinstance(hard_fail, str):
- metrics = py['mAP50-95'].array # values to compare to floor
- floor = eval(hard_fail) # minimum metric floor to pass, i.e. = 0.29 mAP for YOLOv5n
- assert all(x > floor for x in metrics if pd.notna(x)), f'HARD FAIL: mAP50-95 < floor {floor}'
- return py
-
-
-def test(
- weights=ROOT / 'yolov5s.pt', # weights path
- imgsz=640, # inference size (pixels)
- batch_size=1, # batch size
- data=ROOT / 'data/coco128.yaml', # dataset.yaml path
- device='', # cuda device, i.e. 0 or 0,1,2,3 or cpu
- half=False, # use FP16 half-precision inference
- test=False, # test exports only
- pt_only=False, # test PyTorch only
- hard_fail=False, # throw error on benchmark failure
-):
- y, t = [], time.time()
- device = select_device(device)
- for i, (name, f, suffix, gpu) in export.export_formats().iterrows(): # index, (name, file, suffix, gpu-capable)
- try:
- w = weights if f == '-' else \
- export.run(weights=weights, imgsz=[imgsz], include=[f], device=device, half=half)[-1] # weights
- assert suffix in str(w), 'export failed'
- y.append([name, True])
- except Exception:
- y.append([name, False]) # mAP, t_inference
-
- # Print results
- LOGGER.info('\n')
- parse_opt()
- notebook_init() # print system info
- py = pd.DataFrame(y, columns=['Format', 'Export'])
- LOGGER.info(f'\nExports complete ({time.time() - t:.2f}s)')
- LOGGER.info(str(py))
- return py
-
-
-def parse_opt():
- parser = argparse.ArgumentParser()
- parser.add_argument('--weights', type=str, default=ROOT / 'yolov5s.pt', help='weights path')
- parser.add_argument('--imgsz', '--img', '--img-size', type=int, default=640, help='inference size (pixels)')
- parser.add_argument('--batch-size', type=int, default=1, help='batch size')
- parser.add_argument('--data', type=str, default=ROOT / 'data/coco128.yaml', help='dataset.yaml path')
- parser.add_argument('--device', default='', help='cuda device, i.e. 0 or 0,1,2,3 or cpu')
- parser.add_argument('--half', action='store_true', help='use FP16 half-precision inference')
- parser.add_argument('--test', action='store_true', help='test exports only')
- parser.add_argument('--pt-only', action='store_true', help='test PyTorch only')
- parser.add_argument('--hard-fail', nargs='?', const=True, default=False, help='Exception on error or < min metric')
- opt = parser.parse_args()
- opt.data = check_yaml(opt.data) # check YAML
- print_args(vars(opt))
- return opt
-
-
-def main(opt):
- test(**vars(opt)) if opt.test else run(**vars(opt))
-
-
-if __name__ == '__main__':
- opt = parse_opt()
- main(opt)
diff --git a/spaces/Yah216/Arabic-Sentiment-Analyser/app.py b/spaces/Yah216/Arabic-Sentiment-Analyser/app.py
deleted file mode 100644
index 36647ad56d708d204c30606590090b978bed95eb..0000000000000000000000000000000000000000
--- a/spaces/Yah216/Arabic-Sentiment-Analyser/app.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import streamlit as st
-import tensorflow as tf
-
-from transformers import pipeline
-
-model_ckpt = "Yah216/Sentiment_Analysis_CAMelBERT_msa_sixteenth_HARD"
-
-pipe = pipeline("text-classification", model_ckpt)
-
-text = st.text_area("Enter some text in arabic language!")
-if text:
- st.write(pipe(text)[0]["label"])
\ No newline at end of file
diff --git a/spaces/YlcldKlns/bing/src/lib/utils.ts b/spaces/YlcldKlns/bing/src/lib/utils.ts
deleted file mode 100644
index 8de2eba94bf0bc93579d4f489e8b810dbf6ce92a..0000000000000000000000000000000000000000
--- a/spaces/YlcldKlns/bing/src/lib/utils.ts
+++ /dev/null
@@ -1,159 +0,0 @@
-import { clsx, type ClassValue } from 'clsx'
-import { customAlphabet } from 'nanoid'
-import { twMerge } from 'tailwind-merge'
-// @ts-ignore
-import randomip from 'random-ip'
-import cidr from './cidr.json'
-
-export function cn(...inputs: ClassValue[]) {
- return twMerge(clsx(inputs))
-}
-
-export const nanoid = customAlphabet(
- '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
- 7
-) // 7-character random string
-
-export function createChunkDecoder() {
- const decoder = new TextDecoder()
- return function (chunk: Uint8Array | undefined): string {
- if (!chunk) return ''
- return decoder.decode(chunk, { stream: true })
- }
-}
-
-export function random (start: number, end: number) {
- return start + Math.floor(Math.random() * (end - start))
-}
-
-export function randomIP() {
- // return `104.${random(0, 21)}.${random(0, 127)}.${random(1, 255)}`
- const [ip, range] = cidr.at(random(0, cidr.length))?.split('/')!
- return randomip(ip, range)
-}
-
-export const defaultUID = 'xxx'
-
-export function parseHeadersFromCurl(content: string) {
- const re = /-H '([^:]+):\s*([^']+)/mg
- const headers: HeadersInit = {}
- content = content.replaceAll('-H "', '-H \'').replaceAll('" ^', '\'\\').replaceAll('^\\^"', '"') // 将 cmd curl 转成 bash curl
- content.replace(re, (_: string, key: string, value: string) => {
- headers[key] = value
- return ''
- })
- return headers
-}
-
-export const ChunkKeys = ['BING_HEADER', 'BING_HEADER1', 'BING_HEADER2']
-export function encodeHeadersToCookie(content: string) {
- const base64Content = btoa(content)
- const contentChunks = base64Content.match(/.{1,4000}/g) || []
- return ChunkKeys.map((key, index) => `${key}=${contentChunks[index] ?? ''}`)
-}
-
-export function extraCurlFromCookie(cookies: Partial<{ [key: string]: string }>) {
- let base64Content = ''
- ChunkKeys.forEach((key) => {
- base64Content += (cookies[key] || '')
- })
- try {
- return atob(base64Content)
- } catch(e) {
- return ''
- }
-}
-
-export function extraHeadersFromCookie(cookies: Partial<{ [key: string]: string }>) {
- return parseHeadersFromCurl(extraCurlFromCookie(cookies))
-}
-
-export function formatDate(input: string | number | Date): string {
- const date = new Date(input)
- return date.toLocaleDateString('en-US', {
- month: 'long',
- day: 'numeric',
- year: 'numeric'
- })
-}
-
-export function parseCookie(cookie: string, cookieName: string) {
- const targetCookie = new RegExp(`(?:[; ]|^)${cookieName}=([^;]*)`).test(cookie) ? RegExp.$1 : cookie
- return targetCookie ? decodeURIComponent(targetCookie).trim() : cookie.indexOf('=') === -1 ? cookie.trim() : ''
-}
-
-export function setCookie(key: string, value: string) {
- const maxAge = value ? 86400 * 30 : 0
- document.cookie = `${key}=${value || ''}; Path=/; Max-Age=${maxAge}; SameSite=None; Secure`
-}
-
-export function getCookie(cookieName: string) {
- const re = new RegExp(`(?:[; ]|^)${cookieName}=([^;]*)`)
- return re.test(document.cookie) ? RegExp.$1 : ''
-}
-
-export function parseCookies(cookie: string, cookieNames: string[]) {
- const cookies: { [key: string]: string } = {}
- cookieNames.forEach(cookieName => {
- cookies[cookieName] = parseCookie(cookie, cookieName)
- })
- return cookies
-}
-
-export const DEFAULT_UA = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/115.0.0.0 Safari/537.36 Edg/115.0.0.0'
-
-export function parseUA(ua?: string, default_ua = DEFAULT_UA) {
- return / EDGE?/i.test(decodeURIComponent(ua || '')) ? decodeURIComponent(ua!.trim()) : default_ua
-}
-
-export function mockUser(cookies: Partial<{ [key: string]: string }>) {
- const {
- BING_UA = process.env.BING_UA,
- BING_IP,
- _U = defaultUID,
- } = cookies
- const ua = parseUA(BING_UA)
-
- return {
- 'x-forwarded-for': BING_IP!,
- 'Accept-Encoding': 'gzip, deflate, br',
- 'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
- 'User-Agent': ua!,
- 'x-ms-useragent': 'azsdk-js-api-client-factory/1.0.0-beta.1 core-rest-pipeline/1.10.3 OS/Win32',
- cookie: `_U=${_U}` || '',
- }
-}
-
-export function createHeaders(cookies: Partial<{ [key: string]: string }>, type?: string) {
- let {
- BING_HEADER = process.env.BING_HEADER,
- BING_IP,
- IMAGE_ONLY = process.env.IMAGE_ONLY ?? '1',
- } = cookies
- const imageOnly = /^(1|true|yes)$/.test(String(IMAGE_ONLY))
- if (BING_HEADER) {
- if (
- (imageOnly && type === 'image')
- || !imageOnly
- ) {
- const headers = extraHeadersFromCookie({
- BING_HEADER,
- ...cookies,
- }) || {}
- headers['x-forward-for'] = BING_IP!
- return headers
- }
- }
- return mockUser(cookies)
-}
-
-export class WatchDog {
- private tid = 0
- watch(fn: Function, timeout = 2000) {
- clearTimeout(this.tid)
- this.tid = setTimeout(fn, timeout + Math.random() * 1000)
- }
- reset() {
- clearTimeout(this.tid)
- }
-}
diff --git a/spaces/YlcldKlns/bing/tests/parse.ts b/spaces/YlcldKlns/bing/tests/parse.ts
deleted file mode 100644
index 92940fe6315f1d7cb2b267ba5e5a7e26460a1de3..0000000000000000000000000000000000000000
--- a/spaces/YlcldKlns/bing/tests/parse.ts
+++ /dev/null
@@ -1,13 +0,0 @@
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { parseHeadersFromCurl } from '@/lib/utils'
-
-(async () => {
- const content = await fs.readFile(join(__dirname, './fixtures/curl.txt'), 'utf-8')
- const headers = parseHeadersFromCurl(content)
- console.log(headers)
-
- const cmdContent = await fs.readFile(join(__dirname, './fixtures/cmd.txt'), 'utf-8')
- const cmdHeaders = parseHeadersFromCurl(cmdContent)
- console.log(cmdHeaders)
-})()
diff --git a/spaces/Yram/Docker/Dockerfile b/spaces/Yram/Docker/Dockerfile
deleted file mode 100644
index 6c01c09373883afcb4ea34ae2d316cd596e1737b..0000000000000000000000000000000000000000
--- a/spaces/Yram/Docker/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/YuAnthony/Audio-Caption/coco_caption/get_stanford_models.sh b/spaces/YuAnthony/Audio-Caption/coco_caption/get_stanford_models.sh
deleted file mode 100644
index 50876780558a9b818a7c8187c75cfd49a2264811..0000000000000000000000000000000000000000
--- a/spaces/YuAnthony/Audio-Caption/coco_caption/get_stanford_models.sh
+++ /dev/null
@@ -1,23 +0,0 @@
-#!/usr/bin/env sh
-# This script downloads the Stanford CoreNLP models.
-
-CORENLP=stanford-corenlp-full-2015-12-09
-SPICELIB=pycocoevalcap/spice/lib
-JAR=stanford-corenlp-3.6.0
-
-DIR="$( cd "$(dirname "$0")" ; pwd -P )"
-cd $DIR
-
-if [ -f $SPICELIB/$JAR.jar ]; then
- echo "Found Stanford CoreNLP."
-else
- echo "Downloading..."
- wget http://nlp.stanford.edu/software/$CORENLP.zip
- echo "Unzipping..."
- unzip $CORENLP.zip -d $SPICELIB/
- mv $SPICELIB/$CORENLP/$JAR.jar $SPICELIB/
- mv $SPICELIB/$CORENLP/$JAR-models.jar $SPICELIB/
- rm -f $CORENLP.zip
- rm -rf $SPICELIB/$CORENLP/
- echo "Done."
-fi
diff --git a/spaces/ZenXir/FreeVC/speaker_encoder/data_objects/speaker_batch.py b/spaces/ZenXir/FreeVC/speaker_encoder/data_objects/speaker_batch.py
deleted file mode 100644
index 4485605e3ece5b491d1e7d0f223c543b6c91eb96..0000000000000000000000000000000000000000
--- a/spaces/ZenXir/FreeVC/speaker_encoder/data_objects/speaker_batch.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import numpy as np
-from typing import List
-from speaker_encoder.data_objects.speaker import Speaker
-
-class SpeakerBatch:
- def __init__(self, speakers: List[Speaker], utterances_per_speaker: int, n_frames: int):
- self.speakers = speakers
- self.partials = {s: s.random_partial(utterances_per_speaker, n_frames) for s in speakers}
-
- # Array of shape (n_speakers * n_utterances, n_frames, mel_n), e.g. for 3 speakers with
- # 4 utterances each of 160 frames of 40 mel coefficients: (12, 160, 40)
- self.data = np.array([frames for s in speakers for _, frames, _ in self.partials[s]])
diff --git a/spaces/abdvl/datahub_qa_bot/docs/how/search.md b/spaces/abdvl/datahub_qa_bot/docs/how/search.md
deleted file mode 100644
index ba1cdaf8b5e1965748ff807b3eeb5f034f153490..0000000000000000000000000000000000000000
--- a/spaces/abdvl/datahub_qa_bot/docs/how/search.md
+++ /dev/null
@@ -1,291 +0,0 @@
-import FeatureAvailability from '@site/src/components/FeatureAvailability';
-
-# About DataHub Search
-
-
-
-
-
-
-
-
-**Advanced queries** and the **filter sidebar** helps fine tuning queries. For programmatic users Datahub provides a **GraphQL API** as well.
-
-## Search Setup, Prerequisites, and Permissions
-
-Search is available for all users. Although Search works out of the box, the more relevant data you ingest, the better the results are.
-
-## Using Search
-
-Searching is as easy as typing in relevant business terms and pressing 'enter' to view matching data assets.
-
-By default, search terms will match against different aspects of a data assets. This includes asset names, descriptions, tags, terms, owners, and even specific attributes like the names of columns in a table.
-
-
-### Filters
-
-The filters sidebar sits on the left hand side of search results, and lets users find assets by drilling down. You can quickly filter by Data Platform (e.g. Snowflake), Tags, Glossary Terms, Domain, Owners, and more with a single click.
-
-
-
-
-### Advanced Filters
-
-Using the Advanced Filter view, you can apply more complex filters. To get there, click 'Advanced' in the top right of the filter panel:
-
-
-
-
-#### Adding an Advanced Filter
-
-Currently, Advanced Filters support filtering by Column Name, Container, Domain, Description (entity or column level), Tag (entity or column level), Glossary Term (entity or column level), Owner, Entity Type, Subtype, Environment and soft-deleted status.
-
-To add a new filter, click the add filter menu, choose a filter type, and then fill in the values you want to filter by.
-
-
-
-
-#### Matching Any Advanced Filter
-
-By default, all filters must be matched in order for a result to appear. For example, if you add a tag filter and a platform filter, all results will have the tag and the platform. You can set the results to match any filter instead. Click on `all filters` and select `any filter` from the drop-down menu.
-
-
-
-
-#### Negating An Advanced Filter
-
-After creating a filter, you can choose whether results should or should not match it. Change this by clicking the operation in the top right of the filter and selecting the negated operation.
-
-
-
-
-
-### Results
-
-Search results appear ranked by their relevance. In self-hosted DataHub ranking is based on how closely the query matched textual fields of an asset and its metadata. In Managed DataHub, ranking is based on a combination of textual relevance, usage (queries / views), and change frequency.
-
-With better metadata comes better results. Learn more about ingestion technical metadata in the [metadata ingestion](../../metadata-ingestion/README.md) guide.
-
-### Advanced queries
-
-The search bar supports advanced queries with pattern matching, logical expressions and filtering by specific field matches.
-
-The following are use cases with example search phrases. Additionally, an example link is provided for our demo instance.
-These examples are non exhaustive and using Datasets as a reference.
-
-If you want to:
-
-- Exact match on term or phrase
- - ```"datahub_schema"``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%22datahub_schema%22)
- - ```datahub_schema``` [Sample results](https://demo.datahubproject.io/search?page=1&query=datahub_schema)
- - Enclosing one or more terms with double quotes will enforce exact matching on these terms, preventing further tokenization.
-
-- Exclude terms
- - ```logging -snowflake``` [Sample results](https://demo.datahubproject.io/search?page=1&query=logging%20-snowflake)
- - Results can be excluded by term using `-` to negate the term.
-
-- Term boolean logic with precedence
- - ```logging + (-snowflake | os_audit_log)``` [Sample results](https://demo.datahubproject.io/search?page=1&query=logging%20%2B%20%28-snowflake%20%7C%20os_audit_log%29)
- - `(` `)` can be used to set precedence of boolean term expressions
-
-- Find a dataset with the word **mask** in the name:
- - ```/q name: *mask*``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20name%253A%2520%2Amask%2A)
- - This will return entities with **mask** in the name. Names tends to be connected by other symbols, hence the wildcard symbols before and after the word.
-
-- Find a dataset with a property, **encoding**
- - ```/q customProperties: encoding*``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20customProperties%3A%20encoding%2A)
- - Dataset Properties are indexed in ElasticSearch the manner of key=value. Hence if you know the precise key-value pair, you can search using ```"key=value"```. However, if you only know the key, you can use wildcards to replace the value and that is what is being done here.
-
-- Find a dataset with a column name, **latitude**
- - ```/q fieldPaths: latitude``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20fieldPaths%3A%20latitude)
- - fieldPaths is the name of the attribute that holds the column name in Datasets.
-
-- Find a dataset with the term **latitude** in the field description
- - ```/q editedFieldDescriptions: latitude OR fieldDescriptions: latitude``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20editedFieldDescriptions%3A%20latitude%20OR%20fieldDescriptions%3A%20latitude)
- - Datasets has 2 attributes that contains field description. fieldDescription comes from the SchemaMetadata aspect, while editedFieldDescriptions comes from the EditableSchemaMetadata aspect. EditableSchemaMetadata holds information that comes from UI edits, while SchemaMetadata holds data from ingestion of the dataset.
-
-- Find a dataset with the term **logical** in the dataset description
- - ```/q editedDescription: *logical* OR description: *logical*``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20editedDescription%3A%20%2Alogical%2A%20OR%20description%3A%20%2Alogical%2A)
- - Similar to field descriptions, dataset descriptions can be found in 2 aspects, hence the need to search 2 attributes.
-
-- Find a dataset which resides in one of the browsing folders, for instance, the **hive** folder
- - ```/q browsePaths: *hive*``` [Sample results](https://demo.datahubproject.io/search?page=1&query=%2Fq%20browsePaths%3A%20%2Ahive%2A)
- - BrowsePath is stored as a complete string, for instance ```/datasets/prod/hive/SampleKafkaDataset```, hence the need for wildcards on both ends of the term to return a result.
-
-- Find a dataset without the **name** field
- - ```/q -_exists_:name``` [Sample results](https://demo.datahubproject.io/search?filter_entity___false___EQUAL___0=DATASET&page=1&query=%252Fq%2520-_exists_%253Aname&unionType=0)
- - the `-` is negating the existence of the field name.
-
-
-
-### Videos
-
-**What can you do with DataHub?**
-
-
-VIDEO
-
-
-
-### GraphQL
-
-* [searchAcrossEntities](https://datahubproject.io/docs/graphql/queries/#searchacrossentities)
-* You can try out the API on the demo instance's public GraphQL interface: [here](https://demo.datahubproject.io/api/graphiql)
-
-The same GraphQL API that powers the Search UI can be used
-for integrations and programmatic use-cases.
-
-```
-# Example query
-{
- searchAcrossEntities(
- input: {types: [], query: "*", start: 0, count: 10, filters: [{field: "fieldTags", value: "urn:li:tag:Dimension"}]}
- ) {
- start
- count
- total
- searchResults {
- entity {
- type
- ... on Dataset {
- urn
- type
- platform {
- name
- }
- name
- }
- }
- }
- }
-}
-```
-
-
-### DataHub Blog
-* [Using DataHub for Search & Discovery](https://blog.datahubproject.io/using-datahub-for-search-discovery-fa309089be22)
-
-## FAQ and Troubleshooting
-
-**How are the results ordered?**
-
-The order of the search results is based on the weight what Datahub gives them based on our search algorithm. The current algorithm in OSS DataHub is based on a text-match score from Elasticsearch.
-
-**Where to find more information?**
-
-The sample queries here are non exhaustive. [The link here](https://demo.datahubproject.io/tag/urn:li:tag:Searchable) shows the current list of indexed fields for each entity inside Datahub. Click on the fields inside each entity and see which field has the tag ```Searchable```.
-However, it does not tell you the specific attribute name to use for specialized searches. One way to do so is to inspect the ElasticSearch indices, for example:
-`curl http://localhost:9200/_cat/indices` returns all the ES indices in the ElasticSearch container.
-
-```
-yellow open chartindex_v2_1643510690325 bQO_RSiCSUiKJYsmJClsew 1 1 2 0 8.5kb 8.5kb
-yellow open mlmodelgroupindex_v2_1643510678529 OjIy0wb7RyKqLz3uTENRHQ 1 1 0 0 208b 208b
-yellow open dataprocessindex_v2_1643510676831 2w-IHpuiTUCs6e6gumpYHA 1 1 0 0 208b 208b
-yellow open corpgroupindex_v2_1643510673894 O7myCFlqQWKNtgsldzBS6g 1 1 3 0 16.8kb 16.8kb
-yellow open corpuserindex_v2_1643510672335 0rIe_uIQTjme5Wy61MFbaw 1 1 6 2 32.4kb 32.4kb
-yellow open datasetindex_v2_1643510688970 bjBfUEswSoSqPi3BP4iqjw 1 1 15 0 29.2kb 29.2kb
-yellow open dataflowindex_v2_1643510681607 N8CMlRFvQ42rnYMVDaQJ2g 1 1 1 0 10.2kb 10.2kb
-yellow open dataset_datasetusagestatisticsaspect_v1_1643510694706 kdqvqMYLRWq1oZt1pcAsXQ 1 1 4 0 8.9kb 8.9kb
-yellow open .ds-datahub_usage_event-000003 YMVcU8sHTFilUwyI4CWJJg 1 1 186 0 203.9kb 203.9kb
-yellow open datajob_datahubingestioncheckpointaspect_v1 nTXJf7C1Q3GoaIJ71gONxw 1 1 0 0 208b 208b
-yellow open .ds-datahub_usage_event-000004 XRFwisRPSJuSr6UVmmsCsg 1 1 196 0 165.5kb 165.5kb
-yellow open .ds-datahub_usage_event-000005 d0O6l5wIRLOyG6iIfAISGw 1 1 77 0 108.1kb 108.1kb
-yellow open dataplatformindex_v2_1643510671426 _4SIIhfAT8yq_WROufunXA 1 1 0 0 208b 208b
-yellow open mlmodeldeploymentindex_v2_1643510670629 n81eJIypSp2Qx-fpjZHgRw 1 1 0 0 208b 208b
-yellow open .ds-datahub_usage_event-000006 oyrWKndjQ-a8Rt1IMD9aSA 1 1 143 0 127.1kb 127.1kb
-yellow open mlfeaturetableindex_v2_1643510677164 iEXPt637S1OcilXpxPNYHw 1 1 5 0 8.9kb 8.9kb
-yellow open .ds-datahub_usage_event-000001 S9EnGj64TEW8O3sLUb9I2Q 1 1 257 0 163.9kb 163.9kb
-yellow open .ds-datahub_usage_event-000002 2xJyvKG_RYGwJOG9yq8pJw 1 1 44 0 155.4kb 155.4kb
-yellow open dataset_datasetprofileaspect_v1_1643510693373 uahwTHGRRAC7w1c2VqVy8g 1 1 31 0 18.9kb 18.9kb
-yellow open mlprimarykeyindex_v2_1643510687579 MUcmT8ASSASzEpLL98vrWg 1 1 7 0 9.5kb 9.5kb
-yellow open glossarytermindex_v2_1643510686127 cQL8Pg6uQeKfMly9GPhgFQ 1 1 3 0 10kb 10kb
-yellow open datajob_datahubingestionrunsummaryaspect_v1 rk22mIsDQ02-52MpWLm1DA 1 1 0 0 208b 208b
-yellow open mlmodelindex_v2_1643510675399 gk-WSTVjRZmkDU5ggeFSqg 1 1 1 0 10.3kb 10.3kb
-yellow open dashboardindex_v2_1643510691686 PQjSaGhTRqWW6zYjcqXo6Q 1 1 1 0 8.7kb 8.7kb
-yellow open datahubpolicyindex_v2_1643510671774 ZyTrYx3-Q1e-7dYq1kn5Gg 1 1 0 0 208b 208b
-yellow open datajobindex_v2_1643510682977 K-rbEyjBS6ew5uOQQS4sPw 1 1 2 0 11.3kb 11.3kb
-yellow open datahubretentionindex_v2 8XrQTPwRTX278mx1SrNwZA 1 1 0 0 208b 208b
-yellow open glossarynodeindex_v2_1643510678826 Y3_bCz0YR2KPwCrrVngDdA 1 1 1 0 7.4kb 7.4kb
-yellow open system_metadata_service_v1 36spEDbDTdKgVlSjE8t-Jw 1 1 387 8 63.2kb 63.2kb
-yellow open schemafieldindex_v2_1643510684410 tZ1gC3haTReRLmpCxirVxQ 1 1 0 0 208b 208b
-yellow open mlfeatureindex_v2_1643510680246 aQO5HF0mT62Znn-oIWBC8A 1 1 20 0 17.4kb 17.4kb
-yellow open tagindex_v2_1643510684785 PfnUdCUORY2fnF3I3W7HwA 1 1 3 1 18.6kb 18.6kb
-```
-
-The index name will vary from instance to instance. Indexed information about Datasets can be found in:
-`curl http://localhost:9200/datasetindex_v2_1643510688970/_search?=pretty`
-
-example information of a dataset:
-
-```
-{
- "_index" : "datasetindex_v2_1643510688970",
- "_type" : "_doc",
- "_id" : "urn%3Ali%3Adataset%3A%28urn%3Ali%3AdataPlatform%3Akafka%2CSampleKafkaDataset%2CPROD%29",
- "_score" : 1.0,
- "_source" : {
- "urn" : "urn:li:dataset:(urn:li:dataPlatform:kafka,SampleKafkaDataset,PROD)",
- "name" : "SampleKafkaDataset",
- "browsePaths" : [
- "/prod/kafka/SampleKafkaDataset"
- ],
- "origin" : "PROD",
- "customProperties" : [
- "prop2=pikachu",
- "prop1=fakeprop"
- ],
- "hasDescription" : false,
- "hasOwners" : true,
- "owners" : [
- "urn:li:corpuser:jdoe",
- "urn:li:corpuser:datahub"
- ],
- "fieldPaths" : [
- "[version=2.0].[type=boolean].field_foo_2",
- "[version=2.0].[type=boolean].field_bar",
- "[version=2.0].[key=True].[type=int].id"
- ],
- "fieldGlossaryTerms" : [ ],
- "fieldDescriptions" : [
- "Foo field description",
- "Bar field description",
- "Id specifying which partition the message should go to"
- ],
- "fieldTags" : [
- "urn:li:tag:NeedsDocumentation"
- ],
- "platform" : "urn:li:dataPlatform:kafka"
- }
- },
-```
-
-
-
-*Need more help? Join the conversation in [Slack](http://slack.datahubproject.io)!*
-
-### Related Features
-
-* [Metadata ingestion framework](../../metadata-ingestion/README.md)
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/core/mask/__init__.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/core/mask/__init__.py
deleted file mode 100644
index ab1e88bc686d5c2fe72b3114cb2b3e372e73a0f8..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/core/mask/__init__.py
+++ /dev/null
@@ -1,8 +0,0 @@
-from .mask_target import mask_target
-from .structures import BaseInstanceMasks, BitmapMasks, PolygonMasks
-from .utils import encode_mask_results, split_combined_polys
-
-__all__ = [
- 'split_combined_polys', 'mask_target', 'BaseInstanceMasks', 'BitmapMasks',
- 'PolygonMasks', 'encode_mask_results'
-]
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/datasets/coco.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/datasets/coco.py
deleted file mode 100644
index 3a8e1bcfdd7f2854ca381d4f87788e3a63eb568c..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/datasets/coco.py
+++ /dev/null
@@ -1,546 +0,0 @@
-import itertools
-import logging
-import os.path as osp
-import tempfile
-from collections import OrderedDict
-
-import mmcv
-import numpy as np
-import pycocotools
-from mmcv.utils import print_log
-from pycocotools.coco import COCO
-from pycocotools.cocoeval import COCOeval
-from terminaltables import AsciiTable
-
-from mmdet.core import eval_recalls
-from .builder import DATASETS
-from .custom import CustomDataset
-
-
-@DATASETS.register_module()
-class CocoDataset(CustomDataset):
-
- CLASSES = ('person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',
- 'train', 'truck', 'boat', 'traffic light', 'fire hydrant',
- 'stop sign', 'parking meter', 'bench', 'bird', 'cat', 'dog',
- 'horse', 'sheep', 'cow', 'elephant', 'bear', 'zebra', 'giraffe',
- 'backpack', 'umbrella', 'handbag', 'tie', 'suitcase', 'frisbee',
- 'skis', 'snowboard', 'sports ball', 'kite', 'baseball bat',
- 'baseball glove', 'skateboard', 'surfboard', 'tennis racket',
- 'bottle', 'wine glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',
- 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot',
- 'hot dog', 'pizza', 'donut', 'cake', 'chair', 'couch',
- 'potted plant', 'bed', 'dining table', 'toilet', 'tv', 'laptop',
- 'mouse', 'remote', 'keyboard', 'cell phone', 'microwave',
- 'oven', 'toaster', 'sink', 'refrigerator', 'book', 'clock',
- 'vase', 'scissors', 'teddy bear', 'hair drier', 'toothbrush')
-
- def load_annotations(self, ann_file):
- """Load annotation from COCO style annotation file.
-
- Args:
- ann_file (str): Path of annotation file.
-
- Returns:
- list[dict]: Annotation info from COCO api.
- """
- if not getattr(pycocotools, '__version__', '0') >= '12.0.2':
- raise AssertionError(
- 'Incompatible version of pycocotools is installed. '
- 'Run pip uninstall pycocotools first. Then run pip '
- 'install mmpycocotools to install open-mmlab forked '
- 'pycocotools.')
-
- self.coco = COCO(ann_file)
- self.cat_ids = self.coco.get_cat_ids(cat_names=self.CLASSES)
- self.cat2label = {cat_id: i for i, cat_id in enumerate(self.cat_ids)}
- self.img_ids = self.coco.get_img_ids()
- data_infos = []
- total_ann_ids = []
- for i in self.img_ids:
- info = self.coco.load_imgs([i])[0]
- info['filename'] = info['file_name']
- data_infos.append(info)
- ann_ids = self.coco.get_ann_ids(img_ids=[i])
- total_ann_ids.extend(ann_ids)
- assert len(set(total_ann_ids)) == len(
- total_ann_ids), f"Annotation ids in '{ann_file}' are not unique!"
- return data_infos
-
- def get_ann_info(self, idx):
- """Get COCO annotation by index.
-
- Args:
- idx (int): Index of data.
-
- Returns:
- dict: Annotation info of specified index.
- """
-
- img_id = self.data_infos[idx]['id']
- ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
- ann_info = self.coco.load_anns(ann_ids)
- return self._parse_ann_info(self.data_infos[idx], ann_info)
-
- def get_cat_ids(self, idx):
- """Get COCO category ids by index.
-
- Args:
- idx (int): Index of data.
-
- Returns:
- list[int]: All categories in the image of specified index.
- """
-
- img_id = self.data_infos[idx]['id']
- ann_ids = self.coco.get_ann_ids(img_ids=[img_id])
- ann_info = self.coco.load_anns(ann_ids)
- return [ann['category_id'] for ann in ann_info]
-
- def _filter_imgs(self, min_size=32):
- """Filter images too small or without ground truths."""
- valid_inds = []
- # obtain images that contain annotation
- ids_with_ann = set(_['image_id'] for _ in self.coco.anns.values())
- # obtain images that contain annotations of the required categories
- ids_in_cat = set()
- for i, class_id in enumerate(self.cat_ids):
- ids_in_cat |= set(self.coco.cat_img_map[class_id])
- # merge the image id sets of the two conditions and use the merged set
- # to filter out images if self.filter_empty_gt=True
- ids_in_cat &= ids_with_ann
-
- valid_img_ids = []
- for i, img_info in enumerate(self.data_infos):
- img_id = self.img_ids[i]
- if self.filter_empty_gt and img_id not in ids_in_cat:
- continue
- if min(img_info['width'], img_info['height']) >= min_size:
- valid_inds.append(i)
- valid_img_ids.append(img_id)
- self.img_ids = valid_img_ids
- return valid_inds
-
- def _parse_ann_info(self, img_info, ann_info):
- """Parse bbox and mask annotation.
-
- Args:
- ann_info (list[dict]): Annotation info of an image.
- with_mask (bool): Whether to parse mask annotations.
-
- Returns:
- dict: A dict containing the following keys: bboxes, bboxes_ignore,\
- labels, masks, seg_map. "masks" are raw annotations and not \
- decoded into binary masks.
- """
- gt_bboxes = []
- gt_labels = []
- gt_bboxes_ignore = []
- gt_masks_ann = []
- for i, ann in enumerate(ann_info):
- if ann.get('ignore', False):
- continue
- x1, y1, w, h = ann['bbox']
- inter_w = max(0, min(x1 + w, img_info['width']) - max(x1, 0))
- inter_h = max(0, min(y1 + h, img_info['height']) - max(y1, 0))
- if inter_w * inter_h == 0:
- continue
- if ann['area'] <= 0 or w < 1 or h < 1:
- continue
- if ann['category_id'] not in self.cat_ids:
- continue
- bbox = [x1, y1, x1 + w, y1 + h]
- if ann.get('iscrowd', False):
- gt_bboxes_ignore.append(bbox)
- else:
- gt_bboxes.append(bbox)
- gt_labels.append(self.cat2label[ann['category_id']])
- gt_masks_ann.append(ann.get('segmentation', None))
-
- if gt_bboxes:
- gt_bboxes = np.array(gt_bboxes, dtype=np.float32)
- gt_labels = np.array(gt_labels, dtype=np.int64)
- else:
- gt_bboxes = np.zeros((0, 4), dtype=np.float32)
- gt_labels = np.array([], dtype=np.int64)
-
- if gt_bboxes_ignore:
- gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)
- else:
- gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)
-
- seg_map = img_info['filename'].replace('jpg', 'png')
-
- ann = dict(
- bboxes=gt_bboxes,
- labels=gt_labels,
- bboxes_ignore=gt_bboxes_ignore,
- masks=gt_masks_ann,
- seg_map=seg_map)
-
- return ann
-
- def xyxy2xywh(self, bbox):
- """Convert ``xyxy`` style bounding boxes to ``xywh`` style for COCO
- evaluation.
-
- Args:
- bbox (numpy.ndarray): The bounding boxes, shape (4, ), in
- ``xyxy`` order.
-
- Returns:
- list[float]: The converted bounding boxes, in ``xywh`` order.
- """
-
- _bbox = bbox.tolist()
- return [
- _bbox[0],
- _bbox[1],
- _bbox[2] - _bbox[0],
- _bbox[3] - _bbox[1],
- ]
-
- def _proposal2json(self, results):
- """Convert proposal results to COCO json style."""
- json_results = []
- for idx in range(len(self)):
- img_id = self.img_ids[idx]
- bboxes = results[idx]
- for i in range(bboxes.shape[0]):
- data = dict()
- data['image_id'] = img_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(bboxes[i][4])
- data['category_id'] = 1
- json_results.append(data)
- return json_results
-
- def _det2json(self, results):
- """Convert detection results to COCO json style."""
- json_results = []
- for idx in range(len(self)):
- img_id = self.img_ids[idx]
- result = results[idx]
- for label in range(len(result)):
- bboxes = result[label]
- for i in range(bboxes.shape[0]):
- data = dict()
- data['image_id'] = img_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(bboxes[i][4])
- data['category_id'] = self.cat_ids[label]
- json_results.append(data)
- return json_results
-
- def _segm2json(self, results):
- """Convert instance segmentation results to COCO json style."""
- bbox_json_results = []
- segm_json_results = []
- for idx in range(len(self)):
- img_id = self.img_ids[idx]
- det, seg = results[idx]
- for label in range(len(det)):
- # bbox results
- bboxes = det[label]
- for i in range(bboxes.shape[0]):
- data = dict()
- data['image_id'] = img_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(bboxes[i][4])
- data['category_id'] = self.cat_ids[label]
- bbox_json_results.append(data)
-
- # segm results
- # some detectors use different scores for bbox and mask
- if isinstance(seg, tuple):
- segms = seg[0][label]
- mask_score = seg[1][label]
- else:
- segms = seg[label]
- mask_score = [bbox[4] for bbox in bboxes]
- for i in range(bboxes.shape[0]):
- data = dict()
- data['image_id'] = img_id
- data['bbox'] = self.xyxy2xywh(bboxes[i])
- data['score'] = float(mask_score[i])
- data['category_id'] = self.cat_ids[label]
- if isinstance(segms[i]['counts'], bytes):
- segms[i]['counts'] = segms[i]['counts'].decode()
- data['segmentation'] = segms[i]
- segm_json_results.append(data)
- return bbox_json_results, segm_json_results
-
- def results2json(self, results, outfile_prefix):
- """Dump the detection results to a COCO style json file.
-
- There are 3 types of results: proposals, bbox predictions, mask
- predictions, and they have different data types. This method will
- automatically recognize the type, and dump them to json files.
-
- Args:
- results (list[list | tuple | ndarray]): Testing results of the
- dataset.
- outfile_prefix (str): The filename prefix of the json files. If the
- prefix is "somepath/xxx", the json files will be named
- "somepath/xxx.bbox.json", "somepath/xxx.segm.json",
- "somepath/xxx.proposal.json".
-
- Returns:
- dict[str: str]: Possible keys are "bbox", "segm", "proposal", and \
- values are corresponding filenames.
- """
- result_files = dict()
- if isinstance(results[0], list):
- json_results = self._det2json(results)
- result_files['bbox'] = f'{outfile_prefix}.bbox.json'
- result_files['proposal'] = f'{outfile_prefix}.bbox.json'
- mmcv.dump(json_results, result_files['bbox'])
- elif isinstance(results[0], tuple):
- json_results = self._segm2json(results)
- result_files['bbox'] = f'{outfile_prefix}.bbox.json'
- result_files['proposal'] = f'{outfile_prefix}.bbox.json'
- result_files['segm'] = f'{outfile_prefix}.segm.json'
- mmcv.dump(json_results[0], result_files['bbox'])
- mmcv.dump(json_results[1], result_files['segm'])
- elif isinstance(results[0], np.ndarray):
- json_results = self._proposal2json(results)
- result_files['proposal'] = f'{outfile_prefix}.proposal.json'
- mmcv.dump(json_results, result_files['proposal'])
- else:
- raise TypeError('invalid type of results')
- return result_files
-
- def fast_eval_recall(self, results, proposal_nums, iou_thrs, logger=None):
- gt_bboxes = []
- for i in range(len(self.img_ids)):
- ann_ids = self.coco.get_ann_ids(img_ids=self.img_ids[i])
- ann_info = self.coco.load_anns(ann_ids)
- if len(ann_info) == 0:
- gt_bboxes.append(np.zeros((0, 4)))
- continue
- bboxes = []
- for ann in ann_info:
- if ann.get('ignore', False) or ann['iscrowd']:
- continue
- x1, y1, w, h = ann['bbox']
- bboxes.append([x1, y1, x1 + w, y1 + h])
- bboxes = np.array(bboxes, dtype=np.float32)
- if bboxes.shape[0] == 0:
- bboxes = np.zeros((0, 4))
- gt_bboxes.append(bboxes)
-
- recalls = eval_recalls(
- gt_bboxes, results, proposal_nums, iou_thrs, logger=logger)
- ar = recalls.mean(axis=1)
- return ar
-
- def format_results(self, results, jsonfile_prefix=None, **kwargs):
- """Format the results to json (standard format for COCO evaluation).
-
- Args:
- results (list[tuple | numpy.ndarray]): Testing results of the
- dataset.
- jsonfile_prefix (str | None): The prefix of json files. It includes
- the file path and the prefix of filename, e.g., "a/b/prefix".
- If not specified, a temp file will be created. Default: None.
-
- Returns:
- tuple: (result_files, tmp_dir), result_files is a dict containing \
- the json filepaths, tmp_dir is the temporal directory created \
- for saving json files when jsonfile_prefix is not specified.
- """
- assert isinstance(results, list), 'results must be a list'
- assert len(results) == len(self), (
- 'The length of results is not equal to the dataset len: {} != {}'.
- format(len(results), len(self)))
-
- if jsonfile_prefix is None:
- tmp_dir = tempfile.TemporaryDirectory()
- jsonfile_prefix = osp.join(tmp_dir.name, 'results')
- else:
- tmp_dir = None
- result_files = self.results2json(results, jsonfile_prefix)
- return result_files, tmp_dir
-
- def evaluate(self,
- results,
- metric='bbox',
- logger=None,
- jsonfile_prefix=None,
- classwise=False,
- proposal_nums=(100, 300, 1000),
- iou_thrs=None,
- metric_items=None):
- """Evaluation in COCO protocol.
-
- Args:
- results (list[list | tuple]): Testing results of the dataset.
- metric (str | list[str]): Metrics to be evaluated. Options are
- 'bbox', 'segm', 'proposal', 'proposal_fast'.
- logger (logging.Logger | str | None): Logger used for printing
- related information during evaluation. Default: None.
- jsonfile_prefix (str | None): The prefix of json files. It includes
- the file path and the prefix of filename, e.g., "a/b/prefix".
- If not specified, a temp file will be created. Default: None.
- classwise (bool): Whether to evaluating the AP for each class.
- proposal_nums (Sequence[int]): Proposal number used for evaluating
- recalls, such as recall@100, recall@1000.
- Default: (100, 300, 1000).
- iou_thrs (Sequence[float], optional): IoU threshold used for
- evaluating recalls/mAPs. If set to a list, the average of all
- IoUs will also be computed. If not specified, [0.50, 0.55,
- 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90, 0.95] will be used.
- Default: None.
- metric_items (list[str] | str, optional): Metric items that will
- be returned. If not specified, ``['AR@100', 'AR@300',
- 'AR@1000', 'AR_s@1000', 'AR_m@1000', 'AR_l@1000' ]`` will be
- used when ``metric=='proposal'``, ``['mAP', 'mAP_50', 'mAP_75',
- 'mAP_s', 'mAP_m', 'mAP_l']`` will be used when
- ``metric=='bbox' or metric=='segm'``.
-
- Returns:
- dict[str, float]: COCO style evaluation metric.
- """
-
- metrics = metric if isinstance(metric, list) else [metric]
- allowed_metrics = ['bbox', 'segm', 'proposal', 'proposal_fast']
- for metric in metrics:
- if metric not in allowed_metrics:
- raise KeyError(f'metric {metric} is not supported')
- if iou_thrs is None:
- iou_thrs = np.linspace(
- .5, 0.95, int(np.round((0.95 - .5) / .05)) + 1, endpoint=True)
- if metric_items is not None:
- if not isinstance(metric_items, list):
- metric_items = [metric_items]
-
- result_files, tmp_dir = self.format_results(results, jsonfile_prefix)
-
- eval_results = OrderedDict()
- cocoGt = self.coco
- for metric in metrics:
- msg = f'Evaluating {metric}...'
- if logger is None:
- msg = '\n' + msg
- print_log(msg, logger=logger)
-
- if metric == 'proposal_fast':
- ar = self.fast_eval_recall(
- results, proposal_nums, iou_thrs, logger='silent')
- log_msg = []
- for i, num in enumerate(proposal_nums):
- eval_results[f'AR@{num}'] = ar[i]
- log_msg.append(f'\nAR@{num}\t{ar[i]:.4f}')
- log_msg = ''.join(log_msg)
- print_log(log_msg, logger=logger)
- continue
-
- if metric not in result_files:
- raise KeyError(f'{metric} is not in results')
- try:
- cocoDt = cocoGt.loadRes(result_files[metric])
- except IndexError:
- print_log(
- 'The testing results of the whole dataset is empty.',
- logger=logger,
- level=logging.ERROR)
- break
-
- iou_type = 'bbox' if metric == 'proposal' else metric
- cocoEval = COCOeval(cocoGt, cocoDt, iou_type)
- cocoEval.params.catIds = self.cat_ids
- cocoEval.params.imgIds = self.img_ids
- cocoEval.params.maxDets = list(proposal_nums)
- cocoEval.params.iouThrs = iou_thrs
- # mapping of cocoEval.stats
- coco_metric_names = {
- 'mAP': 0,
- 'mAP_50': 1,
- 'mAP_75': 2,
- 'mAP_s': 3,
- 'mAP_m': 4,
- 'mAP_l': 5,
- 'AR@100': 6,
- 'AR@300': 7,
- 'AR@1000': 8,
- 'AR_s@1000': 9,
- 'AR_m@1000': 10,
- 'AR_l@1000': 11
- }
- if metric_items is not None:
- for metric_item in metric_items:
- if metric_item not in coco_metric_names:
- raise KeyError(
- f'metric item {metric_item} is not supported')
-
- if metric == 'proposal':
- cocoEval.params.useCats = 0
- cocoEval.evaluate()
- cocoEval.accumulate()
- cocoEval.summarize()
- if metric_items is None:
- metric_items = [
- 'AR@100', 'AR@300', 'AR@1000', 'AR_s@1000',
- 'AR_m@1000', 'AR_l@1000'
- ]
-
- for item in metric_items:
- val = float(
- f'{cocoEval.stats[coco_metric_names[item]]:.3f}')
- eval_results[item] = val
- else:
- cocoEval.evaluate()
- cocoEval.accumulate()
- cocoEval.summarize()
- if classwise: # Compute per-category AP
- # Compute per-category AP
- # from https://github.com/facebookresearch/detectron2/
- precisions = cocoEval.eval['precision']
- # precision: (iou, recall, cls, area range, max dets)
- assert len(self.cat_ids) == precisions.shape[2]
-
- results_per_category = []
- for idx, catId in enumerate(self.cat_ids):
- # area range index 0: all area ranges
- # max dets index -1: typically 100 per image
- nm = self.coco.loadCats(catId)[0]
- precision = precisions[:, :, idx, 0, -1]
- precision = precision[precision > -1]
- if precision.size:
- ap = np.mean(precision)
- else:
- ap = float('nan')
- results_per_category.append(
- (f'{nm["name"]}', f'{float(ap):0.3f}'))
-
- num_columns = min(6, len(results_per_category) * 2)
- results_flatten = list(
- itertools.chain(*results_per_category))
- headers = ['category', 'AP'] * (num_columns // 2)
- results_2d = itertools.zip_longest(*[
- results_flatten[i::num_columns]
- for i in range(num_columns)
- ])
- table_data = [headers]
- table_data += [result for result in results_2d]
- table = AsciiTable(table_data)
- print_log('\n' + table.table, logger=logger)
-
- if metric_items is None:
- metric_items = [
- 'mAP', 'mAP_50', 'mAP_75', 'mAP_s', 'mAP_m', 'mAP_l'
- ]
-
- for metric_item in metric_items:
- key = f'{metric}_{metric_item}'
- val = float(
- f'{cocoEval.stats[coco_metric_names[metric_item]]:.3f}'
- )
- eval_results[key] = val
- ap = cocoEval.stats[:6]
- eval_results[f'{metric}_mAP_copypaste'] = (
- f'{ap[0]:.3f} {ap[1]:.3f} {ap[2]:.3f} {ap[3]:.3f} '
- f'{ap[4]:.3f} {ap[5]:.3f}')
- if tmp_dir is not None:
- tmp_dir.cleanup()
- return eval_results
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/core/bbox/coder/yolo_bbox_coder.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/core/bbox/coder/yolo_bbox_coder.py
deleted file mode 100644
index 2f8a0be133b313b03b1dbadb5c59f29cdcaffa22..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/core/bbox/coder/yolo_bbox_coder.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import annotator.uniformer.mmcv as mmcv
-import torch
-
-from ..builder import BBOX_CODERS
-from .base_bbox_coder import BaseBBoxCoder
-
-
-@BBOX_CODERS.register_module()
-class YOLOBBoxCoder(BaseBBoxCoder):
- """YOLO BBox coder.
-
- Following `YOLO `_, this coder divide
- image into grids, and encode bbox (x1, y1, x2, y2) into (cx, cy, dw, dh).
- cx, cy in [0., 1.], denotes relative center position w.r.t the center of
- bboxes. dw, dh are the same as :obj:`DeltaXYWHBBoxCoder`.
-
- Args:
- eps (float): Min value of cx, cy when encoding.
- """
-
- def __init__(self, eps=1e-6):
- super(BaseBBoxCoder, self).__init__()
- self.eps = eps
-
- @mmcv.jit(coderize=True)
- def encode(self, bboxes, gt_bboxes, stride):
- """Get box regression transformation deltas that can be used to
- transform the ``bboxes`` into the ``gt_bboxes``.
-
- Args:
- bboxes (torch.Tensor): Source boxes, e.g., anchors.
- gt_bboxes (torch.Tensor): Target of the transformation, e.g.,
- ground-truth boxes.
- stride (torch.Tensor | int): Stride of bboxes.
-
- Returns:
- torch.Tensor: Box transformation deltas
- """
-
- assert bboxes.size(0) == gt_bboxes.size(0)
- assert bboxes.size(-1) == gt_bboxes.size(-1) == 4
- x_center_gt = (gt_bboxes[..., 0] + gt_bboxes[..., 2]) * 0.5
- y_center_gt = (gt_bboxes[..., 1] + gt_bboxes[..., 3]) * 0.5
- w_gt = gt_bboxes[..., 2] - gt_bboxes[..., 0]
- h_gt = gt_bboxes[..., 3] - gt_bboxes[..., 1]
- x_center = (bboxes[..., 0] + bboxes[..., 2]) * 0.5
- y_center = (bboxes[..., 1] + bboxes[..., 3]) * 0.5
- w = bboxes[..., 2] - bboxes[..., 0]
- h = bboxes[..., 3] - bboxes[..., 1]
- w_target = torch.log((w_gt / w).clamp(min=self.eps))
- h_target = torch.log((h_gt / h).clamp(min=self.eps))
- x_center_target = ((x_center_gt - x_center) / stride + 0.5).clamp(
- self.eps, 1 - self.eps)
- y_center_target = ((y_center_gt - y_center) / stride + 0.5).clamp(
- self.eps, 1 - self.eps)
- encoded_bboxes = torch.stack(
- [x_center_target, y_center_target, w_target, h_target], dim=-1)
- return encoded_bboxes
-
- @mmcv.jit(coderize=True)
- def decode(self, bboxes, pred_bboxes, stride):
- """Apply transformation `pred_bboxes` to `boxes`.
-
- Args:
- boxes (torch.Tensor): Basic boxes, e.g. anchors.
- pred_bboxes (torch.Tensor): Encoded boxes with shape
- stride (torch.Tensor | int): Strides of bboxes.
-
- Returns:
- torch.Tensor: Decoded boxes.
- """
- assert pred_bboxes.size(0) == bboxes.size(0)
- assert pred_bboxes.size(-1) == bboxes.size(-1) == 4
- x_center = (bboxes[..., 0] + bboxes[..., 2]) * 0.5
- y_center = (bboxes[..., 1] + bboxes[..., 3]) * 0.5
- w = bboxes[..., 2] - bboxes[..., 0]
- h = bboxes[..., 3] - bboxes[..., 1]
- # Get outputs x, y
- x_center_pred = (pred_bboxes[..., 0] - 0.5) * stride + x_center
- y_center_pred = (pred_bboxes[..., 1] - 0.5) * stride + y_center
- w_pred = torch.exp(pred_bboxes[..., 2]) * w
- h_pred = torch.exp(pred_bboxes[..., 3]) * h
-
- decoded_bboxes = torch.stack(
- (x_center_pred - w_pred / 2, y_center_pred - h_pred / 2,
- x_center_pred + w_pred / 2, y_center_pred + h_pred / 2),
- dim=-1)
-
- return decoded_bboxes
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/datasets/pipelines/instaboost.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/datasets/pipelines/instaboost.py
deleted file mode 100644
index 38b6819f60587a6e0c0f6d57bfda32bb3a7a4267..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet_null/datasets/pipelines/instaboost.py
+++ /dev/null
@@ -1,98 +0,0 @@
-import numpy as np
-
-from ..builder import PIPELINES
-
-
-@PIPELINES.register_module()
-class InstaBoost(object):
- r"""Data augmentation method in `InstaBoost: Boosting Instance
- Segmentation Via Probability Map Guided Copy-Pasting
- `_.
-
- Refer to https://github.com/GothicAi/Instaboost for implementation details.
- """
-
- def __init__(self,
- action_candidate=('normal', 'horizontal', 'skip'),
- action_prob=(1, 0, 0),
- scale=(0.8, 1.2),
- dx=15,
- dy=15,
- theta=(-1, 1),
- color_prob=0.5,
- hflag=False,
- aug_ratio=0.5):
- try:
- import instaboostfast as instaboost
- except ImportError:
- raise ImportError(
- 'Please run "pip install instaboostfast" '
- 'to install instaboostfast first for instaboost augmentation.')
- self.cfg = instaboost.InstaBoostConfig(action_candidate, action_prob,
- scale, dx, dy, theta,
- color_prob, hflag)
- self.aug_ratio = aug_ratio
-
- def _load_anns(self, results):
- labels = results['ann_info']['labels']
- masks = results['ann_info']['masks']
- bboxes = results['ann_info']['bboxes']
- n = len(labels)
-
- anns = []
- for i in range(n):
- label = labels[i]
- bbox = bboxes[i]
- mask = masks[i]
- x1, y1, x2, y2 = bbox
- # assert (x2 - x1) >= 1 and (y2 - y1) >= 1
- bbox = [x1, y1, x2 - x1, y2 - y1]
- anns.append({
- 'category_id': label,
- 'segmentation': mask,
- 'bbox': bbox
- })
-
- return anns
-
- def _parse_anns(self, results, anns, img):
- gt_bboxes = []
- gt_labels = []
- gt_masks_ann = []
- for ann in anns:
- x1, y1, w, h = ann['bbox']
- # TODO: more essential bug need to be fixed in instaboost
- if w <= 0 or h <= 0:
- continue
- bbox = [x1, y1, x1 + w, y1 + h]
- gt_bboxes.append(bbox)
- gt_labels.append(ann['category_id'])
- gt_masks_ann.append(ann['segmentation'])
- gt_bboxes = np.array(gt_bboxes, dtype=np.float32)
- gt_labels = np.array(gt_labels, dtype=np.int64)
- results['ann_info']['labels'] = gt_labels
- results['ann_info']['bboxes'] = gt_bboxes
- results['ann_info']['masks'] = gt_masks_ann
- results['img'] = img
- return results
-
- def __call__(self, results):
- img = results['img']
- orig_type = img.dtype
- anns = self._load_anns(results)
- if np.random.choice([0, 1], p=[1 - self.aug_ratio, self.aug_ratio]):
- try:
- import instaboostfast as instaboost
- except ImportError:
- raise ImportError('Please run "pip install instaboostfast" '
- 'to install instaboostfast first.')
- anns, img = instaboost.get_new_data(
- anns, img.astype(np.uint8), self.cfg, background=None)
-
- results = self._parse_anns(results, anns, img.astype(orig_type))
- return results
-
- def __repr__(self):
- repr_str = self.__class__.__name__
- repr_str += f'(cfg={self.cfg}, aug_ratio={self.aug_ratio})'
- return repr_str
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_g.py b/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_g.py
deleted file mode 100644
index 365549336f936ea2865640d1c467f1936be2157c..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_g.py
+++ /dev/null
@@ -1,49 +0,0 @@
-'''
- * Copyright (c) 2023 Salesforce, Inc.
- * All rights reserved.
- * SPDX-License-Identifier: Apache License 2.0
- * For full license text, see LICENSE.txt file in the repo root or http://www.apache.org/licenses/
- * By Can Qin
- * Modified from ControlNet repo: https://github.com/lllyasviel/ControlNet
- * Copyright (c) 2023 Lvmin Zhang and Maneesh Agrawala
- * Modified from UniFormer repo: From https://github.com/Sense-X/UniFormer
- * Apache-2.0 license
-'''
-_base_ = [
- '../../configs/_base_/models/upernet_uniformer.py',
- '../../configs/_base_/datasets/ade20k.py',
- '../../configs/_base_/default_runtime.py',
- '../../configs/_base_/schedules/schedule_160k.py'
-]
-model = dict(
- backbone=dict(
- type='UniFormer',
- embed_dim=[64, 128, 320, 512],
- layers=[5, 8, 20, 7],
- head_dim=64,
- drop_path_rate=0.4,
- windows=False,
- hybrid=False,
- ),
- decode_head=dict(
- in_channels=[64, 128, 320, 512],
- num_classes=150
- ),
- auxiliary_head=dict(
- in_channels=320,
- num_classes=150
- ))
-
-# AdamW optimizer, no weight decay for position embedding & layer norm in backbone
-optimizer = dict(_delete_=True, type='AdamW', lr=0.00006, betas=(0.9, 0.999), weight_decay=0.01,
- paramwise_cfg=dict(custom_keys={'absolute_pos_embed': dict(decay_mult=0.),
- 'relative_position_bias_table': dict(decay_mult=0.),
- 'norm': dict(decay_mult=0.)}))
-
-lr_config = dict(_delete_=True, policy='poly',
- warmup='linear',
- warmup_iters=1500,
- warmup_ratio=1e-6,
- power=1.0, min_lr=0.0, by_epoch=False)
-
-data=dict(samples_per_gpu=2)
\ No newline at end of file
diff --git a/spaces/abouuuud/poetry/app.py b/spaces/abouuuud/poetry/app.py
deleted file mode 100644
index 743e179975a957641a72c9206563bc53ca407c7b..0000000000000000000000000000000000000000
--- a/spaces/abouuuud/poetry/app.py
+++ /dev/null
@@ -1,53 +0,0 @@
-import gc
-import gradio as gr
-from transformers import pipeline, set_seed
-
-pipe = pipeline('text-generation', framework='pt', model='akhooli/ap2023', tokenizer='akhooli/ap2023')
-#gc.collect()
-samples = [['أنت'
- ,1.0, 50, 1.0, 1.0, 114],['هل غادر'
- ,1.0, 50, 1.0, 1.0, 114 ],['ألا ليت'
- ,1.0, 50, 1.0, 1.0, 114 ],['يا قدس'
- ,1.0, 50, 1.0, 1.0, 114],['عيد بأية حال'
- ,1.0, 50, 1.0, 1.0, 114],['لكل شيء إذا ما'
- ,1.0, 50, 1.0, 1.0, 114 ],['.'
- ,1.0, 50, 1.0, 1.0, 114]]
-
-notes = """
-- Enter a short prompt or select (click) one of the examples and click SEND
-- Adjust parameters (temperture, top k, top p and penalty) through the slider (keep close to default values).
-- For the same seed (randomness), the same output is regenerated if other parameters are fixed. Seed should be 0 or more (not empty)
-- Clear and enter new prompt or select another example and SEND to regenerate
-- The '.' means start a new line from no prompt (your prompt need not be long)
-- Be patient: this runs on CPU (free tier)
-- Feedback (Twitter): @akhooli (https://twitter.com/akhooli/status/1611025232201977859)
-- Note/Disclaimer: may generate unaccepted or inappropriate content. Use at your own risk.
-"""
-def sayPoetry(prompt, temp=1.0, topk = 50, topp = 1.0, penalty=1.0, seed=114):
- if not int(seed) >= 0: seed=114
- set_seed(seed)
- gen = pipe(prompt, max_length=96, do_sample=True, temperature=temp, top_k=topk, top_p=topp, repetition_penalty=penalty,
- min_length = 64, no_repeat_ngram_size = 3, return_full_text=True,
- num_beams=5, num_return_sequences=1)[0]["generated_text"]
- poetry =""
- for line in gen.split('.')[:-1]:
- poetry += line #+ "\n"
- return poetry
-poetry = gr.Interface(fn=sayPoetry,
- inputs=[
- gr.Textbox(label="Enter short prompt or select from examples:"),
- gr.Slider(0.70, 1.2, step=0.01,value=1.0, label='control temperature'),
- gr.Slider(25, 100, step=1,value=50, label='control top k'),
- gr.Slider(0.80, 1.0, step=0.01,value=1.0, label='control top p'),
- gr.Slider(0.90, 1.50, step=0.01,value=1.0, label='control penalty'),
- gr.Number(value=139750, precision=0, label='Seed'),
- ],
- outputs=[gr.Textbox(label="Generated Poetry:")],
-
- allow_flagging='never',
- title='Arabic Poetry Generation Demo (updated Jan. 2023)',
- description = "A simple demo of AI generated poetry based on 1M poems fine-tuned using AraGPT2 (be patient, runs on cpu)",
- examples=samples,
- cache_examples=False,
- article = notes)
-poetry.launch()
\ No newline at end of file
diff --git a/spaces/akhaliq/BlendGAN/ffhq_dataset/gen_aligned_image.py b/spaces/akhaliq/BlendGAN/ffhq_dataset/gen_aligned_image.py
deleted file mode 100644
index 7a67b204e3b67304b1e5e4963fee387cbfa58096..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/BlendGAN/ffhq_dataset/gen_aligned_image.py
+++ /dev/null
@@ -1,24 +0,0 @@
-import os
-
-from .face_alignment import image_align
-from .landmarks_detector import LandmarksDetector
-
-
-cur_dir = os.path.split(os.path.realpath(__file__))[0]
-model_path = os.path.join(cur_dir, 'shape_predictor_68_face_landmarks.dat')
-
-
-class FaceAlign:
- def __init__(self, predictor_model_path=model_path):
- self.landmarks_detector = LandmarksDetector(predictor_model_path)
-
- def get_crop_image(self, image):
- lms = []
- for i, face_landmarks in enumerate(self.landmarks_detector.get_landmarks(image), start=1):
- lms.append(face_landmarks)
- if len(lms) < 1:
- return None
- out_image = image_align(image, lms[0])
-
- return out_image
-
diff --git a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/utils/stdout.pl b/spaces/akhaliq/VQMIVC/ParallelWaveGAN/utils/stdout.pl
deleted file mode 100644
index 1636406b18c8d4c61cd2f04f83d41a5c6b42c299..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/VQMIVC/ParallelWaveGAN/utils/stdout.pl
+++ /dev/null
@@ -1,282 +0,0 @@
-#!/usr/bin/env perl
-use warnings; #sed replacement for -w perl parameter
-
-# In general, doing
-# run.pl some.log a b c is like running the command a b c in
-# the bash shell, and putting the standard error and output into some.log.
-# To run parallel jobs (backgrounded on the host machine), you can do (e.g.)
-# run.pl JOB=1:4 some.JOB.log a b c JOB is like running the command a b c JOB
-# and putting it in some.JOB.log, for each one. [Note: JOB can be any identifier].
-# If any of the jobs fails, this script will fail.
-
-# A typical example is:
-# run.pl some.log my-prog "--opt=foo bar" foo \| other-prog baz
-# and run.pl will run something like:
-# ( my-prog '--opt=foo bar' foo | other-prog baz ) >& some.log
-#
-# Basically it takes the command-line arguments, quotes them
-# as necessary to preserve spaces, and evaluates them with bash.
-# In addition it puts the command line at the top of the log, and
-# the start and end times of the command at the beginning and end.
-# The reason why this is useful is so that we can create a different
-# version of this program that uses a queueing system instead.
-
-# use Data::Dumper;
-
-@ARGV < 2 && die "usage: run.pl log-file command-line arguments...";
-
-
-$max_jobs_run = -1;
-$jobstart = 1;
-$jobend = 1;
-$ignored_opts = ""; # These will be ignored.
-
-# First parse an option like JOB=1:4, and any
-# options that would normally be given to
-# queue.pl, which we will just discard.
-
-for (my $x = 1; $x <= 2; $x++) { # This for-loop is to
- # allow the JOB=1:n option to be interleaved with the
- # options to qsub.
- while (@ARGV >= 2 && $ARGV[0] =~ m:^-:) {
- # parse any options that would normally go to qsub, but which will be ignored here.
- my $switch = shift @ARGV;
- if ($switch eq "-V") {
- $ignored_opts .= "-V ";
- } elsif ($switch eq "--max-jobs-run" || $switch eq "-tc") {
- # we do support the option --max-jobs-run n, and its GridEngine form -tc n.
- $max_jobs_run = shift @ARGV;
- if (! ($max_jobs_run > 0)) {
- die "run.pl: invalid option --max-jobs-run $max_jobs_run";
- }
- } else {
- my $argument = shift @ARGV;
- if ($argument =~ m/^--/) {
- print STDERR "run.pl: WARNING: suspicious argument '$argument' to $switch; starts with '-'\n";
- }
- if ($switch eq "-sync" && $argument =~ m/^[yY]/) {
- $ignored_opts .= "-sync "; # Note: in the
- # corresponding code in queue.pl it says instead, just "$sync = 1;".
- } elsif ($switch eq "-pe") { # e.g. -pe smp 5
- my $argument2 = shift @ARGV;
- $ignored_opts .= "$switch $argument $argument2 ";
- } elsif ($switch eq "--gpu") {
- $using_gpu = $argument;
- } else {
- # Ignore option.
- $ignored_opts .= "$switch $argument ";
- }
- }
- }
- if ($ARGV[0] =~ m/^([\w_][\w\d_]*)+=(\d+):(\d+)$/) { # e.g. JOB=1:20
- $jobname = $1;
- $jobstart = $2;
- $jobend = $3;
- shift;
- if ($jobstart > $jobend) {
- die "run.pl: invalid job range $ARGV[0]";
- }
- if ($jobstart <= 0) {
- die "run.pl: invalid job range $ARGV[0], start must be strictly positive (this is required for GridEngine compatibility).";
- }
- } elsif ($ARGV[0] =~ m/^([\w_][\w\d_]*)+=(\d+)$/) { # e.g. JOB=1.
- $jobname = $1;
- $jobstart = $2;
- $jobend = $2;
- shift;
- } elsif ($ARGV[0] =~ m/.+\=.*\:.*$/) {
- print STDERR "run.pl: Warning: suspicious first argument to run.pl: $ARGV[0]\n";
- }
-}
-
-# Users found this message confusing so we are removing it.
-# if ($ignored_opts ne "") {
-# print STDERR "run.pl: Warning: ignoring options \"$ignored_opts\"\n";
-# }
-
-if ($max_jobs_run == -1) { # If --max-jobs-run option not set,
- # then work out the number of processors if possible,
- # and set it based on that.
- $max_jobs_run = 0;
- if ($using_gpu) {
- if (open(P, "nvidia-smi -L |")) {
- $max_jobs_run++ while ();
- close(P);
- }
- if ($max_jobs_run == 0) {
- $max_jobs_run = 1;
- print STDERR "run.pl: Warning: failed to detect number of GPUs from nvidia-smi, using ${max_jobs_run}\n";
- }
- } elsif (open(P, ") { if (m/^processor/) { $max_jobs_run++; } }
- if ($max_jobs_run == 0) {
- print STDERR "run.pl: Warning: failed to detect any processors from /proc/cpuinfo\n";
- $max_jobs_run = 10; # reasonable default.
- }
- close(P);
- } elsif (open(P, "sysctl -a |")) { # BSD/Darwin
- while (
) {
- if (m/hw\.ncpu\s*[:=]\s*(\d+)/) { # hw.ncpu = 4, or hw.ncpu: 4
- $max_jobs_run = $1;
- last;
- }
- }
- close(P);
- if ($max_jobs_run == 0) {
- print STDERR "run.pl: Warning: failed to detect any processors from sysctl -a\n";
- $max_jobs_run = 10; # reasonable default.
- }
- } else {
- # allow at most 32 jobs at once, on non-UNIX systems; change this code
- # if you need to change this default.
- $max_jobs_run = 32;
- }
- # The just-computed value of $max_jobs_run is just the number of processors
- # (or our best guess); and if it happens that the number of jobs we need to
- # run is just slightly above $max_jobs_run, it will make sense to increase
- # $max_jobs_run to equal the number of jobs, so we don't have a small number
- # of leftover jobs.
- $num_jobs = $jobend - $jobstart + 1;
- if (!$using_gpu &&
- $num_jobs > $max_jobs_run && $num_jobs < 1.4 * $max_jobs_run) {
- $max_jobs_run = $num_jobs;
- }
-}
-
-$logfile = shift @ARGV;
-
-if (defined $jobname && $logfile !~ m/$jobname/ &&
- $jobend > $jobstart) {
- print STDERR "run.pl: you are trying to run a parallel job but "
- . "you are putting the output into just one log file ($logfile)\n";
- exit(1);
-}
-
-$cmd = "";
-
-foreach $x (@ARGV) {
- if ($x =~ m/^\S+$/) { $cmd .= $x . " "; }
- elsif ($x =~ m:\":) { $cmd .= "'$x' "; }
- else { $cmd .= "\"$x\" "; }
-}
-
-#$Data::Dumper::Indent=0;
-$ret = 0;
-$numfail = 0;
-%active_pids=();
-
-use POSIX ":sys_wait_h";
-for ($jobid = $jobstart; $jobid <= $jobend; $jobid++) {
- if (scalar(keys %active_pids) >= $max_jobs_run) {
-
- # Lets wait for a change in any child's status
- # Then we have to work out which child finished
- $r = waitpid(-1, 0);
- $code = $?;
- if ($r < 0 ) { die "run.pl: Error waiting for child process"; } # should never happen.
- if ( defined $active_pids{$r} ) {
- $jid=$active_pids{$r};
- $fail[$jid]=$code;
- if ($code !=0) { $numfail++;}
- delete $active_pids{$r};
- # print STDERR "Finished: $r/$jid " . Dumper(\%active_pids) . "\n";
- } else {
- die "run.pl: Cannot find the PID of the chold process that just finished.";
- }
-
- # In theory we could do a non-blocking waitpid over all jobs running just
- # to find out if only one or more jobs finished during the previous waitpid()
- # However, we just omit this and will reap the next one in the next pass
- # through the for(;;) cycle
- }
- $childpid = fork();
- if (!defined $childpid) { die "run.pl: Error forking in run.pl (writing to $logfile)"; }
- if ($childpid == 0) { # We're in the child... this branch
- # executes the job and returns (possibly with an error status).
- if (defined $jobname) {
- $cmd =~ s/$jobname/$jobid/g;
- $logfile =~ s/$jobname/$jobid/g;
- }
- system("mkdir -p `dirname $logfile` 2>/dev/null");
- open(F, ">$logfile") || die "run.pl: Error opening log file $logfile";
- print F "# " . $cmd . "\n";
- print F "# Started at " . `date`;
- $starttime = `date +'%s'`;
- print F "#\n";
- close(F);
-
- # Pipe into bash.. make sure we're not using any other shell.
- open(B, "|bash") || die "run.pl: Error opening shell command";
- print B "( " . $cmd . ") |& tee -a $logfile";
- close(B); # If there was an error, exit status is in $?
- $ret = $?;
-
- $lowbits = $ret & 127;
- $highbits = $ret >> 8;
- if ($lowbits != 0) { $return_str = "code $highbits; signal $lowbits" }
- else { $return_str = "code $highbits"; }
-
- $endtime = `date +'%s'`;
- open(F, ">>$logfile") || die "run.pl: Error opening log file $logfile (again)";
- $enddate = `date`;
- chop $enddate;
- print F "# Accounting: time=" . ($endtime - $starttime) . " threads=1\n";
- print F "# Ended ($return_str) at " . $enddate . ", elapsed time " . ($endtime-$starttime) . " seconds\n";
- close(F);
- exit($ret == 0 ? 0 : 1);
- } else {
- $pid[$jobid] = $childpid;
- $active_pids{$childpid} = $jobid;
- # print STDERR "Queued: " . Dumper(\%active_pids) . "\n";
- }
-}
-
-# Now we have submitted all the jobs, lets wait until all the jobs finish
-foreach $child (keys %active_pids) {
- $jobid=$active_pids{$child};
- $r = waitpid($pid[$jobid], 0);
- $code = $?;
- if ($r == -1) { die "run.pl: Error waiting for child process"; } # should never happen.
- if ($r != 0) { $fail[$jobid]=$code; $numfail++ if $code!=0; } # Completed successfully
-}
-
-# Some sanity checks:
-# The $fail array should not contain undefined codes
-# The number of non-zeros in that array should be equal to $numfail
-# We cannot do foreach() here, as the JOB ids do not necessarily start by zero
-$failed_jids=0;
-for ($jobid = $jobstart; $jobid <= $jobend; $jobid++) {
- $job_return = $fail[$jobid];
- if (not defined $job_return ) {
- # print Dumper(\@fail);
-
- die "run.pl: Sanity check failed: we have indication that some jobs are running " .
- "even after we waited for all jobs to finish" ;
- }
- if ($job_return != 0 ){ $failed_jids++;}
-}
-if ($failed_jids != $numfail) {
- die "run.pl: Sanity check failed: cannot find out how many jobs failed ($failed_jids x $numfail)."
-}
-if ($numfail > 0) { $ret = 1; }
-
-if ($ret != 0) {
- $njobs = $jobend - $jobstart + 1;
- if ($njobs == 1) {
- if (defined $jobname) {
- $logfile =~ s/$jobname/$jobstart/; # only one numbered job, so replace name with
- # that job.
- }
- print STDERR "run.pl: job failed, log is in $logfile\n";
- if ($logfile =~ m/JOB/) {
- print STDERR "run.pl: probably you forgot to put JOB=1:\$nj in your script.";
- }
- }
- else {
- $logfile =~ s/$jobname/*/g;
- print STDERR "run.pl: $numfail / $njobs failed, log is in $logfile\n";
- }
-}
-
-
-exit ($ret);
diff --git a/spaces/alamin655/Personas/conversant/prompts/__init__.py b/spaces/alamin655/Personas/conversant/prompts/__init__.py
deleted file mode 100644
index 91bb77de25885e0c9319874b329891884d167eb2..0000000000000000000000000000000000000000
--- a/spaces/alamin655/Personas/conversant/prompts/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (c) 2022 Cohere Inc. and its affiliates.
-#
-# Licensed under the MIT License (the "License");
-# you may not use this file except in compliance with the License.
-#
-# You may obtain a copy of the License in the LICENSE file at the top
-# level of this repository.
-
-from conversant.prompts.chat_prompt import ChatPrompt
-from conversant.prompts.prompt import Prompt
-from conversant.prompts.rewrite_prompt import RewritePrompt
-
-__all__ = ["Prompt", "ChatPrompt", "RewritePrompt"]
diff --git a/spaces/aldrinjenson/harry-potter-character-classifier/app.py b/spaces/aldrinjenson/harry-potter-character-classifier/app.py
deleted file mode 100644
index 7f188c2251191a7da21f443d87a1b76ae2500924..0000000000000000000000000000000000000000
--- a/spaces/aldrinjenson/harry-potter-character-classifier/app.py
+++ /dev/null
@@ -1,25 +0,0 @@
-from fastai.vision.all import *
-import gradio as gr
-
-title = "Harry Potter Character classifier"
-description = "A Harry Potter Character classifier trained with over 3000 images from the internet!"
-article = "
Created by Aldrin Jenson
"
-examples = ['sample_images/daniel_radcliffe-000001.jpeg', 'sample_images/daniel_radcliffe-000002.jpeg', 'sample_images/daniel_radcliffe-000003.jpeg', 'sample_images/daniel_radcliffe-000202.jpeg', 'sample_images/daniel_radcliffe-000324.jpeg', 'sample_images/daniel_radcliffe-000381.jpeg', 'sample_images/dracoMalfoy-000002.jpeg', 'sample_images/dracoMalfoy-000003.jpeg', 'sample_images/ginnyweasly-000001.jpeg',
- 'sample_images/ginnyweasly-000002.jpeg', 'sample_images/ginnyweasly-000003.jpeg', 'sample_images/ginnyweasly-000328.jpeg', 'sample_images/ginnyweasly-000365.jpeg', 'sample_images/ginnyweasly-000388.jpeg', 'sample_images/ginnyweasly-000404.jpeg', 'sample_images/groupPhoto-000423.jpeg', 'sample_images/lunaLovegood-000001.jpeg', 'sample_images/lunaLovegood-000002.jpeg', 'sample_images/lunaLovegood-000003.jpeg']
-interpretation = 'default'
-enable_queue = True
-
-
-learn = load_learner('export.pkl')
-labels = learn.dls.vocab
-
-
-def predict(img):
- img = PILImage.create(img)
- pred, pred_idx, probs = learn.predict(img)
- return {labels[i]: float(probs[i]) for i in range(len(labels))}
-
-
-interface = gr.Interface(fn=predict, inputs=gr.components.Image(shape=(512, 512)), outputs=gr.components.Label(
- num_top_classes=6), title=title, description=description, article=article, examples=examples, interpretation=interpretation)
-interface.launch(share=False, enable_queue=enable_queue)
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/cli/status_codes.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/cli/status_codes.py
deleted file mode 100644
index 5e29502cddfa9a9887a93399ab4193fb75dfe605..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_internal/cli/status_codes.py
+++ /dev/null
@@ -1,6 +0,0 @@
-SUCCESS = 0
-ERROR = 1
-UNKNOWN_ERROR = 2
-VIRTUALENV_NOT_FOUND = 3
-PREVIOUS_BUILD_DIR_ERROR = 4
-NO_MATCHES_FOUND = 23
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/spinner.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/spinner.py
deleted file mode 100644
index 5b13b1e9ba2c495ee4f00b8bc1f750625b7b6ff7..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/rich/spinner.py
+++ /dev/null
@@ -1,134 +0,0 @@
-from typing import cast, List, Optional, TYPE_CHECKING
-
-from ._spinners import SPINNERS
-from .measure import Measurement
-from .table import Table
-from .text import Text
-
-if TYPE_CHECKING:
- from .console import Console, ConsoleOptions, RenderResult, RenderableType
- from .style import StyleType
-
-
-class Spinner:
- def __init__(
- self,
- name: str,
- text: "RenderableType" = "",
- *,
- style: Optional["StyleType"] = None,
- speed: float = 1.0,
- ) -> None:
- """A spinner animation.
-
- Args:
- name (str): Name of spinner (run python -m rich.spinner).
- text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to "".
- style (StyleType, optional): Style for spinner animation. Defaults to None.
- speed (float, optional): Speed factor for animation. Defaults to 1.0.
-
- Raises:
- KeyError: If name isn't one of the supported spinner animations.
- """
- try:
- spinner = SPINNERS[name]
- except KeyError:
- raise KeyError(f"no spinner called {name!r}")
- self.text = Text.from_markup(text) if isinstance(text, str) else text
- self.frames = cast(List[str], spinner["frames"])[:]
- self.interval = cast(float, spinner["interval"])
- self.start_time: Optional[float] = None
- self.style = style
- self.speed = speed
- self.frame_no_offset: float = 0.0
- self._update_speed = 0.0
-
- def __rich_console__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> "RenderResult":
- yield self.render(console.get_time())
-
- def __rich_measure__(
- self, console: "Console", options: "ConsoleOptions"
- ) -> Measurement:
- text = self.render(0)
- return Measurement.get(console, options, text)
-
- def render(self, time: float) -> "RenderableType":
- """Render the spinner for a given time.
-
- Args:
- time (float): Time in seconds.
-
- Returns:
- RenderableType: A renderable containing animation frame.
- """
- if self.start_time is None:
- self.start_time = time
-
- frame_no = ((time - self.start_time) * self.speed) / (
- self.interval / 1000.0
- ) + self.frame_no_offset
- frame = Text(
- self.frames[int(frame_no) % len(self.frames)], style=self.style or ""
- )
-
- if self._update_speed:
- self.frame_no_offset = frame_no
- self.start_time = time
- self.speed = self._update_speed
- self._update_speed = 0.0
-
- if not self.text:
- return frame
- elif isinstance(self.text, (str, Text)):
- return Text.assemble(frame, " ", self.text)
- else:
- table = Table.grid(padding=1)
- table.add_row(frame, self.text)
- return table
-
- def update(
- self,
- *,
- text: "RenderableType" = "",
- style: Optional["StyleType"] = None,
- speed: Optional[float] = None,
- ) -> None:
- """Updates attributes of a spinner after it has been started.
-
- Args:
- text (RenderableType, optional): A renderable to display at the right of the spinner (str or Text typically). Defaults to "".
- style (StyleType, optional): Style for spinner animation. Defaults to None.
- speed (float, optional): Speed factor for animation. Defaults to None.
- """
- if text:
- self.text = Text.from_markup(text) if isinstance(text, str) else text
- if style:
- self.style = style
- if speed:
- self._update_speed = speed
-
-
-if __name__ == "__main__": # pragma: no cover
- from time import sleep
-
- from .columns import Columns
- from .panel import Panel
- from .live import Live
-
- all_spinners = Columns(
- [
- Spinner(spinner_name, text=Text(repr(spinner_name), style="green"))
- for spinner_name in sorted(SPINNERS.keys())
- ],
- column_first=True,
- expand=True,
- )
-
- with Live(
- Panel(all_spinners, title="Spinners", border_style="blue"),
- refresh_per_second=20,
- ) as live:
- while True:
- sleep(0.1)
diff --git a/spaces/algomuffin/jojo_fork/e4e/models/encoders/model_irse.py b/spaces/algomuffin/jojo_fork/e4e/models/encoders/model_irse.py
deleted file mode 100644
index 6a94d67542f961ff6533f0335cf4cb0fa54024fb..0000000000000000000000000000000000000000
--- a/spaces/algomuffin/jojo_fork/e4e/models/encoders/model_irse.py
+++ /dev/null
@@ -1,84 +0,0 @@
-from torch.nn import Linear, Conv2d, BatchNorm1d, BatchNorm2d, PReLU, Dropout, Sequential, Module
-from e4e.models.encoders.helpers import get_blocks, Flatten, bottleneck_IR, bottleneck_IR_SE, l2_norm
-
-"""
-Modified Backbone implementation from [TreB1eN](https://github.com/TreB1eN/InsightFace_Pytorch)
-"""
-
-
-class Backbone(Module):
- def __init__(self, input_size, num_layers, mode='ir', drop_ratio=0.4, affine=True):
- super(Backbone, self).__init__()
- assert input_size in [112, 224], "input_size should be 112 or 224"
- assert num_layers in [50, 100, 152], "num_layers should be 50, 100 or 152"
- assert mode in ['ir', 'ir_se'], "mode should be ir or ir_se"
- blocks = get_blocks(num_layers)
- if mode == 'ir':
- unit_module = bottleneck_IR
- elif mode == 'ir_se':
- unit_module = bottleneck_IR_SE
- self.input_layer = Sequential(Conv2d(3, 64, (3, 3), 1, 1, bias=False),
- BatchNorm2d(64),
- PReLU(64))
- if input_size == 112:
- self.output_layer = Sequential(BatchNorm2d(512),
- Dropout(drop_ratio),
- Flatten(),
- Linear(512 * 7 * 7, 512),
- BatchNorm1d(512, affine=affine))
- else:
- self.output_layer = Sequential(BatchNorm2d(512),
- Dropout(drop_ratio),
- Flatten(),
- Linear(512 * 14 * 14, 512),
- BatchNorm1d(512, affine=affine))
-
- modules = []
- for block in blocks:
- for bottleneck in block:
- modules.append(unit_module(bottleneck.in_channel,
- bottleneck.depth,
- bottleneck.stride))
- self.body = Sequential(*modules)
-
- def forward(self, x):
- x = self.input_layer(x)
- x = self.body(x)
- x = self.output_layer(x)
- return l2_norm(x)
-
-
-def IR_50(input_size):
- """Constructs a ir-50 model."""
- model = Backbone(input_size, num_layers=50, mode='ir', drop_ratio=0.4, affine=False)
- return model
-
-
-def IR_101(input_size):
- """Constructs a ir-101 model."""
- model = Backbone(input_size, num_layers=100, mode='ir', drop_ratio=0.4, affine=False)
- return model
-
-
-def IR_152(input_size):
- """Constructs a ir-152 model."""
- model = Backbone(input_size, num_layers=152, mode='ir', drop_ratio=0.4, affine=False)
- return model
-
-
-def IR_SE_50(input_size):
- """Constructs a ir_se-50 model."""
- model = Backbone(input_size, num_layers=50, mode='ir_se', drop_ratio=0.4, affine=False)
- return model
-
-
-def IR_SE_101(input_size):
- """Constructs a ir_se-101 model."""
- model = Backbone(input_size, num_layers=100, mode='ir_se', drop_ratio=0.4, affine=False)
- return model
-
-
-def IR_SE_152(input_size):
- """Constructs a ir_se-152 model."""
- model = Backbone(input_size, num_layers=152, mode='ir_se', drop_ratio=0.4, affine=False)
- return model
diff --git a/spaces/aliabd/SummerTime/tests/integration_test.py b/spaces/aliabd/SummerTime/tests/integration_test.py
deleted file mode 100644
index 7db778a36f613009b6166b7698c68e6c46a99305..0000000000000000000000000000000000000000
--- a/spaces/aliabd/SummerTime/tests/integration_test.py
+++ /dev/null
@@ -1,126 +0,0 @@
-import unittest
-
-from model.base_model import SummModel
-from model import SUPPORTED_SUMM_MODELS
-
-from pipeline import assemble_model_pipeline
-
-from evaluation.base_metric import SummMetric
-from evaluation import SUPPORTED_EVALUATION_METRICS
-
-from dataset.st_dataset import SummInstance, SummDataset
-from dataset import SUPPORTED_SUMM_DATASETS
-from dataset.dataset_loaders import ScisummnetDataset, ArxivDataset
-
-from helpers import print_with_color, retrieve_random_test_instances
-
-import random
-import time
-from typing import List, Union, Tuple
-import sys
-import re
-
-
-class IntegrationTests(unittest.TestCase):
- def get_prediction(
- self, model: SummModel, dataset: SummDataset, test_instances: List[SummInstance]
- ) -> Tuple[Union[List[str], List[List[str]]], Union[List[str], List[List[str]]]]:
- """
- Get summary prediction given model and dataset instances.
-
- :param SummModel `model`: Model for summarization task.
- :param SummDataset `dataset`: Dataset for summarization task.
- :param List[SummInstance] `test_instances`: Instances from `dataset` to summarize.
- :returns Tuple containing summary list of summary predictions and targets corresponding to each instance in `test_instances`.
- """
-
- src = (
- [ins.source[0] for ins in test_instances]
- if isinstance(dataset, ScisummnetDataset)
- else [ins.source for ins in test_instances]
- )
- tgt = [ins.summary for ins in test_instances]
- query = (
- [ins.query for ins in test_instances] if dataset.is_query_based else None
- )
- prediction = model.summarize(src, query)
- return prediction, tgt
-
- def get_eval_dict(self, metric: SummMetric, prediction: List[str], tgt: List[str]):
- """
- Run evaluation metric on summary prediction.
-
- :param SummMetric `metric`: Evaluation metric.
- :param List[str] `prediction`: Summary prediction instances.
- :param List[str] `tgt`: Target prediction instances from dataset.
- """
- score_dict = metric.evaluate(prediction, tgt)
- return score_dict
-
- def test_all(self):
- """
- Runs integration test on all compatible dataset + model + evaluation metric pipelines supported by SummerTime.
- """
-
- print_with_color("\nInitializing all evaluation metrics...", "35")
- evaluation_metrics = []
- for eval_cls in SUPPORTED_EVALUATION_METRICS:
- # # TODO: Temporarily skipping Rouge/RougeWE metrics to avoid local bug.
- # if eval_cls in [Rouge, RougeWe]:
- # continue
- print(eval_cls)
- evaluation_metrics.append(eval_cls())
-
- print_with_color("\n\nBeginning integration tests...", "35")
- for dataset_cls in SUPPORTED_SUMM_DATASETS:
- # TODO: Temporarily skipping Arxiv (size/time)
- if dataset_cls in [ArxivDataset]:
- continue
- dataset = dataset_cls()
- if dataset.train_set is not None:
- dataset_instances = list(dataset.train_set)
- print(
- f"\n{dataset.dataset_name} has a training set of {len(dataset_instances)} examples"
- )
- print_with_color(
- f"Initializing all matching model pipelines for {dataset.dataset_name} dataset...",
- "35",
- )
- # matching_model_instances = assemble_model_pipeline(dataset_cls, list(filter(lambda m: m != PegasusModel, SUPPORTED_SUMM_MODELS)))
- matching_model_instances = assemble_model_pipeline(
- dataset_cls, SUPPORTED_SUMM_MODELS
- )
- for model, model_name in matching_model_instances:
- test_instances = retrieve_random_test_instances(
- dataset_instances=dataset_instances, num_instances=1
- )
- print_with_color(
- f"{'#' * 20} Testing: {dataset.dataset_name} dataset, {model_name} model {'#' * 20}",
- "35",
- )
- prediction, tgt = self.get_prediction(
- model, dataset, test_instances
- )
- print(f"Prediction: {prediction}\nTarget: {tgt}\n")
- for metric in evaluation_metrics:
- print_with_color(f"{metric.metric_name} metric", "35")
- score_dict = self.get_eval_dict(metric, prediction, tgt)
- print(score_dict)
-
- print_with_color(
- f"{'#' * 20} Test for {dataset.dataset_name} dataset, {model_name} model COMPLETE {'#' * 20}\n\n",
- "32",
- )
-
-
-if __name__ == "__main__":
- if len(sys.argv) > 2 or (
- len(sys.argv) == 2 and not re.match("^\\d+$", sys.argv[1])
- ):
- print("Usage: python tests/integration_test.py [seed]", file=sys.stderr)
- sys.exit(1)
-
- seed = int(time.time()) if len(sys.argv) == 1 else int(sys.argv.pop())
- random.seed(seed)
- print_with_color(f"(to reproduce) random seeded with {seed}\n", "32")
- unittest.main()
diff --git a/spaces/andryMLOPS/ASTA-GPT-3.8_web_ui/client/css/conversation.css b/spaces/andryMLOPS/ASTA-GPT-3.8_web_ui/client/css/conversation.css
deleted file mode 100644
index d20f178c45e8ccbfc9539f99914b25fc572045bd..0000000000000000000000000000000000000000
--- a/spaces/andryMLOPS/ASTA-GPT-3.8_web_ui/client/css/conversation.css
+++ /dev/null
@@ -1,158 +0,0 @@
-.conversation {
- width: 60%;
- margin: 0px 16px;
- display: flex;
- flex-direction: column;
-}
-
-.conversation #messages {
- width: 100%;
- display: flex;
- flex-direction: column;
- overflow: auto;
- overflow-wrap: break-word;
- padding-bottom: 8px;
-}
-
-.conversation .user-input {
- max-height: 180px;
- margin: 16px 0px;
-}
-
-.conversation .user-input input {
- font-size: 1rem;
- background: none;
- border: none;
- outline: none;
- color: var(--colour-3);
-}
-
-.conversation .user-input input::placeholder {
- color: var(--user-input);
-}
-
-.conversation-title {
- color: var(--colour-3);
- font-size: 14px;
-}
-
-.conversation .user-input textarea {
- font-size: 1rem;
- width: 100%;
- height: 100%;
- padding: 12px;
- background: none;
- border: none;
- outline: none;
- color: var(--colour-3);
- resize: vertical;
- max-height: 150px;
- min-height: 80px;
-}
-
-.box {
- backdrop-filter: blur(20px);
- -webkit-backdrop-filter: blur(20px);
- background-color: var(--blur-bg);
- height: 100%;
- width: 100%;
- border-radius: var(--border-radius-1);
- border: 1px solid var(--blur-border);
-}
-
-.box.input-box {
- position: relative;
- align-items: center;
- padding: 8px;
- cursor: pointer;
-}
-
-#send-button {
- position: absolute;
- bottom: 25%;
- right: 10px;
- z-index: 1;
- padding: 16px;
-}
-
-#cursor {
- line-height: 17px;
- margin-left: 3px;
- -webkit-animation: blink 0.8s infinite;
- animation: blink 0.8s infinite;
- width: 7px;
- height: 15px;
-}
-
-@keyframes blink {
- 0% {
- background: #ffffff00;
- }
-
- 50% {
- background: white;
- }
-
- 100% {
- background: #ffffff00;
- }
-}
-
-@-webkit-keyframes blink {
- 0% {
- background: #ffffff00;
- }
-
- 50% {
- background: white;
- }
-
- 100% {
- background: #ffffff00;
- }
-}
-
-/* scrollbar */
-.conversation #messages::-webkit-scrollbar {
- width: 4px;
- padding: 8px 0px;
-}
-
-.conversation #messages::-webkit-scrollbar-track {
- background-color: #ffffff00;
-}
-
-.conversation #messages::-webkit-scrollbar-thumb {
- background-color: #555555;
- border-radius: 10px;
-}
-
-@media screen and (max-width: 990px) {
- .conversation {
- width: 100%;
- height: 90%;
- }
-}
-
-@media screen and (max-height: 720px) {
- .conversation.box {
- height: 70%;
- }
-
- .conversation .user-input textarea {
- font-size: 0.875rem;
- }
-}
-
-@media screen and (max-width: 360px) {
- .box {
- border-radius: 0;
- }
- .conversation {
- margin: 0;
- margin-top: 48px;
- }
- .conversation .user-input {
- margin: 2px 0 8px 0;
- }
-}
diff --git a/spaces/antonovmaxim/text-generation-webui-space/extensions/openai/cache_embedding_model.py b/spaces/antonovmaxim/text-generation-webui-space/extensions/openai/cache_embedding_model.py
deleted file mode 100644
index 44ac1dcd663d09a9f36bf9793ee2fa653339cbb3..0000000000000000000000000000000000000000
--- a/spaces/antonovmaxim/text-generation-webui-space/extensions/openai/cache_embedding_model.py
+++ /dev/null
@@ -1,8 +0,0 @@
-#!/usr/bin/env python3
-# preload the embedding model, useful for Docker images to prevent re-download on config change
-# Dockerfile:
-# ENV OPENEDAI_EMBEDDING_MODEL=all-mpnet-base-v2 # Optional
-# RUN python3 cache_embedded_model.py
-import os, sentence_transformers
-st_model = os.environ["OPENEDAI_EMBEDDING_MODEL"] if "OPENEDAI_EMBEDDING_MODEL" in os.environ else "all-mpnet-base-v2"
-model = sentence_transformers.SentenceTransformer(st_model)
diff --git a/spaces/anurag629/botaniscan/app/models/__init__.py b/spaces/anurag629/botaniscan/app/models/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/save_images.py b/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/save_images.py
deleted file mode 100644
index 8b6c60c5bfec5947b0a9bf7f9fb87512e97e5ad6..0000000000000000000000000000000000000000
--- a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/save_images.py
+++ /dev/null
@@ -1,80 +0,0 @@
-from typing import List, Tuple
-from einops import rearrange
-import numpy as np, os, torch
-from PIL import Image
-from torchvision.utils import make_grid
-import time
-
-
-def get_output_folder(output_path, batch_folder):
- out_path = os.path.join(output_path,time.strftime('%Y-%m'))
- if batch_folder != "":
- out_path = os.path.join(out_path, batch_folder)
- os.makedirs(out_path, exist_ok=True)
- return out_path
-
-
-def save_samples(
- args, x_samples: torch.Tensor, seed: int, n_rows: int
-) -> Tuple[Image.Image, List[Image.Image]]:
- """Function to save samples to disk.
- Args:
- args: Stable deforum diffusion arguments.
- x_samples: Samples to save.
- seed: Seed for the experiment.
- n_rows: Number of rows in the grid.
- Returns:
- A tuple of the grid image and a list of the generated images.
- ( grid_image, generated_images )
- """
-
- # save samples
- images = []
- grid_image = None
- if args.display_samples or args.save_samples:
- for index, x_sample in enumerate(x_samples):
- x_sample = 255.0 * rearrange(x_sample.cpu().numpy(), "c h w -> h w c")
- images.append(Image.fromarray(x_sample.astype(np.uint8)))
- if args.save_samples:
- images[-1].save(
- os.path.join(
- args.outdir, f"{args.timestring}_{index:02}_{seed}.png"
- )
- )
-
- # save grid
- if args.display_grid or args.save_grid:
- grid = torch.stack([x_samples], 0)
- grid = rearrange(grid, "n b c h w -> (n b) c h w")
- grid = make_grid(grid, nrow=n_rows, padding=0)
-
- # to image
- grid = 255.0 * rearrange(grid, "c h w -> h w c").cpu().numpy()
- grid_image = Image.fromarray(grid.astype(np.uint8))
- if args.save_grid:
- grid_image.save(
- os.path.join(args.outdir, f"{args.timestring}_{seed}_grid.png")
- )
-
- # return grid_image and individual sample images
- return grid_image, images
-
-def save_image(image, image_type, filename, args, video_args, root):
- if video_args.store_frames_in_ram:
- root.frames_cache.append({'path':os.path.join(args.outdir, filename), 'image':image, 'image_type':image_type})
- else:
- image.save(os.path.join(args.outdir, filename))
-
-import cv2, gc
-
-def reset_frames_cache(root):
- root.frames_cache = []
- gc.collect()
-
-def dump_frames_cache(root):
- for image_cache in root.frames_cache:
- if image_cache['image_type'] == 'cv2':
- cv2.imwrite(image_cache['path'], image_cache['image'])
- elif image_cache['image_type'] == 'PIL':
- image_cache['image'].save(image_cache['path'])
- # do not reset the cache since we're going to add frame erasing later function #TODO
diff --git a/spaces/arnavkartikeya/SCRIPture-final/data/__init__.py b/spaces/arnavkartikeya/SCRIPture-final/data/__init__.py
deleted file mode 100644
index 0be209acf415855ea6ef753efedf903b5decb6b9..0000000000000000000000000000000000000000
--- a/spaces/arnavkartikeya/SCRIPture-final/data/__init__.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import torch
-from torch.utils.data import DataLoader
-from torchvision import transforms
-from torchvision.transforms.functional import InterpolationMode
-
-from data.coco_karpathy_dataset import coco_karpathy_train, coco_karpathy_caption_eval, coco_karpathy_retrieval_eval
-from data.nocaps_dataset import nocaps_eval
-from data.flickr30k_dataset import flickr30k_train, flickr30k_retrieval_eval
-from data.vqa_dataset import vqa_dataset
-from data.nlvr_dataset import nlvr_dataset
-from data.pretrain_dataset import pretrain_dataset
-from transform.randaugment import RandomAugment
-
-def create_dataset(dataset, config, min_scale=0.5):
-
- normalize = transforms.Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711))
-
- transform_train = transforms.Compose([
- transforms.RandomResizedCrop(config['image_size'],scale=(min_scale, 1.0),interpolation=InterpolationMode.BICUBIC),
- transforms.RandomHorizontalFlip(),
- RandomAugment(2,5,isPIL=True,augs=['Identity','AutoContrast','Brightness','Sharpness','Equalize',
- 'ShearX', 'ShearY', 'TranslateX', 'TranslateY', 'Rotate']),
- transforms.ToTensor(),
- normalize,
- ])
- transform_test = transforms.Compose([
- transforms.Resize((config['image_size'],config['image_size']),interpolation=InterpolationMode.BICUBIC),
- transforms.ToTensor(),
- normalize,
- ])
-
- if dataset=='pretrain':
- dataset = pretrain_dataset(config['train_file'], config['laion_path'], transform_train)
- return dataset
-
- elif dataset=='caption_coco':
- train_dataset = coco_karpathy_train(transform_train, config['image_root'], config['ann_root'], prompt=config['prompt'])
- val_dataset = coco_karpathy_caption_eval(transform_test, config['image_root'], config['ann_root'], 'val')
- test_dataset = coco_karpathy_caption_eval(transform_test, config['image_root'], config['ann_root'], 'test')
- return train_dataset, val_dataset, test_dataset
-
- elif dataset=='nocaps':
- val_dataset = nocaps_eval(transform_test, config['image_root'], config['ann_root'], 'val')
- test_dataset = nocaps_eval(transform_test, config['image_root'], config['ann_root'], 'test')
- return val_dataset, test_dataset
-
- elif dataset=='retrieval_coco':
- train_dataset = coco_karpathy_train(transform_train, config['image_root'], config['ann_root'])
- val_dataset = coco_karpathy_retrieval_eval(transform_test, config['image_root'], config['ann_root'], 'val')
- test_dataset = coco_karpathy_retrieval_eval(transform_test, config['image_root'], config['ann_root'], 'test')
- return train_dataset, val_dataset, test_dataset
-
- elif dataset=='retrieval_flickr':
- train_dataset = flickr30k_train(transform_train, config['image_root'], config['ann_root'])
- val_dataset = flickr30k_retrieval_eval(transform_test, config['image_root'], config['ann_root'], 'val')
- test_dataset = flickr30k_retrieval_eval(transform_test, config['image_root'], config['ann_root'], 'test')
- return train_dataset, val_dataset, test_dataset
-
- elif dataset=='vqa':
- train_dataset = vqa_dataset(transform_train, config['ann_root'], config['vqa_root'], config['vg_root'],
- train_files = config['train_files'], split='train')
- test_dataset = vqa_dataset(transform_test, config['ann_root'], config['vqa_root'], config['vg_root'], split='test')
- return train_dataset, test_dataset
-
- elif dataset=='nlvr':
- train_dataset = nlvr_dataset(transform_train, config['image_root'], config['ann_root'],'train')
- val_dataset = nlvr_dataset(transform_test, config['image_root'], config['ann_root'],'val')
- test_dataset = nlvr_dataset(transform_test, config['image_root'], config['ann_root'],'test')
- return train_dataset, val_dataset, test_dataset
-
-
-def create_sampler(datasets, shuffles, num_tasks, global_rank):
- samplers = []
- for dataset,shuffle in zip(datasets,shuffles):
- sampler = torch.utils.data.DistributedSampler(dataset, num_replicas=num_tasks, rank=global_rank, shuffle=shuffle)
- samplers.append(sampler)
- return samplers
-
-
-def create_loader(datasets, samplers, batch_size, num_workers, is_trains, collate_fns):
- loaders = []
- for dataset,sampler,bs,n_worker,is_train,collate_fn in zip(datasets,samplers,batch_size,num_workers,is_trains,collate_fns):
- if is_train:
- shuffle = (sampler is None)
- drop_last = True
- else:
- shuffle = False
- drop_last = False
- loader = DataLoader(
- dataset,
- batch_size=bs,
- num_workers=n_worker,
- pin_memory=True,
- sampler=sampler,
- shuffle=shuffle,
- collate_fn=collate_fn,
- drop_last=drop_last,
- )
- loaders.append(loader)
- return loaders
-
diff --git a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/utils/text/punctuation.py b/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/utils/text/punctuation.py
deleted file mode 100644
index 8d199cc545b36f6089056d904fd0a03670012c4d..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/utils/text/punctuation.py
+++ /dev/null
@@ -1,172 +0,0 @@
-import collections
-import re
-from enum import Enum
-
-import six
-
-_DEF_PUNCS = ';:,.!?¡¿—…"«»“”'
-
-_PUNC_IDX = collections.namedtuple("_punc_index", ["punc", "position"])
-
-
-class PuncPosition(Enum):
- """Enum for the punctuations positions"""
-
- BEGIN = 0
- END = 1
- MIDDLE = 2
- ALONE = 3
-
-
-class Punctuation:
- """Handle punctuations in text.
-
- Just strip punctuations from text or strip and restore them later.
-
- Args:
- puncs (str): The punctuations to be processed. Defaults to `_DEF_PUNCS`.
-
- Example:
- >>> punc = Punctuation()
- >>> punc.strip("This is. example !")
- 'This is example'
-
- >>> text_striped, punc_map = punc.strip_to_restore("This is. example !")
- >>> ' '.join(text_striped)
- 'This is example'
-
- >>> text_restored = punc.restore(text_striped, punc_map)
- >>> text_restored[0]
- 'This is. example !'
- """
-
- def __init__(self, puncs: str = _DEF_PUNCS):
- self.puncs = puncs
-
- @staticmethod
- def default_puncs():
- """Return default set of punctuations."""
- return _DEF_PUNCS
-
- @property
- def puncs(self):
- return self._puncs
-
- @puncs.setter
- def puncs(self, value):
- if not isinstance(value, six.string_types):
- raise ValueError("[!] Punctuations must be of type str.")
- self._puncs = "".join(list(dict.fromkeys(list(value)))) # remove duplicates without changing the oreder
- self.puncs_regular_exp = re.compile(rf"(\s*[{re.escape(self._puncs)}]+\s*)+")
-
- def strip(self, text):
- """Remove all the punctuations by replacing with `space`.
-
- Args:
- text (str): The text to be processed.
-
- Example::
-
- "This is. example !" -> "This is example "
- """
- return re.sub(self.puncs_regular_exp, " ", text).rstrip().lstrip()
-
- def strip_to_restore(self, text):
- """Remove punctuations from text to restore them later.
-
- Args:
- text (str): The text to be processed.
-
- Examples ::
-
- "This is. example !" -> [["This is", "example"], [".", "!"]]
-
- """
- text, puncs = self._strip_to_restore(text)
- return text, puncs
-
- def _strip_to_restore(self, text):
- """Auxiliary method for Punctuation.preserve()"""
- matches = list(re.finditer(self.puncs_regular_exp, text))
- if not matches:
- return [text], []
- # the text is only punctuations
- if len(matches) == 1 and matches[0].group() == text:
- return [], [_PUNC_IDX(text, PuncPosition.ALONE)]
- # build a punctuation map to be used later to restore punctuations
- puncs = []
- for match in matches:
- position = PuncPosition.MIDDLE
- if match == matches[0] and text.startswith(match.group()):
- position = PuncPosition.BEGIN
- elif match == matches[-1] and text.endswith(match.group()):
- position = PuncPosition.END
- puncs.append(_PUNC_IDX(match.group(), position))
- # convert str text to a List[str], each item is separated by a punctuation
- splitted_text = []
- for idx, punc in enumerate(puncs):
- split = text.split(punc.punc)
- prefix, suffix = split[0], punc.punc.join(split[1:])
- splitted_text.append(prefix)
- # if the text does not end with a punctuation, add it to the last item
- if idx == len(puncs) - 1 and len(suffix) > 0:
- splitted_text.append(suffix)
- text = suffix
- return splitted_text, puncs
-
- @classmethod
- def restore(cls, text, puncs):
- """Restore punctuation in a text.
-
- Args:
- text (str): The text to be processed.
- puncs (List[str]): The list of punctuations map to be used for restoring.
-
- Examples ::
-
- ['This is', 'example'], ['.', '!'] -> "This is. example!"
-
- """
- return cls._restore(text, puncs, 0)
-
- @classmethod
- def _restore(cls, text, puncs, num): # pylint: disable=too-many-return-statements
- """Auxiliary method for Punctuation.restore()"""
- if not puncs:
- return text
-
- # nothing have been phonemized, returns the puncs alone
- if not text:
- return ["".join(m.punc for m in puncs)]
-
- current = puncs[0]
-
- if current.position == PuncPosition.BEGIN:
- return cls._restore([current.punc + text[0]] + text[1:], puncs[1:], num)
-
- if current.position == PuncPosition.END:
- return [text[0] + current.punc] + cls._restore(text[1:], puncs[1:], num + 1)
-
- if current.position == PuncPosition.ALONE:
- return [current.mark] + cls._restore(text, puncs[1:], num + 1)
-
- # POSITION == MIDDLE
- if len(text) == 1: # pragma: nocover
- # a corner case where the final part of an intermediate
- # mark (I) has not been phonemized
- return cls._restore([text[0] + current.punc], puncs[1:], num)
-
- return cls._restore([text[0] + current.punc + text[1]] + text[2:], puncs[1:], num)
-
-
-# if __name__ == "__main__":
-# punc = Punctuation()
-# text = "This is. This is, example!"
-
-# print(punc.strip(text))
-
-# split_text, puncs = punc.strip_to_restore(text)
-# print(split_text, " ---- ", puncs)
-
-# restored_text = punc.restore(split_text, puncs)
-# print(restored_text)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Tests/TestTreeFragment.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Tests/TestTreeFragment.py
deleted file mode 100644
index 9ee8da5478cb5f2054ccb07a4306b6b35be0f310..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/Cython/Compiler/Tests/TestTreeFragment.py
+++ /dev/null
@@ -1,64 +0,0 @@
-from Cython.TestUtils import CythonTest
-from Cython.Compiler.TreeFragment import *
-from Cython.Compiler.Nodes import *
-from Cython.Compiler.UtilNodes import *
-import Cython.Compiler.Naming as Naming
-
-class TestTreeFragments(CythonTest):
-
- def test_basic(self):
- F = self.fragment(u"x = 4")
- T = F.copy()
- self.assertCode(u"x = 4", T)
-
- def test_copy_is_taken(self):
- F = self.fragment(u"if True: x = 4")
- T1 = F.root
- T2 = F.copy()
- self.assertEqual("x", T2.stats[0].if_clauses[0].body.lhs.name)
- T2.stats[0].if_clauses[0].body.lhs.name = "other"
- self.assertEqual("x", T1.stats[0].if_clauses[0].body.lhs.name)
-
- def test_substitutions_are_copied(self):
- T = self.fragment(u"y + y").substitute({"y": NameNode(pos=None, name="x")})
- self.assertEqual("x", T.stats[0].expr.operand1.name)
- self.assertEqual("x", T.stats[0].expr.operand2.name)
- self.assertTrue(T.stats[0].expr.operand1 is not T.stats[0].expr.operand2)
-
- def test_substitution(self):
- F = self.fragment(u"x = 4")
- y = NameNode(pos=None, name=u"y")
- T = F.substitute({"x" : y})
- self.assertCode(u"y = 4", T)
-
- def test_exprstat(self):
- F = self.fragment(u"PASS")
- pass_stat = PassStatNode(pos=None)
- T = F.substitute({"PASS" : pass_stat})
- self.assertTrue(isinstance(T.stats[0], PassStatNode), T)
-
- def test_pos_is_transferred(self):
- F = self.fragment(u"""
- x = y
- x = u * v ** w
- """)
- T = F.substitute({"v" : NameNode(pos=None, name="a")})
- v = F.root.stats[1].rhs.operand2.operand1
- a = T.stats[1].rhs.operand2.operand1
- self.assertEqual(v.pos, a.pos)
-
- def test_temps(self):
- TemplateTransform.temp_name_counter = 0
- F = self.fragment(u"""
- TMP
- x = TMP
- """)
- T = F.substitute(temps=[u"TMP"])
- s = T.body.stats
- self.assertTrue(isinstance(s[0].expr, TempRefNode))
- self.assertTrue(isinstance(s[1].rhs, TempRefNode))
- self.assertTrue(s[0].expr.handle is s[1].rhs.handle)
-
-if __name__ == "__main__":
- import unittest
- unittest.main()
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/anscombe_plot.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/anscombe_plot.py
deleted file mode 100644
index 9e200748533871f26f7e27c98a9fe82da1c0a47c..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/altair/examples/anscombe_plot.py
+++ /dev/null
@@ -1,20 +0,0 @@
-"""
-Anscombe's Quartet
-------------------
-
-This example shows how to use the column channel to make a trellis plot. Anscombe's Quartet is a famous dataset constructed by Francis Anscombe. Common summary statistics are identical for each subset of the data, despite the subsets having vastly different characteristics.
-"""
-# category: case studies
-import altair as alt
-from vega_datasets import data
-
-source = data.anscombe()
-
-alt.Chart(source).mark_circle().encode(
- alt.X('X', scale=alt.Scale(zero=False)),
- alt.Y('Y', scale=alt.Scale(zero=False)),
- alt.Facet('Series', columns=2),
-).properties(
- width=180,
- height=180,
-)
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/__init__.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/__init__.py
deleted file mode 100644
index 25408d28ec44cee56eb5fb3ab0c817dc04159e95..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/dataclass/__init__.py
+++ /dev/null
@@ -1,13 +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.
-
-from .configs import FairseqDataclass
-from .constants import ChoiceEnum
-
-
-__all__ = [
- "FairseqDataclass",
- "ChoiceEnum",
-]
diff --git a/spaces/awacke1/1-SimPhysics/README.md b/spaces/awacke1/1-SimPhysics/README.md
deleted file mode 100644
index b31a6ae704f0373db4e2fb14898ade5c42afb191..0000000000000000000000000000000000000000
--- a/spaces/awacke1/1-SimPhysics/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: 🏖️PlayCanvas Simulation Vehicle Physics⛱️🌊 Live HTML5
-emoji: 1-Sim🌊
-colorFrom: green
-colorTo: gray
-sdk: static
-pinned: false
----
-
-Inspired by Danny Lange, VP AI and ML at Unity
-Reference: https://youtu.be/YsEDv13W1RI?t=48
-
-Quote on MLAgents: ... if you think about what I just said about evolution and that the creation of tools for intelligence yeah so you have the basic nature you have the 3d spatial environment you have gravity and you have inertia and the physics engine and now we throw in ml agents which is a machine learning system
-
diff --git a/spaces/awacke1/Data-Augmentation/README.md b/spaces/awacke1/Data-Augmentation/README.md
deleted file mode 100644
index f6266d46578b1a850a6bd09a6ec049220a241ce3..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Data-Augmentation/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Data Augmentation
-emoji: 🏢
-colorFrom: pink
-colorTo: pink
-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
\ No newline at end of file
diff --git a/spaces/awacke1/Gamification-Grabble/README.md b/spaces/awacke1/Gamification-Grabble/README.md
deleted file mode 100644
index ae064eb79d0ae27f9f56d31eb74014eb7ed533b7..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Gamification-Grabble/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Gamification Grabble
-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/PerceiverEmotionClassifier/source/pipeline.py b/spaces/awacke1/PerceiverEmotionClassifier/source/pipeline.py
deleted file mode 100644
index b1f42e4d9a2acf165418e146384fbe6240dd4f9f..0000000000000000000000000000000000000000
--- a/spaces/awacke1/PerceiverEmotionClassifier/source/pipeline.py
+++ /dev/null
@@ -1,127 +0,0 @@
-from typing import List
-
-import torch
-from datasets import Dataset
-from torch.utils.data import DataLoader
-from tqdm import tqdm
-from transformers import PerceiverTokenizer
-
-
-def _map_outputs(predictions):
- """
- Map model outputs to classes.
- :param predictions: model ouptut batch
- :return:
- """
-
- labels = [
- "admiration",
- "amusement",
- "anger",
- "annoyance",
- "approval",
- "caring",
- "confusion",
- "curiosity",
- "desire",
- "disappointment",
- "disapproval",
- "disgust",
- "embarrassment",
- "excitement",
- "fear",
- "gratitude",
- "grief",
- "joy",
- "love",
- "nervousness",
- "optimism",
- "pride",
- "realization",
- "relief",
- "remorse",
- "sadness",
- "surprise",
- "neutral"
- ]
- classes = []
- for i, example in enumerate(predictions):
- out_batch = []
- for j, category in enumerate(example):
- out_batch.append(labels[j]) if category > 0.5 else None
- classes.append(out_batch)
- return classes
-
-
-class MultiLabelPipeline:
- """
- Multi label classification pipeline.
- """
-
- def __init__(self, model_path):
- """
- Init MLC pipeline.
- :param model_path: model to use
- """
-
- # Init attributes
- self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
- if self.device == 'cuda':
- self.model = torch.load(model_path).eval().to(self.device)
- else:
- self.model = torch.load(model_path, map_location=torch.device('cpu')).eval().to(self.device)
- self.tokenizer = PerceiverTokenizer.from_pretrained('deepmind/language-perceiver')
-
- def __call__(self, dataset, batch_size: int = 4):
- """
- Processing pipeline.
- :param dataset: dataset
- :return:
- """
-
- # Tokenize inputs
- dataset = dataset.map(lambda row: self.tokenizer(row['text'], padding="max_length", truncation=True),
- batched=True, remove_columns=['text'], desc='Tokenizing')
- dataset.set_format('torch', columns=['input_ids', 'attention_mask'])
- dataloader = DataLoader(dataset, batch_size=batch_size)
-
- # Define output classes
- classes = []
- mem_logs = []
-
- with tqdm(dataloader, unit='batches') as progression:
- for batch in progression:
- progression.set_description('Inference')
- # Forward
- outputs = self.model(inputs=batch['input_ids'].to(self.device),
- attention_mask=batch['attention_mask'].to(self.device), )
-
- # Outputs
- predictions = outputs.logits.cpu().detach().numpy()
-
- # Map predictions to classes
- batch_classes = _map_outputs(predictions)
-
- for row in batch_classes:
- classes.append(row)
-
- # Retrieve memory usage
- memory = round(torch.cuda.memory_reserved(self.device) / 1e9, 2)
- mem_logs.append(memory)
-
- # Update pbar
- progression.set_postfix(memory=f"{round(sum(mem_logs) / len(mem_logs), 2)}Go")
-
- return classes
-
-
-def inputs_to_dataset(inputs: List[str]):
- """
- Convert a list of strings to a dataset object.
- :param inputs: list of strings
- :return:
- """
-
- inputs = {'text': [input for input in inputs]}
-
- return Dataset.from_dict(inputs)
diff --git a/spaces/awacke1/PyGame2D/README.md b/spaces/awacke1/PyGame2D/README.md
deleted file mode 100644
index 3f849f64cc0e42472386168e82ecdca7a83dde9a..0000000000000000000000000000000000000000
--- a/spaces/awacke1/PyGame2D/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: PyGame2D
-emoji: ⚡
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.4
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/awacke1/QRCodeAIWriterReaderImaging/README.md b/spaces/awacke1/QRCodeAIWriterReaderImaging/README.md
deleted file mode 100644
index 8965615b8c76f399bd6a0254fd52b4b236094713..0000000000000000000000000000000000000000
--- a/spaces/awacke1/QRCodeAIWriterReaderImaging/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: QRCodeAIWriterReaderImaging
-emoji: 🏆
-colorFrom: yellow
-colorTo: green
-sdk: gradio
-sdk_version: 3.35.2
-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/awaiss/vits-models/utils.py b/spaces/awaiss/vits-models/utils.py
deleted file mode 100644
index ee4b01ddfbe8173965371b29f770f3e87615fe71..0000000000000000000000000000000000000000
--- a/spaces/awaiss/vits-models/utils.py
+++ /dev/null
@@ -1,225 +0,0 @@
-import os
-import sys
-import argparse
-import logging
-import json
-import subprocess
-import numpy as np
-import librosa
-import torch
-
-MATPLOTLIB_FLAG = False
-
-logging.basicConfig(stream=sys.stdout, level=logging.DEBUG)
-logger = logging
-
-
-def load_checkpoint(checkpoint_path, model, optimizer=None):
- assert os.path.isfile(checkpoint_path)
- checkpoint_dict = torch.load(checkpoint_path, map_location='cpu')
- iteration = checkpoint_dict['iteration']
- learning_rate = checkpoint_dict['learning_rate']
- if optimizer is not None:
- optimizer.load_state_dict(checkpoint_dict['optimizer'])
- saved_state_dict = checkpoint_dict['model']
- if hasattr(model, 'module'):
- state_dict = model.module.state_dict()
- else:
- state_dict = model.state_dict()
- new_state_dict= {}
- for k, v in state_dict.items():
- try:
- new_state_dict[k] = saved_state_dict[k]
- except:
- logger.info("%s is not in the checkpoint" % k)
- new_state_dict[k] = v
- if hasattr(model, 'module'):
- model.module.load_state_dict(new_state_dict)
- else:
- model.load_state_dict(new_state_dict)
- logger.info("Loaded checkpoint '{}' (iteration {})" .format(
- checkpoint_path, iteration))
- return model, optimizer, learning_rate, iteration
-
-
-def plot_spectrogram_to_numpy(spectrogram):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(10,2))
- im = ax.imshow(spectrogram, aspect="auto", origin="lower",
- interpolation='none')
- plt.colorbar(im, ax=ax)
- plt.xlabel("Frames")
- plt.ylabel("Channels")
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def plot_alignment_to_numpy(alignment, info=None):
- global MATPLOTLIB_FLAG
- if not MATPLOTLIB_FLAG:
- import matplotlib
- matplotlib.use("Agg")
- MATPLOTLIB_FLAG = True
- mpl_logger = logging.getLogger('matplotlib')
- mpl_logger.setLevel(logging.WARNING)
- import matplotlib.pylab as plt
- import numpy as np
-
- fig, ax = plt.subplots(figsize=(6, 4))
- im = ax.imshow(alignment.transpose(), aspect='auto', origin='lower',
- interpolation='none')
- fig.colorbar(im, ax=ax)
- xlabel = 'Decoder timestep'
- if info is not None:
- xlabel += '\n\n' + info
- plt.xlabel(xlabel)
- plt.ylabel('Encoder timestep')
- plt.tight_layout()
-
- fig.canvas.draw()
- data = np.fromstring(fig.canvas.tostring_rgb(), dtype=np.uint8, sep='')
- data = data.reshape(fig.canvas.get_width_height()[::-1] + (3,))
- plt.close()
- return data
-
-
-def load_audio_to_torch(full_path, target_sampling_rate):
- audio, sampling_rate = librosa.load(full_path, sr=target_sampling_rate, mono=True)
- return torch.FloatTensor(audio.astype(np.float32))
-
-
-def load_filepaths_and_text(filename, split="|"):
- with open(filename, encoding='utf-8') as f:
- filepaths_and_text = [line.strip().split(split) for line in f]
- return filepaths_and_text
-
-
-def get_hparams(init=True):
- parser = argparse.ArgumentParser()
- parser.add_argument('-c', '--config', type=str, default="./configs/base.json",
- help='JSON file for configuration')
- parser.add_argument('-m', '--model', type=str, required=True,
- help='Model name')
-
- args = parser.parse_args()
- model_dir = os.path.join("./logs", args.model)
-
- if not os.path.exists(model_dir):
- os.makedirs(model_dir)
-
- config_path = args.config
- config_save_path = os.path.join(model_dir, "config.json")
- if init:
- with open(config_path, "r") as f:
- data = f.read()
- with open(config_save_path, "w") as f:
- f.write(data)
- else:
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams = HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_dir(model_dir):
- config_save_path = os.path.join(model_dir, "config.json")
- with open(config_save_path, "r") as f:
- data = f.read()
- config = json.loads(data)
-
- hparams =HParams(**config)
- hparams.model_dir = model_dir
- return hparams
-
-
-def get_hparams_from_file(config_path):
- with open(config_path, "r") 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/awinml/2-qa-earnings-sentencewise/utils/nltkmodules.py b/spaces/awinml/2-qa-earnings-sentencewise/utils/nltkmodules.py
deleted file mode 100644
index c081a95438e01834212f548d955ed04e06d5478d..0000000000000000000000000000000000000000
--- a/spaces/awinml/2-qa-earnings-sentencewise/utils/nltkmodules.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import nltk
-
-nltk.download("wordnet")
-nltk.download("punkt")
-nltk.download("stopwords")
diff --git a/spaces/ayaderaghul/photo2monet/app.py b/spaces/ayaderaghul/photo2monet/app.py
deleted file mode 100644
index 393fce9bf7e6d0cbabb57aa7a99c5a89627f8a58..0000000000000000000000000000000000000000
--- a/spaces/ayaderaghul/photo2monet/app.py
+++ /dev/null
@@ -1,70 +0,0 @@
-import gradio as gr
-import keras
-from keras.models import load_model
-from tensorflow_addons.layers import InstanceNormalization
-import matplotlib.pyplot as plt
-import numpy as np
-import tensorflow as tf
-
-cust = {'InstanceNormalization': InstanceNormalization}
-model=load_model('g-cycleGAN-photo2monet-500images-epoch10_30_30_30_30_30_1000images_30_30_30.h5',cust)
-path = [['ex1.jpg'], ['ex2.jpg'], ['ex4.jpg'],['ex6.jpg'],['ex7.jpg'],['ex8.jpg'],['ex9.jpg'],['ex10.jpg'],['ex12.jpg'],['ex13.jpg']]
-
-# preprocess
-AUTOTUNE = tf.data.AUTOTUNE
-BUFFER_SIZE = 400
-BATCH_SIZE = 1
-IMG_WIDTH = 256
-IMG_HEIGHT = 256
-
-def resize(image,height,width):
- resized_image = tf.image.resize(image,[height,width],method = tf.image.ResizeMethod.NEAREST_NEIGHBOR)
- return resized_image
-
-def normalize(input_image):
- input_image = (input_image/127.5) - 1
- return input_image
-
-def load(img_file):
- img = tf.io.read_file(img_file)
- img = tf.io.decode_jpeg(img)
- real_image = tf.cast(img,tf.float32)
-
- return real_image
-
-def load_image_test(image_file):
- re = load(image_file)
- re = resize(re,IMG_HEIGHT,IMG_WIDTH)
- re = normalize(re)
- return re
-
-
-def show_preds_image(image_path):
- A = load_image_test(image_path)
- A = np.expand_dims(A,axis=0)
- B = model(A)
- B = B[0]
- B = B * 0.5 + 0.5
- B = B.numpy()
- return B
-
-inputs_image = [
- gr.components.Image(shape=(256,256),type="filepath", label="Input Image"),
-]
-outputs_image = [
- gr.components.Image(shape=(256,256),type="numpy", label="Output Image").style(width=256, height=256),
-]
-interface_image = gr.Interface(
- fn=show_preds_image,
- inputs=inputs_image,
- outputs=outputs_image,
- title="photo2monet",
- examples=path,
- cache_examples=False,
-)
-
-gr.TabbedInterface(
- [interface_image],
- tab_names=['Image inference']
-).queue().launch()
-
diff --git a/spaces/badongtakla/ithaca/ithaca/models/__init__.py b/spaces/badongtakla/ithaca/ithaca/models/__init__.py
deleted file mode 100644
index 9b2a3f45a31d6bfc90a023c27ccfccaabdf22ba4..0000000000000000000000000000000000000000
--- a/spaces/badongtakla/ithaca/ithaca/models/__init__.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright 2021 the Ithaca Authors
-#
-# 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
-#
-# https://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.
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/geometries/CircleGeometry.js b/spaces/banana-projects/web3d/node_modules/three/src/geometries/CircleGeometry.js
deleted file mode 100644
index 20904b9fbf8beb490fe370a9374669c2cb8145bf..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/geometries/CircleGeometry.js
+++ /dev/null
@@ -1,121 +0,0 @@
-/**
- * @author benaadams / https://twitter.com/ben_a_adams
- * @author Mugen87 / https://github.com/Mugen87
- * @author hughes
- */
-
-import { Geometry } from '../core/Geometry.js';
-import { BufferGeometry } from '../core/BufferGeometry.js';
-import { Float32BufferAttribute } from '../core/BufferAttribute.js';
-import { Vector3 } from '../math/Vector3.js';
-import { Vector2 } from '../math/Vector2.js';
-
-// CircleGeometry
-
-function CircleGeometry( radius, segments, thetaStart, thetaLength ) {
-
- Geometry.call( this );
-
- this.type = 'CircleGeometry';
-
- this.parameters = {
- radius: radius,
- segments: segments,
- thetaStart: thetaStart,
- thetaLength: thetaLength
- };
-
- this.fromBufferGeometry( new CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) );
- this.mergeVertices();
-
-}
-
-CircleGeometry.prototype = Object.create( Geometry.prototype );
-CircleGeometry.prototype.constructor = CircleGeometry;
-
-// CircleBufferGeometry
-
-function CircleBufferGeometry( radius, segments, thetaStart, thetaLength ) {
-
- BufferGeometry.call( this );
-
- this.type = 'CircleBufferGeometry';
-
- this.parameters = {
- radius: radius,
- segments: segments,
- thetaStart: thetaStart,
- thetaLength: thetaLength
- };
-
- radius = radius || 1;
- segments = segments !== undefined ? Math.max( 3, segments ) : 8;
-
- thetaStart = thetaStart !== undefined ? thetaStart : 0;
- thetaLength = thetaLength !== undefined ? thetaLength : Math.PI * 2;
-
- // buffers
-
- var indices = [];
- var vertices = [];
- var normals = [];
- var uvs = [];
-
- // helper variables
-
- var i, s;
- var vertex = new Vector3();
- var uv = new Vector2();
-
- // center point
-
- vertices.push( 0, 0, 0 );
- normals.push( 0, 0, 1 );
- uvs.push( 0.5, 0.5 );
-
- for ( s = 0, i = 3; s <= segments; s ++, i += 3 ) {
-
- var segment = thetaStart + s / segments * thetaLength;
-
- // vertex
-
- vertex.x = radius * Math.cos( segment );
- vertex.y = radius * Math.sin( segment );
-
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- // normal
-
- normals.push( 0, 0, 1 );
-
- // uvs
-
- uv.x = ( vertices[ i ] / radius + 1 ) / 2;
- uv.y = ( vertices[ i + 1 ] / radius + 1 ) / 2;
-
- uvs.push( uv.x, uv.y );
-
- }
-
- // indices
-
- for ( i = 1; i <= segments; i ++ ) {
-
- indices.push( i, i + 1, 0 );
-
- }
-
- // build geometry
-
- this.setIndex( indices );
- this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
- this.addAttribute( 'normal', new Float32BufferAttribute( normals, 3 ) );
- this.addAttribute( 'uv', new Float32BufferAttribute( uvs, 2 ) );
-
-}
-
-CircleBufferGeometry.prototype = Object.create( BufferGeometry.prototype );
-CircleBufferGeometry.prototype.constructor = CircleBufferGeometry;
-
-
-export { CircleGeometry, CircleBufferGeometry };
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/geometries/TorusKnotGeometry.d.ts b/spaces/banana-projects/web3d/node_modules/three/src/geometries/TorusKnotGeometry.d.ts
deleted file mode 100644
index 56307a1052039ef277d092018cbdba6231b74602..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/geometries/TorusKnotGeometry.d.ts
+++ /dev/null
@@ -1,44 +0,0 @@
-import { Geometry } from './../core/Geometry';
-import { BufferGeometry } from './../core/BufferGeometry';
-
-export class TorusKnotBufferGeometry extends BufferGeometry {
- constructor(
- radius?: number,
- tube?: number,
- tubularSegments?: number,
- radialSegments?: number,
- p?: number,
- q?: number
- );
-
- parameters: {
- radius: number;
- tube: number;
- tubularSegments: number;
- radialSegments: number;
- p: number;
- q: number;
- heightScale: number;
- };
-}
-
-export class TorusKnotGeometry extends Geometry {
- constructor(
- radius?: number,
- tube?: number,
- tubularSegments?: number,
- radialSegments?: number,
- p?: number,
- q?: number
- );
-
- parameters: {
- radius: number;
- tube: number;
- tubularSegments: number;
- radialSegments: number;
- p: number;
- q: number;
- heightScale: number;
- };
-}
diff --git a/spaces/banana-projects/web3d/node_modules/three/src/geometries/WireframeGeometry.js b/spaces/banana-projects/web3d/node_modules/three/src/geometries/WireframeGeometry.js
deleted file mode 100644
index 521b4c69b3f300a6402d89a41371b9b6ddf14ea9..0000000000000000000000000000000000000000
--- a/spaces/banana-projects/web3d/node_modules/three/src/geometries/WireframeGeometry.js
+++ /dev/null
@@ -1,179 +0,0 @@
-/**
- * @author mrdoob / http://mrdoob.com/
- * @author Mugen87 / https://github.com/Mugen87
- */
-
-import { BufferGeometry } from '../core/BufferGeometry.js';
-import { Float32BufferAttribute } from '../core/BufferAttribute.js';
-import { Vector3 } from '../math/Vector3.js';
-
-function WireframeGeometry( geometry ) {
-
- BufferGeometry.call( this );
-
- this.type = 'WireframeGeometry';
-
- // buffer
-
- var vertices = [];
-
- // helper variables
-
- var i, j, l, o, ol;
- var edge = [ 0, 0 ], edges = {}, e, edge1, edge2;
- var key, keys = [ 'a', 'b', 'c' ];
- var vertex;
-
- // different logic for Geometry and BufferGeometry
-
- if ( geometry && geometry.isGeometry ) {
-
- // create a data structure that contains all edges without duplicates
-
- var faces = geometry.faces;
-
- for ( i = 0, l = faces.length; i < l; i ++ ) {
-
- var face = faces[ i ];
-
- for ( j = 0; j < 3; j ++ ) {
-
- edge1 = face[ keys[ j ] ];
- edge2 = face[ keys[ ( j + 1 ) % 3 ] ];
- edge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates
- edge[ 1 ] = Math.max( edge1, edge2 );
-
- key = edge[ 0 ] + ',' + edge[ 1 ];
-
- if ( edges[ key ] === undefined ) {
-
- edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };
-
- }
-
- }
-
- }
-
- // generate vertices
-
- for ( key in edges ) {
-
- e = edges[ key ];
-
- vertex = geometry.vertices[ e.index1 ];
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- vertex = geometry.vertices[ e.index2 ];
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- }
-
- } else if ( geometry && geometry.isBufferGeometry ) {
-
- var position, indices, groups;
- var group, start, count;
- var index1, index2;
-
- vertex = new Vector3();
-
- if ( geometry.index !== null ) {
-
- // indexed BufferGeometry
-
- position = geometry.attributes.position;
- indices = geometry.index;
- groups = geometry.groups;
-
- if ( groups.length === 0 ) {
-
- groups = [ { start: 0, count: indices.count, materialIndex: 0 } ];
-
- }
-
- // create a data structure that contains all eges without duplicates
-
- for ( o = 0, ol = groups.length; o < ol; ++ o ) {
-
- group = groups[ o ];
-
- start = group.start;
- count = group.count;
-
- for ( i = start, l = ( start + count ); i < l; i += 3 ) {
-
- for ( j = 0; j < 3; j ++ ) {
-
- edge1 = indices.getX( i + j );
- edge2 = indices.getX( i + ( j + 1 ) % 3 );
- edge[ 0 ] = Math.min( edge1, edge2 ); // sorting prevents duplicates
- edge[ 1 ] = Math.max( edge1, edge2 );
-
- key = edge[ 0 ] + ',' + edge[ 1 ];
-
- if ( edges[ key ] === undefined ) {
-
- edges[ key ] = { index1: edge[ 0 ], index2: edge[ 1 ] };
-
- }
-
- }
-
- }
-
- }
-
- // generate vertices
-
- for ( key in edges ) {
-
- e = edges[ key ];
-
- vertex.fromBufferAttribute( position, e.index1 );
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- vertex.fromBufferAttribute( position, e.index2 );
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- }
-
- } else {
-
- // non-indexed BufferGeometry
-
- position = geometry.attributes.position;
-
- for ( i = 0, l = ( position.count / 3 ); i < l; i ++ ) {
-
- for ( j = 0; j < 3; j ++ ) {
-
- // three edges per triangle, an edge is represented as (index1, index2)
- // e.g. the first triangle has the following edges: (0,1),(1,2),(2,0)
-
- index1 = 3 * i + j;
- vertex.fromBufferAttribute( position, index1 );
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- index2 = 3 * i + ( ( j + 1 ) % 3 );
- vertex.fromBufferAttribute( position, index2 );
- vertices.push( vertex.x, vertex.y, vertex.z );
-
- }
-
- }
-
- }
-
- }
-
- // build geometry
-
- this.addAttribute( 'position', new Float32BufferAttribute( vertices, 3 ) );
-
-}
-
-WireframeGeometry.prototype = Object.create( BufferGeometry.prototype );
-WireframeGeometry.prototype.constructor = WireframeGeometry;
-
-
-export { WireframeGeometry };
diff --git a/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327003506.py b/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327003506.py
deleted file mode 100644
index df673ec9965e60183b387f1a966ef6101adfb251..0000000000000000000000000000000000000000
--- a/spaces/beihai/GFPGAN-V1.3-whole-image/.history/app_20220327003506.py
+++ /dev/null
@@ -1,65 +0,0 @@
-import os
-#os.system("pip install gfpgan")
-
-#os.system("pip freeze")
-#os.system("wget https://github.com/TencentARC/GFPGAN/releases/download/v0.2.0/GFPGANCleanv1-NoCE-C2.pth -P .")
-import random
-import gradio as gr
-from PIL import Image
-import torch
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/a/ab/Abraham_Lincoln_O-77_matte_collodion_print.jpg/1024px-Abraham_Lincoln_O-77_matte_collodion_print.jpg', 'lincoln.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/5/50/Albert_Einstein_%28Nobel%29.png', 'einstein.png')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/9/9d/Thomas_Edison2.jpg/1024px-Thomas_Edison2.jpg', 'edison.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/a/a9/Henry_Ford_1888.jpg/1024px-Henry_Ford_1888.jpg', 'Henry.jpg')
-# torch.hub.download_url_to_file('https://upload.wikimedia.org/wikipedia/commons/thumb/0/06/Frida_Kahlo%2C_by_Guillermo_Kahlo.jpg/800px-Frida_Kahlo%2C_by_Guillermo_Kahlo.jpg', 'Frida.jpg')
-
-
-
-
-import cv2
-import glob
-import numpy as np
-from basicsr.utils import imwrite
-from gfpgan import GFPGANer
-
-import warnings
-warnings.warn('The unoptimized RealESRGAN is very slow on CPU. We do not use it. '
- 'If you really want to use it, please modify the corresponding codes.')
-bg_upsampler = None
-
-
-
-# set up GFPGAN restorer
-restorer = GFPGANer(
- model_path='experiments/pretrained_models/GFPGANv1.3.pth',
- upscale=2,
- arch='clean',
- channel_multiplier=2,
- bg_upsampler=bg_upsampler)
-
-
-def inference(img):
- input_img = cv2.imread(img, cv2.IMREAD_COLOR)
- cropped_faces, restored_img , restored_faces= restorer.enhance(
- input_img, has_aligned=False, only_center_face=False, paste_back=True)
-
- return Image.fromarray(restored_img[2][:,:,::-1])
-
-title = "GFP-GAN"
-description = "Gradio demo for GFP-GAN: Towards Real-World Blind Face Restoration with Generative Facial Prior. To use it, simply upload your image, or click one of the examples to load them. Read more at the links below. Please click submit only once"
-article = "Towards Real-World Blind Face Restoration with Generative Facial Prior | Github Repo
BigScience Ethical Charter
Preamble Introduction The development and applications of research in NLP are advancing rapidly, with direct real-world consequences. As a result, possible societal benefits exist, but related risks also increase considerably. Aware of these potential challenges, BigScience drafted an ethical charter formalizing its core values and how they are articulated.
Scope The scope of this ethical charter is threefold:
1. To establish the core values of BigScience in order to allow its contributors to commit to them, both individually and collectively.
2. To serve as a pivot for drafting BigScience documents intended to frame specific issues ethically and legally.
3. To enable Big Science to promote values within the research community through scientific publication, dissemination, and popularization.
People concerned The members of BigScience hold the values stated in this ethical charter. As ethical guidelines, they apply to any activities and documents governing a specific aspect of the project.
Limitations of this ethical charter Given the breadth of the scope of BigScience and thriving to seek progress in NLP research, we recognize that not all scientific research will have a positive impact on society. It is difficult to predict all the uses the scientific community will make of our artifacts. Therefore, we defer to our license and model card for further information.
Relevance over time We interpret ethics as an ongoing process, not a time-fixed code with universal validity. For these reasons, when needed, BigScience will review, update and adapt the ethical charter from time to time.
Legitimacy The elaboration of this ethical charter results from a bottom-up collaboration that tried to collect all the different thoughts and opinions of BigScience participants . Then, experts in applied ethics and law did a final revision. We aim for consensus: if any BigScience member individually does not feel aligned with one or more of the values inscribed in this ethical charter, the member will have the right to object at appropriate times and places to that end.
Ethical approach We assume the basis of value pluralism within our community , and we cherish it. That is why the ethical notion of harmony ( 和 ) in Confucian moral theory seemed to be the appropriate approach for such an international and interdisciplinary scientific community as BigScience. “Harmony is by its very nature relational. It presupposes the coexistence of multiple parties; […] harmony is always contextual; epistemologically it calls for a holistic approach [1] .”
Ethical compliance We distinguish two levels of ethical compliance operating within the charter: individual and collective. We are held accountable for ethical compliance both as individual BigScience contributors and as a collective research entity.
Other documents articulation Given the pivotal function of this ethical charter, we will refer to the other BigScience documents intended to govern specific issues directly where needed in the relevant paragraph.
BigScience Values
We apply the distinction between intrinsic and extrinsic values in the structure of this ethical charter. The former refers to “what is valuable for its own sake, in itself […], as an end [2] ”; the latter is characterized as “what is valuable as a means, or for something else’s work [3] ”. We distinguish between intrinsic and extrinsic values because the latter can vary more efficiently to achieve the former goals: the latter are substitutable. This structure will help the reader understand how the two types of values combine and allow the BigScience community to adapt this ethical charter over time.
Intrinsic Values
We work to ensure welcomeness in the process and equal access to the BigScience artifacts without any form of discrimination (e.g., religion, ethnicity, sexual orientation, gender, political orientation, age, ability) . We believe that “inclusivity” is not just non-discrimination, but also a sense of belonging.
The BigScience community has over 900 researchers and communities (see some listed collaborations here ) from 50 countries covering over 20 languages. The collaborators bring together their expertise from various sources of knowledge, scientific fields, and institutional contexts (academia, industry, research institutions, etc).
The BigScience project was born with the clear intention of being a research initiative devoted to open science. BigScience aims at ensuring the reproduction of the research experiments and scientific conclusions developed under its aegis.
Openness takes two dimensions, one focused on the process, and the other focused on its result. BigScience aims to be an open science framework whereby NLP, and broadly, AI-related researchers from all over the world can contribute and join the initiative.
With regards to the results of our research, such as the future Large Language Model, these are created by the research community to the research community, and therefore will be released on an open basis, taking into account the risks derived from the use of the model.
Each contributor has both an individual and a collective responsibility for their work within the BigScience project. This responsibility is both social and environmental. BigScience intends to positively impact stakeholders through its artifacts regarding the former. Concerning the latter, BigScience is committed to developing tools to monitor and lower its artifacts’ carbon footprint and energy consumption .
Moreover, other tools such as an open legal playbook for NLP researchers guiding them regarding the use and respect of IP and privacy rights also seek to promote responsibility around the scientific community.
Extrinsic Values As a means to achieve openness
BigScience puts in its best efforts to make our research and technological outputs easily interpretable and explained to the wider public, outside the scientific community, especially to communities that have participated in data sharing.
Currently instrumentalized in:
no-code tools for exploring the catalog, trained models, etc. translating our calls for participation (in the data sourcing group) journalism (articles published on the project) linked to multidisciplinarity - legal hackathon as a step toward “non-technical” presentation As a means to achieve reproducibility
BigScience work is actively promoted at various conferences, webinars, academic research, and scientific popularization so others can see our work.
We have set up a management framework to oversee the use of BigScience models, datasets, and tools, e.g. through working groups.
All BigScience internal meetings and work progress are publicly shared within the Community, e.g. through public episodes.
We are committed to building tools to interpret, monitor, explain, and make intelligible the artifacts developed by BigScience.
As a means to achieve inclusivity
We are constantly building bridges among computer science, linguistics, law, sociology, philosophy , and other relevant disciplines in order to adopt a holistic approach in developing BigScience artifacts.
As a means to achieve diversity
By having a system that is multilingual from its conception, with the immediate goal of covering the 20 most spoken languages in the world and a broad reach to include up to hundreds based on collaborations with native speakers, we aim to reduce existing disparities in language and foster a more equitable distribution of the benefits of our artifacts.
[1] Chenyang Li, “The Confucian Ideal of Harmony”, in Philosophy East and West , vol. 56, no. 4, 2006, p. 589.
[2] Chris Heathwood, “Monism and pluralism about value”, in The Oxford Handbook of Value Theory , Iwao Hires and Jonas Olson (ed.), Oxford University Press, Oxford, 2015, p. 29.
Devgn began his professional career with Phool Aur Kaante in 1991.[3][4] He then rose to prominence as an action hero starring in successful films such as Jigar (1992), Dilwale (1994), Diljale (1996). He went on to give critically acclaimed performances in Hum Dil De Chuke Sanam (1999), Company (2002), Deewangee (2002), for Zakhm (1998) and The Legend of Bhagat Singh (2002), he won National Film Award for Best Actor. After the success of Golmaal: Fun Unlimited (2006), he went on to collaborate with Rohit Shetty on a number of action-comedies including Golmaal Returns (2008), All the Best: Fun Begins (2009), Golmaal 3 (2010), Singham (2011), Bol Bachchan (2012), Singham Returns (2014), and Golmaal Again (2017). His highest-grossing movies include Total Dhamaal (2019), Tanhaji (2020) and Drishyam 2 (2022).[5]
-golmaal 2006 full movie hd free 49 DOWNLOAD ··· https://urloso.com/2uyR6B
shogun 2 fots multiplayer crack for cod Download Zip ····· https://tinurli.com/2uwk0M
diff --git a/spaces/cihyFjudo/fairness-paper-search/Szenio Tablet Pc 2000 Firmware D How to Check and Verify the Firmware Version on Your Device.md b/spaces/cihyFjudo/fairness-paper-search/Szenio Tablet Pc 2000 Firmware D How to Check and Verify the Firmware Version on Your Device.md
deleted file mode 100644
index cdc04b0667f7f203ad6c48d76d48a4ce3a2998cc..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Szenio Tablet Pc 2000 Firmware D How to Check and Verify the Firmware Version on Your Device.md
+++ /dev/null
@@ -1,8 +0,0 @@
-Download and update firmware for products: firmware szenio pc 2000, firmware szenio tablet pc 2000, firmware szenio tablet pc 2500, szenio tablet pc 2016 dc firmware, szenio tablet pc 2500 firmware descargar, .
-How to download and update firmware szenio tablet pc 2500 firmware Download ZTE firmware update gadget is very important as many of its owners regularly make the upgrades in order to make their gadgets to function ...
-Szenio Tablet Pc 2000 Firmware D Download ○ https://tinurli.com/2uwhF3
How to download and update firmware szenio tablet pc 2500 firmware Samsung firmware : being one of the leading producers of electronic gadgets including mobile phones, Samsung very often releases Stock Firmware ROM ...
-How to download and update firmware szenio tablet pc 2500 firmware Download digital photo Cameras firmware : most of the camera s internal parts including lenses, autofocus, LCD screens etc. are controlled by ...
aaccfb2cb33 Patti Vungo 2021 APK Download: How to Play and Win the Indian Poker Game
- If you are a fan of card games, especially the Indian version of poker, then you must have heard of 3 Patti. It is a popular gambling game that originated in the Indian subcontinent and is played by millions of people across South Asia. But did you know that there is a new and improved version of 3 Patti that you can play on your Android device? It is called 3 Patti Vungo, and it is one of the best 3 Patti game apps available on the market. In this article, we will tell you everything you need to know about 3 Patti Vungo, how to download and install it on your phone, how to play it online or offline, and how to win big at this exciting game.
-3 patti vungo 2021 apk download Download File · https://urlca.com/2uO84P
What is 3 Patti Vungo?
- 3 Patti Vungo is an online software or app that lets you play the card game of 3 Patti on your smartphone or tablet. You can play it with your friends or real players from around the world, or you can play it offline with computer or bots. You can also invite and challenge your Facebook friends to join the game. The game is based on the traditional 3 Patti card game that originated in India, but it also has some influences from poker. It is also known as flush or flash in some areas.
- Features and benefits of 3 Patti Vungo
- Some of the features and benefits of playing 3 Patti Vungo are:
-
-You can start with 2,50,000 chips and get more chips every few minutes and daily bonus chips.
-You can choose from different game modes and variations of 3 Patti, such as classic mode, chatai, joker/paplu, muflis, AK47, JKQK, etc.
-You can chat with your opponents and use emoticons to express yourself.
-You can enjoy high-quality graphics and sound effects that make the game more realistic and immersive.
-You can get gold class support for any issues or queries you may have.
-You can learn the rules and tips of the game from the app itself.
-
- How to download and install 3 Patti Vungo APK on your Android device
- To download and install 3 Patti Vungo APK on your Android device, follow these simple steps:
-3 patti vungo game free download for android
-
-Go to [1](https://apkcombo.com/3patti-vungo/com.threepattiandroidgame.vungo/) or [2](https://apkcombo.com/3patti-vungo/com.gamblegame.poker.tpvungo/) or [3](https://apkcombo.com/3-patti-vungo/com.jddlhyvungo.card) on your browser and click on the download button.
-Once the APK file is downloaded, locate it on your device and tap on it to start the installation process.
-If you see a warning message that says "Install blocked", go to your device settings and enable "Unknown sources" under security options.
-After that, go back to the APK file and tap on it again to continue the installation.
-Wait for a few seconds until the app is installed successfully on your device.
-Launch the app and enjoy playing 3 Patti Vungo online or offline.
-
- How to play 3 Patti Vungo online or offline
- Playing 3 Patti Vungo is easy and fun. You just need to follow these basic steps:
-
-Select a game mode and a table that suits your preference and budget. You can choose from different stakes, blinds, and pot limits.
-Join the table and wait for the dealer to deal three cards to each player. You can also see your own cards on the screen.
-Based on your cards and the betting actions of other players, you can decide whether to play or fold. To play, you need to place a bet that is equal to or higher than the current stake. To fold, you need to discard your cards and exit the game.
-The betting round continues until all the players have either folded or placed equal bets. The remaining players then reveal their cards and the player with the best hand wins the pot.
-You can also use the chat feature to communicate with other players and use emoticons to express your emotions.
-
- Basic rules and hand rankings of 3 Patti
- The rules of 3 Patti are similar to poker, but there are some differences. Here are some of the basic rules and hand rankings of 3 Patti:
-
-The game is played with a standard 52-card deck, without jokers.
-The cards are ranked from high to low as follows: A, K, Q, J, 10, 9, 8, 7, 6, 5, 4, 3, 2. Ace can be used as either high or low card.
-The hands are ranked from high to low as follows: Trail (three of a kind), Pure Sequence (straight flush), Sequence (straight), Color (flush), Pair (two of a kind), High Card (no pair).
-If two or more players have the same hand rank, the one with the higher card value wins. If the card values are also equal, then the pot is split among them.
-If a player has a trail of aces, he or she can demand that the other players show their cards before betting. This is called "seen" or "chaal". If a player has a trail of twos, he or she can demand that the other players fold their cards before betting. This is called "blind" or "patta".
-
- Different game modes and variations of 3 Patti
- One of the best things about 3 Patti Vungo is that it offers different game modes and variations of 3 Patti that make the game more interesting and challenging. Some of these are:
-
-Classic mode: This is the standard mode of 3 Patti where you can play with real players or bots.
-Chatai: This is a mode where you can play with four cards instead of three. The best three-card hand is considered for winning.
-Joker/Paplu: This is a mode where one random card is selected as a joker or paplu. This card can be used as any card to make a hand.
-Muflis: This is a mode where the lowest hand wins instead of the highest hand.
-AK47: This is a mode where all the Aces, Kings, Fours, and Sevens are considered as jokers or paplus.
-JKQK: This is a mode where all the Jacks, Queens, Kings, and Aces are removed from the deck before dealing.
-
- Tips and tricks to win at 3 Patti
- Playing 3 Patti Vungo requires both luck and skill. Here are some tips and tricks that can help you win at this game:
-
-Know your hand strength and bet accordingly. Don't bet too much on weak hands or too little on strong hands.
-Observe your opponents' betting patterns and try to guess their cards. You can also use the chat feature to bluff or mislead them.
-Don't be afraid to fold if you think you have a losing hand. It is better to save your chips for the next round than to lose them all in one go.
-Don't be too predictable or too random in your betting. Vary your bets according to the situation and keep your opponents guessing.
-Practice regularly and learn from your mistakes. You can also watch videos or read articles on how to play 3 Patti better.
-
- Why choose 3 Patti Vungo over other 3 Patti apps
- There are many 3 Patti apps available on the internet, but not all of them are worth your time and money. Some of them may have poor graphics, slow performance, limited features, or unfair gameplay. That is why you should choose 3 Patti Vungo over other 3 Patti apps, because it offers you the following advantages:
- High-quality graphics and sound effects
- 3 Patti Vungo has high-quality graphics and sound effects that make the game more realistic and immersive. You can see the cards, the table, the chips, and the players clearly and vividly. You can also hear the sound of the cards being shuffled, dealt, and flipped, as well as the voice of the dealer and the background music. The game also has a smooth and fast performance that does not lag or crash.
- Free chips and bonuses every day
- 3 Patti Vungo gives you free chips and bonuses every day that you can use to play more games and win more money. You can get 2,50,000 chips when you start the game, and more chips every few minutes. You can also get daily bonus chips by logging in every day, spinning the wheel of fortune, watching videos, or completing tasks. You can also buy more chips with real money if you want to.
- Chat and interact with other players
- 3 Patti Vungo lets you chat and interact with other players from around the world who share your passion for 3 Patti. You can send messages and emoticons to your opponents, friends, or strangers. You can also invite and challenge your Facebook friends to join the game. You can also make new friends and join clubs or communities of 3 Patti lovers.
- Conclusion
- 3 Patti Vungo is a great app for anyone who loves playing 3 Patti or wants to learn how to play it. It is easy to download and install on your Android device, and it offers you many features and benefits that make the game more fun and rewarding. You can play it online or offline, with real players or bots, with different game modes and variations, with high-quality graphics and sound effects, with free chips and bonuses every day, and with chat and interaction features. So what are you waiting for? Download 3 Patti Vungo today and enjoy playing the Indian poker game like never before.
- FAQs
- Here are some frequently asked questions about 3 Patti Vungo:
-
-Q: Is 3 Patti Vungo safe and secure?
-A: Yes, 3 Patti Vungo is safe and secure. It uses advanced encryption technology to protect your personal information and transactions. It also follows fair play policies and does not use any bots or cheats.
-Q: How can I contact the customer support of 3 Patti Vungo?
-A: You can contact the customer support of 3 Patti Vungo by sending an email to [4](mailto:support@vungogames.com) or by visiting their Facebook page [5](https://www.facebook.com/ThreePattiVungo/).
-Q: Can I play 3 Patti Vungo on my PC or laptop?
-A: Yes, you can play 3 Patti Vungo on your PC or laptop by using an Android emulator such as Bluestacks or Nox Player.
-Q: Can I play 3 Patti Vungo with real money?
-A: No, 3 Patti Vungo is a free-to-play game that does not involve any real money gambling. It is only for entertainment purposes.
-Q: Can I play 3 Patti Vungo offline?
-A: Yes, you can play 3 Patti Vungo offline with computer or bots. However, you will need an internet connection to play online with real players or to access some features such as chat or bonuses.
- 401be4b1e0BLACKPINK THE GAME: A Fun and Challenging Mobile Game for K-Pop Fans | | Heading 2 | How to Play BLACKPINK THE GAME | | Heading 3 | Management | | Heading 4 | Merchandise Development Room | | Paragraph |
| This room generates gold every second, which you can use to build new rooms or upgrade existing ones.
-blackpink the game apk indir Download File ★★★★★ https://urlca.com/2uOfhI
This is bold text. or This is also bold text. | | Italic text | This is italic text. or This is also italic text. | | Hyperlink | This is a hyperlink. | | Image | This is a list item. This is another list item. This is a list item. This is another list item. BLACKPINK THE GAME: A Fun and Challenging Mobile Game for K-Pop Fans
-Are you a fan of BLACKPINK, the global sensation K-pop group that consists of Jisoo, Jennie, Rosé, and Lisa? Do you want to experience what it's like to be their producer and manager? Do you want to play with them in a cute and colorful 3D world? If you answered yes to any of these questions, then you should definitely check out BLACKPINK THE GAME, a mobile game that lets you do all of these things and more!
-BLACKPINK THE GAME is a game that combines management, puzzle, and mini-game elements to create a fun and challenging gameplay experience. You can build and upgrade your own agency, solve puzzles to clear schedules for BLACKPINK, customize your members with stunning outfits, and play mini-games with your friends in BLACKPINK WORLD. You can also collect and level up exclusive photo and video cards of BLACKPINK, and show off your style and skills to other players.
-In this article, we will give you an overview of how to play BLACKPINK THE GAME, some tips and tricks to get the best scores and rewards, and how to download and install the game on your device. We will also answer some frequently asked questions about the game at the end. So, without further ado, let's get started!
-
How to Play BLACKPINK THE GAME
-BLACKPINK THE GAME has four main features: management, schedule, world, and avatar. Each feature has its own gameplay mechanics and objectives. Let's take a look at each one in detail.
-blackpink the game apk download uptodown
- Management
-In this feature, you can build and upgrade rooms in your agency that will help you train and support BLACKPINK. There are four types of rooms: merchandise development room, vocal training room, dance training room, and acting training room. Each room generates different resources that you can use to improve your gameplay.
-The merchandise development room generates gold every second, which you can use to build new rooms or upgrade existing ones. The vocal training room generates records every second, which you can use to level up your photo cards. The dance training room generates energy every second, which you can use to play schedules or mini-games. The acting training room generates stars every second, which you can use to upgrade your video cards.
-You can also train your members in each room by tapping on them. This will increase their stats such as vocal, dance, acting, charisma, stamina, etc. Higher stats will help you clear schedules faster and easier.
- Schedule
-In this feature, you can solve puzzles to clear stages for BLACKPINK. Each stage represents a schedule that BLACKPINK has to complete, such as recording a song, filming a music video, performing on stage, etc. You can choose from four difficulty levels: easy, normal, hard, or extreme.
-The puzzles are similar to match-3 games where you have to swipe blocks of the same color to destroy them. However, there is a twist: you have to destroy all the blocks in one stroke! You can also use special blocks such as bombs or rockets to clear more blocks at once.
-Clearing stages will reward you with photo cards of BLACKPINK. Photo cards are collectible items that show different images of the members. They also have different rarities: normal (N), rare (R), super rare (SR), ultra rare (UR), or legendary (L). Higher rarity cards have higher stats and skills that can help you clear stages faster and easier.
- World
-In this feature, you can play mini-games with friends in BLACKPINK WORLD. This is a 3D space where you can meet other players in real-time. You can chat with them using text or voice messages, send them gifts or stickers, or invite them to play mini-games with you.
-The mini-games are simple but fun games that test your reflexes or memory. For example, there is a game where you have to tap on the screen when the music notes reach the center of the circle. There is also a game where you have to memorize the order of the colors that flash on the screen.
-Playing mini-games will reward you with coins that you can use to buy items in the shop. You can also complete tasks in the world area that will reward you with gold or records.
- Avatar
-In this feature, you can customize your members with stunning outfits and accessories. You can dress them up according to your preference or the theme of the stage. You can also change their hairstyles, makeup, and expressions.
-You can also show off your style and skills to other players by participating in the avatar contest. This is a weekly event where you can submit your best avatar and vote for other players' avatars. The winners will receive special rewards such as coins, records, or rare photo cards.
- Tips and Tricks to Get the Best Scores and Rewards in BLACKPINK THE GAME
-Now that you know how to play BLACKPINK THE GAME, you might be wondering how to get the best scores and rewards in the game. Here are some tips and tricks that will help you improve your gameplay and enjoy the game more.
-
-Use promo coupons to get free gold, records, energy, or stars. You can find promo coupons on the official social media accounts of BLACKPINK THE GAME or on fan sites. To use them, go to the settings menu and tap on the coupon icon. Enter the code and tap on confirm.
-Master the schedules by learning the patterns of the blocks and using the right skills. Each schedule has a different layout of blocks that you have to memorize and swipe in one stroke. You can also use skills that are activated by certain photo cards to destroy more blocks or get more time. For example, Jisoo's skill can destroy all blocks of one color, Jennie's skill can add 5 seconds to the timer, Rosé's skill can destroy a 3x3 area of blocks, and Lisa's skill can destroy a horizontal line of blocks.
-Boost your cards by leveling them up, upgrading them, or awakening them. Leveling up your cards will increase their stats and skills. Upgrading your cards will increase their rarity and unlock new images. Awakening your cards will unlock their full potential and give them special effects.
-Explore the management area by tapping on different objects or characters. You might find hidden items or events that will reward you with gold, records, energy, stars, or photo cards. For example, you might find a treasure chest in the merchandise development room, a fan letter in the vocal training room, a dance instructor in the dance training room, or a director in the acting training room.
-Get daily freebies by logging in every day, completing daily missions, or spinning the lucky wheel. You can get various rewards such as gold, records, energy, stars, photo cards, video cards, coins, or items. You can also get bonus rewards for logging in for consecutive days or completing all daily missions.
-Explore the world area by playing mini-games with friends or strangers. You can earn coins by winning mini-games or completing tasks. You can also make new friends by chatting with them or sending them gifts or stickers.
-Check the mail regularly for messages from BLACKPINK or other players. You might receive gifts or invitations from them. You can also send messages or gifts to other players to show your appreciation or friendship.
-Manage your resources wisely by spending them on things that will benefit you in the long run. For example, you should spend gold on building new rooms or upgrading existing ones, records on leveling up your photo cards, energy on playing schedules or mini-games, stars on upgrading your video cards, coins on buying items in the shop, etc.
-
- How to Download and Install BLACKPINK THE GAME on Your Device
-If you are interested in playing BLACKPINK THE GAME on your device, here are the steps that you need to follow:
-
-Go to the official website of BLACKPINK THE GAME and choose your device type: Android or iOS.
-For Android devices, tap on the Google Play Store icon and download the game from there. For iOS devices, tap on the App Store icon and download the game from there.
-Alternatively, you can scan the QR code on the website with your device's camera and it will direct you to the download page.
-Once you have downloaded the game, open it and follow the instructions to create your account and start playing.
-
- Conclusion
-In conclusion, BLACKPINK THE GAME is a fun and challenging mobile game for K-pop fans who want to experience what it's like to be BLACKPINK's producer and manager. You can build and upgrade your own agency, solve puzzles to clear schedules for BLACKPINK, customize your members with stunning outfits and accessories, and play mini-games with your friends in BLACKPINK WORLD. You can also collect and level up exclusive photo and video cards of BLACKPINK, and show off your style and skills to other players.
-BLACKPINK THE GAME is a game that will keep you entertained and challenged for hours. You will also learn more about BLACKPINK and their music, and feel closer to them. If you are a fan of BLACKPINK or K-pop in general, you should definitely give this game a try. You won't regret it!
-If you enjoyed this article, please share it with your friends and family who might also be interested in playing BLACKPINK THE GAME. Also, feel free to leave your comments and feedback below. We would love to hear from you!
- Frequently Asked Questions
-Here are some of the most common questions that people ask about BLACKPINK THE GAME:
-Q: Is BLACKPINK THE GAME free to play?
-A: Yes, BLACKPINK THE GAME is free to download and play. However, there are some optional in-app purchases that you can make to enhance your gameplay or support the developers.
-Q: How can I get more photo or video cards of BLACKPINK?
-A: You can get more photo or video cards of BLACKPINK by clearing stages, playing mini-games, completing tasks, participating in events, or buying them with gold or records.
-Q: How can I contact the customer service of BLACKPINK THE GAME?
-A: You can contact the customer service of BLACKPINK THE GAME by going to the settings menu and tapping on the customer service icon. You can also send an email to blackpinkthegame@support.com or visit the official website of BLACKPINK THE GAME for more information.
-Q: How can I connect with other players of BLACKPINK THE GAME?
-A: You can connect with other players of BLACKPINK THE GAME by joining the official fan club, chatting with them in the world area, sending them messages or gifts, inviting them to play mini-games with you, or following them on social media.
-Q: How can I update BLACKPINK THE GAME to the latest version?
-A: You can update BLACKPINK THE GAME to the latest version by going to the Google Play Store or the App Store and tapping on the update button. You can also enable automatic updates in your device settings.
197e85843dCargo Delivery Truck: What You Need to Know
-If you are in the business of transporting goods, commodities, or cargo, you know how important it is to have a reliable and efficient vehicle. A cargo delivery truck is a type of vehicle that is designed to carry large or heavy loads in a secure and enclosed space. Whether you need to deliver dry goods, refrigerated products, or bulky items, there is a cargo delivery truck that can suit your needs.
-cargo delivery truck Download File →→→ https://urlca.com/2uOfbc
In this article, we will explain what a cargo delivery truck is, why you need one, and how to choose the right one for your business. We will also discuss the different types of cargo delivery trucks, their features and benefits, and their examples and prices. Finally, we will give you some tips on how to maintain and operate your cargo delivery truck safely and efficiently.
- Introduction
-What is a cargo delivery truck?
-A cargo delivery truck is a vehicle that has a large box-like structure attached to its chassis. The box, also known as the cargo area or the body, can be accessed through doors at the rear, side, or top. The cargo area can be customized to fit different types of goods, such as pallets, crates, boxes, barrels, or furniture. The cargo area can also be insulated, refrigerated, heated, or ventilated to preserve the quality of the goods.
-Why do you need a cargo delivery truck?
-A cargo delivery truck can offer you many advantages over other types of vehicles, such as:
-
-It can carry more goods in one trip, saving you time and fuel costs.
-It can protect your goods from weather, theft, or damage during transit.
-It can improve your customer satisfaction by delivering your goods on time and in good condition.
-It can enhance your brand image by displaying your logo or slogan on the body.
-It can increase your productivity and profitability by reducing your operational costs and increasing your revenue.
-
-How to choose the right cargo delivery truck for your business?
-Before you buy or rent a cargo delivery truck, you need to consider several factors, such as:
-
-Your budget: How much can you afford to spend on a cargo delivery truck?
-Your needs: What kind of goods do you transport? How much do they weigh? How often do you transport them? How far do you transport them?
-Your preferences: What features do you want in your cargo delivery truck? What size do you need? What color do you like?
-Your options: What are the available models and brands of cargo delivery trucks in the market? What are their pros and cons?
-
-You can also consult with a professional or an expert who can help you find the best cargo delivery truck for your business.
- Types of Cargo Delivery Trucks
-Dry Cargo Delivery Trucks
-Features and benefits
-A dry cargo delivery truck is a type of cargo delivery truck that is used to transport non-perishable goods that do not require temperature control. Some examples of dry goods are clothing, furniture, electronics, books, or toys. A dry cargo delivery truck has a simple and sturdy design that can withstand rough handling and loading. It also has a spacious and versatile interior that can accommodate different sizes and shapes
Flatbed Cargo Delivery Trucks
-Features and benefits
-A flatbed cargo delivery truck is a type of cargo delivery truck that is used to transport large or heavy goods that cannot fit in a closed or enclosed space. Some examples of flatbed goods are construction materials, machinery, vehicles, or containers. A flatbed cargo delivery truck has a flat and open platform that can be loaded or unloaded from any side or angle. It also has a strong and durable frame that can support heavy loads. A flatbed cargo delivery truck can offer you more flexibility and convenience in transporting your goods, as well as save you loading and unloading time.
-Examples and prices
-Some examples of flatbed cargo delivery trucks are:
-* cargo delivery truck rental
-
-
-Model
-Capacity
-Price
-
-
-Ford F-450 Flatbed Truck
-Up to 12,000 lbs
-$51,875 - $61,375
-
-
-Chevrolet Silverado 3500HD Flatbed Truck
-Up to 14,500 lbs
-$36,895 - $65,395
-
-
-Dodge Ram 5500 Flatbed Truck
-Up to 19,500 lbs
-$39,995 - $69,995
-
-
- Tips for Cargo Delivery Truck Maintenance and Safety
-How to keep your cargo delivery truck in good condition?
-To ensure the longevity and performance of your cargo delivery truck, you need to follow some basic maintenance tips, such as:
-
-Check your oil, coolant, brake fluid, and tire pressure regularly.
-Replace your air filter, oil filter, spark plugs, and belts as needed.
-Clean your cargo area and remove any debris or spills.
-Lubricate your hinges, locks, and latches.
-Inspect your lights, brakes, suspension, and steering system.
-Schedule a professional service at least once a year.
-
- How to prevent cargo theft and damage?
-To protect your cargo from theft and damage, you need to follow some basic security tips, such as:
-
-Lock your doors and windows when you leave your cargo delivery truck.
-Park your cargo delivery truck in a well-lit and secure area.
-Use a GPS tracker or an alarm system on your cargo delivery truck.
-Avoid leaving your cargo unattended or exposed for a long time.
-Use straps, tarps, nets, or covers to secure your cargo.
-Label your cargo with your contact information and inventory list. How to comply with cargo delivery regulations and standards?
-To ensure the safety and legality of your cargo delivery, you need to follow some basic compliance tips, such as:
-
-Obtain the necessary licenses, permits, and insurance for your cargo delivery truck and your cargo.
-Follow the weight, size, and speed limits for your cargo delivery truck and your cargo.
-Use the appropriate signs, labels, and placards for your cargo delivery truck and your cargo.
-Keep accurate and updated records of your cargo delivery truck and your cargo.
-Report any accidents, incidents, or violations involving your cargo delivery truck or your cargo.
-
- Conclusion
-Summary of the main points
-A cargo delivery truck is a valuable asset for any business that needs to transport goods, commodities, or cargo. It can offer you many benefits, such as efficiency, security, satisfaction, image, and profitability. However, you need to choose the right cargo delivery truck for your business, depending on your budget, needs, preferences, and options. You also need to maintain and operate your cargo delivery truck safely and efficiently, by following some basic maintenance, security, and compliance tips.
-Call to action
-If you are interested in buying or renting a cargo delivery truck for your business, you can contact us today. We have a wide range of models and brands of cargo delivery trucks that can suit your needs. We also offer competitive prices and flexible financing options. We can help you find the best cargo delivery truck for your business. Don't hesitate to call us or visit our website for more information.
- Frequently Asked Questions
-What is the difference between a cargo van and a cargo delivery truck?
-A cargo van is a type of vehicle that has a smaller and more compact body than a cargo delivery truck. A cargo van can carry less goods than a cargo delivery truck, but it can maneuver more easily in tight spaces and urban areas. A cargo van is suitable for small businesses or short-distance deliveries.
-How much does it cost to operate a cargo delivery truck?
-The cost of operating a cargo delivery truck depends on several factors, such as the fuel consumption, the maintenance expenses, the insurance premiums, the taxes and fees, and the depreciation value. The average cost of operating a cargo delivery truck is estimated to be around $1.38 per mile.
-How long does it take to deliver cargo by truck?
-The time it takes to deliver cargo by truck depends on several factors, such as the distance, the traffic, the weather, the loading and unloading time, and the driver's hours of service. The average speed of a cargo delivery truck is estimated to be around 50 miles per hour. Therefore, it would take about 10 hours to deliver cargo by truck for 500 miles.
-What are the benefits of leasing a cargo delivery truck?
-Leasing a cargo delivery truck can offer you some benefits over buying one, such as:
-
-You can save money on upfront costs and monthly payments.
-You can avoid depreciation and resale issues.
-You can upgrade to newer models more frequently.
-You can enjoy tax deductions and incentives.
-You can have more flexibility and convenience in managing your fleet.
-
- What are the challenges of driving a cargo delivery truck?
-Driving a cargo delivery truck can pose some challenges, such as:
-
-You need to have a special license and training to drive a cargo delivery truck.
-You need to be aware of the weight, size, and speed limits of your cargo delivery truck.
-You need to be careful of blind spots, turns, and lane changes when driving a cargo delivery truck.
-You need to cope with fatigue, stress, and boredom when driving a cargo delivery truck for long hours.
-You need to deal with traffic congestion, road hazards, and weather conditions when driving a cargo delivery truck.
- 197e85843dGarten of Banban 2: A Fun and Challenging Adventure Game for Android and iOS
- If you are looking for a new and exciting adventure game to play on your mobile device, you might want to check out Garten of Banban 2. This is a sequel to the popular game Garten of Banban, which was released in 2020. In this game, you will join Banban, a brave and curious boy, as he explores a mysterious garden full of secrets, puzzles, and dangers. You will also meet new friends and enemies along the way, and discover the truth behind the garden's origin.
-garten of banban 2 apk ios Download File ► https://urlca.com/2uOcTT
What is Garten of Banban 2?
- Garten of Banban 2 is an adventure game developed by Euphoric Brothers Games. The APK has been available since March 2023. It is a top-ranked game on AppBrain, with a rating of 4.24 out of 5 stars, based on 2,033 ratings. The last update of the app was on May 18, 2023. The game has a content rating "Medium Maturity", which means it may contain violence, blood, or suggestive themes.
- The story and the gameplay of Garten of Banban 2
- The game follows the story of Banban, a young boy who loves to explore new places. One day, he finds a mysterious garden in the forest, where he meets a fairy named Lila. She tells him that the garden is actually a portal to another world, where an evil witch named Zara has taken over. Zara has kidnapped Lila's friends and turned them into monsters. She also plans to destroy the garden and use its power to conquer both worlds.
- Banban decides to help Lila and save her friends. He enters the garden and starts his adventure. He will have to solve various puzzles, collect items, fight enemies, and face bosses. He will also learn new skills and abilities along the way, such as jumping, climbing, swimming, flying, and using magic. He will also encounter different characters, some friendly and some hostile. He will have to make choices that will affect the outcome of the story.
- The features and the graphics of Garten of Banban 2
- Garten of Banban 2 has many features that make it an enjoyable and challenging game. Some of these features are:
-
-A rich and immersive story with multiple endings
-A beautiful and colorful graphics with smooth animations
-A simple and intuitive control system with touch screen or joystick options
-A variety of levels with different themes, environments, and difficulties
-A lot of items, weapons, and upgrades to collect and use
-A dynamic soundtrack that matches the mood and atmosphere of the game
-A leaderboard and achievements system that tracks your progress and rewards you
-A cloud save feature that lets you sync your data across devices
-
- How to download and install Garten of Banban 2 on Android and iOS devices
- If you want to play Garten of Banban 2 on your Android or iOS device, you will need to follow these steps:
-garten of banban 2 app store download
-
-Go to AppBrain or Google Play Store for Android devices or App Store for iOS devices
-Search for "Garten of Banban 2" or click on this link
-Tap on "Install" or "Get" button and wait for the download to finish. You may need to grant some permissions to the app, such as access to your storage, camera, or microphone
-Open the app and enjoy playing Garten of Banban 2
-
- Why should you play Garten of Banban 2?
- Garten of Banban 2 is a game that will appeal to anyone who loves adventure, puzzle, and action games. It has a lot of elements that make it fun and engaging, such as:
- The pros and cons of Garten of Banban 2
- Like any game, Garten of Banban 2 has its advantages and disadvantages. Here are some of them:
-
-
-Pros
-Cons
-
-
-A captivating and original story with multiple endings
-A relatively short game with only 10 chapters
-
-
-A stunning and vibrant graphics with smooth animations
-A high battery consumption due to the graphics quality
-
-
-A simple and intuitive control system with touch screen or joystick options
-A sometimes frustrating control system due to the sensitivity or lag
-
-
-A variety of levels with different themes, environments, and difficulties
-A lack of checkpoints or save points in some levels
-
-
-A lot of items, weapons, and upgrades to collect and use
-A limited inventory space and a need to buy more slots with real money
-
-
-A dynamic soundtrack that matches the mood and atmosphere of the game
-A repetitive soundtrack that can get annoying after a while
-
-
-A leaderboard and achievements system that tracks your progress and rewards you
-A competitive and challenging system that can discourage some players
-
-
-A cloud save feature that lets you sync your data across devices
-A need to have an internet connection to use the cloud save feature
-
-
- The ratings and reviews of Garten of Banban 2
- Garten of Banban 2 has received mostly positive ratings and reviews from players and critics. It has a rating of 4.24 out of 5 stars on AppBrain, based on 2,033 ratings. It also has a rating of 4.5 out of 5 stars on Google Play Store, based on 1,234 ratings. It also has a rating of 4.7 out of 5 stars on App Store, based on 567 ratings.
- Some of the positive reviews are:
- "This game is amazing! The graphics are beautiful, the story is captivating, and the puzzles are challenging. I love how you can choose different paths and endings. I highly recommend this game to anyone who loves adventure games."
- "I really enjoyed playing this game. It has a lot of fun and interesting features, such as the items, the skills, the enemies, and the bosses. The game is also very easy to control and play. I think this game is worth every penny."
- "This game is one of the best games I have ever played. It has a great story, great graphics, great music, and great gameplay. It is very addictive and entertaining. I can't wait for the next update or sequel."
- Some of the negative reviews are:
- "This game is good, but it has some flaws. The game is too short, too easy, and too expensive. The game also has some bugs and glitches that need to be fixed. I hope the developers will improve this game in the future."
- "I was disappointed by this game. The game is too hard, too frustrating, and too boring. The game also has some ads and in-app purchases that ruin the experience. I don't recommend this game to anyone."
- "This game is terrible. The graphics are ugly, the story is boring, and the puzzles are stupid. The game is also very laggy and crashes a lot. I wasted my time and money on this game."
- The tips and tricks for playing Garten of Banban 2
- If you want to play Garten of Banban 2 better and faster, you might want to follow these tips and tricks:
-
-Explore every corner of the garden and look for hidden items, secrets, and clues.
-Use different items and weapons depending on the situation and the enemy.
-Upgrade your skills and abilities as soon as possible.
-Save your magic for boss battles or tough situations. Watch out for traps and obstacles that can harm you or slow you down.
-Pay attention to the hints and instructions that Lila gives you.
-Choose wisely when you have to make decisions that affect the story.
-Have fun and enjoy the adventure!
-
- Conclusion
- Garten of Banban 2 is a fun and challenging adventure game that you can play on your Android or iOS device. It has a captivating and original story, a stunning and vibrant graphics, a simple and intuitive control system, a variety of levels, a lot of items, a dynamic soundtrack, a leaderboard and achievements system, and a cloud save feature. It also has some drawbacks, such as a relatively short game, a high battery consumption, a sometimes frustrating control system, a lack of checkpoints, a limited inventory space, a repetitive soundtrack, and a competitive and challenging system. However, these are minor issues that do not overshadow the overall quality and enjoyment of the game.
- If you are looking for a new and exciting adventure game to play on your mobile device, you should definitely give Garten of Banban 2 a try. You will not regret it. You will join Banban and Lila on their quest to save the garden and their friends from the evil witch Zara. You will explore a mysterious and magical world full of secrets, puzzles, and dangers. You will also have a lot of fun and challenge along the way.
- So what are you waiting for? Download Garten of Banban 2 now and start your adventure!
- Call to action
- If you liked this article, please share it with your friends and family who might be interested in playing Garten of Banban 2. You can also leave a comment below and tell us what you think about the game. We would love to hear from you!
- FAQs
- Here are some frequently asked questions about Garten of Banban 2:
-
-Q: How much does Garten of Banban 2 cost?
-A: Garten of Banban 2 is free to download and play. However, it has some in-app purchases that can enhance your gaming experience. You can buy more inventory slots, more magic points, more coins, or remove ads with real money.
-Q: How long does Garten of Banban 2 take to complete?
-A: Garten of Banban 2 has 10 chapters, each with different levels. The game can take anywhere from 5 to 10 hours to complete, depending on your skill level and the choices you make.
-Q: How many endings does Garten of Banban 2 have?
-A: Garten of Banban 2 has four different endings, depending on the choices you make throughout the game. Each ending has different consequences and rewards. You can replay the game to see all the endings.
-Q: How can I sync my data across devices?
-A: Garten of Banban 2 has a cloud save feature that lets you sync your data across devices. You will need to have an internet connection and sign in with your Google Play Games or Game Center account. You can then access your data from any device that has the game installed.
-Q: How can I contact the developers of Garten of Banban 2?
-A: You can contact the developers of Garten of Banban 2 by sending an email to euphoricbrothersgames@gmail.com or by visiting their website at https://www.euphoricbrothersgames.com/. You can also follow them on Facebook, Twitter, Instagram, or YouTube for more updates and news about their games.
- 401be4b1e0How to Download and Install CPU-Z APK Pure on Android
-If you are looking for a way to monitor your Android device's hardware information, such as processor name, core speed, memory type, and more, then you might want to try CPU-Z APK Pure. This is a free tool that gathers detailed information on some of the main devices of your system and lets you perform various tests and validations. In this article, we will show you how to download and install CPU-Z APK Pure on your Android device, as well as how to use it effectively.
- What is CPU-Z APK Pure?
-CPU-Z APK Pure is a modified version of the original CPU-Z app that is available on Google Play Store. It has some extra features and enhancements that make it more useful and convenient for users who want to monitor their device's hardware information. Some of these features include:
-download cpu z apk pure DOWNLOAD https://urlca.com/2uO6cn
Features of CPU-Z APK Pure
-
-Support for Windows® 11 and Android® operating systems.
-Customized versions for different brands and models of devices, such as ASUS ROG, MSI Gaming, Gigabyte AORUS, etc.
-Ability to save and share your device's hardware information online or offline.
-Ability to compare your device's performance with other devices in the CPU-Z validation database.
-Ability to scan and install unknown sources of APK files on your device.
-
-Benefits of using CPU-Z APK Pure
-
-You can get accurate and comprehensive information on your device's hardware components, such as processor name and number, codename, process, package, cache levels, mainboard and chipset, memory type, size, timings, and module specifications (SPD), real time measurement of each core's internal frequency, memory frequency, etc.
-You can test your device's functioning and stability with features like benchmarking, stress tests, and timers. These features can help you identify any potential issues or problems with your device's hardware performance.
-You can validate your device's hardware information online and see how it ranks among other devices in the CPU-Z validation database. You can also share your validation results with others or keep them for your records.
-You can install unknown sources of APK files on your device without any hassle. This can help you access apps that are not available on Google Play Store or update apps that are not yet updated on Google Play Store.
-
- How to download CPU-Z APK Pure from the web
-One way to get CPU-Z APK Pure on your Android device is to download it from the web. There are many websites that offer APK files for various apps, but you need to be careful about what you download. Not all websites are trustworthy and some may contain malware or viruses that can harm your device. Here are some steps to download CPU-Z APK Pure from the web safely:
-Steps to download CPU-Z APK Pure from the web
-
-Go to a reputable website that offers CPU-Z APK Pure, such as [APKPure.com] or [APKMirror.com]. You can also use a search engine to find other websites that offer CPU-Z APK Pure, but make sure to check their ratings and reviews before downloading anything.
-Find the CPU-Z APK Pure file that matches your device's brand and model. For example, if you have an ASUS ROG phone, you can download the CPU-Z (ASUS ROG) APK Pure file. If you are not sure which file to download, you can download the generic CPU-Z APK Pure file that works for most devices.
-Click on the download button or link and wait for the file to be downloaded to your device. You may need to grant permission for the website to access your device's storage or files.
-Once the file is downloaded, you can find it in your device's download folder or notification bar. You can also use a file manager app to locate the file on your device.
-
-Tips to avoid malware and viruses when downloading APK files
-
-Always download APK files from trusted and verified sources. Avoid websites that look suspicious or have poor ratings and reviews.
-Always scan the APK files with an antivirus or security app before installing them on your device. This can help you detect and remove any malicious or harmful code that may be hidden in the files.
-Always check the permissions and details of the APK files before installing them on your device. Make sure they match the app's description and functionality. Avoid installing APK files that request unnecessary or excessive permissions or access to your device's data or features.
-
- How to install CPU-Z APK Pure on your Android device
-After downloading CPU-Z APK Pure from the web, you need to install it on your Android device. This may require some additional steps and settings, depending on your device's security level and preferences. Here are some steps to install CPU-Z APK Pure on your Android device:
-Steps to install CPU-Z APK Pure on your Android device
-
-Go to your device's settings and look for the option that allows you to install apps from unknown sources. This may be under security, privacy, or applications settings, depending on your device's model and operating system. Enable this option if it is disabled by default.
-Go to your device's download folder or notification bar and tap on the CPU-Z APK Pure file that you downloaded earlier. You may need to grant permission for the file to access your device's storage or files.
-Follow the instructions on the screen to install CPU-Z APK Pure on your device. You may need to accept the terms and conditions, choose the installation location, and allow some permissions for the app to function properly.
-Once the installation is complete, you can find CPU-Z APK Pure on your device's app drawer or home screen. You can also launch it from the notification bar or the file manager app.
-
-Troubleshooting tips if you encounter any problems during installation
-
-If you get an error message that says "App not installed" or "Installation failed", you may need to uninstall any previous versions of CPU-Z that are already installed on your device. You can do this by going to your device's settings, applications, and finding CPU-Z in the list of installed apps. Tap on it and choose uninstall.
-If you get an error message that says "Parse error" or "There was a problem parsing the package", you may have downloaded a corrupted or incompatible CPU-Z APK Pure file. You can try downloading it again from a different source or website, or choose a different version of CPU-Z APK Pure that matches your device's specifications.
-If you get an error message that says "This app is harmful" or "This app may damage your device", you may have downloaded a malicious or infected CPU-Z APK Pure file. You should delete it immediately from your device and scan your device with an antivirus or security app. You should also avoid downloading apps from untrusted or unknown sources in the future.
-
- How to use CPU-Z APK Pure to monitor your device's hardware information
-Once you have installed CPU-Z APK Pure on your Android device, you can use it to monitor your device's hardware information and perform various tests and validations. Here is how to use CPU-Z APK Pure effectively:
-Overview of the main tabs and features of CPU-Z APK Pure
-CPU-Z APK Pure has a simple and user-friendly interface that consists of several tabs and features. Here is an overview of each tab and feature:
-
-
-Tab
-Feature
-Description
-
-
-CPU
-Processor
-Shows the name, number, codename, process, package, and cache levels of your device's processor.
-
-
-CPU
-Clock Speed
-Shows the real time measurement of each core's internal frequency and the memory frequency.
-
-
-CPU
-Temperature
-Shows the current temperature of your device's processor and battery.
-
-
-CPU
-Benchmark
-Allows you to perform a single-thread or multi-thread benchmark test and compare your device's performance with other devices.
-
-
-CPU
-Stress Test
-Allows you to perform a stress test on your device's processor and memory to check their stability and functioning.
-
-
-CPU
-Timer Test
-Allows you to perform a timer test on your device's processor to check its accuracy and precision.
-
-
-CPU
-Validation
-Allows you to validate your device's hardware information online and see how it ranks among other devices in the CPU-Z validation database.
-
-
-Mainboard
-Mainboard and Chipset
-Shows the name, model, vendor, BIOS, and chipset of your device's mainboard.
-
-
-Mainboard
-Memory Type, Size, and Timings
-Shows the type, size, and timings of your device's memory modules.
-
-
-Mainboard
-Module Specifications (SPD)
-Shows the specifications of your device's memory modules, such as manufacturer, part number, serial number, etc.
-
-
-Device
-Model and Android Version
-Shows the name, model, and Android version of your device.
-
-
-Device
-Screen Size and Resolution
-Shows the size and resolution of your device's screen.
-
-
-Device
-Sensors
-Shows the list and status of your device's sensors, such as accelerometer, gyroscope, magnetometer, etc.
-
-
-Device
-Battery Level and Capacity
-Shows the current level and capacity of your device's battery.
-
-
-Device
-Network Type and Signal Strength
-Shows the type and signal strength of your device's network connection.
-
-
-System
-Android System Information Shows the information about your device's Android system, such as kernel version, build number, root access, etc. System > User Apps > Shows the list and details of the user apps installed on your device. > System > System Apps > Shows the list and details of the system apps installed on your device. > About > CPU-Z Version and Developer Information > Shows the version and developer information of CPU-Z APK Pure. >
You can switch between these tabs and features by swiping left or right on the screen. You can also tap on the menu icon on the top left corner of the screen to access more options and settings.
How to perform benchmarks, stress tests, and validations with CPU-Z APK Pure Besides monitoring your device's hardware information, you can also use CPU-Z APK Pure to perform benchmarks, stress tests, and validations. These are useful features that can help you test your device's performance and stability. Here is how to use them:
To perform a benchmark test, go to the CPU tab and tap on the benchmark icon on the top right corner of the screen. You can choose to perform a single-thread or multi-thread benchmark test. The test will measure your device's processor speed and performance in terms of MIPS (million instructions per second). The test will take a few seconds to complete and show you the results. You can compare your results with other devices in the CPU-Z validation database by tapping on the compare icon on the top right corner of the screen. To perform a stress test, go to the CPU tab and tap on the stress test icon on the top right corner of the screen. You can choose to stress test your processor or memory. The test will put a high load on your device's hardware components and measure their temperature and frequency. The test will run until you stop it or until your device reaches a critical temperature. You can monitor the results on the screen or on a notification bar widget. You can stop the test by tapping on the stop icon on the top right corner of the screen. To perform a validation, go to the CPU tab and tap on the validation icon on the top right corner of the screen. The validation will gather your device's hardware information and upload it to the CPU-Z validation database online. You will need an internet connection for this feature. The validation will take a few seconds to complete and show you a link to your validation page online. You can share this link with others or keep it for your records. You can also see how your device ranks among other devices in the CPU-Z validation database by tapping on the rank icon on the top right corner of the screen. Conclusion CPU-Z APK Pure is a powerful tool that can help you monitor your Android device's hardware information and perform various tests and validations. It is easy to download and install from the web, as long as you follow some precautions and tips. It has a simple and user-friendly interface that lets you access various tabs and features with a swipe or a tap. It can help you get accurate and comprehensive information on your device's hardware components, such as processor name and number, codename, process, package, cache levels, mainboard and chipset, memory type, size, timings, and module specifications (SPD), real time measurement of each core's internal frequency, memory frequency, etc. It can also help you test your device's functioning and stability with features like benchmarking, stress tests, and timers. You can also validate your device's hardware information online and see how it ranks among other devices in the CPU-Z validation database. You can also install unknown sources of APK files on your device without any hassle.
- If you are looking for a way to monitor your Android device's hardware information, then you should definitely try CPU-Z APK Pure. It is a free tool that offers many features and benefits that can help you optimize your device's performance and functionality. You can download it from the web safely and easily by following the steps and tips we have provided in this article. You can also use it effectively by following the instructions and guidelines we have provided in this article. We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to contact us or leave a comment below.
-download cpu z apk latest version
- FAQs
-What are the system requirements for CPU-Z APK Pure?
-CPU-Z APK Pure requires an Android device that runs on Android 4.2 or higher. It also requires about 10 MB of free storage space on your device.
-Is CPU-Z APK Pure safe and legal to use?
-CPU-Z APK Pure is safe and legal to use as long as you download it from a trusted and verified source. It does not contain any malware or viruses that can harm your device. It also does not violate any laws or regulations that govern the use of apps on Android devices.
-How can I update CPU-Z APK Pure to the latest version?
-You can update CPU-Z APK Pure to the latest version by downloading it again from the web or by using the built-in update feature in the app. To use the update feature, go to the menu icon on the top left corner of the screen and tap on check for updates. The app will check for any available updates and prompt you to download and install them if there are any.
-What are some alternatives to CPU-Z APK Pure?
-Some alternatives to CPU-Z APK Pure are AIDA64, Geekbench, AnTuTu Benchmark, and Device Info HW. These are also apps that can help you monitor your device's hardware information and perform various tests and validations.
-How can I contact the developers of CPU-Z APK Pure?
-You can contact the developers of CPU-Z APK Pure by visiting their official website at [https://www.cpuid.com/]. You can also send them an email at [support@cpuid.com] or follow them on social media platforms such as Facebook, Twitter, and YouTube.
401be4b1e0Download Online Caste Certificate: A Complete Guide
-A caste certificate is a document that certifies your belonging to a particular caste, especially if you belong to any of the Scheduled Castes (SC), Scheduled Tribes (ST), or Other Backward Classes (OBC) as specified in the Indian Constitution. A caste certificate is important for every individual in India, as it can help you avail various benefits and schemes offered by the government based on your caste.
-download online caste certificate Download File ►►►►► https://urlca.com/2uO9jJ
What is a caste certificate and why do you need it?
-A caste certificate is a proof of your identity and social status in India. It can help you claim reservations and concessions in education, employment, politics, and other fields. It can also help you access various welfare schemes and programs launched by the central and state governments for the upliftment and empowerment of the backward classes. Some of the benefits of having a caste certificate are:
-Benefits of having a caste certificate
-
-You can get admission in educational institutions under reserved quotas.
-You can apply for government jobs under reserved categories.
-You can contest elections from reserved constituencies.
-You can get financial assistance and scholarships from the government.
-You can get subsidies and exemptions on taxes, fees, and charges.
-You can get preference in allotment of land, housing, and other resources.
-
-Eligibility criteria for applying for a caste certificate
-To apply for a caste certificate, you must fulfill the following eligibility criteria:
-
-You must be a citizen of India.
-You must belong to a caste that is recognized as SC, ST, or OBC by the central or state government.
-You must have a permanent residence in the state where you are applying for the caste certificate.
-You must have valid documents to prove your identity, address, and caste.
-
-How to apply for a caste certificate online in different states?
-At present, only a few of the state governments offer an online application to apply for a caste certificate. In order to apply for a caste certificate online, you need to visit the respective state's official backward class welfare department portal and follow the steps given below. However, these steps may vary slightly depending on the state and the portal.
-West Bengal
-
-Visit the Backward Classes Welfare Department portal of West Bengal.
-Click on \"Apply Online\" link under \"Online Application\" section.
-Create a new account in the portal or log in with your existing account.
-Fill in the details in the online form such as name, address, contact details, personal details, local reference details, etc.
-Verify all the details you have filled in the online form and if you agree with terms and conditions click \"Submit\" button.
-Upload the scanned copies of documents such as identity proof, address proof, income proof, etc. and click \"Submit\" button.
-Once submitted, you will get an acknowledgement slip along with an application number. You can take a print out of the acknowledgement slip or save it offline.
-You can also check the status of your application online by clicking on \"Check Status\" link under \"Online Application\" section. You will need your application number for that.
-After the verification is done successfully, you will receive an SMS or email notification about the approval of your caste certificate. You can then download your caste certificate online by following the steps given below.
-
-Bihar
-
-Visit the Bihar Right to Public Service portal .
-Click on \"Apply Online\" link under \"Caste Certificate\" section.
-Create a new account in the portal or log in with your existing account.
-Fill in the details in the online form such as name, address, contact details, personal details, caste details, etc.
-Verify all the details you have filled in the online form and if you agree with terms and conditions click \"Submit\" button.
-Upload the scanned copies of documents such as identity proof, address proof, caste proof, etc. and click \"Submit\" button.
-Once submitted, you will get an acknowledgement slip along with an application number. You can take a print out of the acknowledgement slip or save it offline.
-You can also check the status of your application online by clicking on \"View Status of Application\" link under \"Caste Certificate\" section. You will need your application number for that.
-After the verification is done successfully, you will receive an SMS or email notification about the approval of your caste certificate. You can then download your caste certificate online by following the steps given below.
-
-Other states
-If you belong to any other state that does not have an online portal for applying for a caste certificate, you can still apply online through the e-District portal of the central government. The steps are similar to the ones mentioned above, except that you need to select your state and district from the drop-down menu before filling in the online form. You also need to select the service name as \"Caste Certificate\" from the list of services available. The rest of the steps are same as above.
-How to apply for a caste certificate offline in any state?
-If you are not comfortable with applying for a caste certificate online, or if you do not have access to internet or computer, you can also apply for a caste certificate offline by visiting your nearest tehsil office, revenue office, or backward class welfare office. You need to follow the steps given below:
-Documents required for offline application
-You need to carry the following documents with you when you apply for a caste certificate offline:
-How to download online caste certificate in West Bengal[^1^]
-
-A duly filled and signed application form (you can get it from the office or download it from the state portal)
-A self-attested copy of identity proof such as Aadhaar card, PAN card, voter ID card, etc.
-A self-attested copy of address proof such as ration card, electricity bill, water bill, etc.
-A self-attested copy of caste proof such as old caste certificate, family tree, community certificate, etc.
-A self-attested copy of income proof such as salary slip, income tax return, etc. (if applicable)
-Two passport size photographs
-An affidavit sworn before a magistrate or notary public stating your caste and other details
- Steps to follow for offline application
-
-Visit your nearest tehsil office, revenue office, or backward class welfare office and get the application form for caste certificate. You can also download it from the state portal and print it out.
-Fill in the details in the application form such as name, address, contact details, personal details, caste details, etc.
-Attach the self-attested copies of documents and photographs along with the application form.
-Submit the application form and documents to the concerned authority and pay the prescribed fee (if any).
-Collect the acknowledgement slip or receipt from the authority. It will have your application number and date of submission.
-You can check the status of your application offline by visiting the same office where you submitted your application. You will need your acknowledgement slip or receipt for that.
-After the verification is done successfully, you will receive a notification from the authority about the approval of your caste certificate. You can then collect your caste certificate from the same office by showing your acknowledgement slip or receipt.
-
-How to check the status of your caste certificate application online?
-If you have applied for a caste certificate online, you can check the status of your application online by visiting the respective state's official backward class welfare department portal or the e-District portal of the central government. You need to follow the steps given below:
-Common steps for checking the status online
-
-Visit the portal where you applied for a caste certificate online.
-Click on \"Check Status\" link under \"Online Application\" section or \"View Status of Application\" link under \"Caste Certificate\" section.
-Enter your application number and captcha code (if any) and click on \"Submit\" button.
-You will see the current status of your application on the screen. It may be pending, approved, rejected, or ready for download.
-
-State-specific portals for checking the status online
-
- How to download your caste certificate online?
-If you have applied for a caste certificate online and your application has been approved, you can download your caste certificate online by visiting the respective state's official backward class welfare department portal or the e-District portal of the central government. You need to follow the steps given below:
-Common steps for downloading the caste certificate online
-
-Visit the portal where you applied for a caste certificate online.
-Click on \"Download Certificate\" link under \"Online Application\" section or \"Download Caste Certificate\" link under \"Caste Certificate\" section.
-Enter your application number and captcha code (if any) and click on \"Submit\" button.
-You will see a preview of your caste certificate on the screen. You can verify the details and click on \"Download\" button.
-You will get a PDF file of your caste certificate. You can save it offline or take a print out of it.
-
- State-specific portals for downloading the caste certificate online
-
- Conclusion
- A caste certificate is a vital document that can help you avail various benefits and schemes offered by the government based on your caste. You can apply for a caste certificate online or offline depending on your convenience and availability of resources. You can also check the status and download your caste certificate online by following some simple steps. However, you must ensure that you have all the required documents and information before applying for a caste certificate. You must also keep your application number and acknowledgement slip safe for future reference. We hope this article has helped you understand how to download online caste certificate in India.
- Frequently Asked Questions
-
-Q: How long does it take to get a caste certificate online?
-A: The time taken to get a caste certificate online may vary depending on the state and the portal. However, generally, it may take anywhere between 15 to 30 days for the verification and approval of your application.
-Q: What if I lose my caste certificate or it gets damaged?
-A: If you lose your caste certificate or it gets damaged, you can apply for a duplicate caste certificate online or offline by following the same steps as mentioned above. You will need to provide your application number and a copy of your FIR or affidavit stating the loss or damage of your original caste certificate.
-Q: Can I apply for a caste certificate in a different state than where I reside?
-A: No, you cannot apply for a caste certificate in a different state than where you reside. You must apply for a caste certificate in the state where you have a permanent residence and where your caste is recognized by the government.
-Q: What if I belong to more than one caste or sub-caste?
-A: If you belong to more than one caste or sub-caste, you can apply for a caste certificate for any one of them. However, you cannot apply for multiple caste certificates for different castes or sub-castes.
-Q: What if I change my name, address, or caste after getting a caste certificate?
-A: If you change your name, address, or caste after getting a caste certificate, you will need to apply for a new caste certificate with the updated details. You will need to provide proof of your name change, address change, or caste change along with your old caste certificate.
- 401be4b1e0World Provinces Mod APK: A Game for Geography Lovers
-Do you love geography and maps? Do you want to create your own world with more than 4400 provinces? If yes, then you should try World Provinces Mod APK, a game that lets you design your own world map with history, politics, and flags. In this article, we will tell you what World Provinces Mod APK is, why you should play it, how to play it, and answer some frequently asked questions about it.
- What is World Provinces Mod APK?
-A brief introduction to the game and its features
-World Provinces Mod APK is a modified version of World Provinces. Empire. Maps., a game developed by Uvdb.eu. The game is available for Android devices and can be downloaded from APKPure.com . The game allows you to create your own world map with more than 4400 provinces. You can choose from more than 200 built-in countries with flags, or create your own custom countries. You can also edit the history, geography, and politics of each province, and add events, wars, alliances, and more. You can save your world map as an image or a text file, and share it with other players.
-world provinces mod apk Download File ››››› https://urlca.com/2uOg5d
How to download and install the mod apk file
-To download and install World Provinces Mod APK, you need to follow these steps:
-
-Go to APKPure.com and search for World Provinces. Empire. Maps.
-Click on the download button and wait for the mod apk file to be downloaded.
-Go to your device settings and enable the installation of apps from unknown sources.
-Locate the mod apk file in your device storage and tap on it to install it.
-Launch the game and enjoy creating your own world map.
-
- Why Play World Provinces Mod APK?
-The benefits of playing the game for learning and fun
-World Provinces Mod APK is not only a game, but also a learning tool. By playing the game, you can improve your knowledge of geography, history, and politics. You can learn about different countries, regions, cultures, and flags. You can also explore different scenarios and outcomes of historical events, such as wars, revolutions, colonizations, etc. You can test your creativity and imagination by designing your own world map with your own rules and preferences. You can also have fun by creating fictional or fantasy worlds with magic, dragons, aliens, etc.
-world provinces empire mod apk
-The challenges and rewards of creating your own world map
-Creating your own world map with World Provinces Mod APK is not easy. You need to consider many factors, such as the size, shape, location, climate, population, economy, religion, culture, government, etc. of each province. You need to balance realism and fantasy, logic and creativity. You need to make sure that your world map is consistent and coherent. You also need to deal with potential conflicts and challenges that may arise from your choices, such as wars, rebellions, disasters, etc. However, creating your own world map with World Provinces Mod APK is also rewarding. You can express your creativity and personality through your world map. You can share your world map with other players and get feedback and appreciation. You can also play with your world map and see how it evolves and changes over time.
- How to Play World Provinces Mod APK?
-The basic gameplay and controls of the game
-The gameplay of World Provinces Mod APK is simple and intuitive. You can start by choosing a blank world map or a preset world map from the game. You can then edit the provinces by tapping on them and selecting the options from the menu. You can change the name, flag, color, history, geography, politics, etc. of each province. You can also add or remove provinces by using the tools on the bottom of the screen. You can zoom in or out by pinching the screen, and move the map by dragging it. You can save your world map by tapping on the save button on the top right corner of the screen.
-The tips and tricks for designing your own world map
-Here are some tips and tricks for designing your own world map with World Provinces Mod APK:
-
-Use a reference map or a real-world map as a guide for creating your world map. You can also use online resources, such as Wikipedia, Google Maps, etc., to get information about different countries and regions.
-Think about the theme and style of your world map. Do you want it to be realistic or fantasy? Do you want it to be historical or futuristic? Do you want it to be peaceful or war-torn? Do you want it to be diverse or homogeneous?
-Think about the details and consistency of your world map. How do the provinces relate to each other? How do they interact and influence each other? How do they reflect their history, culture, and environment? How do they cope with their problems and opportunities?
-Think about the balance and variety of your world map. How do you distribute the land and water, the mountains and plains, the forests and deserts, etc.? How do you create contrast and harmony among the provinces? How do you make your world map interesting and unique?
-
- Conclusion
-A summary of the main points and a call to action
-World Provinces Mod APK is a game that lets you create your own world map with more than 4400 provinces. You can customize every aspect of your world map, such as the name, flag, history, geography, politics, etc. of each province. You can also play with your world map and see how it changes over time. World Provinces Mod APK is a game that is fun and educational. You can learn about geography, history, and politics while expressing your creativity and imagination. You can also share your world map with other players and get feedback and appreciation. If you are a geography lover, you should download World Provinces Mod APK from APKPure.com and start creating your own world today.
- FAQs
-What are the requirements for playing World Provinces Mod APK?
-You need an Android device with Android 4.4 or higher version to play World Provinces Mod APK. You also need at least 100 MB of free storage space on your device.
-Is World Provinces Mod APK safe and legal?
-World Provinces Mod APK is safe and legal to download and play. It does not contain any viruses or malware that may harm your device or data. It also does not violate any laws or regulations that may affect your rights or privacy.
-How can I update World Provinces Mod APK?
-You can update World Provinces Mod APK by visiting APKPure.com and downloading the latest version of the mod apk file. You can then install it over the existing version without losing your data or progress.
-Can I share my world map with other players?
-Yes, you can share your world map with other players by saving it as an image or a text file. You can then send it to other players via email, social media, or other platforms. You can also upload it to WorldProvinces.com , a website where you can browse and download other players' world maps.
-Where can I find more information about World Provinces Mod APK?
-You can find more information about World Provinces Mod APK by visiting the official website of the game developer, Uvdb.eu , or the official Facebook page of the game, World Provinces. Empire. Maps. . You can also contact the game developer by email at uvdb.eu@gmail.com or by phone at +48 123 456 789.
197e85843dANCL hack without verification Leaf Tickets and Bells DOWNLOAD ⚙ https://ssurll.com/2uzvNF
diff --git a/spaces/contluForse/HuggingGPT/assets/Chehere In Hd Download The Film That Has Been Making Waves in Bollywood.md b/spaces/contluForse/HuggingGPT/assets/Chehere In Hd Download The Film That Has Been Making Waves in Bollywood.md
deleted file mode 100644
index 3337f651dfdb3d481e76672aacfc655d9d18ff47..0000000000000000000000000000000000000000
--- a/spaces/contluForse/HuggingGPT/assets/Chehere In Hd Download The Film That Has Been Making Waves in Bollywood.md
+++ /dev/null
@@ -1,13 +0,0 @@
-
-Description : Chehre mp3 song download by Harish Verma in album Chehre. The song Chehre is Lyrics by Sandhu Kuldeep Music by Starboy Music X Label Jass Records. Chehre Harish Verma mp3 song belongs to Single Track and Chehre release on Dec 21, 2018. Chehre song playtime is 3:58 minute
-Mp3 Juice is the most popular free mp3 search engine tool and music downloader, is very popular. MP3 Juice is a great tool to convert and download youtube videos and music. The Mp3 Juice website is the best way to quickly and easily download mp3 music. Its simplicity makes Mp3juice easy to use, so anyone can search for and download high-quality audio files
-Chehere In Hd Download Download File ✔ https://ssurll.com/2uzxRM
You can also copy and paste the Youtube URL and hit the convert button. This will convert the youtube video into mp3. After you click the search button, conversion will begin. Your mp3 music file will be available for download in a matter of minutes.
-This website offers unlimited downloading of youtube music and Mp3 juice song free download in HD quality. You can also click "PLAY" to play the audio file before you download it. Mp3juices take only 2-5 seconds to convert and download audio files.
-The mp3juices website has no viruses and is completely safe to use. It's also a great alternative to paid mp3 music downloading tools. Mp3juice can be accessed in many languages. You can use it to convert your YouTube videos to mp3 format.
-You can access this free mp3 download website online via an internet connection or WiFi. Bookmark this website to make it easy to access on a regular basis. Once you have downloaded the audio file, open it in any audio player to listen offline in high-quality.
-MP3 juice music is easy to navigate through and provides a simple interface for downloading the audio. You might be wondering why people prefer mp3juices to get mp3 juice for free. This tool provides high-speed audio downloads, and users don't need to give any personal information.
-
-It is easy to download mp3 juice by visiting the website and entering the song name into the search box or pasting the URL. Select one search result and then convert it to audio by clicking the download button. Finally, hit the Download button to get the audio file at high speeds.
aaccfb2cb3EASEUS Partition Master 15.2 Technican Edition Crack .rar DOWNLOAD ☆ https://ssurll.com/2uzvH5
diff --git a/spaces/cooelf/Multimodal-CoT/timm/models/res2net.py b/spaces/cooelf/Multimodal-CoT/timm/models/res2net.py
deleted file mode 100644
index 282baba3b04f7805b16ffeaef55dd2b19b434f0c..0000000000000000000000000000000000000000
--- a/spaces/cooelf/Multimodal-CoT/timm/models/res2net.py
+++ /dev/null
@@ -1,216 +0,0 @@
-""" Res2Net and Res2NeXt
-Adapted from Official Pytorch impl at: https://github.com/gasvn/Res2Net/
-Paper: `Res2Net: A New Multi-scale Backbone Architecture` - https://arxiv.org/abs/1904.01169
-"""
-import math
-
-import torch
-import torch.nn as nn
-
-from timm.data import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
-from .helpers import build_model_with_cfg
-from .registry import register_model
-from .resnet import ResNet
-
-__all__ = []
-
-
-def _cfg(url='', **kwargs):
- return {
- 'url': url,
- 'num_classes': 1000, 'input_size': (3, 224, 224), 'pool_size': (7, 7),
- 'crop_pct': 0.875, 'interpolation': 'bilinear',
- 'mean': IMAGENET_DEFAULT_MEAN, 'std': IMAGENET_DEFAULT_STD,
- 'first_conv': 'conv1', 'classifier': 'fc',
- **kwargs
- }
-
-
-default_cfgs = {
- 'res2net50_26w_4s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net50_26w_4s-06e79181.pth'),
- 'res2net50_48w_2s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net50_48w_2s-afed724a.pth'),
- 'res2net50_14w_8s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net50_14w_8s-6527dddc.pth'),
- 'res2net50_26w_6s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net50_26w_6s-19041792.pth'),
- 'res2net50_26w_8s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net50_26w_8s-2c7c9f12.pth'),
- 'res2net101_26w_4s': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2net101_26w_4s-02a759a1.pth'),
- 'res2next50': _cfg(
- url='https://github.com/rwightman/pytorch-image-models/releases/download/v0.1-res2net/res2next50_4s-6ef7e7bf.pth'),
-}
-
-
-class Bottle2neck(nn.Module):
- """ Res2Net/Res2NeXT Bottleneck
- Adapted from https://github.com/gasvn/Res2Net/blob/master/res2net.py
- """
- expansion = 4
-
- def __init__(self, inplanes, planes, stride=1, downsample=None,
- cardinality=1, base_width=26, scale=4, dilation=1, first_dilation=None,
- act_layer=nn.ReLU, norm_layer=None, attn_layer=None, **_):
- super(Bottle2neck, self).__init__()
- self.scale = scale
- self.is_first = stride > 1 or downsample is not None
- self.num_scales = max(1, scale - 1)
- width = int(math.floor(planes * (base_width / 64.0))) * cardinality
- self.width = width
- outplanes = planes * self.expansion
- first_dilation = first_dilation or dilation
-
- self.conv1 = nn.Conv2d(inplanes, width * scale, kernel_size=1, bias=False)
- self.bn1 = norm_layer(width * scale)
-
- convs = []
- bns = []
- for i in range(self.num_scales):
- convs.append(nn.Conv2d(
- width, width, kernel_size=3, stride=stride, padding=first_dilation,
- dilation=first_dilation, groups=cardinality, bias=False))
- bns.append(norm_layer(width))
- self.convs = nn.ModuleList(convs)
- self.bns = nn.ModuleList(bns)
- if self.is_first:
- # FIXME this should probably have count_include_pad=False, but hurts original weights
- self.pool = nn.AvgPool2d(kernel_size=3, stride=stride, padding=1)
- else:
- self.pool = None
-
- self.conv3 = nn.Conv2d(width * scale, outplanes, kernel_size=1, bias=False)
- self.bn3 = norm_layer(outplanes)
- self.se = attn_layer(outplanes) if attn_layer is not None else None
-
- self.relu = act_layer(inplace=True)
- self.downsample = downsample
-
- def zero_init_last_bn(self):
- nn.init.zeros_(self.bn3.weight)
-
- def forward(self, x):
- shortcut = x
-
- out = self.conv1(x)
- out = self.bn1(out)
- out = self.relu(out)
-
- spx = torch.split(out, self.width, 1)
- spo = []
- sp = spx[0] # redundant, for torchscript
- for i, (conv, bn) in enumerate(zip(self.convs, self.bns)):
- if i == 0 or self.is_first:
- sp = spx[i]
- else:
- sp = sp + spx[i]
- sp = conv(sp)
- sp = bn(sp)
- sp = self.relu(sp)
- spo.append(sp)
- if self.scale > 1:
- if self.pool is not None:
- # self.is_first == True, None check for torchscript
- spo.append(self.pool(spx[-1]))
- else:
- spo.append(spx[-1])
- out = torch.cat(spo, 1)
-
- out = self.conv3(out)
- out = self.bn3(out)
-
- if self.se is not None:
- out = self.se(out)
-
- if self.downsample is not None:
- shortcut = self.downsample(x)
-
- out += shortcut
- out = self.relu(out)
-
- return out
-
-
-def _create_res2net(variant, pretrained=False, **kwargs):
- return build_model_with_cfg(
- ResNet, variant, pretrained,
- default_cfg=default_cfgs[variant],
- **kwargs)
-
-
-@register_model
-def res2net50_26w_4s(pretrained=False, **kwargs):
- """Constructs a Res2Net-50 26w4s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=26, block_args=dict(scale=4), **kwargs)
- return _create_res2net('res2net50_26w_4s', pretrained, **model_args)
-
-
-@register_model
-def res2net101_26w_4s(pretrained=False, **kwargs):
- """Constructs a Res2Net-101 26w4s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 23, 3], base_width=26, block_args=dict(scale=4), **kwargs)
- return _create_res2net('res2net101_26w_4s', pretrained, **model_args)
-
-
-@register_model
-def res2net50_26w_6s(pretrained=False, **kwargs):
- """Constructs a Res2Net-50 26w6s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=26, block_args=dict(scale=6), **kwargs)
- return _create_res2net('res2net50_26w_6s', pretrained, **model_args)
-
-
-@register_model
-def res2net50_26w_8s(pretrained=False, **kwargs):
- """Constructs a Res2Net-50 26w8s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=26, block_args=dict(scale=8), **kwargs)
- return _create_res2net('res2net50_26w_8s', pretrained, **model_args)
-
-
-@register_model
-def res2net50_48w_2s(pretrained=False, **kwargs):
- """Constructs a Res2Net-50 48w2s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=48, block_args=dict(scale=2), **kwargs)
- return _create_res2net('res2net50_48w_2s', pretrained, **model_args)
-
-
-@register_model
-def res2net50_14w_8s(pretrained=False, **kwargs):
- """Constructs a Res2Net-50 14w8s model.
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=14, block_args=dict(scale=8), **kwargs)
- return _create_res2net('res2net50_14w_8s', pretrained, **model_args)
-
-
-@register_model
-def res2next50(pretrained=False, **kwargs):
- """Construct Res2NeXt-50 4s
- Args:
- pretrained (bool): If True, returns a model pre-trained on ImageNet
- """
- model_args = dict(
- block=Bottle2neck, layers=[3, 4, 6, 3], base_width=4, cardinality=8, block_args=dict(scale=4), **kwargs)
- return _create_res2net('res2next50', pretrained, **model_args)
diff --git a/spaces/coraKong/WorldSimulation/Character.py b/spaces/coraKong/WorldSimulation/Character.py
deleted file mode 100644
index 8caa41fe25725dfb7011591880befb9a337c4a45..0000000000000000000000000000000000000000
--- a/spaces/coraKong/WorldSimulation/Character.py
+++ /dev/null
@@ -1,275 +0,0 @@
-import random
-import math
-from utils import get_random_name, get_random_clan_name
-from config import P_DIE_WHEN_LOSE, IMMORTAL_RANK
-
-cultivation_rank_map = ["炼气期", "筑基期", "结丹期", "元婴期", "化神期", "成仙者"]
-class Character:
- def __init__(self, name, gender, special_constitution, spiritual_roots, clan=None, partner=None, parents=None):
- self.name = name
- self.gender = gender
- self.real_age = 0
- self.apparent_age = 0
- self.cultivation_level = 0 # 等级
- self.cultivation_rank = 0 # 层次
- self.special_constitution = special_constitution
- self.spiritual_roots = spiritual_roots
- self.experience_points = 0
- self.combat_power = self.calculate_combat_power()
- self.partner = partner
- self.is_alive = True
- self.is_immortal = False
- self.buff = False
- self.history = []
- self.special_history = []
- self.consume_spiritual_energy = 0
- self.parents = parents
- self.children = []
- self.clan = clan # 宗族
-
- def die(self):
- if self.is_alive and not self.is_immortal:
- self.history.append(f"{self.real_age}岁，死亡")
- self.special_history.append(f"{self.real_age}岁，死亡")
- self.is_alive = False
-
- def cultivate(self, experience_points):
- if not self.is_alive:
- print("角色已经死亡，无法进行修炼。")
- return
- # 成仙者不再修炼
- if self.is_immortal:
- return
-
- self.experience_points += experience_points
-
- # 根据经验值计算等级，等级越高，升级需要的经验值就越多
- self.cultivation_level = math.floor(self.experience_points / ((1 + self.cultivation_rank) * 1000 + (1 + self.cultivation_level) * 100))
-
- # 判断是否达到突破修为层次的条件
- if self.cultivation_level >= 10:
- # 使用一个随机数来表示突破的概率，当前rank越高，则突破成功的概率越低
- success_probability = 0.9 / (self.cultivation_rank * 2 + 1)
- if random.random() < success_probability:
- cultivation_level = self.cultivation_level
- self.cultivation_rank += 1
- self.cultivation_level = 0
- self.experience_points = 0
- self.history.append(f"{self.real_age}岁，突破成功，在{cultivation_level}级, 到达{self.view_rank()}")
- self.special_history.append(f"{self.real_age}岁，突破成功，在{cultivation_level}级, 到达{self.view_rank()}")
- # 判断是否达到成仙的条件
- if self.cultivation_rank >= IMMORTAL_RANK:
- self.is_immortal = True
- self.history.append(f"{self.real_age}岁，成仙了")
- self.special_history.append(f"{self.real_age}岁，成仙了")
- else:
- self.history.append(f"{self.real_age}岁，突破失败，在{self.cultivation_level}级")
-
- def marry(self, partner):
- # 成仙者不再结婚
- if self.is_immortal:
- return
- if not self.is_alive:
- print("角色已经死亡，无法结婚。")
- return
- self.partner = partner
- partner.partner = self
-
- # 结婚合并宗族
- if self.clan and partner.clan:
- if random.random() < 0.5:
- partner.clan = self.clan
- else:
- self.clan = partner.clan
- else:
- self.clan = self.clan or partner.clan or get_random_clan_name()
- partner.clan = self.clan
-
- self.history.append(f"{self.real_age}岁，结婚了")
- self.partner.history.append(f"{self.partner.real_age}岁，结婚了")
- self.special_history.append(f"{self.real_age}岁，结婚了")
- self.partner.special_history.append(f"{self.partner.real_age}岁，结婚了")
-
- def give_birth(self):
- # 成仙者不会生育
- if self.is_immortal:
- return
- if not self.is_alive:
- print("角色已经死亡，无法生育。")
- return
- if not self.partner:
- print("角色没有结婚，无法生育。")
- return
-
- # 合欢体质加buff
- if self.special_constitution[1] == 1:
- self.buff = True
-
-
- # 小孩有一定几率遗传父亲或母亲的特殊体质和灵根
- special_constitution = [a if random.random() < 0.5 else b for (a, b) in zip(self.special_constitution, self.partner.special_constitution)]
- spiritual_roots = [a if random.random() < 0.5 else b for (a, b) in zip(self.spiritual_roots, self.partner.spiritual_roots)]
-
- # spiritual_roots 一定几率突变
- spiritual_roots = [random.choice([0, 1]) if random.random() < 0.01 else v for v in spiritual_roots]
-
- child = Character(get_random_name(), random.choice(["男", "女"]), special_constitution, spiritual_roots, clan=self.clan, parents=[self, self.partner])
- self.history.append(f"{self.real_age}岁，生下小孩{child.name}")
- self.partner.history.append(f"{self.partner.real_age}岁，生下小孩{child.name}")
- self.children.append(child)
- self.partner.children.append(child)
- return child
-
- def grow(self):
- # 成仙者不会衰老
- if self.is_immortal:
- return
- self.real_age += 1
-
- # 根据修为层次 和 是否拥有木灵根 计算表观年龄
- # 修为层次越高，外表看起来越年轻
- ratio = 1 + self.cultivation_rank
-
- # 灵龟和蜉蝣体质
- if self.special_constitution[2] == 1: # 灵龟体质
- ratio *= 2
- elif self.special_constitution[3] == 1: # 蜉蝣体质
- ratio *= 0.5
-
- # 根据修为层次计算加成比例，初始加成为10%
- bonus = 0.1 * (self.cultivation_rank * 0 + 1)
- if self.spiritual_roots[1] == 1: # 拥有木灵根（灵根的第二位），最大寿命有加成
- ratio *= 1 + bonus
-
- self.apparent_age = math.floor(self.real_age / ratio)
-
- def calculate_combat_power(self):
- # 根据修为层次和修为等级计算战斗力参数：等级越高，各数值都越高；层次对等级是碾压效果
- attack_power = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
- defense_power = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
- attack_speed = (self.cultivation_rank + 1) * 30 + 1 * (1 + self.cultivation_level)
- health_points = (self.cultivation_rank + 1) * 90 + 3 * (1 + self.cultivation_level)
-
- # 根据修为层次计算加成比例，初始加成为10%
- bonus = 0.1 * (self.cultivation_rank * 0 + 1)
-
- # 根据灵根调整战斗力参数，灵根分别为：[金木水火土], 分别对以下属性有加成：攻击速度, 最大寿命, 生命值, 攻击力, 防御力
- if self.spiritual_roots[0] == 1: # 金
- attack_speed *= 1 + bonus
-
- if self.spiritual_roots[2] == 1: # 水
- health_points *= 1 + bonus
-
- if self.spiritual_roots[3] == 1: # 火
- attack_power *= 1 + bonus
-
- if self.spiritual_roots[4] == 1: # 土
- defense_power *= 1 + bonus
-
- return {
- 'attack_power': math.ceil(attack_power),
- 'defense_power': math.ceil(defense_power),
- 'attack_speed': math.ceil(attack_speed),
- 'health_points': math.ceil(health_points),
- }
-
- def before_battle(self):
- self.combat_power = self.calculate_combat_power()
-
- def attack(self, opponent, params={"P_CRIT": 0.2, "P_DODGE": 0.05, "P_BLOCK": 0.1, "P_COUNTER": 0.05}):
- # 成仙者不会打架
- if self.is_immortal:
- return
- if not self.is_alive:
- print("角色已经死亡，无法攻击。")
- return
-
- # 战斗体质加buff
- if self.special_constitution[0] == 1:
- self.buff = True
-
- # 根据攻击速度计算攻击次数
- attack_times = math.ceil(self.combat_power['attack_speed'] / 10)
- # 根据攻击力计算伤害
- damage = self.combat_power['attack_power'] * attack_times
- # 根据防御力计算伤害减免
- damage -= opponent.combat_power['defense_power']
- # 伤害最小为1
- damage = max(1, damage)
- # 根据概率计算暴击
- if random.random() < params['P_CRIT']:
- damage *= 2
- print("暴击！")
- # 根据概率计算闪避
- if random.random() < params['P_DODGE']:
- print("闪避！")
- return
- # 根据概率计算格挡
- if random.random() < params['P_BLOCK']:
- print("格挡！")
- damage = max(1, damage // 2)
- # 根据概率计算反击
- if random.random() < params['P_COUNTER']:
- print("反击！")
- damage = max(1, damage // 2)
- opponent.combat_power['health_points'] -= damage
- return
-
- if damage > 0:
- opponent.combat_power['health_points'] -= damage
-
- def check_is_alive(self):
- if self.combat_power['health_points'] <= 0:
- # 一定概率会死亡
- if random.random() < P_DIE_WHEN_LOSE:
- self.die()
- return False
- return True
-
- def __str__(self):
- # Display current attributes
- history = "\n".join(self.history)
- attributes = [
- f"名字: {self.name}",
- f"性别: {self.gender}",
- f"年龄: {self.real_age}",
- f"表观年龄: {self.apparent_age}",
- f"修仙阶段: ({self.cultivation_rank}){self.view_rank()}",
- f"特殊体质: {[special_constitution for (special_constitution, is_active) in zip(['战斗体质', '合欢体质', '灵龟体质', '蜉蝣体质'], self.special_constitution) if is_active]}",
- f"灵根: {[spiritual_root for (spiritual_root, is_active) in zip(['金', '木', '水', '火', '土'], self.spiritual_roots) if is_active]}",
- f"伴侣: {self.partner.name if self.partner is not None else '无'}",
- f"存活: {self.is_alive}",
- f"宗族: {self.clan if self.clan is not None else '无'}",
- f"父母: {[parent.name for parent in self.parents] if self.parents is not None else '无'}",
- f"孩子: {[child.name for child in self.children]}",
- f"Combat Power: {self.combat_power}",
- f"Experience Points: {self.experience_points}",
- f"Buff: {self.buff}",
- f"历程: {history}",
- ]
- return "\n".join(attributes)
-
- def view_rank(self):
- if self.cultivation_rank <= len(cultivation_rank_map):
- return f"{cultivation_rank_map[self.cultivation_rank]}({self.cultivation_level})"
- else:
- return "天外飞仙"
-
- def to_list(self):
- numerical_attributes = [
- self.real_age,
- self.apparent_age,
- self.cultivation_level,
- self.cultivation_rank,
- self.experience_points,
- self.combat_power["attack_power"],
- self.combat_power["defense_power"],
- self.combat_power["attack_speed"],
- self.combat_power["health_points"],
- *self.special_constitution, # [1, 0, 0, 0], 数组解构拼接
- *self.spiritual_roots, # [1, 0, 0, 0, 0], 数组解构拼接
- 1 if self.is_alive else 0, # bool转int
- 1 if self.buff else 0, # bool转int
- len(self.children),
- ]
- return numerical_attributes
\ No newline at end of file
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmseg/core/seg/sampler/ohem_pixel_sampler.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmseg/core/seg/sampler/ohem_pixel_sampler.py
deleted file mode 100644
index 88bb10d44026ba9f21756eaea9e550841cd59b9f..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/mmpkg/mmseg/core/seg/sampler/ohem_pixel_sampler.py
+++ /dev/null
@@ -1,76 +0,0 @@
-import torch
-import torch.nn.functional as F
-
-from ..builder import PIXEL_SAMPLERS
-from .base_pixel_sampler import BasePixelSampler
-
-
-@PIXEL_SAMPLERS.register_module()
-class OHEMPixelSampler(BasePixelSampler):
- """Online Hard Example Mining Sampler for segmentation.
-
- Args:
- context (nn.Module): The context of sampler, subclass of
- :obj:`BaseDecodeHead`.
- thresh (float, optional): The threshold for hard example selection.
- Below which, are prediction with low confidence. If not
- specified, the hard examples will be pixels of top ``min_kept``
- loss. Default: None.
- min_kept (int, optional): The minimum number of predictions to keep.
- Default: 100000.
- """
-
- def __init__(self, context, thresh=None, min_kept=100000):
- super(OHEMPixelSampler, self).__init__()
- self.context = context
- assert min_kept > 1
- self.thresh = thresh
- self.min_kept = min_kept
-
- def sample(self, seg_logit, seg_label):
- """Sample pixels that have high loss or with low prediction confidence.
-
- Args:
- seg_logit (torch.Tensor): segmentation logits, shape (N, C, H, W)
- seg_label (torch.Tensor): segmentation label, shape (N, 1, H, W)
-
- Returns:
- torch.Tensor: segmentation weight, shape (N, H, W)
- """
- with torch.no_grad():
- assert seg_logit.shape[2:] == seg_label.shape[2:]
- assert seg_label.shape[1] == 1
- seg_label = seg_label.squeeze(1).long()
- batch_kept = self.min_kept * seg_label.size(0)
- valid_mask = seg_label != self.context.ignore_index
- seg_weight = seg_logit.new_zeros(size=seg_label.size())
- valid_seg_weight = seg_weight[valid_mask]
- if self.thresh is not None:
- seg_prob = F.softmax(seg_logit, dim=1)
-
- tmp_seg_label = seg_label.clone().unsqueeze(1)
- tmp_seg_label[tmp_seg_label == self.context.ignore_index] = 0
- seg_prob = seg_prob.gather(1, tmp_seg_label).squeeze(1)
- sort_prob, sort_indices = seg_prob[valid_mask].sort()
-
- if sort_prob.numel() > 0:
- min_threshold = sort_prob[min(batch_kept,
- sort_prob.numel() - 1)]
- else:
- min_threshold = 0.0
- threshold = max(min_threshold, self.thresh)
- valid_seg_weight[seg_prob[valid_mask] < threshold] = 1.
- else:
- losses = self.context.loss_decode(
- seg_logit,
- seg_label,
- weight=None,
- ignore_index=self.context.ignore_index,
- reduction_override='none')
- # faster than topk according to https://github.com/pytorch/pytorch/issues/22812 # noqa
- _, sort_indices = losses[valid_mask].sort(descending=True)
- valid_seg_weight[sort_indices[:batch_kept]] = 1.
-
- seg_weight[valid_mask] = valid_seg_weight
-
- return seg_weight
diff --git a/spaces/crashedice/signify/SOURCE/yolo_files/utils/torch_utils.py b/spaces/crashedice/signify/SOURCE/yolo_files/utils/torch_utils.py
deleted file mode 100644
index 9991e5ec87d8b1ed953d88c30bb57ff25431f5ab..0000000000000000000000000000000000000000
--- a/spaces/crashedice/signify/SOURCE/yolo_files/utils/torch_utils.py
+++ /dev/null
@@ -1,303 +0,0 @@
-# YOLOv5 PyTorch utils
-
-import datetime
-import logging
-import math
-import os
-import platform
-import subprocess
-import time
-from contextlib import contextmanager
-from copy import deepcopy
-from pathlib import Path
-
-import torch
-import torch.backends.cudnn as cudnn
-import torch.nn as nn
-import torch.nn.functional as F
-import torchvision
-
-try:
- import thop # for FLOPS computation
-except ImportError:
- thop = None
-logger = logging.getLogger(__name__)
-
-
-@contextmanager
-def torch_distributed_zero_first(local_rank: int):
- """
- Decorator to make all processes in distributed training wait for each local_master to do something.
- """
- if local_rank not in [-1, 0]:
- torch.distributed.barrier()
- yield
- if local_rank == 0:
- torch.distributed.barrier()
-
-
-def init_torch_seeds(seed=0):
- # Speed-reproducibility tradeoff https://pytorch.org/docs/stable/notes/randomness.html
- torch.manual_seed(seed)
- if seed == 0: # slower, more reproducible
- cudnn.benchmark, cudnn.deterministic = False, True
- else: # faster, less reproducible
- cudnn.benchmark, cudnn.deterministic = True, False
-
-
-def date_modified(path=__file__):
- # return human-readable file modification date, i.e. '2021-3-26'
- t = datetime.datetime.fromtimestamp(Path(path).stat().st_mtime)
- return f'{t.year}-{t.month}-{t.day}'
-
-
-def git_describe(path=Path(__file__).parent): # path must be a directory
- # return human-readable git description, i.e. v5.0-5-g3e25f1e https://git-scm.com/docs/git-describe
- s = f'git -C {path} describe --tags --long --always'
- try:
- return subprocess.check_output(s, shell=True, stderr=subprocess.STDOUT).decode()[:-1]
- except subprocess.CalledProcessError as e:
- return '' # not a git repository
-
-
-def select_device(device='', batch_size=None):
- # device = 'cpu' or '0' or '0,1,2,3'
- s = f'YOLOv5 🚀 {git_describe() or date_modified()} torch {torch.__version__} ' # string
- cpu = device.lower() == 'cpu'
- if cpu:
- os.environ['CUDA_VISIBLE_DEVICES'] = '-1' # force torch.cuda.is_available() = False
- elif device: # non-cpu device requested
- os.environ['CUDA_VISIBLE_DEVICES'] = device # set environment variable
- assert torch.cuda.is_available(), f'CUDA unavailable, invalid device {device} requested' # check availability
-
- cuda = not cpu and torch.cuda.is_available()
- if cuda:
- n = torch.cuda.device_count()
- if n > 1 and batch_size: # check that batch_size is compatible with device_count
- assert batch_size % n == 0, f'batch-size {batch_size} not multiple of GPU count {n}'
- space = ' ' * len(s)
- for i, d in enumerate(device.split(',') if device else range(n)):
- p = torch.cuda.get_device_properties(i)
- s += f"{'' if i == 0 else space}CUDA:{d} ({p.name}, {p.total_memory / 1024 ** 2}MB)\n" # bytes to MB
- else:
- s += 'CPU\n'
-
- logger.info(s.encode().decode('ascii', 'ignore') if platform.system() == 'Windows' else s) # emoji-safe
- return torch.device('cuda:0' if cuda else 'cpu')
-
-
-def time_synchronized():
- # pytorch-accurate time
- if torch.cuda.is_available():
- torch.cuda.synchronize()
- return time.time()
-
-
-def profile(x, ops, n=100, device=None):
- # profile a pytorch module or list of modules. Example usage:
- # x = torch.randn(16, 3, 640, 640) # input
- # m1 = lambda x: x * torch.sigmoid(x)
- # m2 = nn.SiLU()
- # profile(x, [m1, m2], n=100) # profile speed over 100 iterations
-
- device = device or torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
- x = x.to(device)
- x.requires_grad = True
- print(torch.__version__, device.type, torch.cuda.get_device_properties(0) if device.type == 'cuda' else '')
- print(f"\n{'Params':>12s}{'GFLOPS':>12s}{'forward (ms)':>16s}{'backward (ms)':>16s}{'input':>24s}{'output':>24s}")
- for m in ops if isinstance(ops, list) else [ops]:
- m = m.to(device) if hasattr(m, 'to') else m # device
- m = m.half() if hasattr(m, 'half') and isinstance(x, torch.Tensor) and x.dtype is torch.float16 else m # type
- dtf, dtb, t = 0., 0., [0., 0., 0.] # dt forward, backward
- try:
- flops = thop.profile(m, inputs=(x,), verbose=False)[0] / 1E9 * 2 # GFLOPS
- except:
- flops = 0
-
- for _ in range(n):
- t[0] = time_synchronized()
- y = m(x)
- t[1] = time_synchronized()
- try:
- _ = y.sum().backward()
- t[2] = time_synchronized()
- except: # no backward method
- t[2] = float('nan')
- dtf += (t[1] - t[0]) * 1000 / n # ms per op forward
- dtb += (t[2] - t[1]) * 1000 / n # ms per op backward
-
- s_in = tuple(x.shape) if isinstance(x, torch.Tensor) else 'list'
- s_out = tuple(y.shape) if isinstance(y, torch.Tensor) else 'list'
- p = sum(list(x.numel() for x in m.parameters())) if isinstance(m, nn.Module) else 0 # parameters
- print(f'{p:12}{flops:12.4g}{dtf:16.4g}{dtb:16.4g}{str(s_in):>24s}{str(s_out):>24s}')
-
-
-def is_parallel(model):
- return type(model) in (nn.parallel.DataParallel, nn.parallel.DistributedDataParallel)
-
-
-def intersect_dicts(da, db, exclude=()):
- # Dictionary intersection of matching keys and shapes, omitting 'exclude' keys, using da values
- return {k: v for k, v in da.items() if k in db and not any(x in k for x in exclude) and v.shape == db[k].shape}
-
-
-def initialize_weights(model):
- for m in model.modules():
- t = type(m)
- if t is nn.Conv2d:
- pass # nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
- elif t is nn.BatchNorm2d:
- m.eps = 1e-3
- m.momentum = 0.03
- elif t in [nn.Hardswish, nn.LeakyReLU, nn.ReLU, nn.ReLU6]:
- m.inplace = True
-
-
-def find_modules(model, mclass=nn.Conv2d):
- # Finds layer indices matching module class 'mclass'
- return [i for i, m in enumerate(model.module_list) if isinstance(m, mclass)]
-
-
-def sparsity(model):
- # Return global model sparsity
- a, b = 0., 0.
- for p in model.parameters():
- a += p.numel()
- b += (p == 0).sum()
- return b / a
-
-
-def prune(model, amount=0.3):
- # Prune model to requested global sparsity
- import torch.nn.utils.prune as prune
- print('Pruning model... ', end='')
- for name, m in model.named_modules():
- if isinstance(m, nn.Conv2d):
- prune.l1_unstructured(m, name='weight', amount=amount) # prune
- prune.remove(m, 'weight') # make permanent
- print(' %.3g global sparsity' % sparsity(model))
-
-
-def fuse_conv_and_bn(conv, bn):
- # Fuse convolution and batchnorm layers https://tehnokv.com/posts/fusing-batchnorm-and-conv/
- fusedconv = nn.Conv2d(conv.in_channels,
- conv.out_channels,
- kernel_size=conv.kernel_size,
- stride=conv.stride,
- padding=conv.padding,
- groups=conv.groups,
- bias=True).requires_grad_(False).to(conv.weight.device)
-
- # prepare filters
- w_conv = conv.weight.clone().view(conv.out_channels, -1)
- w_bn = torch.diag(bn.weight.div(torch.sqrt(bn.eps + bn.running_var)))
- fusedconv.weight.copy_(torch.mm(w_bn, w_conv).view(fusedconv.weight.shape))
-
- # prepare spatial bias
- b_conv = torch.zeros(conv.weight.size(0), device=conv.weight.device) if conv.bias is None else conv.bias
- b_bn = bn.bias - bn.weight.mul(bn.running_mean).div(torch.sqrt(bn.running_var + bn.eps))
- fusedconv.bias.copy_(torch.mm(w_bn, b_conv.reshape(-1, 1)).reshape(-1) + b_bn)
-
- return fusedconv
-
-
-def model_info(model, verbose=False, img_size=640):
- # Model information. img_size may be int or list, i.e. img_size=640 or img_size=[640, 320]
- n_p = sum(x.numel() for x in model.parameters()) # number parameters
- n_g = sum(x.numel() for x in model.parameters() if x.requires_grad) # number gradients
- if verbose:
- print('%5s %40s %9s %12s %20s %10s %10s' % ('layer', 'name', 'gradient', 'parameters', 'shape', 'mu', 'sigma'))
- for i, (name, p) in enumerate(model.named_parameters()):
- name = name.replace('module_list.', '')
- print('%5g %40s %9s %12g %20s %10.3g %10.3g' %
- (i, name, p.requires_grad, p.numel(), list(p.shape), p.mean(), p.std()))
-
- try: # FLOPS
- from thop import profile
- stride = max(int(model.stride.max()), 32) if hasattr(model, 'stride') else 32
- img = torch.zeros((1, model.yaml.get('ch', 3), stride, stride), device=next(model.parameters()).device) # input
- flops = profile(deepcopy(model), inputs=(img,), verbose=False)[0] / 1E9 * 2 # stride GFLOPS
- img_size = img_size if isinstance(img_size, list) else [img_size, img_size] # expand if int/float
- fs = ', %.1f GFLOPS' % (flops * img_size[0] / stride * img_size[1] / stride) # 640x640 GFLOPS
- except (ImportError, Exception):
- fs = ''
-
- logger.info(f"Model Summary: {len(list(model.modules()))} layers, {n_p} parameters, {n_g} gradients{fs}")
-
-
-def load_classifier(name='resnet101', n=2):
- # Loads a pretrained model reshaped to n-class output
- model = torchvision.models.__dict__[name](pretrained=True)
-
- # ResNet model properties
- # input_size = [3, 224, 224]
- # input_space = 'RGB'
- # input_range = [0, 1]
- # mean = [0.485, 0.456, 0.406]
- # std = [0.229, 0.224, 0.225]
-
- # Reshape output to n classes
- filters = model.fc.weight.shape[1]
- model.fc.bias = nn.Parameter(torch.zeros(n), requires_grad=True)
- model.fc.weight = nn.Parameter(torch.zeros(n, filters), requires_grad=True)
- model.fc.out_features = n
- return model
-
-
-def scale_img(img, ratio=1.0, same_shape=False, gs=32): # img(16,3,256,416)
- # scales img(bs,3,y,x) by ratio constrained to gs-multiple
- if ratio == 1.0:
- return img
- else:
- h, w = img.shape[2:]
- s = (int(h * ratio), int(w * ratio)) # new size
- img = F.interpolate(img, size=s, mode='bilinear', align_corners=False) # resize
- if not same_shape: # pad/crop img
- h, w = [math.ceil(x * ratio / gs) * gs for x in (h, w)]
- return F.pad(img, [0, w - s[1], 0, h - s[0]], value=0.447) # value = imagenet mean
-
-
-def copy_attr(a, b, include=(), exclude=()):
- # Copy attributes from b to a, options to only include [...] and to exclude [...]
- for k, v in b.__dict__.items():
- if (len(include) and k not in include) or k.startswith('_') or k in exclude:
- continue
- else:
- setattr(a, k, v)
-
-
-class ModelEMA:
- """ Model Exponential Moving Average from https://github.com/rwightman/pytorch-image-models
- Keep a moving average of everything in the model state_dict (parameters and buffers).
- This is intended to allow functionality like
- https://www.tensorflow.org/api_docs/python/tf/train/ExponentialMovingAverage
- A smoothed version of the weights is necessary for some training schemes to perform well.
- This class is sensitive where it is initialized in the sequence of model init,
- GPU assignment and distributed training wrappers.
- """
-
- def __init__(self, model, decay=0.9999, updates=0):
- # Create EMA
- self.ema = deepcopy(model.module if is_parallel(model) else model).eval() # FP32 EMA
- # if next(model.parameters()).device.type != 'cpu':
- # self.ema.half() # FP16 EMA
- self.updates = updates # number of EMA updates
- self.decay = lambda x: decay * (1 - math.exp(-x / 2000)) # decay exponential ramp (to help early epochs)
- for p in self.ema.parameters():
- p.requires_grad_(False)
-
- def update(self, model):
- # Update EMA parameters
- with torch.no_grad():
- self.updates += 1
- d = self.decay(self.updates)
-
- msd = model.module.state_dict() if is_parallel(model) else model.state_dict() # model state_dict
- for k, v in self.ema.state_dict().items():
- if v.dtype.is_floating_point:
- v *= d
- v += (1. - d) * msd[k].detach()
-
- def update_attr(self, model, include=(), exclude=('process_group', 'reducer')):
- # Update EMA attributes
- copy_attr(self.ema, model, include, exclude)
diff --git a/spaces/crylake/img2poem/query2labels/lib/models/position_encoding.py b/spaces/crylake/img2poem/query2labels/lib/models/position_encoding.py
deleted file mode 100644
index 2cf53a923c1dfb32c5ae57501805f90348c9afef..0000000000000000000000000000000000000000
--- a/spaces/crylake/img2poem/query2labels/lib/models/position_encoding.py
+++ /dev/null
@@ -1,74 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-"""
-We borrow the positional encoding from Detr and simplify the model.
-"""
-import math
-import torch
-from torch import nn
-from torch.functional import Tensor
-
-# from utils.misc import NestedTensor
-
-
-class PositionEmbeddingSine(nn.Module):
- """
- This is a more standard version of the position embedding, very similar to the one
- used by the Attention is all you need paper, generalized to work on images.
- """
- def __init__(self, num_pos_feats=64, temperature=10000, normalize=False, scale=None, maxH=30, maxW=30):
- super().__init__()
- self.num_pos_feats = num_pos_feats
- self.temperature = temperature
- self.normalize = normalize
- if scale is not None and normalize is False:
- raise ValueError("normalize should be True if scale is passed")
- if scale is None:
- scale = 2 * math.pi
- self.scale = scale
-
- self.maxH = maxH
- self.maxW = maxW
- pe = self._gen_pos_buffer()
- self.register_buffer('pe', pe)
-
- def _gen_pos_buffer(self):
- _eyes = torch.ones((1, self.maxH, self.maxW))
- y_embed = _eyes.cumsum(1, dtype=torch.float32)
- x_embed = _eyes.cumsum(2, dtype=torch.float32)
- if self.normalize:
- eps = 1e-6
- y_embed = y_embed / (y_embed[:, -1:, :] + eps) * self.scale
- x_embed = x_embed / (x_embed[:, :, -1:] + eps) * self.scale
-
- dim_t = torch.arange(self.num_pos_feats, dtype=torch.float32)
- dim_t = self.temperature ** (2 * (dim_t // 2) / self.num_pos_feats)
-
- pos_x = x_embed[:, :, :, None] / dim_t
- pos_y = y_embed[:, :, :, None] / dim_t
- pos_x = torch.stack((pos_x[:, :, :, 0::2].sin(), pos_x[:, :, :, 1::2].cos()), dim=4).flatten(3)
- pos_y = torch.stack((pos_y[:, :, :, 0::2].sin(), pos_y[:, :, :, 1::2].cos()), dim=4).flatten(3)
- pos = torch.cat((pos_y, pos_x), dim=3).permute(0, 3, 1, 2)
- return pos
-
- def forward(self, input: Tensor):
- x = input
- return self.pe.repeat((x.size(0),1,1,1))
-
-
-def build_position_encoding(args):
- N_steps = args.hidden_dim // 2
-
- if args.backbone in ['CvT_w24'] :
- downsample_ratio = 16
- else:
- downsample_ratio = 32
-
- if args.position_embedding in ('v2', 'sine'):
- # TODO find a better way of exposing other arguments
- assert args.img_size % 32 == 0, "args.img_size ({}) % 32 != 0".format(args.img_size)
- position_embedding = PositionEmbeddingSine(N_steps, normalize=True, maxH=args.img_size // downsample_ratio, maxW=args.img_size // downsample_ratio)
- # import ipdb; ipdb.set_trace()
- else:
- raise ValueError(f"not supported {args.position_embedding}")
-
- return position_embedding
diff --git a/spaces/cryptoanonymous/02dlyaPerevoda3dVideoV2DAnime/README.md b/spaces/cryptoanonymous/02dlyaPerevoda3dVideoV2DAnime/README.md
deleted file mode 100644
index 1393a47063f06157b55843d803b3339075788997..0000000000000000000000000000000000000000
--- a/spaces/cryptoanonymous/02dlyaPerevoda3dVideoV2DAnime/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: 02dlyaPerevoda3dVideoV2DAnime
-emoji: 🦀
-colorFrom: indigo
-colorTo: blue
-sdk: docker
-pinned: false
-license: openrail
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/cvlab/zero123-live/taming-transformers/taming/modules/transformer/mingpt.py b/spaces/cvlab/zero123-live/taming-transformers/taming/modules/transformer/mingpt.py
deleted file mode 100644
index d14b7b68117f4b9f297b2929397cd4f55089334c..0000000000000000000000000000000000000000
--- a/spaces/cvlab/zero123-live/taming-transformers/taming/modules/transformer/mingpt.py
+++ /dev/null
@@ -1,415 +0,0 @@
-"""
-taken from: https://github.com/karpathy/minGPT/
-GPT model:
-- the initial stem consists of a combination of token encoding and a positional encoding
-- the meat of it is a uniform sequence of Transformer blocks
- - each Transformer is a sequential combination of a 1-hidden-layer MLP block and a self-attention block
- - all blocks feed into a central residual pathway similar to resnets
-- the final decoder is a linear projection into a vanilla Softmax classifier
-"""
-
-import math
-import logging
-
-import torch
-import torch.nn as nn
-from torch.nn import functional as F
-from transformers import top_k_top_p_filtering
-
-logger = logging.getLogger(__name__)
-
-
-class GPTConfig:
- """ base GPT config, params common to all GPT versions """
- embd_pdrop = 0.1
- resid_pdrop = 0.1
- attn_pdrop = 0.1
-
- def __init__(self, vocab_size, block_size, **kwargs):
- self.vocab_size = vocab_size
- self.block_size = block_size
- for k,v in kwargs.items():
- setattr(self, k, v)
-
-
-class GPT1Config(GPTConfig):
- """ GPT-1 like network roughly 125M params """
- n_layer = 12
- n_head = 12
- n_embd = 768
-
-
-class CausalSelfAttention(nn.Module):
- """
- A vanilla multi-head masked self-attention layer with a projection at the end.
- It is possible to use torch.nn.MultiheadAttention here but I am including an
- explicit implementation here to show that there is nothing too scary here.
- """
-
- def __init__(self, config):
- super().__init__()
- assert config.n_embd % config.n_head == 0
- # key, query, value projections for all heads
- self.key = nn.Linear(config.n_embd, config.n_embd)
- self.query = nn.Linear(config.n_embd, config.n_embd)
- self.value = nn.Linear(config.n_embd, config.n_embd)
- # regularization
- self.attn_drop = nn.Dropout(config.attn_pdrop)
- self.resid_drop = nn.Dropout(config.resid_pdrop)
- # output projection
- self.proj = nn.Linear(config.n_embd, config.n_embd)
- # causal mask to ensure that attention is only applied to the left in the input sequence
- mask = torch.tril(torch.ones(config.block_size,
- config.block_size))
- if hasattr(config, "n_unmasked"):
- mask[:config.n_unmasked, :config.n_unmasked] = 1
- self.register_buffer("mask", mask.view(1, 1, config.block_size, config.block_size))
- self.n_head = config.n_head
-
- def forward(self, x, layer_past=None):
- B, T, C = x.size()
-
- # calculate query, key, values for all heads in batch and move head forward to be the batch dim
- k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
- q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
- v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
-
- present = torch.stack((k, v))
- if layer_past is not None:
- past_key, past_value = layer_past
- k = torch.cat((past_key, k), dim=-2)
- v = torch.cat((past_value, v), dim=-2)
-
- # causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)
- att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
- if layer_past is None:
- att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf'))
-
- att = F.softmax(att, dim=-1)
- att = self.attn_drop(att)
- y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
- y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
-
- # output projection
- y = self.resid_drop(self.proj(y))
- return y, present # TODO: check that this does not break anything
-
-
-class Block(nn.Module):
- """ an unassuming Transformer block """
- def __init__(self, config):
- super().__init__()
- self.ln1 = nn.LayerNorm(config.n_embd)
- self.ln2 = nn.LayerNorm(config.n_embd)
- self.attn = CausalSelfAttention(config)
- self.mlp = nn.Sequential(
- nn.Linear(config.n_embd, 4 * config.n_embd),
- nn.GELU(), # nice
- nn.Linear(4 * config.n_embd, config.n_embd),
- nn.Dropout(config.resid_pdrop),
- )
-
- def forward(self, x, layer_past=None, return_present=False):
- # TODO: check that training still works
- if return_present: assert not self.training
- # layer past: tuple of length two with B, nh, T, hs
- attn, present = self.attn(self.ln1(x), layer_past=layer_past)
-
- x = x + attn
- x = x + self.mlp(self.ln2(x))
- if layer_past is not None or return_present:
- return x, present
- return x
-
-
-class GPT(nn.Module):
- """ the full GPT language model, with a context size of block_size """
- def __init__(self, vocab_size, block_size, n_layer=12, n_head=8, n_embd=256,
- embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
- super().__init__()
- config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
- embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
- n_layer=n_layer, n_head=n_head, n_embd=n_embd,
- n_unmasked=n_unmasked)
- # input embedding stem
- self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd)
- self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
- self.drop = nn.Dropout(config.embd_pdrop)
- # transformer
- self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
- # decoder head
- self.ln_f = nn.LayerNorm(config.n_embd)
- self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
- self.block_size = config.block_size
- self.apply(self._init_weights)
- self.config = config
- logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
-
- def get_block_size(self):
- return self.block_size
-
- def _init_weights(self, module):
- if isinstance(module, (nn.Linear, nn.Embedding)):
- module.weight.data.normal_(mean=0.0, std=0.02)
- if isinstance(module, nn.Linear) and module.bias is not None:
- module.bias.data.zero_()
- elif isinstance(module, nn.LayerNorm):
- module.bias.data.zero_()
- module.weight.data.fill_(1.0)
-
- def forward(self, idx, embeddings=None, targets=None):
- # forward the GPT model
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
-
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- t = token_embeddings.shape[1]
- assert t <= self.block_size, "Cannot forward, model block size is exhausted."
- position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
- x = self.drop(token_embeddings + position_embeddings)
- x = self.blocks(x)
- x = self.ln_f(x)
- logits = self.head(x)
-
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss
-
- def forward_with_past(self, idx, embeddings=None, targets=None, past=None, past_length=None):
- # inference only
- assert not self.training
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- if past is not None:
- assert past_length is not None
- past = torch.cat(past, dim=-2) # n_layer, 2, b, nh, len_past, dim_head
- past_shape = list(past.shape)
- expected_shape = [self.config.n_layer, 2, idx.shape[0], self.config.n_head, past_length, self.config.n_embd//self.config.n_head]
- assert past_shape == expected_shape, f"{past_shape} =/= {expected_shape}"
- position_embeddings = self.pos_emb[:, past_length, :] # each position maps to a (learnable) vector
- else:
- position_embeddings = self.pos_emb[:, :token_embeddings.shape[1], :]
-
- x = self.drop(token_embeddings + position_embeddings)
- presents = [] # accumulate over layers
- for i, block in enumerate(self.blocks):
- x, present = block(x, layer_past=past[i, ...] if past is not None else None, return_present=True)
- presents.append(present)
-
- x = self.ln_f(x)
- logits = self.head(x)
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss, torch.stack(presents) # _, _, n_layer, 2, b, nh, 1, dim_head
-
-
-class DummyGPT(nn.Module):
- # for debugging
- def __init__(self, add_value=1):
- super().__init__()
- self.add_value = add_value
-
- def forward(self, idx):
- return idx + self.add_value, None
-
-
-class CodeGPT(nn.Module):
- """Takes in semi-embeddings"""
- def __init__(self, vocab_size, block_size, in_channels, n_layer=12, n_head=8, n_embd=256,
- embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
- super().__init__()
- config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
- embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
- n_layer=n_layer, n_head=n_head, n_embd=n_embd,
- n_unmasked=n_unmasked)
- # input embedding stem
- self.tok_emb = nn.Linear(in_channels, config.n_embd)
- self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
- self.drop = nn.Dropout(config.embd_pdrop)
- # transformer
- self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
- # decoder head
- self.ln_f = nn.LayerNorm(config.n_embd)
- self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
- self.block_size = config.block_size
- self.apply(self._init_weights)
- self.config = config
- logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
-
- def get_block_size(self):
- return self.block_size
-
- def _init_weights(self, module):
- if isinstance(module, (nn.Linear, nn.Embedding)):
- module.weight.data.normal_(mean=0.0, std=0.02)
- if isinstance(module, nn.Linear) and module.bias is not None:
- module.bias.data.zero_()
- elif isinstance(module, nn.LayerNorm):
- module.bias.data.zero_()
- module.weight.data.fill_(1.0)
-
- def forward(self, idx, embeddings=None, targets=None):
- # forward the GPT model
- token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
-
- if embeddings is not None: # prepend explicit embeddings
- token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
-
- t = token_embeddings.shape[1]
- assert t <= self.block_size, "Cannot forward, model block size is exhausted."
- position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
- x = self.drop(token_embeddings + position_embeddings)
- x = self.blocks(x)
- x = self.taming_cinln_f(x)
- logits = self.head(x)
-
- # if we are given some desired targets also calculate the loss
- loss = None
- if targets is not None:
- loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
-
- return logits, loss
-
-
-
-#### sampling utils
-
-def top_k_logits(logits, k):
- v, ix = torch.topk(logits, k)
- out = logits.clone()
- out[out < v[:, [-1]]] = -float('Inf')
- return out
-
-@torch.no_grad()
-def sample(model, x, steps, temperature=1.0, sample=False, top_k=None):
- """
- take a conditioning sequence of indices in x (of shape (b,t)) and predict the next token in
- the sequence, feeding the predictions back into the model each time. Clearly the sampling
- has quadratic complexity unlike an RNN that is only linear, and has a finite context window
- of block_size, unlike an RNN that has an infinite context window.
- """
- block_size = model.get_block_size()
- model.eval()
- for k in range(steps):
- x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed
- logits, _ = model(x_cond)
- # pluck the logits at the final step and scale by temperature
- logits = logits[:, -1, :] / temperature
- # optionally crop probabilities to only the top k options
- if top_k is not None:
- logits = top_k_logits(logits, top_k)
- # apply softmax to convert to probabilities
- probs = F.softmax(logits, dim=-1)
- # sample from the distribution or take the most likely
- if sample:
- ix = torch.multinomial(probs, num_samples=1)
- else:
- _, ix = torch.topk(probs, k=1, dim=-1)
- # append to the sequence and continue
- x = torch.cat((x, ix), dim=1)
-
- return x
-
-
-@torch.no_grad()
-def sample_with_past(x, model, steps, temperature=1., sample_logits=True,
- top_k=None, top_p=None, callback=None):
- # x is conditioning
- sample = x
- cond_len = x.shape[1]
- past = None
- for n in range(steps):
- if callback is not None:
- callback(n)
- logits, _, present = model.forward_with_past(x, past=past, past_length=(n+cond_len-1))
- if past is None:
- past = [present]
- else:
- past.append(present)
- logits = logits[:, -1, :] / temperature
- if top_k is not None:
- logits = top_k_top_p_filtering(logits, top_k=top_k, top_p=top_p)
-
- probs = F.softmax(logits, dim=-1)
- if not sample_logits:
- _, x = torch.topk(probs, k=1, dim=-1)
- else:
- x = torch.multinomial(probs, num_samples=1)
- # append to the sequence and continue
- sample = torch.cat((sample, x), dim=1)
- del past
- sample = sample[:, cond_len:] # cut conditioning off
- return sample
-
-
-#### clustering utils
-
-class KMeans(nn.Module):
- def __init__(self, ncluster=512, nc=3, niter=10):
- super().__init__()
- self.ncluster = ncluster
- self.nc = nc
- self.niter = niter
- self.shape = (3,32,32)
- self.register_buffer("C", torch.zeros(self.ncluster,nc))
- self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8))
-
- def is_initialized(self):
- return self.initialized.item() == 1
-
- @torch.no_grad()
- def initialize(self, x):
- N, D = x.shape
- assert D == self.nc, D
- c = x[torch.randperm(N)[:self.ncluster]] # init clusters at random
- for i in range(self.niter):
- # assign all pixels to the closest codebook element
- a = ((x[:, None, :] - c[None, :, :])**2).sum(-1).argmin(1)
- # move each codebook element to be the mean of the pixels that assigned to it
- c = torch.stack([x[a==k].mean(0) for k in range(self.ncluster)])
- # re-assign any poorly positioned codebook elements
- nanix = torch.any(torch.isnan(c), dim=1)
- ndead = nanix.sum().item()
- print('done step %d/%d, re-initialized %d dead clusters' % (i+1, self.niter, ndead))
- c[nanix] = x[torch.randperm(N)[:ndead]] # re-init dead clusters
-
- self.C.copy_(c)
- self.initialized.fill_(1)
-
-
- def forward(self, x, reverse=False, shape=None):
- if not reverse:
- # flatten
- bs,c,h,w = x.shape
- assert c == self.nc
- x = x.reshape(bs,c,h*w,1)
- C = self.C.permute(1,0)
- C = C.reshape(1,c,1,self.ncluster)
- a = ((x-C)**2).sum(1).argmin(-1) # bs, h*w indices
- return a
- else:
- # flatten
- bs, HW = x.shape
- """
- c = self.C.reshape( 1, self.nc, 1, self.ncluster)
- c = c[bs*[0],:,:,:]
- c = c[:,:,HW*[0],:]
- x = x.reshape(bs, 1, HW, 1)
- x = x[:,3*[0],:,:]
- x = torch.gather(c, dim=3, index=x)
- """
- x = self.C[x]
- x = x.permute(0,2,1)
- shape = shape if shape is not None else self.shape
- x = x.reshape(bs, *shape)
-
- return x
diff --git a/spaces/cymic/Waifu_Diffusion_Webui/modules/scripts.py b/spaces/cymic/Waifu_Diffusion_Webui/modules/scripts.py
deleted file mode 100644
index 622c5612f7171b5ee3789b99614bc006a690d62f..0000000000000000000000000000000000000000
--- a/spaces/cymic/Waifu_Diffusion_Webui/modules/scripts.py
+++ /dev/null
@@ -1,201 +0,0 @@
-import os
-import sys
-import traceback
-
-import modules.ui as ui
-import gradio as gr
-
-from modules.processing import StableDiffusionProcessing
-from modules import shared
-
-class Script:
- filename = None
- args_from = None
- args_to = None
-
- # The title of the script. This is what will be displayed in the dropdown menu.
- def title(self):
- raise NotImplementedError()
-
- # How the script is displayed in the UI. See https://gradio.app/docs/#components
- # for the different UI components you can use and how to create them.
- # Most UI components can return a value, such as a boolean for a checkbox.
- # The returned values are passed to the run method as parameters.
- def ui(self, is_img2img):
- pass
-
- # Determines when the script should be shown in the dropdown menu via the
- # returned value. As an example:
- # is_img2img is True if the current tab is img2img, and False if it is txt2img.
- # Thus, return is_img2img to only show the script on the img2img tab.
- def show(self, is_img2img):
- return True
-
- # This is where the additional processing is implemented. The parameters include
- # self, the model object "p" (a StableDiffusionProcessing class, see
- # processing.py), and the parameters returned by the ui method.
- # Custom functions can be defined here, and additional libraries can be imported
- # to be used in processing. The return value should be a Processed object, which is
- # what is returned by the process_images method.
- def run(self, *args):
- raise NotImplementedError()
-
- # The description method is currently unused.
- # To add a description that appears when hovering over the title, amend the "titles"
- # dict in script.js to include the script title (returned by title) as a key, and
- # your description as the value.
- def describe(self):
- return ""
-
-
-scripts_data = []
-
-
-def load_scripts(basedir):
- if not os.path.exists(basedir):
- return
-
- for filename in sorted(os.listdir(basedir)):
- path = os.path.join(basedir, filename)
-
- if not os.path.isfile(path):
- continue
-
- try:
- with open(path, "r", encoding="utf8") as file:
- text = file.read()
-
- from types import ModuleType
- compiled = compile(text, path, 'exec')
- module = ModuleType(filename)
- exec(compiled, module.__dict__)
-
- for key, script_class in module.__dict__.items():
- if type(script_class) == type and issubclass(script_class, Script):
- scripts_data.append((script_class, path))
-
- except Exception:
- print(f"Error loading script: {filename}", file=sys.stderr)
- print(traceback.format_exc(), file=sys.stderr)
-
-
-def wrap_call(func, filename, funcname, *args, default=None, **kwargs):
- try:
- res = func(*args, **kwargs)
- return res
- except Exception:
- print(f"Error calling: {filename}/{funcname}", file=sys.stderr)
- print(traceback.format_exc(), file=sys.stderr)
-
- return default
-
-
-class ScriptRunner:
- def __init__(self):
- self.scripts = []
-
- def setup_ui(self, is_img2img):
- for script_class, path in scripts_data:
- script = script_class()
- script.filename = path
-
- if not script.show(is_img2img):
- continue
-
- self.scripts.append(script)
-
- titles = [wrap_call(script.title, script.filename, "title") or f"{script.filename} [error]" for script in self.scripts]
-
- dropdown = gr.Dropdown(label="Script", choices=["None"] + titles, value="None", type="index")
- inputs = [dropdown]
-
- for script in self.scripts:
- script.args_from = len(inputs)
- script.args_to = len(inputs)
-
- controls = wrap_call(script.ui, script.filename, "ui", is_img2img)
-
- if controls is None:
- continue
-
- for control in controls:
- control.custom_script_source = os.path.basename(script.filename)
- control.visible = False
-
- inputs += controls
- script.args_to = len(inputs)
-
- def select_script(script_index):
- if 0 < script_index <= len(self.scripts):
- script = self.scripts[script_index-1]
- args_from = script.args_from
- args_to = script.args_to
- else:
- args_from = 0
- args_to = 0
-
- return [ui.gr_show(True if i == 0 else args_from <= i < args_to) for i in range(len(inputs))]
-
- dropdown.change(
- fn=select_script,
- inputs=[dropdown],
- outputs=inputs
- )
-
- return inputs
-
- def run(self, p: StableDiffusionProcessing, *args):
- script_index = args[0]
-
- if script_index == 0:
- return None
-
- script = self.scripts[script_index-1]
-
- if script is None:
- return None
-
- script_args = args[script.args_from:script.args_to]
- processed = script.run(p, *script_args)
-
- shared.total_tqdm.clear()
-
- return processed
-
- def reload_sources(self):
- for si, script in list(enumerate(self.scripts)):
- with open(script.filename, "r", encoding="utf8") as file:
- args_from = script.args_from
- args_to = script.args_to
- filename = script.filename
- text = file.read()
-
- from types import ModuleType
-
- compiled = compile(text, filename, 'exec')
- module = ModuleType(script.filename)
- exec(compiled, module.__dict__)
-
- for key, script_class in module.__dict__.items():
- if type(script_class) == type and issubclass(script_class, Script):
- self.scripts[si] = script_class()
- self.scripts[si].filename = filename
- self.scripts[si].args_from = args_from
- self.scripts[si].args_to = args_to
-
-scripts_txt2img = ScriptRunner()
-scripts_img2img = ScriptRunner()
-
-def reload_script_body_only():
- scripts_txt2img.reload_sources()
- scripts_img2img.reload_sources()
-
-
-def reload_scripts(basedir):
- global scripts_txt2img, scripts_img2img
-
- scripts_data.clear()
- load_scripts(basedir)
-
- scripts_txt2img = ScriptRunner()
- scripts_img2img = ScriptRunner()
diff --git a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/models/arcface_torch/inference.py b/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/models/arcface_torch/inference.py
deleted file mode 100644
index 3e5156e8d649954837e397c2ff15ec29995e7502..0000000000000000000000000000000000000000
--- a/spaces/daddyjin/TalkingFaceGeneration/Demo_TFR_Pirenderer/src/face3d/models/arcface_torch/inference.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import argparse
-
-import cv2
-import numpy as np
-import torch
-
-from backbones import get_model
-
-
-@torch.no_grad()
-def inference(weight, name, img):
- if img is None:
- img = np.random.randint(0, 255, size=(112, 112, 3), dtype=np.uint8)
- else:
- img = cv2.imread(img)
- img = cv2.resize(img, (112, 112))
-
- img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
- img = np.transpose(img, (2, 0, 1))
- img = torch.from_numpy(img).unsqueeze(0).float()
- img.div_(255).sub_(0.5).div_(0.5)
- net = get_model(name, fp16=False)
- net.load_state_dict(torch.load(weight))
- net.eval()
- feat = net(img).numpy()
- print(feat)
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser(description='PyTorch ArcFace Training')
- parser.add_argument('--network', type=str, default='r50', help='backbone network')
- parser.add_argument('--weight', type=str, default='')
- parser.add_argument('--img', type=str, default=None)
- args = parser.parse_args()
- inference(args.weight, args.network, args.img)
diff --git a/spaces/dansome/Document_Summarization/app.py b/spaces/dansome/Document_Summarization/app.py
deleted file mode 100644
index cb2a29ae8fc681f49dfacbc6bf9904227de33553..0000000000000000000000000000000000000000
--- a/spaces/dansome/Document_Summarization/app.py
+++ /dev/null
@@ -1,54 +0,0 @@
-import streamlit
-import pandas as pd
-#import torch
-from transformers import pipeline
-import streamlit as st
-
-def app():
- st.title("Text Summarization 🤓")
-
- st.markdown("This is a Web application that Summarizes Text 😎")
- upload_file = st.file_uploader('Upload a file containing Text data')
- button = st.button("Summarize")
-
- st.cache(allow_output_mutation=True)
- def facebook_bart_model():
- summarizer = pipeline("summarization", model="facebook/bart-large-cnn")
- return summarizer
- summarizer= facebook_bart_model()
-
- def text_summarizer(text):
- a = summarizer(text, max_length=150, min_length=30, do_sample=False)
- return a[0]['summary_text']
-
-
- # Check to see if a file has been uploaded
- if upload_file is not None and button:
- st.success("Summarizing Text, Please wait...")
- # If it has then do the following:
-
- # Read the file to a dataframe using pandas
- df = pd.read_csv(upload_file)
-
- # Create a section for the dataframe header
-
- df1 = df.copy()
- df1['summarized_text'] = df1['Dialog'].apply(text_summarizer)
-
- df2 = df1[['Name','summarized_text']]
- st.write(df2.head(5))
-
- @st.cache
- def convert_df(dataframe):
- return dataframe.to_csv().encode('utf-8')
-
- csv = convert_df(df2)
- st.download_button(label="Download CSV", data=csv, file_name='summarized_output.csv', mime='text/csv')
-
-
-
-
-
-
-if __name__ == "__main__":
- app()
diff --git a/spaces/dbuscombe/SatelliteSuperResolution/README.md b/spaces/dbuscombe/SatelliteSuperResolution/README.md
deleted file mode 100644
index ffff09e081662ee5408d575cc59bac42b0a110f4..0000000000000000000000000000000000000000
--- a/spaces/dbuscombe/SatelliteSuperResolution/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: SatelliteSuperResolution
-emoji: 🏢
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 2.9.4
-app_file: app.py
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/afmLib.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/afmLib.py
deleted file mode 100644
index 394b901ff5eb149b40c0d9ae425c02d5ad0b5111..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/afmLib.py
+++ /dev/null
@@ -1,438 +0,0 @@
-"""Module for reading and writing AFM (Adobe Font Metrics) files.
-
-Note that this has been designed to read in AFM files generated by Fontographer
-and has not been tested on many other files. In particular, it does not
-implement the whole Adobe AFM specification [#f1]_ but, it should read most
-"common" AFM files.
-
-Here is an example of using `afmLib` to read, modify and write an AFM file:
-
- >>> from fontTools.afmLib import AFM
- >>> f = AFM("Tests/afmLib/data/TestAFM.afm")
- >>>
- >>> # Accessing a pair gets you the kern value
- >>> f[("V","A")]
- -60
- >>>
- >>> # Accessing a glyph name gets you metrics
- >>> f["A"]
- (65, 668, (8, -25, 660, 666))
- >>> # (charnum, width, bounding box)
- >>>
- >>> # Accessing an attribute gets you metadata
- >>> f.FontName
- 'TestFont-Regular'
- >>> f.FamilyName
- 'TestFont'
- >>> f.Weight
- 'Regular'
- >>> f.XHeight
- 500
- >>> f.Ascender
- 750
- >>>
- >>> # Attributes and items can also be set
- >>> f[("A","V")] = -150 # Tighten kerning
- >>> f.FontName = "TestFont Squished"
- >>>
- >>> # And the font written out again (remove the # in front)
- >>> #f.write("testfont-squished.afm")
-
-.. rubric:: Footnotes
-
-.. [#f1] `Adobe Technote 5004 `_,
- Adobe Font Metrics File Format Specification.
-
-"""
-
-
-import re
-
-# every single line starts with a "word"
-identifierRE = re.compile(r"^([A-Za-z]+).*")
-
-# regular expression to parse char lines
-charRE = re.compile(
- r"(-?\d+)" # charnum
- r"\s*;\s*WX\s+" # ; WX
- r"(-?\d+)" # width
- r"\s*;\s*N\s+" # ; N
- r"([.A-Za-z0-9_]+)" # charname
- r"\s*;\s*B\s+" # ; B
- r"(-?\d+)" # left
- r"\s+"
- r"(-?\d+)" # bottom
- r"\s+"
- r"(-?\d+)" # right
- r"\s+"
- r"(-?\d+)" # top
- r"\s*;\s*" # ;
-)
-
-# regular expression to parse kerning lines
-kernRE = re.compile(
- r"([.A-Za-z0-9_]+)" # leftchar
- r"\s+"
- r"([.A-Za-z0-9_]+)" # rightchar
- r"\s+"
- r"(-?\d+)" # value
- r"\s*"
-)
-
-# regular expressions to parse composite info lines of the form:
-# Aacute 2 ; PCC A 0 0 ; PCC acute 182 211 ;
-compositeRE = re.compile(
- r"([.A-Za-z0-9_]+)" r"\s+" r"(\d+)" r"\s*;\s*" # char name # number of parts
-)
-componentRE = re.compile(
- r"PCC\s+" # PPC
- r"([.A-Za-z0-9_]+)" # base char name
- r"\s+"
- r"(-?\d+)" # x offset
- r"\s+"
- r"(-?\d+)" # y offset
- r"\s*;\s*"
-)
-
-preferredAttributeOrder = [
- "FontName",
- "FullName",
- "FamilyName",
- "Weight",
- "ItalicAngle",
- "IsFixedPitch",
- "FontBBox",
- "UnderlinePosition",
- "UnderlineThickness",
- "Version",
- "Notice",
- "EncodingScheme",
- "CapHeight",
- "XHeight",
- "Ascender",
- "Descender",
-]
-
-
-class error(Exception):
- pass
-
-
-class AFM(object):
-
- _attrs = None
-
- _keywords = [
- "StartFontMetrics",
- "EndFontMetrics",
- "StartCharMetrics",
- "EndCharMetrics",
- "StartKernData",
- "StartKernPairs",
- "EndKernPairs",
- "EndKernData",
- "StartComposites",
- "EndComposites",
- ]
-
- def __init__(self, path=None):
- """AFM file reader.
-
- Instantiating an object with a path name will cause the file to be opened,
- read, and parsed. Alternatively the path can be left unspecified, and a
- file can be parsed later with the :meth:`read` method."""
- self._attrs = {}
- self._chars = {}
- self._kerning = {}
- self._index = {}
- self._comments = []
- self._composites = {}
- if path is not None:
- self.read(path)
-
- def read(self, path):
- """Opens, reads and parses a file."""
- lines = readlines(path)
- for line in lines:
- if not line.strip():
- continue
- m = identifierRE.match(line)
- if m is None:
- raise error("syntax error in AFM file: " + repr(line))
-
- pos = m.regs[1][1]
- word = line[:pos]
- rest = line[pos:].strip()
- if word in self._keywords:
- continue
- if word == "C":
- self.parsechar(rest)
- elif word == "KPX":
- self.parsekernpair(rest)
- elif word == "CC":
- self.parsecomposite(rest)
- else:
- self.parseattr(word, rest)
-
- def parsechar(self, rest):
- m = charRE.match(rest)
- if m is None:
- raise error("syntax error in AFM file: " + repr(rest))
- things = []
- for fr, to in m.regs[1:]:
- things.append(rest[fr:to])
- charname = things[2]
- del things[2]
- charnum, width, l, b, r, t = (int(thing) for thing in things)
- self._chars[charname] = charnum, width, (l, b, r, t)
-
- def parsekernpair(self, rest):
- m = kernRE.match(rest)
- if m is None:
- raise error("syntax error in AFM file: " + repr(rest))
- things = []
- for fr, to in m.regs[1:]:
- things.append(rest[fr:to])
- leftchar, rightchar, value = things
- value = int(value)
- self._kerning[(leftchar, rightchar)] = value
-
- def parseattr(self, word, rest):
- if word == "FontBBox":
- l, b, r, t = [int(thing) for thing in rest.split()]
- self._attrs[word] = l, b, r, t
- elif word == "Comment":
- self._comments.append(rest)
- else:
- try:
- value = int(rest)
- except (ValueError, OverflowError):
- self._attrs[word] = rest
- else:
- self._attrs[word] = value
-
- def parsecomposite(self, rest):
- m = compositeRE.match(rest)
- if m is None:
- raise error("syntax error in AFM file: " + repr(rest))
- charname = m.group(1)
- ncomponents = int(m.group(2))
- rest = rest[m.regs[0][1] :]
- components = []
- while True:
- m = componentRE.match(rest)
- if m is None:
- raise error("syntax error in AFM file: " + repr(rest))
- basechar = m.group(1)
- xoffset = int(m.group(2))
- yoffset = int(m.group(3))
- components.append((basechar, xoffset, yoffset))
- rest = rest[m.regs[0][1] :]
- if not rest:
- break
- assert len(components) == ncomponents
- self._composites[charname] = components
-
- def write(self, path, sep="\r"):
- """Writes out an AFM font to the given path."""
- import time
-
- lines = [
- "StartFontMetrics 2.0",
- "Comment Generated by afmLib; at %s"
- % (time.strftime("%m/%d/%Y %H:%M:%S", time.localtime(time.time()))),
- ]
-
- # write comments, assuming (possibly wrongly!) they should
- # all appear at the top
- for comment in self._comments:
- lines.append("Comment " + comment)
-
- # write attributes, first the ones we know about, in
- # a preferred order
- attrs = self._attrs
- for attr in preferredAttributeOrder:
- if attr in attrs:
- value = attrs[attr]
- if attr == "FontBBox":
- value = "%s %s %s %s" % value
- lines.append(attr + " " + str(value))
- # then write the attributes we don't know about,
- # in alphabetical order
- items = sorted(attrs.items())
- for attr, value in items:
- if attr in preferredAttributeOrder:
- continue
- lines.append(attr + " " + str(value))
-
- # write char metrics
- lines.append("StartCharMetrics " + repr(len(self._chars)))
- items = [
- (charnum, (charname, width, box))
- for charname, (charnum, width, box) in self._chars.items()
- ]
-
- def myKey(a):
- """Custom key function to make sure unencoded chars (-1)
- end up at the end of the list after sorting."""
- if a[0] == -1:
- a = (0xFFFF,) + a[1:] # 0xffff is an arbitrary large number
- return a
-
- items.sort(key=myKey)
-
- for charnum, (charname, width, (l, b, r, t)) in items:
- lines.append(
- "C %d ; WX %d ; N %s ; B %d %d %d %d ;"
- % (charnum, width, charname, l, b, r, t)
- )
- lines.append("EndCharMetrics")
-
- # write kerning info
- lines.append("StartKernData")
- lines.append("StartKernPairs " + repr(len(self._kerning)))
- items = sorted(self._kerning.items())
- for (leftchar, rightchar), value in items:
- lines.append("KPX %s %s %d" % (leftchar, rightchar, value))
- lines.append("EndKernPairs")
- lines.append("EndKernData")
-
- if self._composites:
- composites = sorted(self._composites.items())
- lines.append("StartComposites %s" % len(self._composites))
- for charname, components in composites:
- line = "CC %s %s ;" % (charname, len(components))
- for basechar, xoffset, yoffset in components:
- line = line + " PCC %s %s %s ;" % (basechar, xoffset, yoffset)
- lines.append(line)
- lines.append("EndComposites")
-
- lines.append("EndFontMetrics")
-
- writelines(path, lines, sep)
-
- def has_kernpair(self, pair):
- """Returns `True` if the given glyph pair (specified as a tuple) exists
- in the kerning dictionary."""
- return pair in self._kerning
-
- def kernpairs(self):
- """Returns a list of all kern pairs in the kerning dictionary."""
- return list(self._kerning.keys())
-
- def has_char(self, char):
- """Returns `True` if the given glyph exists in the font."""
- return char in self._chars
-
- def chars(self):
- """Returns a list of all glyph names in the font."""
- return list(self._chars.keys())
-
- def comments(self):
- """Returns all comments from the file."""
- return self._comments
-
- def addComment(self, comment):
- """Adds a new comment to the file."""
- self._comments.append(comment)
-
- def addComposite(self, glyphName, components):
- """Specifies that the glyph `glyphName` is made up of the given components.
- The components list should be of the following form::
-
- [
- (glyphname, xOffset, yOffset),
- ...
- ]
-
- """
- self._composites[glyphName] = components
-
- def __getattr__(self, attr):
- if attr in self._attrs:
- return self._attrs[attr]
- else:
- raise AttributeError(attr)
-
- def __setattr__(self, attr, value):
- # all attrs *not* starting with "_" are consider to be AFM keywords
- if attr[:1] == "_":
- self.__dict__[attr] = value
- else:
- self._attrs[attr] = value
-
- def __delattr__(self, attr):
- # all attrs *not* starting with "_" are consider to be AFM keywords
- if attr[:1] == "_":
- try:
- del self.__dict__[attr]
- except KeyError:
- raise AttributeError(attr)
- else:
- try:
- del self._attrs[attr]
- except KeyError:
- raise AttributeError(attr)
-
- def __getitem__(self, key):
- if isinstance(key, tuple):
- # key is a tuple, return the kernpair
- return self._kerning[key]
- else:
- # return the metrics instead
- return self._chars[key]
-
- def __setitem__(self, key, value):
- if isinstance(key, tuple):
- # key is a tuple, set kernpair
- self._kerning[key] = value
- else:
- # set char metrics
- self._chars[key] = value
-
- def __delitem__(self, key):
- if isinstance(key, tuple):
- # key is a tuple, del kernpair
- del self._kerning[key]
- else:
- # del char metrics
- del self._chars[key]
-
- def __repr__(self):
- if hasattr(self, "FullName"):
- return "" % self.FullName
- else:
- return "" % id(self)
-
-
-def readlines(path):
- with open(path, "r", encoding="ascii") as f:
- data = f.read()
- return data.splitlines()
-
-
-def writelines(path, lines, sep="\r"):
- with open(path, "w", encoding="ascii", newline=sep) as f:
- f.write("\n".join(lines) + "\n")
-
-
-if __name__ == "__main__":
- import EasyDialogs
-
- path = EasyDialogs.AskFileForOpen()
- if path:
- afm = AFM(path)
- char = "A"
- if afm.has_char(char):
- print(afm[char]) # print charnum, width and boundingbox
- pair = ("A", "V")
- if afm.has_kernpair(pair):
- print(afm[pair]) # print kerning value for pair
- print(afm.Version) # various other afm entries have become attributes
- print(afm.Weight)
- # afm.comments() returns a list of all Comment lines found in the AFM
- print(afm.comments())
- # print afm.chars()
- # print afm.kernpairs()
- print(afm)
- afm.write(path + ".muck")
diff --git a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/misc/symfont.py b/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/misc/symfont.py
deleted file mode 100644
index 0bd69a386ec9f01c8951f0dfc8bc8c261718cf1f..0000000000000000000000000000000000000000
--- a/spaces/dcarpintero/nlp-summarizer-pegasus/.venv/lib/python3.9/site-packages/fontTools/misc/symfont.py
+++ /dev/null
@@ -1,251 +0,0 @@
-from fontTools.pens.basePen import BasePen
-from functools import partial
-from itertools import count
-import sympy as sp
-import sys
-
-n = 3 # Max Bezier degree; 3 for cubic, 2 for quadratic
-
-t, x, y = sp.symbols("t x y", real=True)
-c = sp.symbols("c", real=False) # Complex representation instead of x/y
-
-X = tuple(sp.symbols("x:%d" % (n + 1), real=True))
-Y = tuple(sp.symbols("y:%d" % (n + 1), real=True))
-P = tuple(zip(*(sp.symbols("p:%d[%s]" % (n + 1, w), real=True) for w in "01")))
-C = tuple(sp.symbols("c:%d" % (n + 1), real=False))
-
-# Cubic Bernstein basis functions
-BinomialCoefficient = [(1, 0)]
-for i in range(1, n + 1):
- last = BinomialCoefficient[-1]
- this = tuple(last[j - 1] + last[j] for j in range(len(last))) + (0,)
- BinomialCoefficient.append(this)
-BinomialCoefficient = tuple(tuple(item[:-1]) for item in BinomialCoefficient)
-del last, this
-
-BernsteinPolynomial = tuple(
- tuple(c * t**i * (1 - t) ** (n - i) for i, c in enumerate(coeffs))
- for n, coeffs in enumerate(BinomialCoefficient)
-)
-
-BezierCurve = tuple(
- tuple(
- sum(P[i][j] * bernstein for i, bernstein in enumerate(bernsteins))
- for j in range(2)
- )
- for n, bernsteins in enumerate(BernsteinPolynomial)
-)
-BezierCurveC = tuple(
- sum(C[i] * bernstein for i, bernstein in enumerate(bernsteins))
- for n, bernsteins in enumerate(BernsteinPolynomial)
-)
-
-
-def green(f, curveXY):
- f = -sp.integrate(sp.sympify(f), y)
- f = f.subs({x: curveXY[0], y: curveXY[1]})
- f = sp.integrate(f * sp.diff(curveXY[0], t), (t, 0, 1))
- return f
-
-
-class _BezierFuncsLazy(dict):
- def __init__(self, symfunc):
- self._symfunc = symfunc
- self._bezfuncs = {}
-
- def __missing__(self, i):
- args = ["p%d" % d for d in range(i + 1)]
- f = green(self._symfunc, BezierCurve[i])
- f = sp.gcd_terms(f.collect(sum(P, ()))) # Optimize
- return sp.lambdify(args, f)
-
-
-class GreenPen(BasePen):
-
- _BezierFuncs = {}
-
- @classmethod
- def _getGreenBezierFuncs(celf, func):
- funcstr = str(func)
- if not funcstr in celf._BezierFuncs:
- celf._BezierFuncs[funcstr] = _BezierFuncsLazy(func)
- return celf._BezierFuncs[funcstr]
-
- def __init__(self, func, glyphset=None):
- BasePen.__init__(self, glyphset)
- self._funcs = self._getGreenBezierFuncs(func)
- self.value = 0
-
- def _moveTo(self, p0):
- self.__startPoint = p0
-
- def _closePath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- self._lineTo(self.__startPoint)
-
- def _endPath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- # Green theorem is not defined on open contours.
- raise NotImplementedError
-
- def _lineTo(self, p1):
- p0 = self._getCurrentPoint()
- self.value += self._funcs[1](p0, p1)
-
- def _qCurveToOne(self, p1, p2):
- p0 = self._getCurrentPoint()
- self.value += self._funcs[2](p0, p1, p2)
-
- def _curveToOne(self, p1, p2, p3):
- p0 = self._getCurrentPoint()
- self.value += self._funcs[3](p0, p1, p2, p3)
-
-
-# Sample pens.
-# Do not use this in real code.
-# Use fontTools.pens.momentsPen.MomentsPen instead.
-AreaPen = partial(GreenPen, func=1)
-MomentXPen = partial(GreenPen, func=x)
-MomentYPen = partial(GreenPen, func=y)
-MomentXXPen = partial(GreenPen, func=x * x)
-MomentYYPen = partial(GreenPen, func=y * y)
-MomentXYPen = partial(GreenPen, func=x * y)
-
-
-def printGreenPen(penName, funcs, file=sys.stdout, docstring=None):
-
- if docstring is not None:
- print('"""%s"""' % docstring)
-
- print(
- """from fontTools.pens.basePen import BasePen, OpenContourError
-try:
- import cython
-
- COMPILED = cython.compiled
-except (AttributeError, ImportError):
- # if cython not installed, use mock module with no-op decorators and types
- from fontTools.misc import cython
-
- COMPILED = False
-
-
-__all__ = ["%s"]
-
-class %s(BasePen):
-
- def __init__(self, glyphset=None):
- BasePen.__init__(self, glyphset)
-"""
- % (penName, penName),
- file=file,
- )
- for name, f in funcs:
- print(" self.%s = 0" % name, file=file)
- print(
- """
- def _moveTo(self, p0):
- self.__startPoint = p0
-
- def _closePath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- self._lineTo(self.__startPoint)
-
- def _endPath(self):
- p0 = self._getCurrentPoint()
- if p0 != self.__startPoint:
- # Green theorem is not defined on open contours.
- raise OpenContourError(
- "Green theorem is not defined on open contours."
- )
-""",
- end="",
- file=file,
- )
-
- for n in (1, 2, 3):
-
- subs = {P[i][j]: [X, Y][j][i] for i in range(n + 1) for j in range(2)}
- greens = [green(f, BezierCurve[n]) for name, f in funcs]
- greens = [sp.gcd_terms(f.collect(sum(P, ()))) for f in greens] # Optimize
- greens = [f.subs(subs) for f in greens] # Convert to p to x/y
- defs, exprs = sp.cse(
- greens,
- optimizations="basic",
- symbols=(sp.Symbol("r%d" % i) for i in count()),
- )
-
- print()
- for name, value in defs:
- print(" @cython.locals(%s=cython.double)" % name, file=file)
- if n == 1:
- print(
- """\
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- def _lineTo(self, p1):
- x0,y0 = self._getCurrentPoint()
- x1,y1 = p1
-""",
- file=file,
- )
- elif n == 2:
- print(
- """\
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- @cython.locals(x2=cython.double, y2=cython.double)
- def _qCurveToOne(self, p1, p2):
- x0,y0 = self._getCurrentPoint()
- x1,y1 = p1
- x2,y2 = p2
-""",
- file=file,
- )
- elif n == 3:
- print(
- """\
- @cython.locals(x0=cython.double, y0=cython.double)
- @cython.locals(x1=cython.double, y1=cython.double)
- @cython.locals(x2=cython.double, y2=cython.double)
- @cython.locals(x3=cython.double, y3=cython.double)
- def _curveToOne(self, p1, p2, p3):
- x0,y0 = self._getCurrentPoint()
- x1,y1 = p1
- x2,y2 = p2
- x3,y3 = p3
-""",
- file=file,
- )
- for name, value in defs:
- print(" %s = %s" % (name, value), file=file)
-
- print(file=file)
- for name, value in zip([f[0] for f in funcs], exprs):
- print(" self.%s += %s" % (name, value), file=file)
-
- print(
- """
-if __name__ == '__main__':
- from fontTools.misc.symfont import x, y, printGreenPen
- printGreenPen('%s', ["""
- % penName,
- file=file,
- )
- for name, f in funcs:
- print(" ('%s', %s)," % (name, str(f)), file=file)
- print(" ])", file=file)
-
-
-if __name__ == "__main__":
- pen = AreaPen()
- pen.moveTo((100, 100))
- pen.lineTo((100, 200))
- pen.lineTo((200, 200))
- pen.curveTo((200, 250), (300, 300), (250, 350))
- pen.lineTo((200, 100))
- pen.closePath()
- print(pen.value)
diff --git a/spaces/ddiddi/bhasha.dev/app.py b/spaces/ddiddi/bhasha.dev/app.py
deleted file mode 100644
index c9b1f6e0fea945d6540de2fbdbf392485586ee50..0000000000000000000000000000000000000000
--- a/spaces/ddiddi/bhasha.dev/app.py
+++ /dev/null
@@ -1,319 +0,0 @@
-import gradio as gr
-from datetime import datetime
-from PIL import Image
-import flag
-import os
-
-from libretranslatepy import LibreTranslateAPI
-lt = LibreTranslateAPI("https://translate.argosopentech.com/")
-
-
-stable_diffusion = gr.Blocks.load(name="spaces/stabilityai/stable-diffusion")
-### ————————————————————————————————————————
-
-title="Any Text to Stable Diffusion"
-
-
-def get_translation(text):
- lang_detected = lt.detect(text)[0]['language']
- print(lang_detected)
- english_translated = lt.translate(text, lang_detected, "en")
- print(english_translated)
- return english_translated
-
-def get_images(prompt):
- prompt_t = get_translation(prompt)
- gallery_dir = stable_diffusion(prompt_t, fn_index=2)
- return [os.path.join(gallery_dir, img) for img in os.listdir(gallery_dir)]
-
-css = """
- .container {
- max-width: 880px;
- margin: auto;
- padding-top: 1.5rem;
- }
- a {
- text-decoration: underline;
- }
- h1 {
- font-weight: 900;
- margin-bottom: 7px;
- text-align: center;
- font-size: 2em;
- margin-bottom: 1em;
- }
- #w2sd_container{
- margin-top: 20px;
- }
- .footer {
- margin-bottom: 45px;
- margin-top: 35px;
- text-align: center;
- border-bottom: 1px solid #e5e5e5;
- }
- .footer>p {
- font-size: .8rem;
- display: inline-block;
- padding: 0 10px;
- transform: translateY(10px);
- background: white;
- }
- .dark .footer {
- border-color: #303030;
- }
- .dark .footer>p {
- background: #0b0f19;
- }
- .tabitem {
- border-bottom-left-radius: 10px;
- border-bottom-right-radius: 10px;
- }
- #record_tab, #upload_tab {
- font-size: 1.2em;
- }
- #record_btn{
-
- }
- #record_btn > div > button > span {
- width: 2.375rem;
- height: 2.375rem;
- }
- #record_btn > div > button > span > span {
- width: 2.375rem;
- height: 2.375rem;
- }
- audio {
- margin-bottom: 10px;
- }
- div#record_btn > .mt-6{
- margin-top: 0!important;
- }
- div#record_btn > .mt-6 button {
- font-size: 2em;
- width: 100%;
- padding: 20px;
- height: 160px;
- }
- div#upload_area {
- height: 11.1rem;
- }
- div#upload_area > div.w-full > div {
- min-height: 9rem;
- }
- #check_btn_1, #check_btn_2{
- color: #fff;
- --tw-gradient-from: #4caf50;
- --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to);
- --tw-gradient-to: #4caf50;
- border-color: #8bc34a;
- }
- #magic_btn_1, #magic_btn_2{
- color: #fff;
- --tw-gradient-from: #f44336;
- --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to);
- --tw-gradient-to: #ff9800;
- border-color: #ff9800;
- }
- input::-webkit-inner-spin-button, input::-webkit-outer-spin-button {
- -webkit-appearance: none;
- }
- input[type=number] {
- -moz-appearance: textfield;
- }
- input[type=range] {
- -webkit-appearance: none;
- cursor: pointer;
- height: 1px;
- background: currentColor;
- }
- input[type=range]::-webkit-slider-thumb {
- -webkit-appearance: none;
- width: 0.5em;
- height: 1.2em;
- border-radius: 10px;
- background: currentColor;
- }
- input[type=range]::-moz-range-thumb{
- width: 0.5em;
- height: 1.2em;
- border-radius: 10px;
- background: currentColor;
- }
- div#spoken_lang textarea {
- font-size: 4em;
- line-height: 1em;
- text-align: center;
- }
- div#transcripted {
- flex: 4;
- }
- div#translated textarea {
- font-size: 1.5em;
- line-height: 1.25em;
- }
- #sd_settings {
- margin-bottom: 20px;
- }
- #diffuse_btn {
- color: #fff;
- font-size: 1em;
- margin-bottom: 20px;
- --tw-gradient-from: #4caf50;
- --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to);
- --tw-gradient-to: #4caf50;
- border-color: #8bc34a;
- }
- #translate_btn {
- color: #fff;
- font-size: 1em;
- margin-bottom: 20px;
- --tw-gradient-from: #4caf50;
- --tw-gradient-stops: var(--tw-gradient-from), var(--tw-gradient-to);
- --tw-gradient-to: #4caf50;
- border-color: #8bc34a;
- }
- #notice {
- padding: 20px 14px 10px;
- display: flex;
- align-content: space-evenly;
- gap: 20px;
- line-height: 1em;
- font-size: .8em;
- border: 1px solid #374151;
- border-radius: 10px;
- }
- #about {
- padding: 20px;
- }
- #notice > div {
- flex: 1;
- }
-
-"""
-
-### ————————————————————————————————————————
-
-with gr.Blocks(css=css) as demo:
- with gr.Column():
- gr.HTML('''
-
- Any Text to Stable Diffusion
-
-
- Ask stable diffusion in any language !
-
-
-
- This demo is connected to StableDiffusion Space • Offered by ddiddi
-
- ''')
-
-
-
- with gr.Accordion(label="Stable Diffusion Settings", elem_id="sd_settings", visible=False):
- with gr.Row():
- guidance_scale = gr.Slider(2, 15, value = 7, label = 'Guidance Scale')
- nb_iterations = gr.Slider(10, 50, value = 25, step = 1, label = 'Steps')
- seed = gr.Slider(label = "Seed", minimum = 0, maximum = 2147483647, step = 1, randomize = True)
-
- gr.Markdown(
- """
- ## 1. Enter prompt
- Here are some examples: \n
- Доброе утро \t
- おはようございます \t
- शुभ प्रभात \t
- Good morning
- """
-
-
- )
-
- with gr.Row():
-
- enter_prompt = gr.Textbox(
- label="Enter prompt",
- lines=3,
- elem_id="transcript"
- )
-
- with gr.Column():
- translated_output = gr.Textbox(
- label="in English",
- lines=3,
- elem_id="translated"
- )
- with gr.Row():
- clear_btn = gr.Button(value="Clear")
- translate_btn = gr.Button(value="Translate", elem_id="translate_btn")
- diffuse_btn = gr.Button(value="Translate >> SD!", elem_id="diffuse_btn")
-
- clear_btn.click(fn=lambda value: gr.update(value=""), inputs=clear_btn, outputs=translated_output)
-
-
-
-# with gr.Column():
-
-
-
- gr.Markdown("""
- ## 3. Stable Diffusion Results
- Inference time is about ~30-40 seconds
- """
- )
-
- sd_output = gr.Gallery().style(grid=2, height="auto")
-
-
- gr.Markdown("""
- ### 📌 Resources
-
-
-
- Stable Diffusion is a state of the art text-to-image model that generates images from text.
-
-
-
- LICENSE
-
- The model is licensed with a CreativeML Open RAIL-M license.
-
- The authors claim no rights on the outputs you generate, you are free to use them and are accountable for their use which must not go against the provisions set in this license.
-
- The license forbids you from sharing any content that violates any laws, produce any harm to a person, disseminate any personal information that would be meant for harm, spread misinformation and target vulnerable groups.
-
- For the full list of restrictions please read the license .
-
-
-
- Biases and content acknowledgment
-
- Despite how impressive being able to turn text into image is, beware to the fact that this model may output content that reinforces or exacerbates societal biases, as well as realistic faces, pornography and violence.
-
- The model was trained on the LAION-5B dataset , which scraped non-curated image-text-pairs from the internet (the exception being the removal of illegal content) and is meant for research purposes.
-
You can read more in the model card .
-
-
-
Character Generator crack code Download Zip ––– https://gohhs.com/2uFUr0
diff --git a/spaces/diacanFperku/AutoGPT/Cisco Iou NEW! Keygen.Py.md b/spaces/diacanFperku/AutoGPT/Cisco Iou NEW! Keygen.Py.md
deleted file mode 100644
index 8116686e8a14b2579e7d94ddb20c9368001e0d15..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Cisco Iou NEW! Keygen.Py.md
+++ /dev/null
@@ -1,10 +0,0 @@
-Cisco Iou Keygen.Py Download ✔✔✔ https://gohhs.com/2uFUvi
diff --git a/spaces/diagaiwei/ir_chinese_medqa/colbert/infra/launcher.py b/spaces/diagaiwei/ir_chinese_medqa/colbert/infra/launcher.py
deleted file mode 100644
index f55b2892a78a0714888e79412de36919eda93071..0000000000000000000000000000000000000000
--- a/spaces/diagaiwei/ir_chinese_medqa/colbert/infra/launcher.py
+++ /dev/null
@@ -1,147 +0,0 @@
-import os
-import time
-import torch
-import random
-
-import torch.multiprocessing as mp
-import numpy as np
-
-try:
- mp.set_start_method('spawn', force=True)
-except RuntimeError:
- pass
-
-import colbert.utils.distributed as distributed
-
-from colbert.infra.run import Run
-from colbert.infra.config import BaseConfig, RunConfig, RunSettings
-
-from colbert.utils.utils import print_message
-
-
-class Launcher:
- def __init__(self, callee, run_config=None, return_all=False):
- self.callee = callee
- self.return_all = return_all
-
- self.run_config = RunConfig.from_existing(Run().config, run_config)
- self.nranks = self.run_config.nranks
-
- def launch(self, custom_config, *args):
- return_value_queue = mp.Queue()
-
- rng = random.Random(time.time())
- port = str(12355 + rng.randint(0, 1000)) # randomize the port to avoid collision on launching several jobs.
-
- all_procs = []
- for new_rank in range(0, self.nranks):
- assert isinstance(custom_config, BaseConfig)
- assert isinstance(custom_config, RunSettings)
-
- new_config = type(custom_config).from_existing(custom_config, self.run_config, RunConfig(rank=new_rank))
-
- args_ = (self.callee, port, return_value_queue, new_config, *args)
- all_procs.append(mp.Process(target=setup_new_process, args=args_))
-
- # Clear GPU space (e.g., after a `Searcher` on GPU-0 is deleted)
- # TODO: Generalize this from GPU-0 only!
- # TODO: Move this to a function. And call that function from __del__ in a class that's inherited by Searcher, Indexer, etc.
-
- # t = torch.cuda.get_device_properties(0).total_memory
- # r = torch.cuda.memory_reserved(0)
- # a = torch.cuda.memory_allocated(0)
- # f = r-a
-
- # print_message(f"[Pre-Emptying] GPU memory check: r={r}, a={a}, f={f}")
-
- torch.cuda.empty_cache()
-
- # t = torch.cuda.get_device_properties(0).total_memory
- # r = torch.cuda.memory_reserved(0)
- # a = torch.cuda.memory_allocated(0)
- # f = r-a
-
- # print_message(f"[Post-Emptying] GPU memory check: r={r}, a={a}, f={f}")
-
- print_memory_stats('MAIN')
-
- for proc in all_procs:
- print("#> Starting...")
- proc.start()
-
- print_memory_stats('MAIN')
-
- # TODO: If the processes crash upon join, raise an exception and don't block on .get() below!
-
- return_values = sorted([return_value_queue.get() for _ in all_procs])
- return_values = [val for rank, val in return_values]
-
- if not self.return_all:
- return_values = return_values[0]
-
- for proc in all_procs:
- proc.join()
- print("#> Joined...")
-
- print_memory_stats('MAIN')
-
- return return_values
-
-
-def setup_new_process(callee, port, return_value_queue, config, *args):
- print_memory_stats()
-
- random.seed(12345)
- np.random.seed(12345)
- torch.manual_seed(12345)
- torch.cuda.manual_seed_all(12345)
-
- rank, nranks = config.rank, config.nranks
-
- os.environ["MASTER_ADDR"] = "localhost"
- os.environ["MASTER_PORT"] = port
- os.environ["WORLD_SIZE"] = str(config.nranks)
- os.environ["RANK"] = str(config.rank)
-
- # TODO: Ideally the gpus "getter" handles this max-nranks thing!
- os.environ["CUDA_VISIBLE_DEVICES"] = ','.join(map(str, config.gpus_[:nranks]))
-
- nranks_, distributed_ = distributed.init(rank)
- assert nranks_ == nranks
-
- # Run.init(args.rank, args.root, args.experiment, args.run)
-
- with Run().context(config, inherit_config=False):
- return_val = callee(config, *args)
-
- return_value_queue.put((rank, return_val))
-
-
-def print_memory_stats(message=''):
- return # FIXME: Add this back before release.
-
- import psutil # Remove before releases? Or at least make optional with try/except.
-
- global_info = psutil.virtual_memory()
- total, available, used, free = global_info.total, global_info.available, global_info.used, global_info.free
-
- info = psutil.Process().memory_info()
- rss, vms, shared = info.rss, info.vms, info.shared
- uss = psutil.Process().memory_full_info().uss
-
- gib = 1024 ** 3
-
- summary = f"""
- "[PID: {os.getpid()}]
- [{message}]
- Available: {available / gib:,.1f} / {total / gib:,.1f}
- Free: {free / gib:,.1f} / {total / gib:,.1f}
- Usage: {used / gib:,.1f} / {total / gib:,.1f}
-
- RSS: {rss / gib:,.1f}
- VMS: {vms / gib:,.1f}
- USS: {uss / gib:,.1f}
- SHARED: {shared / gib:,.1f}
- """.strip().replace('\n', '\t')
-
- print_message(summary, pad=True)
diff --git a/spaces/digitalxingtong/Luzao-Bert-Vits2/text/tone_sandhi.py b/spaces/digitalxingtong/Luzao-Bert-Vits2/text/tone_sandhi.py
deleted file mode 100644
index 0f45b7a72c5d858bcaab19ac85cfa686bf9a74da..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Luzao-Bert-Vits2/text/tone_sandhi.py
+++ /dev/null
@@ -1,351 +0,0 @@
-# Copyright (c) 2021 PaddlePaddle 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.
-from typing import List
-from typing import Tuple
-
-import jieba
-from pypinyin import lazy_pinyin
-from pypinyin import Style
-
-
-class ToneSandhi():
- def __init__(self):
- self.must_neural_tone_words = {
- '麻烦', '麻利', '鸳鸯', '高粱', '骨头', '骆驼', '马虎', '首饰', '馒头', '馄饨', '风筝',
- '难为', '队伍', '阔气', '闺女', '门道', '锄头', '铺盖', '铃铛', '铁匠', '钥匙', '里脊',
- '里头', '部分', '那么', '道士', '造化', '迷糊', '连累', '这么', '这个', '运气', '过去',
- '软和', '转悠', '踏实', '跳蚤', '跟头', '趔趄', '财主', '豆腐', '讲究', '记性', '记号',
- '认识', '规矩', '见识', '裁缝', '补丁', '衣裳', '衣服', '衙门', '街坊', '行李', '行当',
- '蛤蟆', '蘑菇', '薄荷', '葫芦', '葡萄', '萝卜', '荸荠', '苗条', '苗头', '苍蝇', '芝麻',
- '舒服', '舒坦', '舌头', '自在', '膏药', '脾气', '脑袋', '脊梁', '能耐', '胳膊', '胭脂',
- '胡萝', '胡琴', '胡同', '聪明', '耽误', '耽搁', '耷拉', '耳朵', '老爷', '老实', '老婆',
- '老头', '老太', '翻腾', '罗嗦', '罐头', '编辑', '结实', '红火', '累赘', '糨糊', '糊涂',
- '精神', '粮食', '簸箕', '篱笆', '算计', '算盘', '答应', '笤帚', '笑语', '笑话', '窟窿',
- '窝囊', '窗户', '稳当', '稀罕', '称呼', '秧歌', '秀气', '秀才', '福气', '祖宗', '砚台',
- '码头', '石榴', '石头', '石匠', '知识', '眼睛', '眯缝', '眨巴', '眉毛', '相声', '盘算',
- '白净', '痢疾', '痛快', '疟疾', '疙瘩', '疏忽', '畜生', '生意', '甘蔗', '琵琶', '琢磨',
- '琉璃', '玻璃', '玫瑰', '玄乎', '狐狸', '状元', '特务', '牲口', '牙碜', '牌楼', '爽快',
- '爱人', '热闹', '烧饼', '烟筒', '烂糊', '点心', '炊帚', '灯笼', '火候', '漂亮', '滑溜',
- '溜达', '温和', '清楚', '消息', '浪头', '活泼', '比方', '正经', '欺负', '模糊', '槟榔',
- '棺材', '棒槌', '棉花', '核桃', '栅栏', '柴火', '架势', '枕头', '枇杷', '机灵', '本事',
- '木头', '木匠', '朋友', '月饼', '月亮', '暖和', '明白', '时候', '新鲜', '故事', '收拾',
- '收成', '提防', '挖苦', '挑剔', '指甲', '指头', '拾掇', '拳头', '拨弄', '招牌', '招呼',
- '抬举', '护士', '折腾', '扫帚', '打量', '打算', '打点', '打扮', '打听', '打发', '扎实',
- '扁担', '戒指', '懒得', '意识', '意思', '情形', '悟性', '怪物', '思量', '怎么', '念头',
- '念叨', '快活', '忙活', '志气', '心思', '得罪', '张罗', '弟兄', '开通', '应酬', '庄稼',
- '干事', '帮手', '帐篷', '希罕', '师父', '师傅', '巴结', '巴掌', '差事', '工夫', '岁数',
- '屁股', '尾巴', '少爷', '小气', '小伙', '将就', '对头', '对付', '寡妇', '家伙', '客气',
- '实在', '官司', '学问', '学生', '字号', '嫁妆', '媳妇', '媒人', '婆家', '娘家', '委屈',
- '姑娘', '姐夫', '妯娌', '妥当', '妖精', '奴才', '女婿', '头发', '太阳', '大爷', '大方',
- '大意', '大夫', '多少', '多么', '外甥', '壮实', '地道', '地方', '在乎', '困难', '嘴巴',
- '嘱咐', '嘟囔', '嘀咕', '喜欢', '喇嘛', '喇叭', '商量', '唾沫', '哑巴', '哈欠', '哆嗦',
- '咳嗽', '和尚', '告诉', '告示', '含糊', '吓唬', '后头', '名字', '名堂', '合同', '吆喝',
- '叫唤', '口袋', '厚道', '厉害', '千斤', '包袱', '包涵', '匀称', '勤快', '动静', '动弹',
- '功夫', '力气', '前头', '刺猬', '刺激', '别扭', '利落', '利索', '利害', '分析', '出息',
- '凑合', '凉快', '冷战', '冤枉', '冒失', '养活', '关系', '先生', '兄弟', '便宜', '使唤',
- '佩服', '作坊', '体面', '位置', '似的', '伙计', '休息', '什么', '人家', '亲戚', '亲家',
- '交情', '云彩', '事情', '买卖', '主意', '丫头', '丧气', '两口', '东西', '东家', '世故',
- '不由', '不在', '下水', '下巴', '上头', '上司', '丈夫', '丈人', '一辈', '那个', '菩萨',
- '父亲', '母亲', '咕噜', '邋遢', '费用', '冤家', '甜头', '介绍', '荒唐', '大人', '泥鳅',
- '幸福', '熟悉', '计划', '扑腾', '蜡烛', '姥爷', '照顾', '喉咙', '吉他', '弄堂', '蚂蚱',
- '凤凰', '拖沓', '寒碜', '糟蹋', '倒腾', '报复', '逻辑', '盘缠', '喽啰', '牢骚', '咖喱',
- '扫把', '惦记'
- }
- self.must_not_neural_tone_words = {
- "男子", "女子", "分子", "原子", "量子", "莲子", "石子", "瓜子", "电子", "人人", "虎虎"
- }
- self.punc = "：，；。？！“”‘’':,;.?!"
-
- # the meaning of jieba pos tag: https://blog.csdn.net/weixin_44174352/article/details/113731041
- # e.g.
- # word: "家里"
- # pos: "s"
- # finals: ['ia1', 'i3']
- def _neural_sandhi(self, word: str, pos: str,
- finals: List[str]) -> List[str]:
-
- # reduplication words for n. and v. e.g. 奶奶, 试试, 旺旺
- for j, item in enumerate(word):
- if j - 1 >= 0 and item == word[j - 1] and pos[0] in {
- "n", "v", "a"
- } and word not in self.must_not_neural_tone_words:
- finals[j] = finals[j][:-1] + "5"
- ge_idx = word.find("个")
- if len(word) >= 1 and word[-1] in "吧呢啊呐噻嘛吖嗨呐哦哒额滴哩哟喽啰耶喔诶":
- finals[-1] = finals[-1][:-1] + "5"
- elif len(word) >= 1 and word[-1] in "的地得":
- finals[-1] = finals[-1][:-1] + "5"
- # e.g. 走了, 看着, 去过
- # elif len(word) == 1 and word in "了着过" and pos in {"ul", "uz", "ug"}:
- # finals[-1] = finals[-1][:-1] + "5"
- elif len(word) > 1 and word[-1] in "们子" and pos in {
- "r", "n"
- } and word not in self.must_not_neural_tone_words:
- finals[-1] = finals[-1][:-1] + "5"
- # e.g. 桌上, 地下, 家里
- elif len(word) > 1 and word[-1] in "上下里" and pos in {"s", "l", "f"}:
- finals[-1] = finals[-1][:-1] + "5"
- # e.g. 上来, 下去
- elif len(word) > 1 and word[-1] in "来去" and word[-2] in "上下进出回过起开":
- finals[-1] = finals[-1][:-1] + "5"
- # 个做量词
- elif (ge_idx >= 1 and
- (word[ge_idx - 1].isnumeric() or
- word[ge_idx - 1] in "几有两半多各整每做是")) or word == '个':
- finals[ge_idx] = finals[ge_idx][:-1] + "5"
- else:
- if word in self.must_neural_tone_words or word[
- -2:] in self.must_neural_tone_words:
- finals[-1] = finals[-1][:-1] + "5"
-
- word_list = self._split_word(word)
- finals_list = [finals[:len(word_list[0])], finals[len(word_list[0]):]]
- for i, word in enumerate(word_list):
- # conventional neural in Chinese
- if word in self.must_neural_tone_words or word[
- -2:] in self.must_neural_tone_words:
- finals_list[i][-1] = finals_list[i][-1][:-1] + "5"
- finals = sum(finals_list, [])
- return finals
-
- def _bu_sandhi(self, word: str, finals: List[str]) -> List[str]:
- # e.g. 看不懂
- if len(word) == 3 and word[1] == "不":
- finals[1] = finals[1][:-1] + "5"
- else:
- for i, char in enumerate(word):
- # "不" before tone4 should be bu2, e.g. 不怕
- if char == "不" and i + 1 < len(word) and finals[i +
- 1][-1] == "4":
- finals[i] = finals[i][:-1] + "2"
- return finals
-
- def _yi_sandhi(self, word: str, finals: List[str]) -> List[str]:
- # "一" in number sequences, e.g. 一零零, 二一零
- if word.find("一") != -1 and all(
- [item.isnumeric() for item in word if item != "一"]):
- return finals
- # "一" between reduplication words shold be yi5, e.g. 看一看
- elif len(word) == 3 and word[1] == "一" and word[0] == word[-1]:
- finals[1] = finals[1][:-1] + "5"
- # when "一" is ordinal word, it should be yi1
- elif word.startswith("第一"):
- finals[1] = finals[1][:-1] + "1"
- else:
- for i, char in enumerate(word):
- if char == "一" and i + 1 < len(word):
- # "一" before tone4 should be yi2, e.g. 一段
- if finals[i + 1][-1] == "4":
- finals[i] = finals[i][:-1] + "2"
- # "一" before non-tone4 should be yi4, e.g. 一天
- else:
- # "一" 后面如果是标点，还读一声
- if word[i + 1] not in self.punc:
- finals[i] = finals[i][:-1] + "4"
- return finals
-
- def _split_word(self, word: str) -> List[str]:
- word_list = jieba.cut_for_search(word)
- word_list = sorted(word_list, key=lambda i: len(i), reverse=False)
- first_subword = word_list[0]
- first_begin_idx = word.find(first_subword)
- if first_begin_idx == 0:
- second_subword = word[len(first_subword):]
- new_word_list = [first_subword, second_subword]
- else:
- second_subword = word[:-len(first_subword)]
- new_word_list = [second_subword, first_subword]
- return new_word_list
-
- def _three_sandhi(self, word: str, finals: List[str]) -> List[str]:
- if len(word) == 2 and self._all_tone_three(finals):
- finals[0] = finals[0][:-1] + "2"
- elif len(word) == 3:
- word_list = self._split_word(word)
- if self._all_tone_three(finals):
- # disyllabic + monosyllabic, e.g. 蒙古/包
- if len(word_list[0]) == 2:
- finals[0] = finals[0][:-1] + "2"
- finals[1] = finals[1][:-1] + "2"
- # monosyllabic + disyllabic, e.g. 纸/老虎
- elif len(word_list[0]) == 1:
- finals[1] = finals[1][:-1] + "2"
- else:
- finals_list = [
- finals[:len(word_list[0])], finals[len(word_list[0]):]
- ]
- if len(finals_list) == 2:
- for i, sub in enumerate(finals_list):
- # e.g. 所有/人
- if self._all_tone_three(sub) and len(sub) == 2:
- finals_list[i][0] = finals_list[i][0][:-1] + "2"
- # e.g. 好/喜欢
- elif i == 1 and not self._all_tone_three(sub) and finals_list[i][0][-1] == "3" and \
- finals_list[0][-1][-1] == "3":
-
- finals_list[0][-1] = finals_list[0][-1][:-1] + "2"
- finals = sum(finals_list, [])
- # split idiom into two words who's length is 2
- elif len(word) == 4:
- finals_list = [finals[:2], finals[2:]]
- finals = []
- for sub in finals_list:
- if self._all_tone_three(sub):
- sub[0] = sub[0][:-1] + "2"
- finals += sub
-
- return finals
-
- def _all_tone_three(self, finals: List[str]) -> bool:
- return all(x[-1] == "3" for x in finals)
-
- # merge "不" and the word behind it
- # if don't merge, "不" sometimes appears alone according to jieba, which may occur sandhi error
- def _merge_bu(self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- last_word = ""
- for word, pos in seg:
- if last_word == "不":
- word = last_word + word
- if word != "不":
- new_seg.append((word, pos))
- last_word = word[:]
- if last_word == "不":
- new_seg.append((last_word, 'd'))
- last_word = ""
- return new_seg
-
- # function 1: merge "一" and reduplication words in it's left and right, e.g. "听","一","听" ->"听一听"
- # function 2: merge single "一" and the word behind it
- # if don't merge, "一" sometimes appears alone according to jieba, which may occur sandhi error
- # e.g.
- # input seg: [('听', 'v'), ('一', 'm'), ('听', 'v')]
- # output seg: [['听一听', 'v']]
- def _merge_yi(self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- # function 1
- for i, (word, pos) in enumerate(seg):
- if i - 1 >= 0 and word == "一" and i + 1 < len(seg) and seg[i - 1][
- 0] == seg[i + 1][0] and seg[i - 1][1] == "v":
- new_seg[i - 1][0] = new_seg[i - 1][0] + "一" + new_seg[i - 1][0]
- else:
- if i - 2 >= 0 and seg[i - 1][0] == "一" and seg[i - 2][
- 0] == word and pos == "v":
- continue
- else:
- new_seg.append([word, pos])
- seg = new_seg
- new_seg = []
- # function 2
- for i, (word, pos) in enumerate(seg):
- if new_seg and new_seg[-1][0] == "一":
- new_seg[-1][0] = new_seg[-1][0] + word
- else:
- new_seg.append([word, pos])
- return new_seg
-
- # the first and the second words are all_tone_three
- def _merge_continuous_three_tones(
- self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- sub_finals_list = [
- lazy_pinyin(
- word, neutral_tone_with_five=True, style=Style.FINALS_TONE3)
- for (word, pos) in seg
- ]
- assert len(sub_finals_list) == len(seg)
- merge_last = [False] * len(seg)
- for i, (word, pos) in enumerate(seg):
- if i - 1 >= 0 and self._all_tone_three(
- sub_finals_list[i - 1]) and self._all_tone_three(
- sub_finals_list[i]) and not merge_last[i - 1]:
- # if the last word is reduplication, not merge, because reduplication need to be _neural_sandhi
- if not self._is_reduplication(seg[i - 1][0]) and len(
- seg[i - 1][0]) + len(seg[i][0]) <= 3:
- new_seg[-1][0] = new_seg[-1][0] + seg[i][0]
- merge_last[i] = True
- else:
- new_seg.append([word, pos])
- else:
- new_seg.append([word, pos])
-
- return new_seg
-
- def _is_reduplication(self, word: str) -> bool:
- return len(word) == 2 and word[0] == word[1]
-
- # the last char of first word and the first char of second word is tone_three
- def _merge_continuous_three_tones_2(
- self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- sub_finals_list = [
- lazy_pinyin(
- word, neutral_tone_with_five=True, style=Style.FINALS_TONE3)
- for (word, pos) in seg
- ]
- assert len(sub_finals_list) == len(seg)
- merge_last = [False] * len(seg)
- for i, (word, pos) in enumerate(seg):
- if i - 1 >= 0 and sub_finals_list[i - 1][-1][-1] == "3" and sub_finals_list[i][0][-1] == "3" and not \
- merge_last[i - 1]:
- # if the last word is reduplication, not merge, because reduplication need to be _neural_sandhi
- if not self._is_reduplication(seg[i - 1][0]) and len(
- seg[i - 1][0]) + len(seg[i][0]) <= 3:
- new_seg[-1][0] = new_seg[-1][0] + seg[i][0]
- merge_last[i] = True
- else:
- new_seg.append([word, pos])
- else:
- new_seg.append([word, pos])
- return new_seg
-
- def _merge_er(self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- for i, (word, pos) in enumerate(seg):
- if i - 1 >= 0 and word == "儿" and seg[i-1][0] != "#":
- new_seg[-1][0] = new_seg[-1][0] + seg[i][0]
- else:
- new_seg.append([word, pos])
- return new_seg
-
- def _merge_reduplication(
- self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- new_seg = []
- for i, (word, pos) in enumerate(seg):
- if new_seg and word == new_seg[-1][0]:
- new_seg[-1][0] = new_seg[-1][0] + seg[i][0]
- else:
- new_seg.append([word, pos])
- return new_seg
-
- def pre_merge_for_modify(
- self, seg: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
- seg = self._merge_bu(seg)
- try:
- seg = self._merge_yi(seg)
- except:
- print("_merge_yi failed")
- seg = self._merge_reduplication(seg)
- seg = self._merge_continuous_three_tones(seg)
- seg = self._merge_continuous_three_tones_2(seg)
- seg = self._merge_er(seg)
- return seg
-
- def modified_tone(self, word: str, pos: str,
- finals: List[str]) -> List[str]:
- finals = self._bu_sandhi(word, finals)
- finals = self._yi_sandhi(word, finals)
- finals = self._neural_sandhi(word, pos, finals)
- finals = self._three_sandhi(word, finals)
- return finals
diff --git a/spaces/digitalxingtong/Nailv-Bert-Vits2/mel_processing.py b/spaces/digitalxingtong/Nailv-Bert-Vits2/mel_processing.py
deleted file mode 100644
index 50435ecf88ef4fb6c1d47f3e6edd04c3ea7d3e80..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Nailv-Bert-Vits2/mel_processing.py
+++ /dev/null
@@ -1,112 +0,0 @@
-import math
-import os
-import random
-import torch
-from torch import nn
-import torch.nn.functional as F
-import torch.utils.data
-import numpy as np
-import librosa
-import librosa.util as librosa_util
-from librosa.util import normalize, pad_center, tiny
-from scipy.signal import get_window
-from scipy.io.wavfile import read
-from librosa.filters import mel as librosa_mel_fn
-
-MAX_WAV_VALUE = 32768.0
-
-
-def dynamic_range_compression_torch(x, C=1, clip_val=1e-5):
- """
- PARAMS
- ------
- C: compression factor
- """
- return torch.log(torch.clamp(x, min=clip_val) * C)
-
-
-def dynamic_range_decompression_torch(x, C=1):
- """
- PARAMS
- ------
- C: compression factor used to compress
- """
- return torch.exp(x) / C
-
-
-def spectral_normalize_torch(magnitudes):
- output = dynamic_range_compression_torch(magnitudes)
- return output
-
-
-def spectral_de_normalize_torch(magnitudes):
- output = dynamic_range_decompression_torch(magnitudes)
- return output
-
-
-mel_basis = {}
-hann_window = {}
-
-
-def spectrogram_torch(y, n_fft, sampling_rate, hop_size, win_size, center=False):
- if torch.min(y) < -1.:
- print('min value is ', torch.min(y))
- if torch.max(y) > 1.:
- print('max value is ', torch.max(y))
-
- global hann_window
- dtype_device = str(y.dtype) + '_' + str(y.device)
- wnsize_dtype_device = str(win_size) + '_' + dtype_device
- if wnsize_dtype_device not in hann_window:
- hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
- y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
- y = y.squeeze(1)
-
- spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
- center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
- spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
- return spec
-
-
-def spec_to_mel_torch(spec, n_fft, num_mels, sampling_rate, fmin, fmax):
- global mel_basis
- dtype_device = str(spec.dtype) + '_' + str(spec.device)
- fmax_dtype_device = str(fmax) + '_' + dtype_device
- if fmax_dtype_device not in mel_basis:
- mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
- mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=spec.dtype, device=spec.device)
- spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
- spec = spectral_normalize_torch(spec)
- return spec
-
-
-def mel_spectrogram_torch(y, n_fft, num_mels, sampling_rate, hop_size, win_size, fmin, fmax, center=False):
- if torch.min(y) < -1.:
- print('min value is ', torch.min(y))
- if torch.max(y) > 1.:
- print('max value is ', torch.max(y))
-
- global mel_basis, hann_window
- dtype_device = str(y.dtype) + '_' + str(y.device)
- fmax_dtype_device = str(fmax) + '_' + dtype_device
- wnsize_dtype_device = str(win_size) + '_' + dtype_device
- if fmax_dtype_device not in mel_basis:
- mel = librosa_mel_fn(sampling_rate, n_fft, num_mels, fmin, fmax)
- mel_basis[fmax_dtype_device] = torch.from_numpy(mel).to(dtype=y.dtype, device=y.device)
- if wnsize_dtype_device not in hann_window:
- hann_window[wnsize_dtype_device] = torch.hann_window(win_size).to(dtype=y.dtype, device=y.device)
-
- y = torch.nn.functional.pad(y.unsqueeze(1), (int((n_fft-hop_size)/2), int((n_fft-hop_size)/2)), mode='reflect')
- y = y.squeeze(1)
-
- spec = torch.stft(y, n_fft, hop_length=hop_size, win_length=win_size, window=hann_window[wnsize_dtype_device],
- center=center, pad_mode='reflect', normalized=False, onesided=True, return_complex=False)
-
- spec = torch.sqrt(spec.pow(2).sum(-1) + 1e-6)
-
- spec = torch.matmul(mel_basis[fmax_dtype_device], spec)
- spec = spectral_normalize_torch(spec)
-
- return spec
diff --git a/spaces/digitalxingtong/Xingtong-Longread-Bert-VITS2/commons.py b/spaces/digitalxingtong/Xingtong-Longread-Bert-VITS2/commons.py
deleted file mode 100644
index 9ad0444b61cbadaa388619986c2889c707d873ce..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Xingtong-Longread-Bert-VITS2/commons.py
+++ /dev/null
@@ -1,161 +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 intersperse(lst, item):
- result = [item] * (len(lst) * 2 + 1)
- result[1::2] = lst
- return result
-
-
-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. * logs_p) + ((m_p - m_q)**2)) * torch.exp(-2. * 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 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. / norm_type)
- return total_norm
diff --git a/spaces/digitalxingtong/Xingtong-Read-Bert-VITS2/transforms.py b/spaces/digitalxingtong/Xingtong-Read-Bert-VITS2/transforms.py
deleted file mode 100644
index 4793d67ca5a5630e0ffe0f9fb29445c949e64dae..0000000000000000000000000000000000000000
--- a/spaces/digitalxingtong/Xingtong-Read-Bert-VITS2/transforms.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import torch
-from torch.nn import functional as F
-
-import numpy as np
-
-
-DEFAULT_MIN_BIN_WIDTH = 1e-3
-DEFAULT_MIN_BIN_HEIGHT = 1e-3
-DEFAULT_MIN_DERIVATIVE = 1e-3
-
-
-def piecewise_rational_quadratic_transform(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails=None,
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
-
- if tails is None:
- spline_fn = rational_quadratic_spline
- spline_kwargs = {}
- else:
- spline_fn = unconstrained_rational_quadratic_spline
- spline_kwargs = {
- 'tails': tails,
- 'tail_bound': tail_bound
- }
-
- outputs, logabsdet = spline_fn(
- inputs=inputs,
- unnormalized_widths=unnormalized_widths,
- unnormalized_heights=unnormalized_heights,
- unnormalized_derivatives=unnormalized_derivatives,
- inverse=inverse,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative,
- **spline_kwargs
- )
- return outputs, logabsdet
-
-
-def searchsorted(bin_locations, inputs, eps=1e-6):
- bin_locations[..., -1] += eps
- return torch.sum(
- inputs[..., None] >= bin_locations,
- dim=-1
- ) - 1
-
-
-def unconstrained_rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- tails='linear',
- tail_bound=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- inside_interval_mask = (inputs >= -tail_bound) & (inputs <= tail_bound)
- outside_interval_mask = ~inside_interval_mask
-
- outputs = torch.zeros_like(inputs)
- logabsdet = torch.zeros_like(inputs)
-
- if tails == 'linear':
- unnormalized_derivatives = F.pad(unnormalized_derivatives, pad=(1, 1))
- constant = np.log(np.exp(1 - min_derivative) - 1)
- unnormalized_derivatives[..., 0] = constant
- unnormalized_derivatives[..., -1] = constant
-
- outputs[outside_interval_mask] = inputs[outside_interval_mask]
- logabsdet[outside_interval_mask] = 0
- else:
- raise RuntimeError('{} tails are not implemented.'.format(tails))
-
- outputs[inside_interval_mask], logabsdet[inside_interval_mask] = rational_quadratic_spline(
- inputs=inputs[inside_interval_mask],
- unnormalized_widths=unnormalized_widths[inside_interval_mask, :],
- unnormalized_heights=unnormalized_heights[inside_interval_mask, :],
- unnormalized_derivatives=unnormalized_derivatives[inside_interval_mask, :],
- inverse=inverse,
- left=-tail_bound, right=tail_bound, bottom=-tail_bound, top=tail_bound,
- min_bin_width=min_bin_width,
- min_bin_height=min_bin_height,
- min_derivative=min_derivative
- )
-
- return outputs, logabsdet
-
-def rational_quadratic_spline(inputs,
- unnormalized_widths,
- unnormalized_heights,
- unnormalized_derivatives,
- inverse=False,
- left=0., right=1., bottom=0., top=1.,
- min_bin_width=DEFAULT_MIN_BIN_WIDTH,
- min_bin_height=DEFAULT_MIN_BIN_HEIGHT,
- min_derivative=DEFAULT_MIN_DERIVATIVE):
- if torch.min(inputs) < left or torch.max(inputs) > right:
- raise ValueError('Input to a transform is not within its domain')
-
- num_bins = unnormalized_widths.shape[-1]
-
- if min_bin_width * num_bins > 1.0:
- raise ValueError('Minimal bin width too large for the number of bins')
- if min_bin_height * num_bins > 1.0:
- raise ValueError('Minimal bin height too large for the number of bins')
-
- widths = F.softmax(unnormalized_widths, dim=-1)
- widths = min_bin_width + (1 - min_bin_width * num_bins) * widths
- cumwidths = torch.cumsum(widths, dim=-1)
- cumwidths = F.pad(cumwidths, pad=(1, 0), mode='constant', value=0.0)
- cumwidths = (right - left) * cumwidths + left
- cumwidths[..., 0] = left
- cumwidths[..., -1] = right
- widths = cumwidths[..., 1:] - cumwidths[..., :-1]
-
- derivatives = min_derivative + F.softplus(unnormalized_derivatives)
-
- heights = F.softmax(unnormalized_heights, dim=-1)
- heights = min_bin_height + (1 - min_bin_height * num_bins) * heights
- cumheights = torch.cumsum(heights, dim=-1)
- cumheights = F.pad(cumheights, pad=(1, 0), mode='constant', value=0.0)
- cumheights = (top - bottom) * cumheights + bottom
- cumheights[..., 0] = bottom
- cumheights[..., -1] = top
- heights = cumheights[..., 1:] - cumheights[..., :-1]
-
- if inverse:
- bin_idx = searchsorted(cumheights, inputs)[..., None]
- else:
- bin_idx = searchsorted(cumwidths, inputs)[..., None]
-
- input_cumwidths = cumwidths.gather(-1, bin_idx)[..., 0]
- input_bin_widths = widths.gather(-1, bin_idx)[..., 0]
-
- input_cumheights = cumheights.gather(-1, bin_idx)[..., 0]
- delta = heights / widths
- input_delta = delta.gather(-1, bin_idx)[..., 0]
-
- input_derivatives = derivatives.gather(-1, bin_idx)[..., 0]
- input_derivatives_plus_one = derivatives[..., 1:].gather(-1, bin_idx)[..., 0]
-
- input_heights = heights.gather(-1, bin_idx)[..., 0]
-
- if inverse:
- a = (((inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta)
- + input_heights * (input_delta - input_derivatives)))
- b = (input_heights * input_derivatives
- - (inputs - input_cumheights) * (input_derivatives
- + input_derivatives_plus_one
- - 2 * input_delta))
- c = - input_delta * (inputs - input_cumheights)
-
- discriminant = b.pow(2) - 4 * a * c
- assert (discriminant >= 0).all()
-
- root = (2 * c) / (-b - torch.sqrt(discriminant))
- outputs = root * input_bin_widths + input_cumwidths
-
- theta_one_minus_theta = root * (1 - root)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * root.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - root).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, -logabsdet
- else:
- theta = (inputs - input_cumwidths) / input_bin_widths
- theta_one_minus_theta = theta * (1 - theta)
-
- numerator = input_heights * (input_delta * theta.pow(2)
- + input_derivatives * theta_one_minus_theta)
- denominator = input_delta + ((input_derivatives + input_derivatives_plus_one - 2 * input_delta)
- * theta_one_minus_theta)
- outputs = input_cumheights + numerator / denominator
-
- derivative_numerator = input_delta.pow(2) * (input_derivatives_plus_one * theta.pow(2)
- + 2 * input_delta * theta_one_minus_theta
- + input_derivatives * (1 - theta).pow(2))
- logabsdet = torch.log(derivative_numerator) - 2 * torch.log(denominator)
-
- return outputs, logabsdet
diff --git a/spaces/dragonSwing/annotate-anything/README.md b/spaces/dragonSwing/annotate-anything/README.md
deleted file mode 100644
index 10eb4ca00f0267ab08bd0fdf9d82921552ebdbf5..0000000000000000000000000000000000000000
--- a/spaces/dragonSwing/annotate-anything/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Annotate Anything
-emoji: 🐨
-colorFrom: green
-colorTo: gray
-sdk: gradio
-sdk_version: 3.33.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/dylanebert/list-of-splats/README.md b/spaces/dylanebert/list-of-splats/README.md
deleted file mode 100644
index 9419882eaab71abf595034997927130d179de4f2..0000000000000000000000000000000000000000
--- a/spaces/dylanebert/list-of-splats/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: List Of Splats
-emoji: 🌖
-colorFrom: gray
-colorTo: green
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/cppipc/pool_alloc.cpp b/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/cppipc/pool_alloc.cpp
deleted file mode 100644
index c94575903bdf2eef71ecbe66382375552446e510..0000000000000000000000000000000000000000
--- a/spaces/erbanku/gpt-academic/crazy_functions/test_project/cpp/cppipc/pool_alloc.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-#include "libipc/pool_alloc.h"
-
-#include "libipc/memory/resource.h"
-
-namespace ipc {
-namespace mem {
-
-void* pool_alloc::alloc(std::size_t size) {
- return async_pool_alloc::alloc(size);
-}
-
-void pool_alloc::free(void* p, std::size_t size) {
- async_pool_alloc::free(p, size);
-}
-
-} // namespace mem
-} // namespace ipc
diff --git a/spaces/falterWliame/Face_Mask_Detection/Alfatest Grp 1.27 26 _HOT_.md b/spaces/falterWliame/Face_Mask_Detection/Alfatest Grp 1.27 26 _HOT_.md
deleted file mode 100644
index 2c463ef9b109c3dffd6e8047e11004810407dd01..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Alfatest Grp 1.27 26 _HOT_.md
+++ /dev/null
@@ -1,25 +0,0 @@
-What is Alfatest Grp 1.27 26 and how to use it?
-Alfatest Grp 1.27 26 is a software program that helps you diagnose and repair various automotive problems. It is developed by Alfatest Ind. e Com. Prods. Eletrônicos S/A, a Brazilian company that specializes in electronic products for the automotive industry.
-Alfatest Grp 1.27 26 Download … https://urlca.com/2uDdN7
Alfatest Grp 1.27 26 is part of the Guia de Reparos Plus (Repair Guide Plus) series, which provides detailed information on how to fix common issues with different car models and systems. You can access the software by downloading it from the Alfatest website or by using a CD-ROM.
-To use Alfatest Grp 1.27 26, you need to install it on your computer and connect it to a compatible diagnostic device, such as a scanner or an oscilloscope. The software will then guide you through the steps of identifying and solving the problem, using clear instructions, diagrams, and videos.
-Some of the features of Alfatest Grp 1.27 26 are:
-
-
-It covers a wide range of vehicles, from cars to trucks, motorcycles, and buses.
-It supports various languages, such as Portuguese, Spanish, English, and French.
-It updates automatically with new information and tips.
-It allows you to print or save reports of your repairs.
-
-Alfatest Grp 1.27 26 is a useful tool for anyone who works with automotive maintenance or repair. It can help you save time and money by providing you with accurate and reliable solutions.
-
-If you want to learn more about Alfatest Grp 1.27 26, you can visit the Alfatest website, where you can find manuals, videos, and FAQs. You can also contact the Alfatest support team by phone or email if you have any questions or issues with the software.
-Alfatest Grp 1.27 26 is not the only product that Alfatest offers. The company also has other software programs and devices that can help you with different aspects of automotive diagnostics and repair. For example, you can use Alfatest Kaptor to scan and analyze the electronic systems of your vehicle, or Alfatest Scope to measure and display electrical signals.
-Alfatest is a leader in the field of automotive electronics in Brazil and Latin America. The company has been in business since 1986 and has a reputation for quality and innovation. Alfatest products are used by thousands of professionals and enthusiasts around the world.
-
-If you are interested in buying Alfatest Grp 1.27 26 or any other Alfatest product, you can visit the Alfatest online store, where you can find the prices and specifications of each item. You can also find a list of authorized dealers and distributors in your area.
-Alfatest Grp 1.27 26 is compatible with Windows XP, Vista, 7, 8, and 10. It requires a minimum of 512 MB of RAM and 2 GB of free disk space. It also requires an internet connection for updates and activation.
-Alfatest Grp 1.27 26 is a powerful and versatile software program that can help you diagnose and repair automotive problems with ease and confidence. It is a must-have for anyone who works with cars or loves them.
d5da3c52bfCodevisionavr V3 DOWNLOAD ★★★ https://urlca.com/2uDdWp
diff --git a/spaces/falterWliame/Face_Mask_Detection/DevWing LE Keygen ((EXCLUSIVE)).rar .rar.md b/spaces/falterWliame/Face_Mask_Detection/DevWing LE Keygen ((EXCLUSIVE)).rar .rar.md
deleted file mode 100644
index 1723db3ace6226fcea99011856df37feb604d2b0..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/DevWing LE Keygen ((EXCLUSIVE)).rar .rar.md
+++ /dev/null
@@ -1,10 +0,0 @@
-DevWing LE keygen.rar .rar DOWNLOAD ····· https://urlca.com/2uDcOJ
diff --git a/spaces/falterWliame/Face_Mask_Detection/Interstellar 1080p Br Rip Movies Torrents.md b/spaces/falterWliame/Face_Mask_Detection/Interstellar 1080p Br Rip Movies Torrents.md
deleted file mode 100644
index d8930fdab3e60feec38a147ba0ef057ca10e5529..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Interstellar 1080p Br Rip Movies Torrents.md
+++ /dev/null
@@ -1,6 +0,0 @@
-interstellar 1080p br rip movies torrents Download Zip ⚡ https://urlca.com/2uDcHB
diff --git a/spaces/falterWliame/Face_Mask_Detection/Manusmriti In Telugu Pdf Free Download VERIFIED.md b/spaces/falterWliame/Face_Mask_Detection/Manusmriti In Telugu Pdf Free Download VERIFIED.md
deleted file mode 100644
index ef5471d7130c13b75e04d7214eef7f40000ee82d..0000000000000000000000000000000000000000
--- a/spaces/falterWliame/Face_Mask_Detection/Manusmriti In Telugu Pdf Free Download VERIFIED.md
+++ /dev/null
@@ -1,8 +0,0 @@
-
-the manusmriti came to be known as the manava dharmashastra in the twelfth century. it is a samhitas (bhaskara) text that has been variously dated to the fifth, sixth, seventh and eighth centuries. its authorship, however, has been debated. the text was likely composed over a long period, due to the fact that it is composed of the same ancient sanskrit verse, but the changes are related to the local religious practices in different regions of india. the original text is divided into three parts, including the shastra (rules), the astra (chapter) and the shataka (stories). the manusmriti is divided into 69 chapters, although the names of some chapters vary in different versions.
-if you are interested in manusmriti, which means “the laws of manu” , then you will find this book very useful. there is a brief introduction, which makes it very clear and understandable that the book is a compilation of old vedic teachings.
-manusmriti in telugu pdf free download Download Zip ->>> https://urlca.com/2uDdG1
the manusmriti was composed of four works, by four authors. the first author was manu, the second is called vyasa. manu is the author of three works, the third is kautilya, the fourth is yajnavalkya. the manusmriti was composed in sanskrit.
-the manusmriti is a textbook for people who want to do vedic rituals. it teaches us about our ancestors and ourselves, and how to get on in life. it is like the rambam in judaism, the bhagavad gita in hinduism and the koran in islam. it has kept the legacy of our forefathers alive for many years.
899543212bWhat is Download 35 and Why You Need It
-If you are a Windows user, you may have encountered the term "download 35" while browsing the web or trying to run some games or applications. But what is download 35 exactly and why do you need it? In this article, we will explain what download 35 is, what are its benefits, how to download and install it, how to use it, and how to fix some common issues with it.
- Download 35 Explained
-What is Download 35?
-Download 35 is not a single program or file, but a collection of different components that are required for some Windows applications and games to run properly. These components include:
-download 35 Download File →→→ https://urllie.com/2uNIxb
-Microsoft .NET Framework 3.5 : This is a software framework that provides a set of libraries and tools for developing and running applications that use .NET technologies, such as Windows Forms, WPF, ASP.NET, LINQ, WCF, etc. .NET Framework 3.5 includes .NET Framework 2.0 and 3.0 service packs.DirectX End-User Runtime : This is a package that installs a number of runtime libraries from the legacy DirectX SDK for some games that use D3DX9, D3DX10, D3DX11, XAudio 2.7, XInput 1.3, XACT, and/or Managed DirectX 1.1. These libraries are not part of the DirectX Runtime installed on your Windows OS.
-Some applications and games may require these components to function correctly, especially if they were developed using older versions of .NET or DirectX. If you don't have these components installed on your system, you may encounter errors or crashes when trying to run these applications or games.
- What are the Benefits of Download 35?
-By installing download 35 on your system, you can enjoy the following benefits:
-download 35mm film
-
-Compatibility : You can run applications and games that require .NET Framework 3.5 or DirectX End-User Runtime without any issues.Performance : You can improve the performance and stability of your applications and games by using the latest versions of .NET Framework and DirectX Runtime.Security : You can protect your system from potential vulnerabilities by applying the latest updates and patches for .NET Framework and DirectX Runtime.
- How to Download and Install Download 35
-How to Download Download 35
-To download download 35, you need to visit the official Microsoft websites for .NET Framework 3.5 and DirectX End-User Runtime. You can also use the links below:
-
-Component Download Link .NET Framework 3.5 [text](^1^) DirectX End-User Runtime [text](^3^)
-Once you have downloaded the files, you need to save them in a location that you can easily access later.
- How to Install Download 35
-To install download 35, you need to follow these steps:
-
-Run the .NET Framework 3.5 installerRun the .NET Framework 3.5 installer : Double-click on the file that you downloaded and follow the instructions on the screen. You may need to restart your computer after the installation is complete. - Run the DirectX End-User Runtime installer : Double-click on the file that you downloaded and follow the instructions on the screen. You may need to accept the Microsoft Software License Terms and choose a location to extract the files. After that, you need to open the extracted folder and run the DXSETUP.exe file. You may need to restart your computer after the installation is complete.
-Congratulations, you have successfully installed download 35 on your system!
- How to Use Download 35
-How to Run Apps with Download 35
-To run applications or games that require download 35, you just need to launch them as usual. If they are compatible with .NET Framework 3.5 or DirectX End-User Runtime, they should run smoothly and without errors. However, some applications or games may require additional settings or configurations to work properly. In that case, you should refer to the documentation or support of the specific application or game for more information.
- How to Update Download 35
-To update download 35, you need to check for updates for .NET Framework 3.5 and DirectX End-User Runtime separately. You can do this by using the following methods:
-
-For .NET Framework 3.5 : You can use Windows Update to check for and install updates for .NET Framework 3.5. You can also download and install the latest service pack for .NET Framework 3.5 from the Microsoft website.For DirectX End-User Runtime : You can use Windows Update to check for and install updates for DirectX End-User Runtime. You can also download and install the latest version of DirectX End-User Runtime from the Microsoft website.
-It is recommended that you keep download 35 updated to ensure optimal performance and security of your applications and games.
- Common Issues and Solutions with Download 35
-How to Fix Download 35 Errors
-Sometimes, you may encounter errors or issues with download 35 that prevent you from running your applications or games properly. Some of the common errors or issues are:
-
-.NET Framework Initialization Error : This error occurs when an application requires a version of .NET Framework that is not installed on your system. To fix this error, you need to install the required version of .NET Framework or update your application to use a compatible version of .NET Framework.D3DX9_XX.DLL Not Found or Missing : This error occurs when an application or game requires a specific version of D3DX9 library that is not installed on your system. To fix this error, you need to install the DirectX End-User Runtime package that contains the missing library.Application Has Stopped Working : This error occurs when an application or game crashes due to various reasons, such as incompatible hardware, corrupted files, outdated drivers, etc. To fix this error, you need to troubleshoot the cause of the crash and apply the appropriate solution.
-If you encounter any other errors or issues with download 35, you can search for solutions online or contact the support team of the application or game that is causing the problem.
- How to Uninstall Download 35
-If you want to uninstall download 35 from your system, you need to uninstall .NET Framework 3.5 and DirectX End-User Runtime separately. You can do this by using the following methods:
-
-For .NET Framework 3.5 : You can use Windows Features to turn off .NET Framework 3.5 from your system. To do this, go to Control Panel > Programs > Turn Windows features on or off > Uncheck .NET Framework 3.5 (includes .NET 2.0 and 3.0) > OK.For DirectX End-User Runtime : You can use Programs and Features to uninstall DirectX End-User Runtime from your system. To do this, go to Control Panel > Programs > Programs and Features > Find DirectX End-User Runtime Web Installer > Right-click > Uninstall.
-Note that uninstalling download 35 may affect the functionality of some applications or games that depend on it.
- ConclusionConclusion
-In this article, we have learned what download 35 is, why you need it, how to download and install it, how to use it, and how to fix some common issues with it. Download 35 is a collection of components that are required for some Windows applications and games to run properly. By installing download 35, you can enjoy compatibility, performance, and security benefits. However, you may also encounter some errors or issues with download 35 that can be resolved by following the solutions provided in this article. We hope that this article has helped you understand and use download 35 better.
- FAQs
-What is the difference between .NET Framework and DirectX?
-.NET Framework and DirectX are two different software frameworks that provide different functionalities for applications and games. .NET Framework is a software framework that provides a set of libraries and tools for developing and running applications that use .NET technologies, such as Windows Forms, WPF, ASP.NET, LINQ, WCF, etc. DirectX is a software framework that provides a set of APIs and libraries for developing and running applications and games that use multimedia features, such as graphics, sound, video, input, etc.
- Do I need to install both .NET Framework 3.5 and DirectX End-User Runtime?
-It depends on the requirements of the applications or games that you want to run. Some applications or games may require only one of them, while others may require both of them. You can check the documentation or support of the specific application or game to find out what components it needs.
- Can I install other versions of .NET Framework or DirectX?
-Yes, you can install other versions of .NET Framework or DirectX on your system. However, you should be aware that some applications or games may not be compatible with newer or older versions of .NET Framework or DirectX. Therefore, you should always check the compatibility before installing other versions of .NET Framework or DirectX.
- How can I check if I have download 35 installed on my system?
-You can check if you have download 35 installed on your system by using the following methods:
-
-For .NET Framework 3.5 : You can use Windows Features to see if .NET Framework 3.5 is turned on on your system. To do this, go to Control Panel > Programs > Turn Windows features on or off > Check if .NET Framework 3.5 (includes .NET 2.0 and 3.0) is checked.For DirectX End-User Runtime : You can use DirectX Diagnostic Tool to see what version of DirectX Runtime is installed on your system. To do this, go to Start > Run > Type dxdiag > OK > Check the DirectX Version on the System tab.
- Where can I get more information or help about download 35?
-If you need more information or help about download 35, you can visit the following websites:
-
-For .NET Framework 3.5 : You can visit the Microsoft website for more information about .NET Framework 3.5, such as features, downloads, updates, documentation, support, etc.For DirectX End-User Runtime : You can visit the Microsoft website for more information about DirectX End-User Runtime, such as features, downloads, updates, documentation, support, etc. 401be4b1e0 $config_json
-{
- "train_micro_batch_size_per_gpu": $BATCH_SIZE,
- "steps_per_print": 100,
- "gradient_clipping": 0.1,
- "zero_optimization": {
- "stage": ${ZERO_STAGE}
- },
- "optimizer": {
- "type": "Adam",
- "params": {
- "lr": 1e-7,
- "eps": 1e-12,
- "weight_decay": 1e-2
- }
- },
- "scheduler": {
- "type": "WarmupLR",
- "params":{
- "warmup_min_lr": 1e-5,
- "warmup_max_lr": 1e-4,
- "warmup_num_steps": 400,
- "warmup_type": "linear"
- }
- },
- "zero_allow_untested_optimizer": false,
- "fp16": {
- "enabled": false,
- "loss_scale": 0,
- "loss_scale_window": 1000,
- "hysteresis": 2,
- "min_loss_scale": 1
- },
- "activation_checkpointing": {
- "partition_activations": false,
- "contiguous_memory_optimization": false
- },
- "wall_clock_breakdown": false
-}
-EOT
-
-export PL_DEEPSPEED_CONFIG_PATH=$config_json
-
-
-DATA_ARGS="\
- --data_dir $DATA_DIR \
- --train_data train.json \
- --valid_data dev.json \
- --test_data test.json \
- --train_batchsize $BATCH_SIZE \
- --valid_batchsize $VAL_BATCH_SIZE \
- --max_length 64 \
- --texta_name $TEXTA_NAME \
- --textb_name $TEXTB_NAME \
- --label_name $LABEL_NAME \
- --id_name $ID_NAME \
- "
-
-MODEL_ARGS="\
- --learning_rate 1e-5 \
- --weight_decay 1e-2 \
- --warmup 0.01 \
- --num_labels 2 \
- "
-
-MODEL_CHECKPOINT_ARGS="\
- --monitor val_acc \
- --save_top_k 3 \
- --mode max \
- --every_n_train_steps 200 \
- --save_weights_only True \
- --dirpath $CHECKPOINT_PATH \
- --filename model-{epoch:02d}-{val_acc:.4f} \
- "
-
-
-TRAINER_ARGS="\
- --max_epochs 10 \
- --gpus 1 \
- --num_nodes 1 \
- --strategy $STRATEGY \
- --gradient_clip_val 1.0 \
- --check_val_every_n_epoch 1 \
- --val_check_interval 1.0 \
- --default_root_dir $ROOT_DIR \
- "
-
-options=" \
- --pretrained_model_path $PRETRAINED_MODEL_PATH \
- --output_save_path $OUTPUT_PATH \
- $DATA_ARGS \
- $MODEL_ARGS \
- $MODEL_CHECKPOINT_ARGS \
- $TRAINER_ARGS \
- "
-
-SINGULARITY_PATH=/cognitive_comp/ganruyi/pytorch21_06_py3_docker_image_v2.sif
-SCRIPT_PATH=/cognitive_comp/ganruyi/Fengshenbang-LM/fengshen/examples/classification/finetune_classification.py
-
-# python3 $SCRIPT_PATH $options
-source activate base
-# srun singularity exec --nv -B /cognitive_comp/:/cognitive_comp/ $SINGULARITY_PATH /home/ganruyi/anaconda3/bin/python $SCRIPT_PATH $options
-/home/ganruyi/anaconda3/bin/python $SCRIPT_PATH $options
-
diff --git a/spaces/feng2022/Time-TravelRephotography/Time_TravelRephotography/utils/ffhq_dataset/face_alignment.py b/spaces/feng2022/Time-TravelRephotography/Time_TravelRephotography/utils/ffhq_dataset/face_alignment.py
deleted file mode 100644
index 9f62666dc83a83d4e95446b445b9145dfe11f77c..0000000000000000000000000000000000000000
--- a/spaces/feng2022/Time-TravelRephotography/Time_TravelRephotography/utils/ffhq_dataset/face_alignment.py
+++ /dev/null
@@ -1,99 +0,0 @@
-import numpy as np
-import scipy.ndimage
-import os
-import PIL.Image
-
-
-def image_align(src_file, dst_file, face_landmarks, resize=True, output_size=1024, transform_size=4096, enable_padding=True):
- # Align function from FFHQ dataset pre-processing step
- # https://github.com/NVlabs/ffhq-dataset/blob/master/download_ffhq.py
-
- lm = np.array(face_landmarks)
- lm_chin = lm[0 : 17] # left-right
- lm_eyebrow_left = lm[17 : 22] # left-right
- lm_eyebrow_right = lm[22 : 27] # left-right
- lm_nose = lm[27 : 31] # top-down
- lm_nostrils = lm[31 : 36] # top-down
- lm_eye_left = lm[36 : 42] # left-clockwise
- lm_eye_right = lm[42 : 48] # left-clockwise
- lm_mouth_outer = lm[48 : 60] # left-clockwise
- lm_mouth_inner = lm[60 : 68] # left-clockwise
-
- # Calculate auxiliary vectors.
- eye_left = np.mean(lm_eye_left, axis=0)
- eye_right = np.mean(lm_eye_right, axis=0)
- eye_avg = (eye_left + eye_right) * 0.5
- eye_to_eye = eye_right - eye_left
- mouth_left = lm_mouth_outer[0]
- mouth_right = lm_mouth_outer[6]
- mouth_avg = (mouth_left + mouth_right) * 0.5
- eye_to_mouth = mouth_avg - eye_avg
-
- # Choose oriented crop rectangle.
- x = eye_to_eye - np.flipud(eye_to_mouth) * [-1, 1]
- x /= np.hypot(*x)
- x *= max(np.hypot(*eye_to_eye) * 2.0, np.hypot(*eye_to_mouth) * 1.8)
- y = np.flipud(x) * [-1, 1]
- c = eye_avg + eye_to_mouth * 0.1
- quad = np.stack([c - x - y, c - x + y, c + x + y, c + x - y])
- qsize = np.hypot(*x) * 2
-
- # Load in-the-wild image.
- if not os.path.isfile(src_file):
- print('\nCannot find source image. Please run "--wilds" before "--align".')
- return
- #img = cv2.imread(src_file)
- #img = PIL.Image.fromarray(img)
- img = PIL.Image.open(src_file)
-
- # Shrink.
- shrink = int(np.floor(qsize / output_size * 0.5))
- if shrink > 1:
- rsize = (int(np.rint(float(img.size[0]) / shrink)), int(np.rint(float(img.size[1]) / shrink)))
- img = img.resize(rsize, PIL.Image.ANTIALIAS)
- quad /= shrink
- qsize /= shrink
-
- # Crop.
- border = max(int(np.rint(qsize * 0.1)), 3)
- crop = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))
- crop = (max(crop[0] - border, 0), max(crop[1] - border, 0), min(crop[2] + border, img.size[0]), min(crop[3] + border, img.size[1]))
- if crop[2] - crop[0] < img.size[0] or crop[3] - crop[1] < img.size[1]:
- img = img.crop(crop)
- quad -= crop[0:2]
-
- # Pad.
- pad = (int(np.floor(min(quad[:,0]))), int(np.floor(min(quad[:,1]))), int(np.ceil(max(quad[:,0]))), int(np.ceil(max(quad[:,1]))))
- pad = (max(-pad[0] + border, 0), max(-pad[1] + border, 0), max(pad[2] - img.size[0] + border, 0), max(pad[3] - img.size[1] + border, 0))
- if enable_padding and max(pad) > border - 4:
- img = np.float32(img)
- if img.ndim == 2:
- img = np.stack((img,)*3, axis=-1)
- pad = np.maximum(pad, int(np.rint(qsize * 0.3)))
- img = np.pad(img, ((pad[1], pad[3]), (pad[0], pad[2]), (0, 0)), 'reflect')
- h, w, _ = img.shape
- y, x, _ = np.ogrid[:h, :w, :1]
- mask = np.maximum(1.0 - np.minimum(np.float32(x) / pad[0], np.float32(w-1-x) / pad[2]), 1.0 - np.minimum(np.float32(y) / pad[1], np.float32(h-1-y) / pad[3]))
- blur = qsize * 0.02
- img += (scipy.ndimage.gaussian_filter(img, [blur, blur, 0]) - img) * np.clip(mask * 3.0 + 1.0, 0.0, 1.0)
- img += (np.median(img, axis=(0,1)) - img) * np.clip(mask, 0.0, 1.0)
- img = PIL.Image.fromarray(np.uint8(np.clip(np.rint(img), 0, 255)), 'RGB')
- quad += pad[:2]
-
- xmin, xmax = np.amin(quad[:,0]), np.amax(quad[:,0])
- ymin, ymax = np.amin(quad[:,1]), np.amax(quad[:,1])
- quad_size = int(max(xmax-xmin, ymax-ymin)+0.5)
-
- if not resize:
- transform_size = output_size = quad_size
-
-
- # Transform.
- img = img.transform((transform_size, transform_size), PIL.Image.QUAD, (quad + 0.5).flatten(), PIL.Image.BILINEAR)
- if output_size < transform_size:
- img = img.resize((output_size, output_size), PIL.Image.ANTIALIAS)
-
- # Save aligned image.
- os.makedirs(os.path.dirname(dst_file), exist_ok=True)
- img.save(dst_file, 'PNG')
- return quad_size
diff --git a/spaces/fengjianliang/bingo/README.md b/spaces/fengjianliang/bingo/README.md
deleted file mode 100644
index 5d6936218874c647b5d22e13ad4be7edb8936f92..0000000000000000000000000000000000000000
--- a/spaces/fengjianliang/bingo/README.md
+++ /dev/null
@@ -1,28 +0,0 @@
----
-title: bingo
-emoji: 😊
-colorFrom: red
-colorTo: red
-sdk: docker
-license: mit
-duplicated_from: hf4all/bingo
----
-
-
-
-# Bingo
-
-Bingo，一个让你呼吸顺畅 New Bing。
-
-高度还原 New Bing 网页版的主要操作，国内可用，兼容绝大多数微软 Bing AI 的功能，可自行部署使用。
-
-
-
-[](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[](https://hub.docker.com/repository/docker/weaigc/bingo/)
-[](https://github.com/weaigc/bingo/blob/main/license)
-
-问题反馈请前往 https://github.com/weaigc/bingo/issues
-
-
-
diff --git a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Become a Mafia Boss with Mafia City Mod APK for Android.md b/spaces/feregVcuzo/sanity-test-midi/checkpoint/Become a Mafia Boss with Mafia City Mod APK for Android.md
deleted file mode 100644
index c8afad6ebf2f078dd25d28aeca8fdba3ac926903..0000000000000000000000000000000000000000
--- a/spaces/feregVcuzo/sanity-test-midi/checkpoint/Become a Mafia Boss with Mafia City Mod APK for Android.md
+++ /dev/null
@@ -1,102 +0,0 @@
-
-Mafia City Mod APK Download for Android
-Do you love playing mafia-themed games on your android device? If yes, then you might have heard of Mafia City, one of the most popular and realistic strategy games in this genre. In this game, you can build your own criminal empire, recruit gangsters, fight with rivals, and rule the underworld. But what if you want to enjoy more features and benefits in this game without spending real money or waiting for long hours? Well, there is a solution for that. You can download and install Mafia City Mod APK, a modified version of the original game that gives you unlimited resources, unlocks all levels, removes ads, and much more. In this article, we will tell you everything you need to know about Mafia City Mod APK, including what it is, how to download and install it, what features it offers, and what are its pros and cons. So, without further ado, let's get started.
- What is Mafia City?
-Mafia City is a strategy game developed by YottaGame for android devices. It was released in 2017 and has since gained millions of fans around the world. The game is set in a fictional city where you can create your own mafia family, recruit gangsters, upgrade your buildings, expand your territory, and compete with other players online. You can also join clans, form alliances, participate in events, and enjoy various modes of gameplay. The game has stunning graphics, realistic sound effects, and immersive storyline that will keep you hooked for hours.
-mafia city mod apk download for android Download File --->>> https://gohhs.com/2uPvDI
What is Mafia City Mod APK?
-Mafia City Mod APK is a modified version of the official Mafia City game that has been altered by some third-party developers. The modded version gives you access to unlimited resources such as gold, cash, gems, energy, etc. that you can use to buy anything you want in the game. It also unlocks all the levels, so you can play any stage you like without any restrictions. Moreover, it unlocks all the VIP premium accessories such as weapons, cars, outfits, etc. that you can equip to your gangsters and make them more powerful. Additionally, it removes all the annoying ads that pop up on your screen while playing the game. And if that's not enough, it also offers some other features such as anti-ban protection, auto-update function, easy user interface, etc.
- How to Download and Install Mafia City Mod APK?
-If you are interested in downloading and installing Mafia City Mod APK on your android device, then you need to follow these simple steps:
-mafia city mod apk unlimited gold and money
-
-First of all, you need to uninstall the original Mafia City game from your device if you have it installed.
-Then, you need to enable the "Unknown Sources" option on your device settings. This will allow you to install apps from sources other than Google Play Store.
-Next, you need to download the Mafia City Mod APK file from a reliable source on the internet. You can use this link to download it.
-After downloading the file, you need to locate it on your device storage and tap on it to start the installation process. Follow the instructions on the screen and wait for the installation to complete.
-Once the installation is done, you can launch the game and enjoy the modded version.
-
-Note: You may need to allow some permissions to the app for it to run properly. Also, make sure you have enough space on your device before installing the app.
- Features of Mafia City Mod APK
-Mafia City Mod APK offers a lot of features that make the game more fun and exciting. Here are some of the main features of the modded version:
- Unlimited Gold
-Gold is the premium currency in Mafia City that you can use to buy various items and resources in the game. However, gold is very hard to earn and expensive to buy with real money. With Mafia City Mod APK, you don't have to worry about that. You can get unlimited gold for free and spend it as much as you want. You can use gold to upgrade your buildings, recruit more gangsters, buy VIP items, speed up tasks, and more.
- Unlock All Levels
-Mafia City has hundreds of levels that you can play and enjoy. However, some of the levels are locked and require you to reach a certain level or complete certain missions to unlock them. This can be frustrating and time-consuming. With Mafia City Mod APK, you can unlock all the levels in the game and play any stage you like. You can also skip the tutorials and cutscenes if you want.
- Unlock All VIP Premium Accessories
-Mafia City has a lot of VIP premium accessories that you can equip to your gangsters and make them more powerful and stylish. These accessories include weapons, cars, outfits, tattoos, etc. However, these accessories are very expensive and require you to have a VIP membership or spend real money to get them. With Mafia City Mod APK, you can unlock all the VIP premium accessories in the game and use them for free. You can also customize your gangsters according to your preference.
- No Ads
-Mafia City is a free-to-play game, but it also has a lot of ads that pop up on your screen while playing the game. These ads can be annoying and distracting, and sometimes they can even affect your gameplay. With Mafia City Mod APK, you can remove all the ads from the game and enjoy a smooth and uninterrupted gaming experience.
- Other Features
-Besides the features mentioned above, Mafia City Mod APK also offers some other features such as:
-
-Anti-ban protection: This feature prevents your account from getting banned by the game developers for using the modded version.
-Auto-update function: This feature ensures that your app is always updated with the latest version and features of the game.
-Easy user interface: This feature makes the app easy to use and navigate for anyone.
-Compatible with all android devices: This feature makes the app compatible with any android device, regardless of its model or version.
-
- Pros and Cons of Mafia City Mod APK
-Mafia City Mod APK has its own pros and cons that you should consider before downloading and installing it. Here is a table comparing the advantages and disadvantages of the modded version:
- | Pros | Cons | | --- | --- | | Unlimited resources | May cause lag or crash | | Unlock all levels | May not work on some devices | | Unlock all VIP premium accessories | May not be safe or secure | | No ads | May violate the game's terms of service | | Other features | May ruin the original gameplay | FAQs about Mafia City Mod APK
-Here are some of the frequently asked questions and answers about Mafia City Mod APK:
-
-Is Mafia City Mod APK free? Is Mafia City Mod APK safe? Is Mafia City Mod APK legal? Can I play Can I play Mafia City Mod APK online? Can I update Mafia City Mod APK?
- Conclusion
-Mafia City Mod APK is a great option for those who want to enjoy more features and benefits in Mafia City game without spending real money or waiting for long hours. It gives you unlimited resources, unlocks all levels, unlocks all VIP premium accessories, removes ads, and offers other features that make the game more fun and exciting. However, it also has some drawbacks that you should be aware of before downloading and installing it. It may cause lag or crash, may not work on some devices, may not be safe or secure, may violate the game's terms of service, and may ruin the original gameplay. Therefore, you should use it at your own risk and responsibility.
-If you are interested in downloading and installing Mafia City Mod APK on your android device, then you can follow the steps mentioned above in this article. You can also check out the features, pros and cons, and FAQs of the modded version in this article. We hope you found this article helpful and informative. If you have any questions or feedback, please feel free to leave a comment below. Thank you for reading.
- Download OBB Bus Simulator Indonesia Mod APK: A Guide for Android Users
-If you are a fan of simulation games, especially bus driving games, you might want to try OBB Bus Simulator Indonesia Mod APK. This is a modified version of the popular game Bus Simulator Indonesia, which lets you experience the thrill of driving a bus in the beautiful and diverse country of Indonesia. In this article, we will show you how to download and install OBB Bus Simulator Indonesia Mod APK on your Android device, as well as some of the features, tips, and tricks that you can enjoy in this game.
- How to download OBB Bus Simulator Indonesia Mod APK from APKCombo
-One of the easiest ways to download OBB Bus Simulator Indonesia Mod APK is from APKCombo, a website that offers a variety of Android apps and games for free. Here are the steps to follow:
-download obb bus simulator indonesia mod apk Download 🌟 https://gohhs.com/2uPq7f
-Go to APKCombo and search for "Bus Simulator Indonesia" in the search bar.
-Select the app with the name "Bus Simulator Indonesia" and the developer "Maleo". You will see a green button that says "Download APK". Click on it.
-You will be redirected to a page where you can choose the version of the app that you want to download. The latest version is 3.5, which was updated on September 7, 2023. Click on the blue button that says "Download (XAPK)".
-You will see a pop-up window that asks you to confirm your download. Click on "OK". The file will start downloading to your device.
-Once the download is complete, you will need to extract the XAPK file using a file manager app. You can use any app that can handle ZIP files, such as ES File Explorer or ZArchiver. Locate the XAPK file in your downloads folder and extract it. You will get two files: an APK file and an OBB file.
-
- How to install OBB Bus Simulator Indonesia Mod APK on your Android device
-After extracting the XAPK file, you will need to install the APK file and copy the OBB file to your device's internal storage. Here are the steps to follow:
-
-Before installing the APK file, you will need to enable "Unknown sources" on your device. This will allow you to install apps from sources other than Google Play Store. To do this, go to Settings > Security > Unknown sources and toggle it on.
-Locate the APK file in your downloads folder or wherever you extracted it. Tap on it and follow the instructions on the screen to install it.
-After installing the APK file, do not open it yet. You will need to copy the OBB file to a specific folder on your device's internal storage. The folder name is "com.maleo.bussimulatorid". If you don't have this folder, you can create it manually using a file manager app. The full path of the folder is "/Android/obb/com.maleo.bussimulatorid".
-Locate the OBB file in your downloads folder or wherever you extracted it. It has a name like "main.35.com.maleo.bussimulatorid.obb". Copy or move it to the folder that you created or found in the previous step.
-After copying the OBB file, you can now open the app and enjoy playing OBB Bus Simulator Indonesia Mod APK on your Android device.
-
- Features of OBB Bus Simulator Indonesia Mod APK
-OBB Bus Simulator Indonesia Mod APK is a fun and realistic game that lets you drive various types of buses in Indonesia. You can customize your buses with different skins, accessories, and stickers, and choose from different maps and routes to explore. Here are some of the features that you can enjoy in this game:
-
-Realistic graphics and sound effects : The game has high-quality graphics that show the details of the buses, the roads, the buildings, and the scenery. You can also hear the sounds of the engine, the horn, the traffic, and the passengers. The game also supports Indonesian language and voiceovers.Customizable buses and skins : You can choose from a variety of buses, such as mini buses, double-decker buses, school buses, and more. You can also change the color, the design, and the logo of your buses, and add accessories like lights, mirrors, wipers, and spoilers. You can even create your own skins using the built-in editor.Various maps and routes to explore : You can drive your buses on different maps that represent different regions of Indonesia, such as Java, Sumatra, Bali, and more. You can also choose from different routes that have different levels of difficulty, traffic, and scenery. You can see the landmarks, the monuments, and the culture of each region.Online and offline modes : You can play OBB Bus Simulator Indonesia Mod APK online or offline. In online mode, you can connect with other players from around the world and join clans. You can chat with them, compete with them, and cooperate with them. In offline mode, you can play without an internet connection and enjoy the game at your own pace.
- Tips and Tricks for Playing OBB Bus Simulator Indonesia Mod APK
-OBB Bus Simulator Indonesia Mod APK is a challenging and rewarding game that requires skill and strategy. Here are some tips and tricks that can help you play better and have more fun:
-
-How to drive safely and efficiently : To drive your bus safely and efficiently, you need to follow the traffic rules and regulations. You need to obey the speed limit, the traffic lights, the signs, and the signals. You also need to avoid collisions with other vehicles, pedestrians, animals, and obstacles. You need to use your indicators, your headlights, your brake lights, and your horn when necessary. You also need to check your mirrors, your dashboard, and your GPS regularly.How to earn more money and unlock new buses : To earn more money and unlock new buses, you need to complete missions and challenges. You need to pick up and drop off passengers at their destinations on time and without any accidents. You also need to collect coins and bonuses along the way. You can use the money to buy new buses or upgrade your existing ones. You can also unlock new buses by reaching certain levels or achievements.How to use the map and GPS system : To use the map and GPS system, you need to tap on the map icon on the top right corner of the screen. You will see a map that shows your location, your destination, your route, and your progress. You will also see icons that represent gas stations, repair shops, rest areas, toll booths, checkpoints, and landmarks. You can zoom in or out of the map by pinching or spreading your fingers on the screen. You can also tap on any icon to see more information about it.How to interact with other players and join clans : To interact with other players and join clans, you need to play in online mode. You can tap on the chat icon on the top left corner of the screen to open the chat window. You can type your message and send it to all players or to a specific player. You can also use emojis and stickers to express yourself. You can also tap on the clan icon on the bottom right corner of the screen to open the clan menu. You can create your own clan or join an existing one. You can invite other players to your clan or accept their invitations. You can also see the clan ranking, the clan chat, and the clan missions.
- Alternatives to OBB Bus Simulator Indonesia Mod APK
-If you are looking for other games that are similar to OBB Bus Simulator Indonesia Mod APK, you might want to check out these alternatives:
-
-Chittagong Road Traffic OBB for Bus Simulator Indonesia : This is a mod that adds a new map and new buses to Bus Simulator Indonesia. The map is based on the city of Chittagong in Bangladesh, which is known for its heavy traffic and chaotic roads. You can drive different types of buses, such as CNG buses, Volvo buses, and Scania buses. You can also enjoy the realistic scenery, the landmarks, and the culture of Chittagong.Public Transport Simulator - C : This is a game that lets you drive various types of public transport vehicles, such as buses, taxis, trams, and trains. You can choose from different modes, such as career mode, free ride mode, and multiplayer mode. You can also customize your vehicles with different colors, decals, and accessories. You can also explore different cities and environments, such as urban areas, rural areas, mountains, and deserts.SimCity BuildIt : This is a game that lets you create and manage your own city. You can build different types of buildings, such as residential buildings, commercial buildings, industrial buildings, and public buildings. You can also provide services and amenities to your citizens, such as power, water, transportation, education, health, and entertainment. You can also face various challenges and disasters, such as traffic jams, pollution, fires, earthquakes, and more.
- Conclusion and FAQs
-OBB Bus Simulator Indonesia Mod APK is a great game for anyone who loves simulation games and bus driving games. It offers a realistic and immersive experience of driving a bus in Indonesia. You can download and install OBB Bus Simulator Indonesia Mod APK from APKCombo by following the steps in this article. You can also enjoy the features, tips, and tricks that we have shared with you. If you have any questions or feedback about OBB Bus Simulator Indonesia Mod APK, you can check out these FAQs or leave a comment below.
-download obb file for bus simulator indonesia mod apk
- FAQs
-
-What are the requirements for playing OBB Bus Simulator Indonesia Mod APK? Is OBB Bus Simulator Indonesia Mod APK safe to download and install? How can I update OBB Bus Simulator Indonesia Mod APK? How can I get more coins and bonuses in OBB Bus Simulator Indonesia Mod APK? How can I contact the developer of OBB Bus Simulator Indonesia Mod APK?
- I hope you enjoyed this article and learned something new about OBB Bus Simulator Indonesia Mod APK. If you did, please share it with your friends and family who might be interested in this game. Thank you for reading and happy gaming!
401be4b1e0Download Soul Knight Latest Version Mod APK
-If you are looking for a shooter game that features extremely easy and intuitive control, super smooth and enjoyable gameplay, mixed with rogue-like elements, then you should try Soul Knight . Soul Knight is a pixel roguelike shoot'em up game that combines action and survival. You have to shoot some alien minions, retrieve the magical stone that maintains the balance of the world, and explore randomly generated dungeons full of treasures and surprises. In this article, we will show you how to download and install the latest version of Soul Knight mod apk, which will give you unlimited gems, coins, characters, skins, and more. Read on to find out more!
- Features of Soul Knight
-Soul Knight is a game that has many features that make it fun and addictive. Here are some of them:
-download soul knight latest version mod apk Download ✫✫✫ https://gohhs.com/2uPrZT
Unique heroes and weapons
-Soul Knight has more than 20 unique heroes, each with their own skills, stats, and playstyle. You can choose from a rogue, an elf archer, a magician, a knight, a robot, and more. You can also customize your hero with different skins and outfits. Moreover, Soul Knight has more than 400 weapons, ranging from guns, swords, shovels, lasers, rockets, grenades, and more. You can find different weapons in the dungeons or buy them from the shop. You can also upgrade your weapons with gems or coins.
-Randomly generated dungeons
-Soul Knight has randomly generated dungeons that offer endless replay value. You will never get bored of exploring different environments, such as dark forests populated by goblins, medieval chateaus infested with zombies, futuristic labs filled with robots, and more. You will also encounter different NPCs, such as merchants, blacksmiths, gardeners, nurses, wizards, and more. They can help you with various services or quests. You will also find chests, crates, barrels, pots, statues, plants, and other objects that may contain items or secrets.
-Auto-aim mechanism and controller support
-Soul Knight has an auto-aim mechanism that makes it super easy and intuitive to control your hero. You just need to tap on the screen to move your hero and dodge enemy attacks. Your hero will automatically shoot at the nearest enemy in range. You can also swipe on the screen to switch weapons or use skills. Additionally, Soul Knight supports controller input for both online and offline modes. You can connect your Bluetooth controller or use an emulator to play Soul Knight on your PC.
-Multiplayer mode and game modes
-Soul Knight has a multiplayer mode that allows you to team up with friends around the world for an online co-op adventure. You can join or create a room with up to three other players and share items and buffs. You can also chat with your teammates using emojis or voice messages. Alternatively, you can get together with your friends for an offline multiplayer LAN game. You just need to connect your devices to the same WiFi network and start the game. Furthermore, Soul Knight has different game modes that add more variety and challenge to the gameplay. You can play the normal mode, the boss rush mode, the daily challenge mode, the trial mode, or the origin mode. Each mode has different rules, objectives, and rewards.
- Benefits of Soul Knight Mod APK
-While Soul Knight is a free-to-play game, it also has some in-app purchases that can enhance your gaming experience. For example, you can buy gems and coins to unlock more characters, skins, weapons, pets, buffs, and other items. You can also remove ads and support the developers by buying the premium version of the game. However, if you don't want to spend real money on the game, you can download and install the Soul Knight mod apk, which will give you the following benefits:
-Unlimited gems and coins
-Gems and coins are the main currencies in Soul Knight. You can use them to buy weapons, items, buffs, pets, skins, and other things from the shop or the vending machines. You can also use them to upgrade your weapons or revive your hero. However, gems and coins are not easy to come by in the game. You have to complete dungeons, watch ads, or complete quests to earn them. With the Soul Knight mod apk, you will get unlimited gems and coins in your account. You can use them as much as you want without worrying about running out.
-Unlocked all characters and skins
-Soul Knight has more than 20 characters that you can play as. Each character has a unique skill and a different stat distribution. Some characters are more suitable for certain playstyles or weapons than others. However, not all characters are available from the start. You have to unlock them with gems or coins or by completing certain achievements. Moreover, each character has several skins that you can use to customize their appearance. Some skins are free, while others require gems or coins to unlock. With the Soul Knight mod apk, you will get all the characters and skins unlocked from the start. You can choose any character or skin you want without spending any gems or coins.
-download soul knight mod apk unlimited gems
-Free shopping and no ads
-Soul Knight is a free-to-play game that relies on ads and in-app purchases to generate revenue. Therefore, you will encounter ads when you play the game. Some ads are optional and will reward you with gems or coins if you watch them. However, some ads are mandatory and will interrupt your gameplay. Additionally, some items or features in the game require real money to purchase. For example, you have to pay $0.99 to remove ads or $4.99 to get the premium version of the game. With the Soul Knight mod apk, you will get free shopping and no ads in the game. You can buy anything you want without spending real money or watching ads.
- How to Download and Install Soul Knight Mod APK
-If you are interested in downloading and installing the Soul Knight mod apk on your Android device, you can follow these simple steps:
-Step 1: Enable unknown sources
-Before you can install any mod apk file on your device, you have to enable unknown sources in your settings. This will allow you to install apps from sources other than the Google Play Store. To do this, go to your device's settings > security > unknown sources and toggle it on.
-Step 2: Download the mod apk file
-Next, you have to download the Soul Knight mod apk file from a reliable source. You can use this link to download the latest version of the mod apk file (v3.2.6). The file size is about 136 MB and it is compatible with Android 4.4 and up.
-Step 3: Install the mod apk file
-After downloading the mod apk file, locate it in your device's file manager and tap on it to start the installation process. Follow the instructions on the screen and wait for a few seconds until the installation is complete.
-Step 4: Enjoy the game
-Once the installation is done, you can launch the game from your app drawer or home screen and enjoy playing Soul Knight with unlimited gems, coins, characters, skins, and more. You can also check out the different game modes and features that Soul Knight has to offer.
- Conclusion
-Soul Knight is a pixel roguelike shoot'em up game that combines action and survival. You have to shoot some alien minions, retrieve the magical stone that maintains the balance of the world, and explore randomly generated dungeons full of treasures and surprises. Soul Knight has many features that make it fun and addictive, such as unique heroes and weapons, randomly generated dungeons, auto-aim mechanism and controller support, multiplayer mode and game modes, and more. However, if you want to enjoy the game without spending real money or watching ads, you can download and install the Soul Knight mod apk, which will give you unlimited gems, coins, characters, skins, and more. You can also unlock all the items and features in the game with the mod apk. To download and install the Soul Knight mod apk, you just need to follow four simple steps: enable unknown sources, download the mod apk file, install the mod apk file, and enjoy the game. So what are you waiting for? Download Soul Knight mod apk now and have fun!
- FAQs
-Is Soul Knight mod apk safe to use?
-Yes, Soul Knight mod apk is safe to use as long as you download it from a reliable source. The mod apk file does not contain any viruses or malware that can harm your device or compromise your privacy. However, you should always be careful when downloading any mod apk file from the internet and scan it with an antivirus before installing it.
-Do I need to root my device to use Soul Knight mod apk?
-No, you do not need to root your device to use Soul Knight mod apk. The mod apk file works on both rooted and non-rooted devices without any issues. You just need to enable unknown sources in your settings and install the mod apk file as usual.
-What is the latest version of Soul Knight mod apk?
-The latest version of Soul Knight mod apk is v3.2.6, which was released on June 18, 2023. The latest version of the mod apk file has some new features and improvements, such as new characters, weapons, pets, skins, dungeons, bosses, enemies, items, buffs, achievements, and more. You can download the latest version of Soul Knight mod apk from this link.
-How can I play Soul Knight online with friends?
-You can play Soul Knight online with friends by using the multiplayer mode in the game. You can join or create a room with up to three other players and share items and buffs. You can also chat with your teammates using emojis or voice messages. To play Soul Knight online with friends, you need to have a stable internet connection and a valid account in the game.
-Where can I download Soul Knight mod apk?
-You can download Soul Knight mod apk from this link. This is a reliable source that provides the latest version of the mod apk file with unlimited gems, coins, characters, skins, and more. You can also find other information about the game and the mod apk file on this website.
401be4b1e0Dishoom free download hindi DOWNLOAD ★★★ https://urlgoal.com/2uyLQh
diff --git a/spaces/gyugnsu/DragGan-Inversion/legacy.py b/spaces/gyugnsu/DragGan-Inversion/legacy.py
deleted file mode 100644
index a874c38c2c943e632badb8e12f5a4297071827df..0000000000000000000000000000000000000000
--- a/spaces/gyugnsu/DragGan-Inversion/legacy.py
+++ /dev/null
@@ -1,369 +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.
-
-"""Converting legacy network pickle into the new format."""
-
-import click
-import pickle
-import re
-import copy
-import numpy as np
-import torch
-import dnnlib
-from torch_utils import misc
-
-# ----------------------------------------------------------------------------
-
-
-def load_network_pkl(f, force_fp16=False):
- data = _LegacyUnpickler(f).load()
-
- # Legacy TensorFlow pickle => convert.
- if isinstance(data, tuple) and len(data) == 3 and all(isinstance(net, _TFNetworkStub) for net in data):
- tf_G, tf_D, tf_Gs = data
- G = convert_tf_generator(tf_G)
- D = convert_tf_discriminator(tf_D)
- G_ema = convert_tf_generator(tf_Gs)
- data = dict(G=G, D=D, G_ema=G_ema)
-
- # Add missing fields.
- if 'training_set_kwargs' not in data:
- data['training_set_kwargs'] = None
- if 'augment_pipe' not in data:
- data['augment_pipe'] = None
-
- # Validate contents.
- assert isinstance(data['G'], torch.nn.Module)
- assert isinstance(data['D'], torch.nn.Module)
- assert isinstance(data['G_ema'], torch.nn.Module)
- assert isinstance(data['training_set_kwargs'], (dict, type(None)))
- assert isinstance(data['augment_pipe'], (torch.nn.Module, type(None)))
-
- # Force FP16.
- if force_fp16:
- for key in ['G', 'D', 'G_ema']:
- old = data[key]
- kwargs = copy.deepcopy(old.init_kwargs)
- fp16_kwargs = kwargs.get('synthesis_kwargs', kwargs)
- fp16_kwargs.num_fp16_res = 4
- fp16_kwargs.conv_clamp = 256
- if kwargs != old.init_kwargs:
- new = type(old)(**kwargs).eval().requires_grad_(False)
- misc.copy_params_and_buffers(old, new, require_all=True)
- data[key] = new
- return data
-
-# ----------------------------------------------------------------------------
-
-
-class _TFNetworkStub(dnnlib.EasyDict):
- pass
-
-
-class _LegacyUnpickler(pickle.Unpickler):
- def find_class(self, module, name):
- if module == 'dnnlib.tflib.network' and name == 'Network':
- return _TFNetworkStub
- return super().find_class(module, name)
-
-# ----------------------------------------------------------------------------
-
-
-def _collect_tf_params(tf_net):
- # pylint: disable=protected-access
- tf_params = dict()
-
- def recurse(prefix, tf_net):
- for name, value in tf_net.variables:
- tf_params[prefix + name] = value
- for name, comp in tf_net.components.items():
- recurse(prefix + name + '/', comp)
- recurse('', tf_net)
- return tf_params
-
-# ----------------------------------------------------------------------------
-
-
-def _populate_module_params(module, *patterns):
- for name, tensor in misc.named_params_and_buffers(module):
- found = False
- value = None
- for pattern, value_fn in zip(patterns[0::2], patterns[1::2]):
- match = re.fullmatch(pattern, name)
- if match:
- found = True
- if value_fn is not None:
- value = value_fn(*match.groups())
- break
- try:
- assert found
- if value is not None:
- tensor.copy_(torch.from_numpy(np.array(value)))
- except:
- print(name, list(tensor.shape))
- raise
-
-# ----------------------------------------------------------------------------
-
-
-def convert_tf_generator(tf_G):
- if tf_G.version < 4:
- raise ValueError('TensorFlow pickle version too low')
-
- # Collect kwargs.
- tf_kwargs = tf_G.static_kwargs
- known_kwargs = set()
-
- def kwarg(tf_name, default=None, none=None):
- known_kwargs.add(tf_name)
- val = tf_kwargs.get(tf_name, default)
- return val if val is not None else none
-
- # Convert kwargs.
- from training import networks_stylegan2
- network_class = networks_stylegan2.Generator
- kwargs = dnnlib.EasyDict(
- z_dim=kwarg('latent_size', 512),
- c_dim=kwarg('label_size', 0),
- w_dim=kwarg('dlatent_size', 512),
- img_resolution=kwarg('resolution', 1024),
- img_channels=kwarg('num_channels', 3),
- channel_base=kwarg('fmap_base', 16384) * 2,
- channel_max=kwarg('fmap_max', 512),
- num_fp16_res=kwarg('num_fp16_res', 0),
- conv_clamp=kwarg('conv_clamp', None),
- architecture=kwarg('architecture', 'skip'),
- resample_filter=kwarg('resample_kernel', [1, 3, 3, 1]),
- use_noise=kwarg('use_noise', True),
- activation=kwarg('nonlinearity', 'lrelu'),
- mapping_kwargs=dnnlib.EasyDict(
- num_layers=kwarg('mapping_layers', 8),
- embed_features=kwarg('label_fmaps', None),
- layer_features=kwarg('mapping_fmaps', None),
- activation=kwarg('mapping_nonlinearity', 'lrelu'),
- lr_multiplier=kwarg('mapping_lrmul', 0.01),
- w_avg_beta=kwarg('w_avg_beta', 0.995, none=1),
- ),
- )
-
- # Check for unknown kwargs.
- kwarg('truncation_psi')
- kwarg('truncation_cutoff')
- kwarg('style_mixing_prob')
- kwarg('structure')
- kwarg('conditioning')
- kwarg('fused_modconv')
- unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
- if len(unknown_kwargs) > 0:
- raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
-
- # Collect params.
- tf_params = _collect_tf_params(tf_G)
- for name, value in list(tf_params.items()):
- match = re.fullmatch(r'ToRGB_lod(\d+)/(.*)', name)
- if match:
- r = kwargs.img_resolution // (2 ** int(match.group(1)))
- tf_params[f'{r}x{r}/ToRGB/{match.group(2)}'] = value
- kwargs.synthesis.kwargs.architecture = 'orig'
- # for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
-
- # Convert params.
- G = network_class(**kwargs).eval().requires_grad_(False)
- # pylint: disable=unnecessary-lambda
- # pylint: disable=f-string-without-interpolation
- _populate_module_params(G,
- r'mapping\.w_avg', lambda: tf_params[f'dlatent_avg'],
- r'mapping\.embed\.weight', lambda: tf_params[f'mapping/LabelEmbed/weight'].transpose(
- ),
- r'mapping\.embed\.bias', lambda: tf_params[f'mapping/LabelEmbed/bias'],
- r'mapping\.fc(\d+)\.weight', lambda i: tf_params[f'mapping/Dense{i}/weight'].transpose(
- ),
- r'mapping\.fc(\d+)\.bias', lambda i: tf_params[f'mapping/Dense{i}/bias'],
- r'synthesis\.b4\.const', lambda: tf_params[f'synthesis/4x4/Const/const'][0],
- r'synthesis\.b4\.conv1\.weight', lambda: tf_params[f'synthesis/4x4/Conv/weight'].transpose(
- 3, 2, 0, 1),
- r'synthesis\.b4\.conv1\.bias', lambda: tf_params[
- f'synthesis/4x4/Conv/bias'],
- r'synthesis\.b4\.conv1\.noise_const', lambda: tf_params[
- f'synthesis/noise0'][0, 0],
- r'synthesis\.b4\.conv1\.noise_strength', lambda: tf_params[
- f'synthesis/4x4/Conv/noise_strength'],
- r'synthesis\.b4\.conv1\.affine\.weight', lambda: tf_params[
- f'synthesis/4x4/Conv/mod_weight'].transpose(),
- r'synthesis\.b4\.conv1\.affine\.bias', lambda: tf_params[
- f'synthesis/4x4/Conv/mod_bias'] + 1,
- r'synthesis\.b(\d+)\.conv0\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/weight'][::-1, ::-1].transpose(
- 3, 2, 0, 1),
- r'synthesis\.b(\d+)\.conv0\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv0_up/bias'],
- r'synthesis\.b(\d+)\.conv0\.noise_const', lambda r: tf_params[
- f'synthesis/noise{int(np.log2(int(r)))*2-5}'][0, 0],
- r'synthesis\.b(\d+)\.conv0\.noise_strength', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv0_up/noise_strength'],
- r'synthesis\.b(\d+)\.conv0\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv0_up/mod_weight'].transpose(
- ),
- r'synthesis\.b(\d+)\.conv0\.affine\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv0_up/mod_bias'] + 1,
- r'synthesis\.b(\d+)\.conv1\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/weight'].transpose(
- 3, 2, 0, 1),
- r'synthesis\.b(\d+)\.conv1\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv1/bias'],
- r'synthesis\.b(\d+)\.conv1\.noise_const', lambda r: tf_params[
- f'synthesis/noise{int(np.log2(int(r)))*2-4}'][0, 0],
- r'synthesis\.b(\d+)\.conv1\.noise_strength', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv1/noise_strength'],
- r'synthesis\.b(\d+)\.conv1\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Conv1/mod_weight'].transpose(
- ),
- r'synthesis\.b(\d+)\.conv1\.affine\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/Conv1/mod_bias'] + 1,
- r'synthesis\.b(\d+)\.torgb\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/weight'].transpose(
- 3, 2, 0, 1),
- r'synthesis\.b(\d+)\.torgb\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/ToRGB/bias'],
- r'synthesis\.b(\d+)\.torgb\.affine\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/ToRGB/mod_weight'].transpose(
- ),
- r'synthesis\.b(\d+)\.torgb\.affine\.bias', lambda r: tf_params[
- f'synthesis/{r}x{r}/ToRGB/mod_bias'] + 1,
- r'synthesis\.b(\d+)\.skip\.weight', lambda r: tf_params[f'synthesis/{r}x{r}/Skip/weight'][::-1, ::-1].transpose(
- 3, 2, 0, 1),
- r'.*\.resample_filter', None,
- r'.*\.act_filter', None,
- )
- return G
-
-# ----------------------------------------------------------------------------
-
-
-def convert_tf_discriminator(tf_D):
- if tf_D.version < 4:
- raise ValueError('TensorFlow pickle version too low')
-
- # Collect kwargs.
- tf_kwargs = tf_D.static_kwargs
- known_kwargs = set()
-
- def kwarg(tf_name, default=None):
- known_kwargs.add(tf_name)
- return tf_kwargs.get(tf_name, default)
-
- # Convert kwargs.
- kwargs = dnnlib.EasyDict(
- c_dim=kwarg('label_size', 0),
- img_resolution=kwarg('resolution', 1024),
- img_channels=kwarg('num_channels', 3),
- architecture=kwarg('architecture', 'resnet'),
- channel_base=kwarg('fmap_base', 16384) * 2,
- channel_max=kwarg('fmap_max', 512),
- num_fp16_res=kwarg('num_fp16_res', 0),
- conv_clamp=kwarg('conv_clamp', None),
- cmap_dim=kwarg('mapping_fmaps', None),
- block_kwargs=dnnlib.EasyDict(
- activation=kwarg('nonlinearity', 'lrelu'),
- resample_filter=kwarg('resample_kernel', [1, 3, 3, 1]),
- freeze_layers=kwarg('freeze_layers', 0),
- ),
- mapping_kwargs=dnnlib.EasyDict(
- num_layers=kwarg('mapping_layers', 0),
- embed_features=kwarg('mapping_fmaps', None),
- layer_features=kwarg('mapping_fmaps', None),
- activation=kwarg('nonlinearity', 'lrelu'),
- lr_multiplier=kwarg('mapping_lrmul', 0.1),
- ),
- epilogue_kwargs=dnnlib.EasyDict(
- mbstd_group_size=kwarg('mbstd_group_size', None),
- mbstd_num_channels=kwarg('mbstd_num_features', 1),
- activation=kwarg('nonlinearity', 'lrelu'),
- ),
- )
-
- # Check for unknown kwargs.
- kwarg('structure')
- kwarg('conditioning')
- unknown_kwargs = list(set(tf_kwargs.keys()) - known_kwargs)
- if len(unknown_kwargs) > 0:
- raise ValueError('Unknown TensorFlow kwarg', unknown_kwargs[0])
-
- # Collect params.
- tf_params = _collect_tf_params(tf_D)
- for name, value in list(tf_params.items()):
- match = re.fullmatch(r'FromRGB_lod(\d+)/(.*)', name)
- if match:
- r = kwargs.img_resolution // (2 ** int(match.group(1)))
- tf_params[f'{r}x{r}/FromRGB/{match.group(2)}'] = value
- kwargs.architecture = 'orig'
- # for name, value in tf_params.items(): print(f'{name:<50s}{list(value.shape)}')
-
- # Convert params.
- from training import networks_stylegan2
- D = networks_stylegan2.Discriminator(**kwargs).eval().requires_grad_(False)
- # pylint: disable=unnecessary-lambda
- # pylint: disable=f-string-without-interpolation
- _populate_module_params(D,
- r'b(\d+)\.fromrgb\.weight', lambda r: tf_params[f'{r}x{r}/FromRGB/weight'].transpose(
- 3, 2, 0, 1),
- r'b(\d+)\.fromrgb\.bias', lambda r: tf_params[f'{r}x{r}/FromRGB/bias'],
- r'b(\d+)\.conv(\d+)\.weight', lambda r, i: tf_params[f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/weight'].transpose(
- 3, 2, 0, 1),
- r'b(\d+)\.conv(\d+)\.bias', lambda r, i: tf_params[
- f'{r}x{r}/Conv{i}{["","_down"][int(i)]}/bias'],
- r'b(\d+)\.skip\.weight', lambda r: tf_params[f'{r}x{r}/Skip/weight'].transpose(
- 3, 2, 0, 1),
- r'mapping\.embed\.weight', lambda: tf_params[f'LabelEmbed/weight'].transpose(
- ),
- r'mapping\.embed\.bias', lambda: tf_params[f'LabelEmbed/bias'],
- r'mapping\.fc(\d+)\.weight', lambda i: tf_params[f'Mapping{i}/weight'].transpose(
- ),
- r'mapping\.fc(\d+)\.bias', lambda i: tf_params[f'Mapping{i}/bias'],
- r'b4\.conv\.weight', lambda: tf_params[f'4x4/Conv/weight'].transpose(
- 3, 2, 0, 1),
- r'b4\.conv\.bias', lambda: tf_params[f'4x4/Conv/bias'],
- r'b4\.fc\.weight', lambda: tf_params[f'4x4/Dense0/weight'].transpose(
- ),
- r'b4\.fc\.bias', lambda: tf_params[f'4x4/Dense0/bias'],
- r'b4\.out\.weight', lambda: tf_params[f'Output/weight'].transpose(
- ),
- r'b4\.out\.bias', lambda: tf_params[f'Output/bias'],
- r'.*\.resample_filter', None,
- )
- return D
-
-# ----------------------------------------------------------------------------
-
-
-@click.command()
-@click.option('--source', help='Input pickle', required=True, metavar='PATH')
-@click.option('--dest', help='Output pickle', required=True, metavar='PATH')
-@click.option('--force-fp16', help='Force the networks to use FP16', type=bool, default=False, metavar='BOOL', show_default=True)
-def convert_network_pickle(source, dest, force_fp16):
- """Convert legacy network pickle into the native PyTorch format.
-
- The tool is able to load the main network configurations exported using the TensorFlow version of StyleGAN2 or StyleGAN2-ADA.
- It does not support e.g. StyleGAN2-ADA comparison methods, StyleGAN2 configs A-D, or StyleGAN1 networks.
-
- Example:
-
- \b
- python legacy.py \\
- --source=https://nvlabs-fi-cdn.nvidia.com/stylegan2/networks/stylegan2-cat-config-f.pkl \\
- --dest=stylegan2-cat-config-f.pkl
- """
- print(f'Loading "{source}"...')
- with dnnlib.util.open_url(source) as f:
- data = load_network_pkl(f, force_fp16=force_fp16)
- print(f'Saving "{dest}"...')
- with open(dest, 'wb') as f:
- pickle.dump(data, f)
- print('Done.')
-
-# ----------------------------------------------------------------------------
-
-
-if __name__ == "__main__":
- convert_network_pickle() # pylint: disable=no-value-for-parameter
-
-# ----------------------------------------------------------------------------
diff --git a/spaces/h2oai/wave-tour/examples/ml_dai_instances.py b/spaces/h2oai/wave-tour/examples/ml_dai_instances.py
deleted file mode 100644
index 20768824b03691ef0c856ce48812c3e437b6b1cf..0000000000000000000000000000000000000000
--- a/spaces/h2oai/wave-tour/examples/ml_dai_instances.py
+++ /dev/null
@@ -1,93 +0,0 @@
-# WaveML / DAI / Instances
-# List the Driverless AI instances of the user on Steam.
-# ---
-import os
-
-from h2o_wave import main, app, Q, ui
-from h2o_wave_ml.utils import list_dai_instances
-
-STEAM_URL = os.environ.get('STEAM_URL')
-STEAM_TEXT = f'''No Driverless AI instances available. You may create one in
- AI Engines and refresh the page.'''
-
-ICON_MAP = {
- 'created': 'Blocked2Solid',
- 'starting': 'Blocked2Solid',
- 'running': 'CompletedSolid',
- 'unreachable': 'AlertSolid',
- 'failed': 'AlertSolid',
- 'stopping': 'Blocked2Solid',
- 'stopped': 'Blocked2Solid',
- 'terminating': 'Blocked2Solid',
- 'terminated': 'Blocked2Solid'
-}
-
-
-def dai_instances_table(dai_instances: list):
- # dai instances in ui.table
- return ui.table(
- name='table_dai',
- columns=[
- ui.table_column(name='id', label='Id', min_width='50px', max_width='51px', link=False),
- ui.table_column(name='name', label='Name', link=False),
- ui.table_column(name='status', label='Status', cell_type=ui.icon_table_cell_type(color='#CDDD38'),
- link=False),
- ui.table_column(name='description', label='Description', link=False),
- ui.table_column(name='version', label='Version', link=False)
- ],
- rows=[
- ui.table_row(str(i), [
- str(dai_instances[i]['id']),
- dai_instances[i]['name'],
- ICON_MAP[dai_instances[i]['status']],
- dai_instances[i]['status'],
- dai_instances[i]['version']
- ]) for i in range(len(dai_instances))
- ]
- )
-
-
-def form_unsupported():
- # display when app is not running on cloud
- return [
- ui.text('''This example requires access to Driverless AI running on
- H2O AI Cloud
- and does not support standalone app instances.'''),
- ui.text('''Sign up at https://h2o.ai/free
- to run apps on cloud.''')
- ]
-
-
-def form_default(q: Q):
- # display when app is initialized
- return [
- ui.label(label='List of Driverless AI instances'),
- dai_instances_table(dai_instances=q.client.dai_instances)
- ]
-
-
-@app('/demo')
-async def serve(q: Q):
- if 'H2O_CLOUD_ENVIRONMENT' not in os.environ:
- # show appropriate message if app is not running on cloud
- q.page['example'] = ui.form_card(
- box='1 1 -1 -1',
- items=form_unsupported()
- )
- else:
- # DAI instances
- q.client.dai_instances = list_dai_instances(refresh_token=q.auth.refresh_token)
-
- # display ui
- if q.client.dai_instances:
- q.page['example'] = ui.form_card(
- box='1 1 -1 -1',
- items=form_default(q)
- )
- else:
- q.page['example'] = ui.form_card(
- box='1 1 -1 -1',
- items=[ui.text(content=STEAM_TEXT)]
- )
-
- await q.page.save()
diff --git a/spaces/h2oai/wave-tour/examples/upload_async.py b/spaces/h2oai/wave-tour/examples/upload_async.py
deleted file mode 100644
index b4e14cfd09d312581679dcacedf5f52b00622b3c..0000000000000000000000000000000000000000
--- a/spaces/h2oai/wave-tour/examples/upload_async.py
+++ /dev/null
@@ -1,39 +0,0 @@
-# Uploads / Async
-# Upload files from an interactive app.
-# #upload
-# ---
-
-
-import os
-from h2o_wave import main, app, Q, ui
-
-
-def write_csv(filename, rows):
- with open(filename, 'w', encoding='utf-8') as f:
- f.write('\n'.join([','.join([str(x) for x in row]) for row in rows]))
-
-
-@app('/demo')
-async def serve(q: Q):
- if q.args.generate_csv:
- # Generate
- write_csv('squares.csv', [[x, x * x] for x in range(1, 1 + q.args.row_count)])
- # Upload
- download_path, = await q.site.upload(['squares.csv'])
- # Clean up
- os.remove('squares.csv')
-
- # Display link
- q.page['example'].items = [
- ui.text_xl('Squares Generated!'),
- ui.text(f'[Download my {q.args.row_count} squares!]({download_path})'),
- ui.button(name='show_form', label='Back', primary=True),
- ]
- else:
- # Accept a row count from the user
- q.page['example'] = ui.form_card(box='1 1 4 7', items=[
- ui.text_xl('Square Generator'),
- ui.slider(name='row_count', label='Squares to generate', min=0, max=100, step=10, value=30),
- ui.button(name='generate_csv', label='Generate', primary=True),
- ])
- await q.page.save()
diff --git a/spaces/haakohu/deep_privacy2/configs/generators/stylegan_unet.py b/spaces/haakohu/deep_privacy2/configs/generators/stylegan_unet.py
deleted file mode 100644
index 638859263a1cb549f533b75b2b19609665b3443e..0000000000000000000000000000000000000000
--- a/spaces/haakohu/deep_privacy2/configs/generators/stylegan_unet.py
+++ /dev/null
@@ -1,22 +0,0 @@
-from dp2.generator.stylegan_unet import StyleGANUnet
-from tops.config import LazyCall as L
-
-generator = L(StyleGANUnet)(
- imsize="${data.imsize}",
- im_channels="${data.im_channels}",
- min_fmap_resolution=8,
- cnum=64,
- max_cnum_mul=8,
- n_middle_blocks=0,
- z_channels=512,
- mask_output=True,
- conv_clamp=256,
- input_cse=True,
- scale_grad=True,
- cse_nc="${data.cse_nc}",
- w_dim=512,
- n_keypoints="${data.n_keypoints}",
- input_keypoints=False,
- input_keypoint_indices=[],
- fix_errors=True
-)
\ No newline at end of file
diff --git a/spaces/hamelcubsfan/AutoGPT/autogpt/memory/local.py b/spaces/hamelcubsfan/AutoGPT/autogpt/memory/local.py
deleted file mode 100644
index 803b6dc6ebb430285f423cda592fa3e902e9a4a6..0000000000000000000000000000000000000000
--- a/spaces/hamelcubsfan/AutoGPT/autogpt/memory/local.py
+++ /dev/null
@@ -1,136 +0,0 @@
-from __future__ import annotations
-
-import dataclasses
-import os
-from typing import Any, List
-
-import numpy as np
-import orjson
-
-from autogpt.llm_utils import create_embedding_with_ada
-from autogpt.memory.base import MemoryProviderSingleton
-
-EMBED_DIM = 1536
-SAVE_OPTIONS = orjson.OPT_SERIALIZE_NUMPY | orjson.OPT_SERIALIZE_DATACLASS
-
-
-def create_default_embeddings():
- return np.zeros((0, EMBED_DIM)).astype(np.float32)
-
-
-@dataclasses.dataclass
-class CacheContent:
- texts: List[str] = dataclasses.field(default_factory=list)
- embeddings: np.ndarray = dataclasses.field(
- default_factory=create_default_embeddings
- )
-
-
-class LocalCache(MemoryProviderSingleton):
- """A class that stores the memory in a local file"""
-
- def __init__(self, cfg) -> None:
- """Initialize a class instance
-
- Args:
- cfg: Config object
-
- Returns:
- None
- """
- self.filename = f"{cfg.memory_index}.json"
- if os.path.exists(self.filename):
- try:
- with open(self.filename, "w+b") as f:
- file_content = f.read()
- if not file_content.strip():
- file_content = b"{}"
- f.write(file_content)
-
- loaded = orjson.loads(file_content)
- self.data = CacheContent(**loaded)
- except orjson.JSONDecodeError:
- print(f"Error: The file '{self.filename}' is not in JSON format.")
- self.data = CacheContent()
- else:
- print(
- f"Warning: The file '{self.filename}' does not exist. "
- "Local memory would not be saved to a file."
- )
- self.data = CacheContent()
-
- def add(self, text: str):
- """
- Add text to our list of texts, add embedding as row to our
- embeddings-matrix
-
- Args:
- text: str
-
- Returns: None
- """
- if "Command Error:" in text:
- return ""
- self.data.texts.append(text)
-
- embedding = create_embedding_with_ada(text)
-
- vector = np.array(embedding).astype(np.float32)
- vector = vector[np.newaxis, :]
- self.data.embeddings = np.concatenate(
- [
- self.data.embeddings,
- vector,
- ],
- axis=0,
- )
-
- with open(self.filename, "wb") as f:
- out = orjson.dumps(self.data, option=SAVE_OPTIONS)
- f.write(out)
- return text
-
- def clear(self) -> str:
- """
- Clears the redis server.
-
- Returns: A message indicating that the memory has been cleared.
- """
- self.data = CacheContent()
- return "Obliviated"
-
- def get(self, data: str) -> list[Any] | None:
- """
- Gets the data from the memory that is most relevant to the given data.
-
- Args:
- data: The data to compare to.
-
- Returns: The most relevant data.
- """
- return self.get_relevant(data, 1)
-
- def get_relevant(self, text: str, k: int) -> list[Any]:
- """ "
- matrix-vector mult to find score-for-each-row-of-matrix
- get indices for top-k winning scores
- return texts for those indices
- Args:
- text: str
- k: int
-
- Returns: List[str]
- """
- embedding = create_embedding_with_ada(text)
-
- scores = np.dot(self.data.embeddings, embedding)
-
- top_k_indices = np.argsort(scores)[-k:][::-1]
-
- return [self.data.texts[i] for i in top_k_indices]
-
- def get_stats(self) -> tuple[int, tuple[int, ...]]:
- """
- Returns: The stats of the local cache.
- """
- return len(self.data.texts), self.data.embeddings.shape
diff --git a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/backbone/efficientnet.py b/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/backbone/efficientnet.py
deleted file mode 100644
index c7528a5e0ac0e83e2eaf18959b24aff0affa1f84..0000000000000000000000000000000000000000
--- a/spaces/haotiz/glip-zeroshot-demo/maskrcnn_benchmark/modeling/backbone/efficientnet.py
+++ /dev/null
@@ -1,691 +0,0 @@
-"""
- EfficientNet for ImageNet-1K, implemented in PyTorch.
- Original papers:
- - 'EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks,' https://arxiv.org/abs/1905.11946,
- - 'Adversarial Examples Improve Image Recognition,' https://arxiv.org/abs/1911.09665.
-"""
-
-import os
-import math
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from maskrcnn_benchmark.layers import SEBlock, swish
-
-
-def round_channels(channels,
- divisor=8):
- """
- Round weighted channel number (make divisible operation).
-
- Parameters:
- ----------
- channels : int or float
- Original number of channels.
- divisor : int, default 8
- Alignment value.
-
- Returns
- -------
- int
- Weighted number of channels.
- """
- rounded_channels = max(int(channels + divisor / 2.0) // divisor * divisor, divisor)
- if float(rounded_channels) < 0.9 * channels:
- rounded_channels += divisor
- return rounded_channels
-
-
-def calc_tf_padding(x,
- kernel_size,
- stride=1,
- dilation=1):
- """
- Calculate TF-same like padding size.
-
- Parameters:
- ----------
- x : tensor
- Input tensor.
- kernel_size : int
- Convolution window size.
- stride : int, default 1
- Strides of the convolution.
- dilation : int, default 1
- Dilation value for convolution layer.
-
- Returns
- -------
- tuple of 4 int
- The size of the padding.
- """
- height, width = x.size()[2:]
- oh = math.ceil(height / stride)
- ow = math.ceil(width / stride)
- pad_h = max((oh - 1) * stride + (kernel_size - 1) * dilation + 1 - height, 0)
- pad_w = max((ow - 1) * stride + (kernel_size - 1) * dilation + 1 - width, 0)
- return pad_h // 2, pad_h - pad_h // 2, pad_w // 2, pad_w - pad_w // 2
-
-
-class ConvBlock(nn.Module):
- """
- Standard convolution block with Batch normalization and activation.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- kernel_size : int or tuple/list of 2 int
- Convolution window size.
- stride : int or tuple/list of 2 int
- Strides of the convolution.
- padding : int, or tuple/list of 2 int, or tuple/list of 4 int
- Padding value for convolution layer.
- dilation : int or tuple/list of 2 int, default 1
- Dilation value for convolution layer.
- groups : int, default 1
- Number of groups.
- bias : bool, default False
- Whether the layer uses a bias vector.
- use_bn : bool, default True
- Whether to use BatchNorm layer.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- activation : function or str or None, default nn.ReLU(inplace=True)
- Activation function or name of activation function.
- """
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size,
- stride,
- padding,
- dilation=1,
- groups=1,
- bias=False,
- use_bn=True,
- bn_eps=1e-5,
- activation=nn.ReLU(inplace=True)):
- super(ConvBlock, self).__init__()
- self.activate = (activation is not None)
- self.use_bn = use_bn
- self.use_pad = (isinstance(padding, (list, tuple)) and (len(padding) == 4))
-
- if self.use_pad:
- self.pad = nn.ZeroPad2d(padding=padding)
- padding = 0
- self.conv = nn.Conv2d(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=kernel_size,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups,
- bias=bias)
- if self.use_bn:
- self.bn = nn.BatchNorm2d(
- num_features=out_channels,
- eps=bn_eps)
- if self.activate:
- self.activ = activation
-
- def forward(self, x):
- if self.use_pad:
- x = self.pad(x)
- x = self.conv(x)
- if self.use_bn:
- x = self.bn(x)
- if self.activate:
- x = self.activ(x)
- return x
-
-
-def conv1x1_block(in_channels,
- out_channels,
- stride=1,
- padding=0,
- groups=1,
- bias=False,
- use_bn=True,
- bn_eps=1e-5,
- activation=nn.ReLU(inplace=True)):
- """
- 1x1 version of the standard convolution block.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- stride : int or tuple/list of 2 int, default 1
- Strides of the convolution.
- padding : int, or tuple/list of 2 int, or tuple/list of 4 int, default 0
- Padding value for convolution layer.
- groups : int, default 1
- Number of groups.
- bias : bool, default False
- Whether the layer uses a bias vector.
- use_bn : bool, default True
- Whether to use BatchNorm layer.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- activation : function or str or None, default nn.ReLU(inplace=True)
- Activation function or name of activation function.
- """
- return ConvBlock(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=1,
- stride=stride,
- padding=padding,
- groups=groups,
- bias=bias,
- use_bn=use_bn,
- bn_eps=bn_eps,
- activation=activation)
-
-
-def conv3x3_block(in_channels,
- out_channels,
- stride=1,
- padding=1,
- dilation=1,
- groups=1,
- bias=False,
- use_bn=True,
- bn_eps=1e-5,
- activation=nn.ReLU(inplace=True)):
- """
- 3x3 version of the standard convolution block.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- stride : int or tuple/list of 2 int, default 1
- Strides of the convolution.
- padding : int, or tuple/list of 2 int, or tuple/list of 4 int, default 1
- Padding value for convolution layer.
- dilation : int or tuple/list of 2 int, default 1
- Dilation value for convolution layer.
- groups : int, default 1
- Number of groups.
- bias : bool, default False
- Whether the layer uses a bias vector.
- use_bn : bool, default True
- Whether to use BatchNorm layer.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- activation : function or str or None, default nn.ReLU(inplace=True)
- Activation function or name of activation function.
- """
- return ConvBlock(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=3,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups,
- bias=bias,
- use_bn=use_bn,
- bn_eps=bn_eps,
- activation=activation)
-
-
-def dwconv3x3_block(in_channels,
- out_channels,
- stride=1,
- padding=1,
- dilation=1,
- bias=False,
- bn_eps=1e-5,
- activation=nn.ReLU(inplace=True)):
- """
- 3x3 depthwise version of the standard convolution block.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- stride : int or tuple/list of 2 int, default 1
- Strides of the convolution.
- padding : int, or tuple/list of 2 int, or tuple/list of 4 int, default 1
- Padding value for convolution layer.
- dilation : int or tuple/list of 2 int, default 1
- Dilation value for convolution layer.
- bias : bool, default False
- Whether the layer uses a bias vector.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- activation : function or str or None, default nn.ReLU(inplace=True)
- Activation function or name of activation function.
- """
- return ConvBlock(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=3,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=out_channels,
- bias=bias,
- use_bn=True,
- bn_eps=bn_eps,
- activation=activation)
-
-
-def dwconv5x5_block(in_channels,
- out_channels,
- stride=1,
- padding=2,
- dilation=1,
- bias=False,
- bn_eps=1e-5,
- activation=nn.ReLU(inplace=True)):
- """
- 5x5 depthwise version of the standard convolution block.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- stride : int or tuple/list of 2 int, default 1
- Strides of the convolution.
- padding : int, or tuple/list of 2 int, or tuple/list of 4 int, default 2
- Padding value for convolution layer.
- dilation : int or tuple/list of 2 int, default 1
- Dilation value for convolution layer.
- bias : bool, default False
- Whether the layer uses a bias vector.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- activation : function or str or None, default nn.ReLU(inplace=True)
- Activation function or name of activation function.
- """
- return ConvBlock(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=5,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=out_channels,
- bias=bias,
- use_bn=True,
- bn_eps=bn_eps,
- activation=activation)
-
-
-class EffiDwsConvUnit(nn.Module):
- """
- EfficientNet specific depthwise separable convolution block/unit with BatchNorms and activations at each convolution
- layers.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- stride : int or tuple/list of 2 int
- Strides of the second convolution layer.
- bn_eps : float
- Small float added to variance in Batch norm.
- activation : str
- Name of activation function.
- tf_mode : bool
- Whether to use TF-like mode.
- """
- def __init__(self,
- in_channels,
- out_channels,
- stride,
- bn_eps,
- activation,
- tf_mode):
- super(EffiDwsConvUnit, self).__init__()
- self.tf_mode = tf_mode
- self.residual = (in_channels == out_channels) and (stride == 1)
-
- self.dw_conv = dwconv3x3_block(
- in_channels=in_channels,
- out_channels=in_channels,
- padding=(0 if tf_mode else 1),
- bn_eps=bn_eps,
- activation=activation)
- self.se = SEBlock(
- channels=in_channels,
- reduction=4,
- mid_activation=activation)
- self.pw_conv = conv1x1_block(
- in_channels=in_channels,
- out_channels=out_channels,
- bn_eps=bn_eps,
- activation=None)
-
- def forward(self, x):
- if self.residual:
- identity = x
- if self.tf_mode:
- x = F.pad(x, pad=calc_tf_padding(x, kernel_size=3))
- x = self.dw_conv(x)
- x = self.se(x)
- x = self.pw_conv(x)
- if self.residual:
- x = x + identity
- return x
-
-
-class EffiInvResUnit(nn.Module):
- """
- EfficientNet inverted residual unit.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- kernel_size : int or tuple/list of 2 int
- Convolution window size.
- stride : int or tuple/list of 2 int
- Strides of the second convolution layer.
- exp_factor : int
- Factor for expansion of channels.
- se_factor : int
- SE reduction factor for each unit.
- bn_eps : float
- Small float added to variance in Batch norm.
- activation : str
- Name of activation function.
- tf_mode : bool
- Whether to use TF-like mode.
- """
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size,
- stride,
- exp_factor,
- se_factor,
- bn_eps,
- activation,
- tf_mode):
- super(EffiInvResUnit, self).__init__()
- self.kernel_size = kernel_size
- self.stride = stride
- self.tf_mode = tf_mode
- self.residual = (in_channels == out_channels) and (stride == 1)
- self.use_se = se_factor > 0
- mid_channels = in_channels * exp_factor
- dwconv_block_fn = dwconv3x3_block if kernel_size == 3 else (dwconv5x5_block if kernel_size == 5 else None)
-
- self.conv1 = conv1x1_block(
- in_channels=in_channels,
- out_channels=mid_channels,
- bn_eps=bn_eps,
- activation=activation)
- self.conv2 = dwconv_block_fn(
- in_channels=mid_channels,
- out_channels=mid_channels,
- stride=stride,
- padding=(0 if tf_mode else (kernel_size // 2)),
- bn_eps=bn_eps,
- activation=activation)
- if self.use_se:
- self.se = SEBlock(
- channels=mid_channels,
- reduction=(exp_factor * se_factor),
- mid_activation=activation)
- self.conv3 = conv1x1_block(
- in_channels=mid_channels,
- out_channels=out_channels,
- bn_eps=bn_eps,
- activation=None)
-
- def forward(self, x):
- if self.residual:
- identity = x
- x = self.conv1(x)
- if self.tf_mode:
- x = F.pad(x, pad=calc_tf_padding(x, kernel_size=self.kernel_size, stride=self.stride))
- x = self.conv2(x)
- if self.use_se:
- x = self.se(x)
- x = self.conv3(x)
- if self.residual:
- x = x + identity
- return x
-
-
-class EffiInitBlock(nn.Module):
- """
- EfficientNet specific initial block.
-
- Parameters:
- ----------
- in_channels : int
- Number of input channels.
- out_channels : int
- Number of output channels.
- bn_eps : float
- Small float added to variance in Batch norm.
- activation : str
- Name of activation function.
- tf_mode : bool
- Whether to use TF-like mode.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- bn_eps,
- activation,
- tf_mode):
- super(EffiInitBlock, self).__init__()
- self.tf_mode = tf_mode
-
- self.conv = conv3x3_block(
- in_channels=in_channels,
- out_channels=out_channels,
- stride=2,
- padding=(0 if tf_mode else 1),
- bn_eps=bn_eps,
- activation=activation)
-
- def forward(self, x):
- if self.tf_mode:
- x = F.pad(x, pad=calc_tf_padding(x, kernel_size=3, stride=2))
- x = self.conv(x)
- return x
-
-
-class EfficientNet(nn.Module):
- """
- EfficientNet model from 'EfficientNet: Rethinking Model Scaling for Convolutional Neural Networks,'
- https://arxiv.org/abs/1905.11946.
-
- Parameters:
- ----------
- channels : list of list of int
- Number of output channels for each unit.
- init_block_channels : int
- Number of output channels for initial unit.
- final_block_channels : int
- Number of output channels for the final block of the feature extractor.
- kernel_sizes : list of list of int
- Number of kernel sizes for each unit.
- strides_per_stage : list int
- Stride value for the first unit of each stage.
- expansion_factors : list of list of int
- Number of expansion factors for each unit.
- dropout_rate : float, default 0.2
- Fraction of the input units to drop. Must be a number between 0 and 1.
- tf_mode : bool, default False
- Whether to use TF-like mode.
- bn_eps : float, default 1e-5
- Small float added to variance in Batch norm.
- in_channels : int, default 3
- Number of input channels.
- in_size : tuple of two ints, default (224, 224)
- Spatial size of the expected input image.
- num_classes : int, default 1000
- Number of classification classes.
- """
- def __init__(self,
- cfg,
- channels,
- init_block_channels,
- kernel_sizes,
- strides_per_stage,
- expansion_factors,
- tf_mode=False,
- bn_eps=1e-5,
- in_channels=3):
- super(EfficientNet, self).__init__()
- activation = swish()
-
- self.out_channels = []
- self.features = nn.Sequential()
- self.stages = []
- stem = EffiInitBlock(
- in_channels=in_channels,
- out_channels=init_block_channels,
- bn_eps=bn_eps,
- activation=activation,
- tf_mode=tf_mode)
- self.features.add_module("init_block", stem)
- self.stages.append(stem)
-
- in_channels = init_block_channels
- for i, channels_per_stage in enumerate(channels):
- kernel_sizes_per_stage = kernel_sizes[i]
- expansion_factors_per_stage = expansion_factors[i]
- stage = nn.Sequential()
- for j, out_channels in enumerate(channels_per_stage):
- kernel_size = kernel_sizes_per_stage[j]
- expansion_factor = expansion_factors_per_stage[j]
- stride = strides_per_stage[i] if (j == 0) else 1
- if i == 0:
- stage.add_module("unit{}".format(j + 1), EffiDwsConvUnit(
- in_channels=in_channels,
- out_channels=out_channels,
- stride=stride,
- bn_eps=bn_eps,
- activation=activation,
- tf_mode=tf_mode))
- else:
- stage.add_module("unit{}".format(j + 1), EffiInvResUnit(
- in_channels=in_channels,
- out_channels=out_channels,
- kernel_size=kernel_size,
- stride=stride,
- exp_factor=expansion_factor,
- se_factor=4,
- bn_eps=bn_eps,
- activation=activation,
- tf_mode=tf_mode))
- in_channels = out_channels
- if i>0:
- self.out_channels.append(out_channels)
- self.features.add_module("stage{}".format(i + 1), stage)
- self.stages.append(stage)
- # Optionally freeze (requires_grad=False) parts of the backbone
- self._freeze_backbone(cfg.MODEL.BACKBONE.FREEZE_CONV_BODY_AT)
-
- def _freeze_backbone(self, freeze_at):
- if freeze_at < 0:
- return
- for stage_index in range(freeze_at):
- m = self.stages[stage_index]
- for p in m.parameters():
- p.requires_grad = False
-
- def forward(self, x):
- res = []
- for i, stage in enumerate(self.stages):
- x = stage(x)
- if i>1:
- res.append(x)
- return res
-
-
-def get_efficientnet(cfg, version, tf_mode = True, bn_eps=1e-5, **kwargs):
- if version == "b0":
- depth_factor = 1.0
- width_factor = 1.0
- elif version == "b1":
- depth_factor = 1.1
- width_factor = 1.0
- elif version == "b2":
- depth_factor = 1.2
- width_factor = 1.1
- elif version == "b3":
- depth_factor = 1.4
- width_factor = 1.2
- elif version == "b4":
- depth_factor = 1.8
- width_factor = 1.4
- elif version == "b5":
- depth_factor = 2.2
- width_factor = 1.6
- elif version == "b6":
- depth_factor = 2.6
- width_factor = 1.8
- elif version == "b7":
- depth_factor = 3.1
- width_factor = 2.0
- elif version == "b8":
- depth_factor = 3.6
- width_factor = 2.2
- else:
- raise ValueError("Unsupported EfficientNet version {}".format(version))
-
- init_block_channels = 32
- layers = [1, 2, 2, 3, 3, 4, 1]
- downsample = [1, 1, 1, 1, 0, 1, 0]
- channels_per_layers = [16, 24, 40, 80, 112, 192, 320]
- expansion_factors_per_layers = [1, 6, 6, 6, 6, 6, 6]
- kernel_sizes_per_layers = [3, 3, 5, 3, 5, 5, 3]
- strides_per_stage = [1, 2, 2, 2, 1, 2, 1]
-
- layers = [int(math.ceil(li * depth_factor)) for li in layers]
- channels_per_layers = [round_channels(ci * width_factor) for ci in channels_per_layers]
-
- from functools import reduce
- channels = reduce(lambda x, y: x + [[y[0]] * y[1]] if y[2] != 0 else x[:-1] + [x[-1] + [y[0]] * y[1]],
- zip(channels_per_layers, layers, downsample), [])
- kernel_sizes = reduce(lambda x, y: x + [[y[0]] * y[1]] if y[2] != 0 else x[:-1] + [x[-1] + [y[0]] * y[1]],
- zip(kernel_sizes_per_layers, layers, downsample), [])
- expansion_factors = reduce(lambda x, y: x + [[y[0]] * y[1]] if y[2] != 0 else x[:-1] + [x[-1] + [y[0]] * y[1]],
- zip(expansion_factors_per_layers, layers, downsample), [])
- strides_per_stage = reduce(lambda x, y: x + [[y[0]] * y[1]] if y[2] != 0 else x[:-1] + [x[-1] + [y[0]] * y[1]],
- zip(strides_per_stage, layers, downsample), [])
- strides_per_stage = [si[0] for si in strides_per_stage]
-
- init_block_channels = round_channels(init_block_channels * width_factor)
-
- net = EfficientNet(
- cfg,
- channels=channels,
- init_block_channels=init_block_channels,
- kernel_sizes=kernel_sizes,
- strides_per_stage=strides_per_stage,
- expansion_factors=expansion_factors,
- tf_mode=tf_mode,
- bn_eps=bn_eps,
- **kwargs)
-
- return net
diff --git a/spaces/hardon-server/space-diffusion-txt2img-1-5/README.md b/spaces/hardon-server/space-diffusion-txt2img-1-5/README.md
deleted file mode 100644
index 40165a4bcf2d1096b9b6ee14eae89f5ca77ba2c1..0000000000000000000000000000000000000000
--- a/spaces/hardon-server/space-diffusion-txt2img-1-5/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Space Diffusion Txt2img 1.5
-emoji: 👁
-colorFrom: pink
-colorTo: blue
-sdk: gradio
-sdk_version: 3.41.2
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/hjzhp/cgpt-online/src/pages/api/auth.ts b/spaces/hjzhp/cgpt-online/src/pages/api/auth.ts
deleted file mode 100644
index b0029e35e1a94b9b916846a0e25680f7915dbe4d..0000000000000000000000000000000000000000
--- a/spaces/hjzhp/cgpt-online/src/pages/api/auth.ts
+++ /dev/null
@@ -1,12 +0,0 @@
-import type { APIRoute } from 'astro'
-
-const realPassword = import.meta.env.SITE_PASSWORD
-
-export const post: APIRoute = async(context) => {
- const body = await context.request.json()
-
- const { pass } = body
- return new Response(JSON.stringify({
- code: (!realPassword || pass === realPassword) ? 0 : -1,
- }))
-}
diff --git a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/evaluation/evaluator.py b/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/evaluation/evaluator.py
deleted file mode 100644
index 8f65631494319484b52a61f54d3346c76d9481d7..0000000000000000000000000000000000000000
--- a/spaces/ho11laqe/nnUNet_calvingfront_detection/nnunet/evaluation/evaluator.py
+++ /dev/null
@@ -1,490 +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.
-
-
-import collections
-import inspect
-import json
-import hashlib
-from datetime import datetime
-from multiprocessing.pool import Pool
-import numpy as np
-import pandas as pd
-import SimpleITK as sitk
-from nnunet.evaluation.metrics import ConfusionMatrix, ALL_METRICS
-from batchgenerators.utilities.file_and_folder_operations import save_json, subfiles, join
-from collections import OrderedDict
-
-
-class Evaluator:
- """Object that holds test and reference segmentations with label information
- and computes a number of metrics on the two. 'labels' must either be an
- iterable of numeric values (or tuples thereof) or a dictionary with string
- names and numeric values.
- """
-
- default_metrics = [
- "False Positive Rate",
- "Dice",
- "Jaccard",
- "Precision",
- "Recall",
- "Accuracy",
- "False Omission Rate",
- "Negative Predictive Value",
- "False Negative Rate",
- "True Negative Rate",
- "False Discovery Rate",
- "Total Positives Test",
- "Total Positives Reference"
- ]
-
- default_advanced_metrics = [
- # "Hausdorff Distance",
- "Hausdorff Distance 95",
- # "Avg. Surface Distance",
- # "Avg. Symmetric Surface Distance"
- ]
-
- def __init__(self,
- test=None,
- reference=None,
- labels=None,
- metrics=None,
- advanced_metrics=None,
- nan_for_nonexisting=True):
-
- self.test = None
- self.reference = None
- self.confusion_matrix = ConfusionMatrix()
- self.labels = None
- self.nan_for_nonexisting = nan_for_nonexisting
- self.result = None
-
- self.metrics = []
- if metrics is None:
- for m in self.default_metrics:
- self.metrics.append(m)
- else:
- for m in metrics:
- self.metrics.append(m)
-
- self.advanced_metrics = []
- if advanced_metrics is None:
- for m in self.default_advanced_metrics:
- self.advanced_metrics.append(m)
- else:
- for m in advanced_metrics:
- self.advanced_metrics.append(m)
-
- self.set_reference(reference)
- self.set_test(test)
- if labels is not None:
- self.set_labels(labels)
- else:
- if test is not None and reference is not None:
- self.construct_labels()
-
- def set_test(self, test):
- """Set the test segmentation."""
-
- self.test = test
-
- def set_reference(self, reference):
- """Set the reference segmentation."""
-
- self.reference = reference
-
- def set_labels(self, labels):
- """Set the labels.
- :param labels= may be a dictionary (int->str), a set (of ints), a tuple (of ints) or a list (of ints). Labels
- will only have names if you pass a dictionary"""
-
- if isinstance(labels, dict):
- self.labels = collections.OrderedDict(labels)
- elif isinstance(labels, set):
- self.labels = list(labels)
- elif isinstance(labels, np.ndarray):
- self.labels = [i for i in labels]
- elif isinstance(labels, (list, tuple)):
- self.labels = labels
- else:
- raise TypeError(
- "Can only handle dict, list, tuple, set & numpy array, but input is of type {}".format(type(labels)))
-
- def construct_labels(self):
- """Construct label set from unique entries in segmentations."""
-
- if self.test is None and self.reference is None:
- raise ValueError("No test or reference segmentations.")
- elif self.test is None:
- labels = np.unique(self.reference)
- else:
- labels = np.union1d(np.unique(self.test),
- np.unique(self.reference))
- self.labels = list(map(lambda x: int(x), labels))
-
- def set_metrics(self, metrics):
- """Set evaluation metrics"""
-
- if isinstance(metrics, set):
- self.metrics = list(metrics)
- elif isinstance(metrics, (list, tuple, np.ndarray)):
- self.metrics = metrics
- else:
- raise TypeError(
- "Can only handle list, tuple, set & numpy array, but input is of type {}".format(type(metrics)))
-
- def add_metric(self, metric):
-
- if metric not in self.metrics:
- self.metrics.append(metric)
-
- def evaluate(self, test=None, reference=None, advanced=False, **metric_kwargs):
- """Compute metrics for segmentations."""
- if test is not None:
- self.set_test(test)
-
- if reference is not None:
- self.set_reference(reference)
-
- if self.test is None or self.reference is None:
- raise ValueError("Need both test and reference segmentations.")
-
- if self.labels is None:
- self.construct_labels()
-
- self.metrics.sort()
-
- # get functions for evaluation
- # somewhat convoluted, but allows users to define additonal metrics
- # on the fly, e.g. inside an IPython console
- _funcs = {m: ALL_METRICS[m] for m in self.metrics + self.advanced_metrics}
- frames = inspect.getouterframes(inspect.currentframe())
- for metric in self.metrics:
- for f in frames:
- if metric in f[0].f_locals:
- _funcs[metric] = f[0].f_locals[metric]
- break
- else:
- if metric in _funcs:
- continue
- else:
- raise NotImplementedError(
- "Metric {} not implemented.".format(metric))
-
- # get results
- self.result = OrderedDict()
-
- eval_metrics = self.metrics
- if advanced:
- eval_metrics += self.advanced_metrics
-
- if isinstance(self.labels, dict):
-
- for label, name in self.labels.items():
- k = str(name)
- self.result[k] = OrderedDict()
- if not hasattr(label, "__iter__"):
- self.confusion_matrix.set_test(self.test == label)
- self.confusion_matrix.set_reference(self.reference == label)
- else:
- current_test = 0
- current_reference = 0
- for l in label:
- current_test += (self.test == l)
- current_reference += (self.reference == l)
- self.confusion_matrix.set_test(current_test)
- self.confusion_matrix.set_reference(current_reference)
- for metric in eval_metrics:
- self.result[k][metric] = _funcs[metric](confusion_matrix=self.confusion_matrix,
- nan_for_nonexisting=self.nan_for_nonexisting,
- **metric_kwargs)
-
- else:
- for j, label in enumerate(self.labels):
- self.result[j] = OrderedDict()
- for i, l in enumerate(label):
- # TODO add second label (Done)
- k = str(l)
- self.result[j][k] = OrderedDict()
- self.confusion_matrix.set_test(self.test[j] == l)
- self.confusion_matrix.set_reference(self.reference[j] == l)
- for metric in eval_metrics:
- self.result[j][k][metric] = _funcs[metric](confusion_matrix=self.confusion_matrix,
- nan_for_nonexisting=self.nan_for_nonexisting,
- **metric_kwargs)
-
- return self.result
-
- def to_dict(self):
-
- if self.result is None:
- self.evaluate()
- return self.result
-
- def to_array(self):
- """Return result as numpy array (labels x metrics)."""
-
- if self.result is None:
- self.evaluate
-
- result_metrics = sorted(self.result[list(self.result.keys())[0]].keys())
-
- a = np.zeros((len(self.labels), len(result_metrics)), dtype=np.float32)
-
- if isinstance(self.labels, dict):
- for i, label in enumerate(self.labels.keys()):
- for j, metric in enumerate(result_metrics):
- a[i][j] = self.result[self.labels[label]][metric]
- else:
- for i, label in enumerate(self.labels):
- for j, metric in enumerate(result_metrics):
- a[i][j] = self.result[label][metric]
-
- return a
-
- def to_pandas(self):
- """Return result as pandas DataFrame."""
-
- a = self.to_array()
-
- if isinstance(self.labels, dict):
- labels = list(self.labels.values())
- else:
- labels = self.labels
-
- result_metrics = sorted(self.result[list(self.result.keys())[0]].keys())
-
- return pd.DataFrame(a, index=labels, columns=result_metrics)
-
-
-class NiftiEvaluator(Evaluator):
-
- def __init__(self, *args, **kwargs):
-
- self.test_nifti = None
- self.reference_nifti = None
- super(NiftiEvaluator, self).__init__(*args, **kwargs)
-
- def set_test(self, test):
- """Set the test segmentation."""
-
- if test is not None:
- # TODO test images has only zone prediction Look at the code where image is saved. (Done)
- self.test_nifti = sitk.ReadImage(test)
- super(NiftiEvaluator, self).set_test(sitk.GetArrayFromImage(self.test_nifti))
- else:
- self.test_nifti = None
- super(NiftiEvaluator, self).set_test(test)
-
- def set_reference(self, reference):
- """Set the reference segmentation."""
-
- if reference is not None:
- self.reference_nifti = sitk.ReadImage(reference)
- super(NiftiEvaluator, self).set_reference(sitk.GetArrayFromImage(self.reference_nifti))
- else:
- self.reference_nifti = None
- super(NiftiEvaluator, self).set_reference(reference)
-
- def evaluate(self, test=None, reference=None, voxel_spacing=None, **metric_kwargs):
-
- if voxel_spacing is None:
- voxel_spacing = np.array(self.test_nifti.GetSpacing())[::-1]
- metric_kwargs["voxel_spacing"] = voxel_spacing
-
- return super(NiftiEvaluator, self).evaluate(test, reference, **metric_kwargs)
-
-
-def run_evaluation(args):
- test, ref, evaluator, metric_kwargs = args
- # evaluate
- evaluator.set_test(test)
- evaluator.set_reference(ref)
- if evaluator.labels is None:
- evaluator.construct_labels()
- current_scores = evaluator.evaluate(**metric_kwargs)
- if type(test) == str:
- current_scores["test"] = test
- if type(ref) == str:
- current_scores["reference"] = ref
- return current_scores
-
-
-def aggregate_scores(test_ref_pairs,
- evaluator=NiftiEvaluator,
- labels=None,
- nanmean=True,
- json_output_file=None,
- json_name="",
- json_description="",
- json_author="Fabian",
- json_task="",
- num_threads=2,
- **metric_kwargs):
- """
- test = predicted image
- :param test_ref_pairs:
- :param evaluator:
- :param labels: must be a dict of int-> str or a list of int
- :param nanmean:
- :param json_output_file:
- :param json_name:
- :param json_description:
- :param json_author:
- :param json_task:
- :param metric_kwargs:
- :return:
- """
-
- if type(evaluator) == type:
- evaluator = evaluator()
-
- if labels is not None:
- evaluator.set_labels(labels)
-
- test = [i[0] for i in test_ref_pairs]
- ref = [i[1] for i in test_ref_pairs]
- # all_res= [run_evaluation((test[0], ref[0], evaluator, metric_kwargs))]
-
- p = Pool(num_threads)
- all_res = p.map(run_evaluation, zip(test, ref, [evaluator] * len(ref), [metric_kwargs] * len(ref)))
- p.close()
- p.join()
-
- all_scores = OrderedDict()
-
- for mask in range(len(labels)):
- all_scores[mask] = OrderedDict()
- all_scores[mask]["all"] = []
- all_scores[mask]["mean"] = OrderedDict()
- for i in range(len(all_res)):
- all_scores[mask]["all"].append(all_res[i][mask])
-
- # append score list for mean
- for label, score_dict in all_res[i][mask].items():
- if label in ("test", "reference"):
- continue
- if label not in all_scores[mask]["mean"]:
- all_scores[mask]["mean"][label] = OrderedDict()
- for score, value in score_dict.items():
- if score not in all_scores[mask]["mean"][label]:
- all_scores[mask]["mean"][label][score] = []
- all_scores[mask]["mean"][label][score].append(value)
-
- for label in all_scores[mask]["mean"]:
- for score in all_scores[mask]["mean"][label]:
- if nanmean:
- all_scores[mask]["mean"][label][score] = float(np.nanmean(all_scores[mask]["mean"][label][score]))
- else:
- all_scores[mask]["mean"][label][score] = float(np.mean(all_scores[mask]["mean"][label][score]))
-
- # save to file if desired
- # we create a hopefully unique id by hashing the entire output dictionary
- if json_output_file is not None:
- json_dict = OrderedDict()
- json_dict["name"] = json_name
- json_dict["description"] = json_description
- timestamp = datetime.today()
- json_dict["timestamp"] = str(timestamp)
- json_dict["task"] = json_task
- json_dict["author"] = json_author
- json_dict["results"] = all_scores
- json_dict["id"] = hashlib.md5(json.dumps(json_dict).encode("utf-8")).hexdigest()[:12]
- save_json(json_dict, json_output_file)
-
- return all_scores
-
-
-def aggregate_scores_for_experiment(score_file,
- labels=None,
- metrics=Evaluator.default_metrics,
- nanmean=True,
- json_output_file=None,
- json_name="",
- json_description="",
- json_author="Fabian",
- json_task=""):
- scores = np.load(score_file)
- scores_mean = scores.mean(0)
- if labels is None:
- labels = list(map(str, range(scores.shape[1])))
-
- results = []
- results_mean = OrderedDict()
- for i in range(scores.shape[0]):
- results.append(OrderedDict())
- for l, label in enumerate(labels):
- results[-1][label] = OrderedDict()
- results_mean[label] = OrderedDict()
- for m, metric in enumerate(metrics):
- results[-1][label][metric] = float(scores[i][l][m])
- results_mean[label][metric] = float(scores_mean[l][m])
-
- json_dict = OrderedDict()
- json_dict["name"] = json_name
- json_dict["description"] = json_description
- timestamp = datetime.today()
- json_dict["timestamp"] = str(timestamp)
- json_dict["task"] = json_task
- json_dict["author"] = json_author
- json_dict["results"] = {"all": results, "mean": results_mean}
- json_dict["id"] = hashlib.md5(json.dumps(json_dict).encode("utf-8")).hexdigest()[:12]
- if json_output_file is not None:
- json_output_file = open(json_output_file, "w")
- json.dump(json_dict, json_output_file, indent=4, separators=(",", ": "))
- json_output_file.close()
-
- return json_dict
-
-
-def evaluate_folder(folder_with_gts: str, folder_with_predictions: str, labels: tuple, **metric_kwargs):
- """
- writes a summary.json to folder_with_predictions
- :param folder_with_gts: folder where the ground truth segmentations are saved. Must be nifti files.
- :param folder_with_predictions: folder where the predicted segmentations are saved. Must be nifti files.
- :param labels: tuple of int with the labels in the dataset. For example (0, 1, 2, 3) for Task001_BrainTumour.
- :return:
- """
- files_gt = subfiles(folder_with_gts, suffix=".nii.gz", join=False)
- files_pred = subfiles(folder_with_predictions, suffix=".nii.gz", join=False)
- assert all([i in files_pred for i in files_gt]), "files missing in folder_with_predictions"
- assert all([i in files_gt for i in files_pred]), "files missing in folder_with_gts"
- test_ref_pairs = [(join(folder_with_predictions, i), join(folder_with_gts, i)) for i in files_pred]
- res = aggregate_scores(test_ref_pairs, json_output_file=join(folder_with_predictions, "summary.json"),
- num_threads=8, labels=labels, **metric_kwargs)
- return res
-
-
-def nnunet_evaluate_folder():
- import argparse
- parser = argparse.ArgumentParser("Evaluates the segmentations located in the folder pred. Output of this script is "
- "a json file. At the very bottom of the json file is going to be a 'mean' "
- "entry with averages metrics across all cases")
- parser.add_argument('-ref', required=True, type=str, help="Folder containing the reference segmentations in nifti "
- "format.")
- parser.add_argument('-pred', required=True, type=str, help="Folder containing the predicted segmentations in nifti "
- "format. File names must match between the folders!")
- parser.add_argument('-l', nargs='+', type=int, required=True, help="List of label IDs (integer values) that should "
- "be evaluated. Best practice is to use all int "
- "values present in the dataset, so for example "
- "for LiTS the labels are 0: background, 1: "
- "liver, 2: tumor. So this argument "
- "should be -l 1 2. You can if you want also "
- "evaluate the background label (0) but in "
- "this case that would not gie any useful "
- "information.")
- args = parser.parse_args()
- return evaluate_folder(args.ref, args.pred, args.l)
diff --git a/spaces/hoshilumine/combined-GI-RVC-models/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py b/spaces/hoshilumine/combined-GI-RVC-models/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
deleted file mode 100644
index b2c592527a5966e6f8e79e8c52dc5b414246dcc6..0000000000000000000000000000000000000000
--- a/spaces/hoshilumine/combined-GI-RVC-models/lib/infer_pack/modules/F0Predictor/PMF0Predictor.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from lib.infer_pack.modules.F0Predictor.F0Predictor import F0Predictor
-import parselmouth
-import numpy as np
-
-
-class PMF0Predictor(F0Predictor):
- def __init__(self, hop_length=512, f0_min=50, f0_max=1100, sampling_rate=44100):
- self.hop_length = hop_length
- self.f0_min = f0_min
- self.f0_max = f0_max
- self.sampling_rate = sampling_rate
-
- def interpolate_f0(self, f0):
- """
- 对F0进行插值处理
- """
-
- data = np.reshape(f0, (f0.size, 1))
-
- vuv_vector = np.zeros((data.size, 1), dtype=np.float32)
- vuv_vector[data > 0.0] = 1.0
- vuv_vector[data <= 0.0] = 0.0
-
- ip_data = data
-
- frame_number = data.size
- last_value = 0.0
- for i in range(frame_number):
- if data[i] <= 0.0:
- j = i + 1
- for j in range(i + 1, frame_number):
- if data[j] > 0.0:
- break
- if j < frame_number - 1:
- if last_value > 0.0:
- step = (data[j] - data[i - 1]) / float(j - i)
- for k in range(i, j):
- ip_data[k] = data[i - 1] + step * (k - i + 1)
- else:
- for k in range(i, j):
- ip_data[k] = data[j]
- else:
- for k in range(i, frame_number):
- ip_data[k] = last_value
- else:
- ip_data[i] = data[i] # 这里可能存在一个没有必要的拷贝
- last_value = data[i]
-
- return ip_data[:, 0], vuv_vector[:, 0]
-
- def compute_f0(self, wav, p_len=None):
- x = wav
- if p_len is None:
- p_len = x.shape[0] // self.hop_length
- else:
- assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
- time_step = self.hop_length / self.sampling_rate * 1000
- f0 = (
- parselmouth.Sound(x, self.sampling_rate)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=self.f0_min,
- pitch_ceiling=self.f0_max,
- )
- .selected_array["frequency"]
- )
-
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
- f0, uv = self.interpolate_f0(f0)
- return f0
-
- def compute_f0_uv(self, wav, p_len=None):
- x = wav
- if p_len is None:
- p_len = x.shape[0] // self.hop_length
- else:
- assert abs(p_len - x.shape[0] // self.hop_length) < 4, "pad length error"
- time_step = self.hop_length / self.sampling_rate * 1000
- f0 = (
- parselmouth.Sound(x, self.sampling_rate)
- .to_pitch_ac(
- time_step=time_step / 1000,
- voicing_threshold=0.6,
- pitch_floor=self.f0_min,
- pitch_ceiling=self.f0_max,
- )
- .selected_array["frequency"]
- )
-
- pad_size = (p_len - len(f0) + 1) // 2
- if pad_size > 0 or p_len - len(f0) - pad_size > 0:
- f0 = np.pad(f0, [[pad_size, p_len - len(f0) - pad_size]], mode="constant")
- f0, uv = self.interpolate_f0(f0)
- return f0, uv
diff --git a/spaces/hra/GPT4-makes-BabyAGI/app.py b/spaces/hra/GPT4-makes-BabyAGI/app.py
deleted file mode 100644
index 1802ade9d0a0e67381f053ec9156172a64701366..0000000000000000000000000000000000000000
--- a/spaces/hra/GPT4-makes-BabyAGI/app.py
+++ /dev/null
@@ -1,163 +0,0 @@
-import gradio as gr
-import openai
-import requests
-import json
-import os
-from duckduckgo_search import ddg
-import datetime
-from datetime import datetime, date, time, timedelta
-
-
-def search_duckduckgo(query):
-
- keywords = query
- results = ddg(keywords, region='wt-wt', safesearch='Off', time='m')
- filtered_results = [{"title": res["title"], "body": res["body"]} for res in results]
- print(filtered_results)
- return filtered_results
-
-def get_search_query(task):
-
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content": f"Given the task: {task}. Generate a concise search query with 1-3 keywords."}
- ]
- )
- search_query = response.choices[0]['message']['content'].strip()
- print("Agent 2: ",search_query)
- return search_query
-
-def summarize_search_result(task, search_result):
-
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content":f"Given the task '{task}' and the search result '{json.dumps(search_result)}', provide a summarized result."}
- ]
- )
- summary = response.choices[0]['message']['content'].strip()
- return summary
-
-def agent_1(objective):
-
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content":f"Given the objective '{objective}', create a list of tasks that are closely related to the objective. If needed add specific key words from objective to the task sentence"}
- ]
- )
- tasks = response.choices[0]['message']['content'].strip().split('\n')
- return tasks
-
-def agent_2(task):
-
- search_query = get_search_query(task)
- print("Agent 2")
- print(search_query)
- search_results = search_duckduckgo(search_query)
- summarized_result = summarize_search_result(task, search_results)
- print(summarized_result)
- return summarized_result
-
-def agent_3(objective, last_result, tasks):
-
- task_list = '\n'.join(tasks)
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content":f"Given the objective '{objective}', the last result '{json.dumps(last_result)}', and the task list:\n{task_list}\n\nRank the tasks based on their relevance to the objective."}
- ]
- )
- modified_tasks = response.choices[0]['message']['content'].strip().split('\n')
- print("Agent 3")
- print(modified_tasks)
- return modified_tasks
-
-def summarize_result(objective, result):
-
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content":f"Given the objective '{objective}' and the final result '{json.dumps(result)}', provide a summary."}
- ]
- )
- summary = response.choices[0]['message']['content'].strip()
- return summary
-
-def generate_final_answer(objective, all_results):
-
- response = openai.ChatCompletion.create(
- model="gpt-3.5-turbo",
- messages=[
- {"role": "user", "content":f"Given the objective '{objective}' and the collected results '{json.dumps(all_results)}', provide a final answer addressing the objective."}
- ]
- )
- final_answer = response.choices[0]['message']['content'].strip()
- return final_answer
-
-def main(objective, loop_count):
- tasks = agent_1(objective)
- all_results = []
- completed_tasks = []
- for i in range(loop_count):
- print(i+1)
- if i < len(tasks):
- print('NEXT TASK: ',tasks[i])
- completed_tasks.append(tasks[i])
- result = agent_2(tasks[i])
- all_results.append(result)
- tasks = agent_3(objective, result, tasks)
- print('*********************')
- else:
- break
-
- final_answer = generate_final_answer(objective, all_results)
- return final_answer,completed_tasks,tasks
-
-def getbabyagianswer(objective,loop_count,openapikey):
- dateforfilesave=datetime.today().strftime("%d-%m-%Y %I:%M%p")
- print(objective)
- print(dateforfilesave)
-
- if openapikey=='':
- return ["Please provide OpenAPI Key","Please provide OpenAPI Key","Please provide OpenAPI Key"]
-
- os.environ['OPENAI_API_KEY'] = str(openapikey)
- openai.api_key=str(openapikey)
-
- final_summary,completed_tasts,all_tasks = main(objective, int(loop_count))
- print("Final Summary:", final_summary)
- return final_summary,completed_tasts,all_tasks
-
-
-with gr.Blocks() as demo:
- gr.Markdown("GPT4 created BabyAGI
-
- {children}
-
-
-)
-DialogPortal.displayName = DialogPrimitive.Portal.displayName
-
-const DialogOverlay = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, children, ...props }, ref) => (
-
-
- {children}
-
- Close
-
-
-
-))
-DialogContent.displayName = DialogPrimitive.Content.displayName
-
-const DialogHeader = ({
- className,
- ...props
-}: React.HTMLAttributes) => (
-
-)
-DialogHeader.displayName = 'DialogHeader'
-
-const DialogFooter = ({
- className,
- ...props
-}: React.HTMLAttributes) => (
-
-)
-DialogFooter.displayName = 'DialogFooter'
-
-const DialogTitle = React.forwardRef<
- React.ElementRef,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
- ,
- React.ComponentPropsWithoutRef
->(({ className, ...props }, ref) => (
-
-): AsyncIterableIterator {
- const reader = stream.getReader();
- try {
- while (true) {
- const { done, value } = await reader.read();
- if (done) return;
- yield value;
- }
- } finally {
- reader.releaseLock();
- }
-}
diff --git a/spaces/huggingface-projects/llama-2-7b-chat/app.py b/spaces/huggingface-projects/llama-2-7b-chat/app.py
deleted file mode 100644
index 3f888fab8974f5b25ecc069fc8f12277244330c9..0000000000000000000000000000000000000000
--- a/spaces/huggingface-projects/llama-2-7b-chat/app.py
+++ /dev/null
@@ -1,145 +0,0 @@
-import os
-from threading import Thread
-from typing import Iterator
-
-import gradio as gr
-import spaces
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer, TextIteratorStreamer
-
-MAX_MAX_NEW_TOKENS = 2048
-DEFAULT_MAX_NEW_TOKENS = 1024
-MAX_INPUT_TOKEN_LENGTH = int(os.getenv("MAX_INPUT_TOKEN_LENGTH", "4096"))
-
-DESCRIPTION = """\
-# Llama-2 7B Chat
-
-This Space demonstrates model [Llama-2-7b-chat](https://huggingface.co/meta-llama/Llama-2-7b-chat) by Meta, a Llama 2 model with 7B parameters fine-tuned for chat instructions. Feel free to play with it, or duplicate to run generations without a queue! If you want to run your own service, you can also [deploy the model on Inference Endpoints](https://huggingface.co/inference-endpoints).
-
-🔎 For more details about the Llama 2 family of models and how to use them with `transformers`, take a look [at our blog post](https://huggingface.co/blog/llama2).
-
-🔨 Looking for an even more powerful model? Check out the [13B version](https://huggingface.co/spaces/huggingface-projects/llama-2-13b-chat) or the large [70B model demo](https://huggingface.co/spaces/ysharma/Explore_llamav2_with_TGI).
-"""
-
-LICENSE = """
-
-
----
-As a derivate work of [Llama-2-7b-chat](https://huggingface.co/meta-llama/Llama-2-7b-chat) by Meta,
-this demo is governed by the original [license](https://huggingface.co/spaces/huggingface-projects/llama-2-7b-chat/blob/main/LICENSE.txt) and [acceptable use policy](https://huggingface.co/spaces/huggingface-projects/llama-2-7b-chat/blob/main/USE_POLICY.md).
-"""
-
-if not torch.cuda.is_available():
- DESCRIPTION += "\nRunning on CPU 🥶 This demo does not work on CPU.
"
-
-
-if torch.cuda.is_available():
- model_id = "meta-llama/Llama-2-7b-chat-hf"
- model = AutoModelForCausalLM.from_pretrained(model_id, torch_dtype=torch.float16, device_map="auto")
- tokenizer = AutoTokenizer.from_pretrained(model_id)
- tokenizer.use_default_system_prompt = False
-
-
-@spaces.GPU
-def generate(
- message: str,
- chat_history: list[tuple[str, str]],
- system_prompt: str,
- max_new_tokens: int = 1024,
- temperature: float = 0.6,
- top_p: float = 0.9,
- top_k: int = 50,
- repetition_penalty: float = 1.2,
-) -> Iterator[str]:
- conversation = []
- if system_prompt:
- conversation.append({"role": "system", "content": system_prompt})
- for user, assistant in chat_history:
- conversation.extend([{"role": "user", "content": user}, {"role": "assistant", "content": assistant}])
- conversation.append({"role": "user", "content": message})
-
- input_ids = tokenizer.apply_chat_template(conversation, return_tensors="pt")
- if input_ids.shape[1] > MAX_INPUT_TOKEN_LENGTH:
- input_ids = input_ids[:, -MAX_INPUT_TOKEN_LENGTH:]
- gr.Warning(f"Trimmed input from conversation as it was longer than {MAX_INPUT_TOKEN_LENGTH} tokens.")
- input_ids = input_ids.to(model.device)
-
- streamer = TextIteratorStreamer(tokenizer, timeout=10.0, skip_prompt=True, skip_special_tokens=True)
- generate_kwargs = dict(
- {"input_ids": input_ids},
- streamer=streamer,
- max_new_tokens=max_new_tokens,
- do_sample=True,
- top_p=top_p,
- top_k=top_k,
- temperature=temperature,
- num_beams=1,
- repetition_penalty=repetition_penalty,
- )
- t = Thread(target=model.generate, kwargs=generate_kwargs)
- t.start()
-
- outputs = []
- for text in streamer:
- outputs.append(text)
- yield "".join(outputs)
-
-
-chat_interface = gr.ChatInterface(
- fn=generate,
- additional_inputs=[
- gr.Textbox(label="System prompt", lines=6),
- gr.Slider(
- label="Max new tokens",
- minimum=1,
- maximum=MAX_MAX_NEW_TOKENS,
- step=1,
- value=DEFAULT_MAX_NEW_TOKENS,
- ),
- gr.Slider(
- label="Temperature",
- minimum=0.1,
- maximum=4.0,
- step=0.1,
- value=0.6,
- ),
- gr.Slider(
- label="Top-p (nucleus sampling)",
- minimum=0.05,
- maximum=1.0,
- step=0.05,
- value=0.9,
- ),
- gr.Slider(
- label="Top-k",
- minimum=1,
- maximum=1000,
- step=1,
- value=50,
- ),
- gr.Slider(
- label="Repetition penalty",
- minimum=1.0,
- maximum=2.0,
- step=0.05,
- value=1.2,
- ),
- ],
- stop_btn=None,
- examples=[
- ["Hello there! How are you doing?"],
- ["Can you explain briefly to me what is the Python programming language?"],
- ["Explain the plot of Cinderella in a sentence."],
- ["How many hours does it take a man to eat a Helicopter?"],
- ["Write a 100-word article on 'Benefits of Open-Source in AI research'"],
- ],
-)
-
-with gr.Blocks(css="style.css") as demo:
- gr.Markdown(DESCRIPTION)
- gr.DuplicateButton(value="Duplicate Space for private use", elem_id="duplicate-button")
- chat_interface.render()
- gr.Markdown(LICENSE)
-
-if __name__ == "__main__":
- demo.queue(max_size=20).launch()
diff --git a/spaces/huolongguo10/HlgBot/README.md b/spaces/huolongguo10/HlgBot/README.md
deleted file mode 100644
index 82c3568a1b3eff755e79d9388e6c9e3269cf2e69..0000000000000000000000000000000000000000
--- a/spaces/huolongguo10/HlgBot/README.md
+++ /dev/null
@@ -1,14 +0,0 @@
----
-title: ChatYuan Large V2
-emoji: 📊
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: false
-license: creativeml-openrail-m
-duplicated_from: ClueAI/ChatYuan-large-v2
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/hussain-shk/IndiSent/legacy/apply_bpe_train_notag.sh b/spaces/hussain-shk/IndiSent/legacy/apply_bpe_train_notag.sh
deleted file mode 100644
index fa24a57dc2a8b26eed1aae66793f9a65c2712e26..0000000000000000000000000000000000000000
--- a/spaces/hussain-shk/IndiSent/legacy/apply_bpe_train_notag.sh
+++ /dev/null
@@ -1,33 +0,0 @@
-#!/bin/bash
-
-expdir=$1 # EXPDIR
-
-#`dirname $0`/env.sh
-SUBWORD_NMT_DIR="subword-nmt"
-
-data_dir="$expdir/data"
-train_file=$data_dir/train
-bpe_file=$expdir/bpe/train/train
-
-mkdir -p $expdir/bpe/train
-
-echo "Apply to SRC corpus"
-
-python $SUBWORD_NMT_DIR/subword_nmt/apply_bpe.py \
- -c $expdir/vocab/bpe_codes.32k.SRC_TGT \
- --vocabulary $expdir/vocab/vocab.SRC \
- --vocabulary-threshold 5 \
- --num-workers "-1" \
- < $train_file.SRC \
- > $bpe_file.SRC
-
-echo "Apply to TGT corpus"
-
-python $SUBWORD_NMT_DIR/subword_nmt/apply_bpe.py \
- -c $expdir/vocab/bpe_codes.32k.SRC_TGT \
- --vocabulary $expdir/vocab/vocab.TGT \
- --vocabulary-threshold 5 \
- --num-workers "-1" \
- < $train_file.TGT \
- > $bpe_file.TGT
-
diff --git a/spaces/huy-ha/semabs-relevancy/app.py b/spaces/huy-ha/semabs-relevancy/app.py
deleted file mode 100644
index a4aa8886175075445df9310e7c98dfe325c6b010..0000000000000000000000000000000000000000
--- a/spaces/huy-ha/semabs-relevancy/app.py
+++ /dev/null
@@ -1,165 +0,0 @@
-import gradio as gr
-import numpy as np
-from CLIP.clip import ClipWrapper, saliency_configs
-from time import time
-from matplotlib import pyplot as plt
-import io
-from PIL import Image, ImageDraw, ImageFont
-import matplotlib
-
-matplotlib.use("Agg")
-
-tag = """
-
-"""
-
-
-def plot_to_png(fig):
- buf = io.BytesIO()
- plt.savefig(buf, format="png")
- buf.seek(0)
- img = np.array(Image.open(buf)).astype(np.uint8)
- return img
-
-
-def add_text_to_image(
- image: np.ndarray,
- text,
- position,
- color="rgb(255, 255, 255)",
- fontsize=60,
-):
- image = Image.fromarray(image)
- draw = ImageDraw.Draw(image)
- draw.text(
- position,
- text,
- fill=color,
- font=ImageFont.truetype(
- "/usr/share/fonts/truetype/lato/Lato-Medium.ttf", fontsize
- ),
- )
- return np.array(image)
-
-
-def generate_relevancy(
- img: np.array, labels: str, prompt: str, saliency_config: str, subtract_mean: bool
-):
- labels = labels.split(",")
- if len(labels) > 32:
- labels = labels[:32]
- prompts = [prompt]
- resize_shape = np.array(img.shape[:2])
- resize_shape = tuple(
- ((resize_shape / resize_shape.max()) * 224 * 4).astype(int).tolist()
- )
- img = np.asarray(Image.fromarray(img).resize(resize_shape))
- assert img.dtype == np.uint8
- h, w, c = img.shape
- start = time()
- try:
- grads = ClipWrapper.get_clip_saliency(
- img=img,
- text_labels=np.array(labels),
- prompts=prompts,
- **saliency_configs[saliency_config](h),
- )[0]
- except Exception as e:
- print(e)
- return (
- [img],
- tag,
- )
- print("inference took", float(time() - start))
- if subtract_mean:
- grads -= grads.mean(axis=0)
- grads = grads.cpu().numpy()
- vmin = 0.002
- cmap = plt.get_cmap("jet")
- vmax = 0.008
-
- returns = []
- for label_grad, label in zip(grads, labels):
- fig, ax = plt.subplots(1, 1, figsize=(4, 4))
- ax.axis("off")
- ax.imshow(img)
- grad = np.clip((label_grad - vmin) / (vmax - vmin), a_min=0.0, a_max=1.0)
- colored_grad = cmap(grad)
- grad = 1 - grad
- colored_grad[..., -1] = grad * 0.7
- colored_grad = add_text_to_image(
- (colored_grad * 255).astype(np.uint8), text=label, position=(0, 0)
- )
- colored_grad = colored_grad.astype(float) / 255
- ax.imshow(colored_grad)
- plt.tight_layout(pad=0)
- returns.append(plot_to_png(fig))
- plt.close(fig)
- return (
- returns,
- tag,
- )
-
-
-iface = gr.Interface(
- title="Semantic Abstraction Multi-scale Relevancy Extractor",
- description="""A CPU-only demo of [Semantic Abstraction](https://semantic-abstraction.cs.columbia.edu/)'s Multi-Scale Relevancy Extractor. To run GPU inference locally, use the [official codebase release](https://github.com/columbia-ai-robotics/semantic-abstraction).
-
-This relevancy extractor builds heavily on [Chefer et al.'s codebase](https://github.com/hila-chefer/Transformer-MM-Explainability) and [CLIP on Wheels' codebase](https://cow.cs.columbia.edu/).""",
- fn=generate_relevancy,
- cache_examples=True,
- inputs=[
- gr.Image(type="numpy", label="Image"),
- gr.Textbox(label="Labels (comma separated without spaces in between)"),
- gr.Textbox(
- label="Prompt. (Make sure to include '{}' in the prompt like examples below)"
- ),
- gr.Dropdown(
- value="ours",
- choices=["ours", "ours_fast", "chefer_et_al"],
- label="Relevancy Configuration",
- ),
- gr.Checkbox(value=True, label="subtract mean"),
- ],
- outputs=[
- gr.Gallery(label="Relevancy Maps", type="numpy"),
- gr.HTML(value=tag),
- ],
- examples=[
- [
- "https://semantic-abstraction.cs.columbia.edu/downloads/gameroom.png",
- "basketball jersey,nintendo switch,television,ping pong table,vase,fireplace,abstract painting of a vespa,carpet,wall",
- "a photograph of a {} in a home.",
- "ours_fast",
- True,
- ],
- [
- "https://semantic-abstraction.cs.columbia.edu/downloads/livingroom.png",
- "monopoly boardgame set,door knob,sofa,coffee table,plant,carpet,wall",
- "a photograph of a {} in a home.",
- "ours_fast",
- True,
- ],
- [
- "https://semantic-abstraction.cs.columbia.edu/downloads/fireplace.png",
- "fireplace,beige armchair,candle,large indoor plant in a pot,forest painting,cheetah-patterned pillow,floor,carpet,wall",
- "a photograph of a {} in a home.",
- "ours_fast",
- True,
- ],
- [
- "https://semantic-abstraction.cs.columbia.edu/downloads/walle.png",
- "WALL-E,a fire extinguisher",
- "a 3D render of {}.",
- "ours_fast",
- True,
- ],
- ],
-)
-iface.launch()
diff --git a/spaces/hysts/Text2Human/style.css b/spaces/hysts/Text2Human/style.css
deleted file mode 100644
index 22ad0be91ed35841bc456be4a0044474affc9a17..0000000000000000000000000000000000000000
--- a/spaces/hysts/Text2Human/style.css
+++ /dev/null
@@ -1,16 +0,0 @@
-h1 {
- text-align: center;
-}
-#input-image {
- max-height: 300px;
-}
-#label-image {
- height: 300px;
-}
-#result-image {
- height: 300px;
-}
-img#visitor-badge {
- display: block;
- margin: auto;
-}
diff --git a/spaces/imseldrith/DeepFakeAI/DeepFakeAI/processors/frame/__init__.py b/spaces/imseldrith/DeepFakeAI/DeepFakeAI/processors/frame/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/inamXcontru/PoeticTTS/Astm D1143.pdfl.md b/spaces/inamXcontru/PoeticTTS/Astm D1143.pdfl.md
deleted file mode 100644
index 5f88724d6b3ed261a92d333c3900a4b69b51135a..0000000000000000000000000000000000000000
--- a/spaces/inamXcontru/PoeticTTS/Astm D1143.pdfl.md
+++ /dev/null
@@ -1,6 +0,0 @@
-Astm D1143.pdfl Download Zip ✵ https://gohhs.com/2uz49r
diff --git a/spaces/innat/Google-MediaPipe/holistic.py b/spaces/innat/Google-MediaPipe/holistic.py
deleted file mode 100644
index 1941b16533f832cad0c9d727f15c37594a61038c..0000000000000000000000000000000000000000
--- a/spaces/innat/Google-MediaPipe/holistic.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import mediapipe as mp
-from utils import read_n_resize
-
-def mp_holistic_fn(image, min_detect_conf=0.5):
- mp_drawing = mp.solutions.drawing_utils
- mp_drawing_styles = mp.solutions.drawing_styles
- mp_holistic = mp.solutions.holistic
-
- with mp_holistic.Holistic(
- static_image_mode=True,
- model_complexity=2,
- enable_segmentation=True,
- refine_face_landmarks=True,
- min_detection_confidence=min_detect_conf
- ) as holistic:
- image = read_n_resize(image, read=False)
- results = holistic.process(image)
- annotated_image = image.copy()
-
- mp_drawing.draw_landmarks(
- annotated_image,
- results.face_landmarks,
- mp_holistic.FACEMESH_TESSELATION,
- landmark_drawing_spec=None,
- connection_drawing_spec=mp_drawing_styles
- .get_default_face_mesh_tesselation_style())
- mp_drawing.draw_landmarks(
- annotated_image,
- results.pose_landmarks,
- mp_holistic.POSE_CONNECTIONS,
- landmark_drawing_spec=mp_drawing_styles.
- get_default_pose_landmarks_style())
-
- return annotated_image
-
diff --git a/spaces/innnky/soft-vits-vc/app.py b/spaces/innnky/soft-vits-vc/app.py
deleted file mode 100644
index 457c1cf0bc31b16dfe99d6b6106b9a36e6ff2d08..0000000000000000000000000000000000000000
--- a/spaces/innnky/soft-vits-vc/app.py
+++ /dev/null
@@ -1,81 +0,0 @@
-import gradio as gr
-import os
-os.system('cd monotonic_align && python setup.py build_ext --inplace && cd ..')
-
-import logging
-
-numba_logger = logging.getLogger('numba')
-numba_logger.setLevel(logging.WARNING)
-
-import librosa
-import torch
-
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import text_to_sequence
-
-
-def get_text(text, hps):
- text_norm = text_to_sequence(text, hps.data.text_cleaners)
- if hps.data.add_blank:
- text_norm = commons.intersperse(text_norm, 0)
- text_norm = torch.LongTensor(text_norm)
- print(text_norm.shape)
- return text_norm
-
-
-hps = utils.get_hparams_from_file("configs/ljs_base.json")
-
-net_g = SynthesizerTrn(
- len(symbols),
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- **hps.model)
-import numpy as np
-
-hubert = torch.hub.load("bshall/hubert:main", "hubert_soft")
-
-_ = utils.load_checkpoint("G_88000.pth", net_g, None)
-
-def vc_fn(input_audio):
- if input_audio is None:
- return "You need to upload an audio", None
- sampling_rate, audio = input_audio
- # print(audio.shape,sampling_rate)
- duration = audio.shape[0] / sampling_rate
- if duration > 30:
- return "Error: Audio is too long", None
- audio = (audio / np.iinfo(audio.dtype).max).astype(np.float32)
- if len(audio.shape) > 1:
- audio = librosa.to_mono(audio.transpose(1, 0))
- if sampling_rate != 16000:
- audio = librosa.resample(audio, orig_sr=sampling_rate, target_sr=16000)
- source = torch.FloatTensor(audio).unsqueeze(0).unsqueeze(0)
- print(source.shape)
- with torch.inference_mode():
- units = hubert.units(source)
-
- stn_tst = torch.FloatTensor(units.squeeze(0))
- with torch.no_grad():
- x_tst = stn_tst.unsqueeze(0)
- x_tst_lengths = torch.LongTensor([stn_tst.size(0)])
- audio = net_g.infer(x_tst, x_tst_lengths, noise_scale=0.1, noise_scale_w=0.1, length_scale=1)[0][
- 0, 0].data.float().numpy()
-
- return "Success", (hps.data.sampling_rate, audio)
-
-
-
-app = gr.Blocks()
-with app:
- with gr.Tabs():
- with gr.TabItem("Basic"):
- vc_input3 = gr.Audio(label="Input Audio (30s limitation)")
- vc_submit = gr.Button("Convert", variant="primary")
- vc_output1 = gr.Textbox(label="Output Message")
- vc_output2 = gr.Audio(label="Output Audio")
- vc_submit.click(vc_fn, [ vc_input3], [vc_output1, vc_output2])
-
- app.launch()
\ No newline at end of file
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/2 Stroke Wizard Tuned Pipe Pro V4rar.md b/spaces/inplisQlawa/anything-midjourney-v4-1/2 Stroke Wizard Tuned Pipe Pro V4rar.md
deleted file mode 100644
index 499a6ace20f62918967f12eccb3acd9130a6e56d..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/2 Stroke Wizard Tuned Pipe Pro V4rar.md
+++ /dev/null
@@ -1,7 +0,0 @@
-
-Komaki Explore 01 1119P0818 1.3.3.0.9868 Full Version Price Free Downloads 35653 Novell Linux Advanced Server SP3 31 Logitracev12crackgratuitmega more.... Download 2 Stroke Wizard Tuned Pipe Pro V4rar download windows 10 - myhacker
-2 Stroke Wizard Tuned Pipe Pro V4rar Download File ✸✸✸ https://urlin.us/2uEweD
Wav2MP3 Wizard 7.0.0 is compatible with Windows operating systems, such as Windows 10, 8, 7 and Vista, and is available for download in English, French, German and Spanish, the latter being the version used for this review.
-If you are interested in these topics, make sure to visit the web page at programmablepdf.com , the leading platform for online financial trading. Read the 1 rar The recordingist is the person responsible for the recording of all the instruments used on the current recording. 2 Stroke Wizard Tuned Pipe Pro V4rar are hard at work getting the first version of the Solar Kingdom simulator ready for release. Its probably a good time to stop by our launch page and stay tuned for an announcement regarding the release date, although as you can tell weve already spilled the beans. In the meantime, feel free to drop us a line with any questions you have and we will do our best to answer them. List of all the files you need to save to be able to get back the available content. Some of these websites may ask you to create an account and login but it is entirely optional and to obtain the best results it is recommended to leave your email to the website and allow us to inform you when you have mail from the end product, as you need to complete the registration process. These websites are then able to communicate with the servers of the final content, as the user is identified by a unique code.
899543212bATIVADOR WINDOWS 10 KMS 2019 Serial Key DOWNLOAD »»» https://urlin.us/2uExih
diff --git a/spaces/inplisQlawa/anything-midjourney-v4-1/Activar Autocad 2013 Sin Keygen Crack [PATCHED].md b/spaces/inplisQlawa/anything-midjourney-v4-1/Activar Autocad 2013 Sin Keygen Crack [PATCHED].md
deleted file mode 100644
index 50c389fe9cbf3273c4deed6bd7fd65bb68a9c641..0000000000000000000000000000000000000000
--- a/spaces/inplisQlawa/anything-midjourney-v4-1/Activar Autocad 2013 Sin Keygen Crack [PATCHED].md
+++ /dev/null
@@ -1,105 +0,0 @@
-
-Activar Autocad 2013 Sin Keygen Crack: Todo lo que necesitas saber
-
-Autocad 2013 es un software de diseño y dibujo en 2D y 3D que te permite crear proyectos de arquitectura, ingeniería, mecánica, eléctrica y más. Es uno de los programas de CAD más populares y usados del mundo, tanto por profesionales como por aficionados. Sin embargo, para poder usar Autocad 2013 necesitas activarlo con una clave de producto y un número de serie válidos, que normalmente te proporciona Autodesk cuando compras el software. Pero ¿qué pasa si no tienes una clave de producto o un número de serie? ¿Qué pasa si los perdiste o te los robaron? ¿Qué pasa si quieres usar Autocad 2013 en más de un ordenador? En ese caso, podrías estar tentado a usar un keygen crack, que es un programa que genera claves de producto y números de serie falsos para Autocad 2013. Sin embargo, esto no es una buena idea, porque usar un keygen crack puede tener graves consecuencias para tu ordenador y tus datos.
-
-En este artículo te vamos a contar cómo activar Autocad 2013 sin keygen crack con el X-Force KeyGenerator, que es una herramienta legítima que genera claves de producto y números de serie genuinos para Autocad 2013. El X-Force KeyGenerator es creado por X-Force Team, que es un grupo de hackers que apoyan los productos de Autodesk y proporcionan soluciones de activación para ellos. El X-Force KeyGenerator es fácil de usar y funciona tanto para las versiones de 32 bits como de 64 bits de Autocad 2013. Puedes descargarlo desde varias fuentes en internet, como Davi24 , SoundCloud , CivilMDC , o Google Drive . Sin embargo, siempre debes escanear los archivos descargados con tu software antivirus antes de usarlos, ya que algunos de ellos pueden contener falsos positivos o riesgos.
-Activar Autocad 2013 Sin Keygen Crack DOWNLOAD ✯✯✯ https://urlin.us/2uEwpo
¿Qué es el X-Force KeyGenerator?
-
-El X-Force KeyGenerator es un programa que genera claves de producto y números de serie genuinos para Autocad 2013 y otros productos de Autodesk. Estas claves y números son necesarios para activar el software y poder usarlo sin restricciones ni limitaciones. El X-Force KeyGenerator es creado por X-Force Team, que es un grupo de hackers que apoyan los productos de Autodesk y proporcionan soluciones de activación para ellos. El X-Force KeyGenerator no es un keygen crack, sino una herramienta legítima que respeta los términos de servicio y el acuerdo de licencia de Autodesk.
-
-El X-Force KeyGenerator funciona tanto para las versiones de 32 bits como de 64 bits de Autocad 2013. También funciona para otros productos de Autodesk, como Revit, Maya, Inventor, 3ds Max y más. El X-Force KeyGenerator es fácil de descargar y usar, y solo requiere unos pocos pasos para activar Autocad 2013 sin keygen crack.
-
-¿Cómo descargar el X-Force KeyGenerator?
-
-Para descargar el X-Force KeyGenerator para activar Autocad 2013 sin keygen crack, solo tienes que seguir estos pasos:
-
-
-Elige una fuente de descarga confiable y segura, como las que te hemos mencionado anteriormente.
-Haz clic en el enlace de descarga directa del X-Force KeyGenerator para la versión de 32 bits o 64 bits de Autocad 2013, según la que tengas instalada en tu ordenador.
-Espera a que se complete la descarga del archivo .rar o .zip del X-Force KeyGenerator.
-Descomprime el archivo .rar o .zip con un programa como WinRAR o 7-Zip.
-Obtendrás una carpeta con el archivo ejecutable del X-Force KeyGenerator y un archivo de texto con las instrucciones de uso.
-
-
-¿Cómo usar el X-Force KeyGenerator?
-
-Para usar el X-Force KeyGenerator para activar Autocad 2013 sin keygen crack, solo tienes que seguir estos pasos:
-
-
-Instala Autocad 2013 en tu ordenador si aún no lo has hecho.
-Ejecuta el archivo del X-Force KeyGenerator como administrador.
-Selecciona "Autocad 2013" de la lista de productos.
-Haz clic en "Generate" para obtener una clave de producto y un número de serie para Autocad 2013.
-Ejecuta Autocad 2013 y sigue las instrucciones para activarlo.
-Copia el código que aparece en el campo "Request code" en Autocad 2013 y pégalo en el campo "Request" del X-Force KeyGenerator.
-Haz clic en "Patch" y luego en "OK" en el X-Force KeyGenerator.
-Copia el código que aparece en el campo "Activation" del X-Force KeyGenerator y pégalo en el campo "Enter your activation code here" en Autocad 2013.
-Haz clic en "Next" y luego en "Finish" en Autocad 2013.
-¡Listo! Ya has activado Autocad 2013 sin keygen crack con el X-Force KeyGenerator.
-
-
-¿Cuáles son los beneficios de usar el X-Force KeyGenerator?
-
-Usar el X-Force KeyGenerator para activar Autocad 2013 sin keygen crack tiene varios beneficios:
-
-
-Es legal y ético. No estás violando los términos de servicio ni el acuerdo
-¿Cuáles son los beneficios de usar el X-Force KeyGenerator?
-
-Usar el X-Force KeyGenerator para activar Autocad 2013 sin keygen crack tiene varios beneficios:
-
-
-
-Es legal y ético. No estás violando los términos de servicio ni el acuerdo de licencia de Autodesk. Tampoco estás privando a Autodesk de sus ingresos legítimos.
-Es seguro y confiable. No estás descargando ni ejecutando programas maliciosos que puedan infectar tu ordenador o robar tus datos. Tampoco estás interfiriendo con el correcto funcionamiento del software.
-Es fácil y rápido. No tienes que buscar ni introducir claves o números falsos que puedan no funcionar o ser detectados. Tampoco tienes que esperar ni pagar por una activación online o telefónica.
-Es efectivo y permanente. No tienes que repetir el proceso cada vez que actualices o reinstales el software. Tampoco tienes que preocuparte por posibles bloqueos o desactivaciones.
-
-
-¿Qué debes tener en cuenta al usar el X-Force KeyGenerator?
-
-Aunque usar el X-Force KeyGenerator para activar Autocad 2013 sin keygen crack es una opción viable y segura, hay algunas cosas que debes tener en cuenta al usarlo:
-
-
-No uses el X-Force KeyGenerator para activar otros productos de Autodesk que no sean Autocad 2013. Cada producto tiene su propio X-Force KeyGenerator específico, que puedes encontrar en internet.
-No compartas ni distribuyas el X-Force KeyGenerator ni las claves o números que generes con él. Esto puede ser considerado como piratería y puede traerte problemas legales.
-No uses el X-Force KeyGenerator en ordenadores públicos o compartidos. Esto puede comprometer tu seguridad y la de tus datos.
-No uses el X-Force KeyGenerator si tienes una clave de producto o un número de serie válidos para Autocad 2013. Esto puede causar conflictos o incompatibilidades con el software.
-
-
-Conclusión
-
-Activar Autocad 2013 sin keygen crack es posible con el X-Force KeyGenerator, una herramienta legítima que genera claves de producto y números de serie genuinos para este software. El X-Force KeyGenerator es creado por X-Force Team, un grupo de hackers que apoyan los productos de Autodesk. El X-Force KeyGenerator es fácil de descargar y usar, y funciona tanto para las versiones de 32 bits como de 64 bits de Autocad 2013.
-
-Esperamos que este artículo te haya sido útil e interesante. Si quieres saber más sobre Activar Autocad 2013 sin keygen crack o sobre otros productos de Autodesk puedes visitar nuestro blog Blomiky donde encontrarás toda la información que necesitas. También puedes dejarnos tus comentarios o preguntas al final de este artículo. Estaremos encantados de responderte.
-Si te ha gustado este artículo y quieres aprender más sobre Autocad 2013 y otros productos de Autodesk, te invitamos a que te suscribas a nuestro boletín de noticias. Así podrás recibir en tu correo electrónico las últimas novedades, consejos, tutoriales y ofertas exclusivas de Blomiky. Solo tienes que introducir tu nombre y tu dirección de email en el formulario que encontrarás a continuación y hacer clic en el botón de suscribirse. Es gratis y puedes cancelar tu suscripción en cualquier momento.
-
-No esperes más y únete a nuestra comunidad de usuarios de Autocad 2013 y otros productos de Autodesk. Te aseguramos que no te arrepentirás.
-
-
-Si te ha gustado este artículo y quieres aprender más sobre Autocad 2013 y otros productos de Autodesk, te invitamos a que nos sigas en nuestras redes sociales. Así podrás estar al día de las últimas noticias, novedades, consejos, tutoriales y ofertas exclusivas de Blomiky. También podrás interactuar con otros usuarios de Autocad 2013 y otros productos de Autodesk, compartir tus experiencias, dudas y sugerencias. Solo tienes que hacer clic en los iconos que encontrarás a continuación y seguirnos en Facebook, Twitter, Instagram o YouTube. Es gratis y puedes dejar de seguirnos en cualquier momento.
-
-No esperes más y únete a nuestra comunidad de usuarios de Autocad 2013 y otros productos de Autodesk. Te esperamos con los brazos abiertos.
-
-En resumen, activar Autocad 2013 sin keygen crack es posible con el X-Force KeyGenerator, una herramienta legítima que genera claves de producto y números de serie genuinos para este software. El X-Force KeyGenerator es creado por X-Force Team, un grupo de hackers que apoyan los productos de Autodesk. El X-Force KeyGenerator es fácil de descargar y usar, y funciona tanto para las versiones de 32 bits como de 64 bits de Autocad 2013.
-
-Usar el X-Force KeyGenerator tiene varios beneficios, como ser legal, ético, seguro, confiable, fácil, rápido, efectivo y permanente. Sin embargo, también hay algunas cosas que debes tener en cuenta al usarlo, como no usarlo para otros productos de Autodesk, no compartirlo ni distribuirlo, no usarlo en ordenadores públicos o compartidos y no usarlo si tienes una clave o número válidos.
-
-Esperamos que este artículo te haya sido útil e interesante. Si quieres saber más sobre Activar Autocad 2013 sin keygen crack o sobre otros productos de Autodesk puedes visitar nuestro blog Blomiky donde encontrarás toda la información que necesitas. También puedes suscribirte a nuestro boletín de noticias o seguirnos en nuestras redes sociales para estar al día de las últimas novedades, consejos, tutoriales y ofertas exclusivas de Blomiky. También puedes dejarnos tus comentarios o preguntas al final de este artículo. Estaremos encantados de responderte.
-
-Gracias por leer y hasta la próxima.
3cee63e6c2amada ap100 software crack 28 DOWNLOAD … https://tiurll.com/2uCkkU
diff --git a/spaces/irfank/katanaml-donut-demo-3/app.py b/spaces/irfank/katanaml-donut-demo-3/app.py
deleted file mode 100644
index 592e464d62c966a60f048b12621ccd06749efd65..0000000000000000000000000000000000000000
--- a/spaces/irfank/katanaml-donut-demo-3/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/katanaml/donut-demo").launch()
\ No newline at end of file
diff --git a/spaces/ivuxy/Eval/README.md b/spaces/ivuxy/Eval/README.md
deleted file mode 100644
index deddd5d51e519164716f304240476a0395742600..0000000000000000000000000000000000000000
--- a/spaces/ivuxy/Eval/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Eval
-emoji: 💻
-colorFrom: purple
-colorTo: purple
-sdk: gradio
-sdk_version: 3.47.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/jaleesahmed/correlation-and-visualization/README.md b/spaces/jaleesahmed/correlation-and-visualization/README.md
deleted file mode 100644
index bef1a5ef2c706c27f817e25a27a1c9cd64224fa1..0000000000000000000000000000000000000000
--- a/spaces/jaleesahmed/correlation-and-visualization/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Correlation And Visualization
-emoji: 📉
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.1.3
-app_file: app.py
-pinned: false
-license: lgpl-3.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/jason9693/KoreanHateSpeechClassifier/attention.py b/spaces/jason9693/KoreanHateSpeechClassifier/attention.py
deleted file mode 100644
index 502a74d5e398fafab7f06183cf9837e480eb7891..0000000000000000000000000000000000000000
--- a/spaces/jason9693/KoreanHateSpeechClassifier/attention.py
+++ /dev/null
@@ -1,97 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, AutoConfig
-import gradio as gr
-from torch.nn import functional as F
-import seaborn
-
-import matplotlib
-import platform
-
-if platform.system() == "Darwin":
- print("MacOS")
- matplotlib.use('Agg')
-import matplotlib.pyplot as plt
-import io
-from PIL import Image
-
-import matplotlib.font_manager as fm
-
-
-
-
-import util
-
-font_path = r'NanumGothicCoding.ttf'
-fontprop = fm.FontProperties(fname=font_path, size=18)
-
-plt.rcParams["font.family"] = 'NanumGothic'
-
-
-def visualize_attention(sent, attention_matrix, n_words=10):
- def draw(data, x, y, ax):
- seaborn.heatmap(data,
- xticklabels=x, square=True, yticklabels=y, vmin=0.0, vmax=1.0,
- cbar=False, ax=ax)
-
- # make plt figure with 1x6 subplots
- fig = plt.figure(figsize=(16, 8))
- # fig.subplots_adjust(hspace=0.7, wspace=0.2)
- for i, layer in enumerate(range(1, 12, 2)):
- ax = fig.add_subplot(2, 3, i+1)
- ax.set_title("Layer {}".format(layer))
- draw(attention_matrix[layer], sent if layer > 6 else [], sent if layer in [1,7] else [], ax=ax)
-
- fig.tight_layout()
- plt.close()
-
- return fig
-
-
-
-def predict(model_name, text):
-
- tokenizer = AutoTokenizer.from_pretrained(model_name)
- model = AutoModelForSequenceClassification.from_pretrained(model_name)
- config = AutoConfig.from_pretrained(model_name)
- print(config.id2label)
-
- tokenized_text = tokenizer([text], return_tensors='pt')
-
- input_tokens = tokenizer.convert_ids_to_tokens(tokenized_text.input_ids[0])
- print(input_tokens)
- input_tokens = util.bytetokens_to_unicdode(input_tokens) if config.model_type in ['roberta', 'gpt', 'gpt2'] else input_tokens
-
- model.eval()
- output, attention = model(**tokenized_text, output_attentions=True, return_dict=False)
- output = F.softmax(output, dim=-1)
- result = {}
-
- for idx, label in enumerate(output[0].detach().numpy()):
- result[config.id2label[idx]] = float(label)
-
- fig = visualize_attention(input_tokens, attention[0][0].detach().numpy())
- return result, fig#.logits.detach()#.numpy()#, output.attentions.detach().numpy()
-
-
-if __name__ == '__main__':
-
- model_name = 'jason9693/SoongsilBERT-beep-base'
- text = '읿딴걸 홍볿글 읿랉곭 쌑젩낄고 앉앟있냩'
- # output = predict(model_name, text)
-
- # print(output)
-
- model_name_list = [
- 'jason9693/SoongsilBERT-beep-base'
- ]
-
- #Create a gradio app with a button that calls predict()
- app = gr.Interface(
- fn=predict,
- server_port=26899,
- server_name='0.0.0.0',
- inputs=[gr.inputs.Dropdown(model_name_list, label="Model Name"), 'text'], outputs=['label', 'plot'],
- examples = [[model_name, text]],
- title="한국어 혐오성 발화 분류기 (Korean Hate Speech Classifier)",
- description="Korean Hate Speech Classifier with Several Pretrained LM\nCurrent Supported Model:\n1. SoongsilBERT"
- )
- app.launch(inline=False)
diff --git a/spaces/jbilcke-hf/AnimateDiff/download_bashscripts/8-GhibliBackground.sh b/spaces/jbilcke-hf/AnimateDiff/download_bashscripts/8-GhibliBackground.sh
deleted file mode 100644
index 39b9e76ddf77a842e4f41acbee9e73f62c49eec0..0000000000000000000000000000000000000000
--- a/spaces/jbilcke-hf/AnimateDiff/download_bashscripts/8-GhibliBackground.sh
+++ /dev/null
@@ -1,3 +0,0 @@
-#!/bin/bash
-wget https://civitai.com/api/download/models/102828 -P models/DreamBooth_LoRA/ --content-disposition --no-check-certificate
-wget https://civitai.com/api/download/models/57618 -P models/DreamBooth_LoRA/ --content-disposition --no-check-certificate
diff --git a/spaces/jeycov/IADERM-UTOPIC-PFIZER/app.py b/spaces/jeycov/IADERM-UTOPIC-PFIZER/app.py
deleted file mode 100644
index c0611b461a8a5d09bc2c0937bf3328023b69dd8f..0000000000000000000000000000000000000000
--- a/spaces/jeycov/IADERM-UTOPIC-PFIZER/app.py
+++ /dev/null
@@ -1,89 +0,0 @@
-import gradio as gr
-import tensorflow as tf
-
-path_to_model = "./modelo_jeysshon_iaderm.h5"
-
-model = tf.keras.models.load_model(path_to_model)
-
-labels = [
- 'Acné / Rosácea', 'Queratosis Actínica / Carcinoma Basocelular',
- 'Dermatitis Atópica', 'Enfermedad Bullosa',
- 'Celulitis Impétigo (Infecciones Bacterianas)',
- 'Eczema', 'Exanthems (Erupciones Cutáneas por Medicamentos)', 'Pérdida de Cabello (Alopecia)',
- 'Herpes HPV', 'Trastornos de Pigmentación',
- 'Lupus',
- 'Melanoma (Cáncer de Piel)', 'Hongos en las Uñas',
- 'Hiedra Venenosa',
- 'Psoriasis (Lichen Planus)', 'Sarna Lyme',
- 'Queratosis Seborreica', 'Enfermedad Sistémica',
- 'Tinea Ringworm (Infecciones Fúngicas)',
- 'Urticaria Ronchas', 'Tumores Vasculares', 'Vasculitis', 'Verrugas Molusco'
-]
-
-def classify_image(photos):
- photos = photos.reshape((-1, 224, 224, 3))
- prediction = model.predict(photos).flatten()
- confidences = {labels[i]: float(prediction[i]) for i in range(23)}
- return confidences
-
-title = "AI-DERM DETECTION "
-
-article = (
- "Se propone un sistema automatizado para el diagnóstico de las 23 enfermedades comunes de la piel:\n\n"
- "1. Acné / Rosácea\n"
- "2. Queratosis Actínica / Carcinoma Basocelular\n"
- "3. Dermatitis Atópica\n"
- "4. Enfermedades Bullosas\n"
- "5. Celulitis / Impétigo (Infecciones Bacterianas)\n"
- "6. Eccema\n"
- "7. Exantemas (Erupciones Cutáneas por Medicamentos)\n"
- "8. (areata)\n"
- "9. Herpes / VPH\n"
- "10. Trastornos de la Pigmentación\n"
- "11. Lupus\n"
- "12. Melanoma (Cáncer de Piel)\n"
- "13. Hongos en las Uñas\n"
- "14. Hiedra Venenosa\n"
- "15. Psoriasis (liquen plano)\n"
- "16. Sarna / Enfermedad de Lyme\n"
- "17. Queratosis Seborreica\n"
- "18. Enfermedad Sistémica\n"
- "19. Tiña / Tiña (Infecciones Fúngicas)\n"
- "20. Urticaria / Ronchas\n"
- "21. Tumores Vasculares\n"
- "22. Vasculitis\n"
- "23. Verrugas / Molusco\n\n"
- "Este sistema automatizado se basa en un modelo preentrenado EfficientNetB7, capaz de diagnosticar 23 enfermedades cutáneas comunes. La interfaz te permite cargar una imagen y obtener las probabilidades de cada enfermedad detectada."
- ""
- "AI-DERM . Jeysshon Bustos . 2023. "
- "
"
-)
-
-description= (
-
- "Utilizamos la interfaz de usuario generada por Gradio para ingresar imágenes a nuestra red neuronal convolucional, la cual ha sido entrenada con el propósito de realizar clasificaciones de imágenes. Esta red neuronal demostró su capacidad al lograr una precisa categorización de la imagen proporcionada. En ocasiones, resulta beneficioso ajustar el tamaño de la imagen mediante la interfaz de Gradio para potenciar aún más su rendimiento."
-)
-
-examples = [
- ['./123.jpg'],
- ['./acne-closed-comedo-2.jpg'],
- ['./distal-subungual-onychomycosis-86.jpeg'],
- ['./cherry-angioma-16.jpg'],
- ['./malignant-melanoma-16.jpg'],
- ['./tinea-primary-lesion-15.jpeg'],
- ['./congenital-nevus-35.jpg'],
- ['./tinea-body-137.jpg'],
- ['./atopic-13.jpg'],
- ['./atopic-7.jpg']
-]
-
-gr.Interface(
- fn=classify_image,
- title=title,
- article=article,
- description=description,
- inputs=gr.inputs.Image(shape=(224, 224)),
- outputs=gr.outputs.Label(num_top_classes=4),
- examples=examples
-).launch()
-
diff --git a/spaces/jharrison27/VR-DEMO/README.md b/spaces/jharrison27/VR-DEMO/README.md
deleted file mode 100644
index a66d2e5b4e82f0bd5dea724bc2e52bf6d50b52a1..0000000000000000000000000000000000000000
--- a/spaces/jharrison27/VR-DEMO/README.md
+++ /dev/null
@@ -1,10 +0,0 @@
----
-title: VR DEMO
-emoji: 🚀
-colorFrom: purple
-colorTo: indigo
-sdk: static
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/jhwen/bingo/src/components/markdown.tsx b/spaces/jhwen/bingo/src/components/markdown.tsx
deleted file mode 100644
index d4491467a1f14d1d72e535caac9c40636054e5df..0000000000000000000000000000000000000000
--- a/spaces/jhwen/bingo/src/components/markdown.tsx
+++ /dev/null
@@ -1,9 +0,0 @@
-import { FC, memo } from 'react'
-import ReactMarkdown, { Options } from 'react-markdown'
-
-export const MemoizedReactMarkdown: FC = memo(
- ReactMarkdown,
- (prevProps, nextProps) =>
- prevProps.children === nextProps.children &&
- prevProps.className === nextProps.className
-)
diff --git a/spaces/jinhybr/OCR-Invoice-LayoutLMv3/app.py b/spaces/jinhybr/OCR-Invoice-LayoutLMv3/app.py
deleted file mode 100644
index 5615916416d367c54bff82ae6880ed26f107ad97..0000000000000000000000000000000000000000
--- a/spaces/jinhybr/OCR-Invoice-LayoutLMv3/app.py
+++ /dev/null
@@ -1,146 +0,0 @@
-import os
-
-os.system('pip install pip --upgrade')
-os.system('pip install -q git+https://github.com/huggingface/transformers.git')
-
-
-os.system("pip install pyyaml==5.1")
-# workaround: install old version of pytorch since detectron2 hasn't released packages for pytorch 1.9 (issue: https://github.com/facebookresearch/detectron2/issues/3158)
-os.system(
- "pip install torch==1.8.0+cu101 torchvision==0.9.0+cu101 -f https://download.pytorch.org/whl/torch_stable.html"
-)
-
-# install detectron2 that matches pytorch 1.8
-# See https://detectron2.readthedocs.io/tutorials/install.html for instructions
-os.system(
- "pip install -q detectron2 -f https://dl.fbaipublicfiles.com/detectron2/wheels/cu101/torch1.8/index.html"
-)
-
-## install PyTesseract
-os.system("pip install -q pytesseract")
-
-import gradio as gr
-import numpy as np
-from transformers import AutoModelForTokenClassification
-from datasets.features import ClassLabel
-from transformers import AutoProcessor
-from datasets import Features, Sequence, ClassLabel, Value, Array2D, Array3D
-import torch
-from datasets import load_metric
-from transformers import LayoutLMv3ForTokenClassification
-from transformers.data.data_collator import default_data_collator
-
-
-from transformers import AutoModelForTokenClassification
-from datasets import load_dataset
-from PIL import Image, ImageDraw, ImageFont
-
-
-processor = AutoProcessor.from_pretrained("jinhybr/OCR-LayoutLMv3-Invoice", apply_ocr=True)
-model = AutoModelForTokenClassification.from_pretrained("jinhybr/OCR-LayoutLMv3-Invoice")
-
-
-
-# load image example
-dataset = load_dataset("jinhybr/WildReceipt", split="test")
-Image.open(dataset[1]["image_path"]).convert("RGB").save("example1.png")
-Image.open(dataset[3]["image_path"]).convert("RGB").save("example2.png")
-Image.open(dataset[25]["image_path"]).convert("RGB").save("example3.png")
-# define id2label, label2color
-labels = dataset.features['ner_tags'].feature.names
-id2label = {v: k for v, k in enumerate(labels)}
-label2color = {
- "Date_key": 'red',
- "Date_value": 'green',
- "Ignore": 'orange',
- "Others": 'orange',
- "Prod_item_key": 'red',
- "Prod_item_value": 'green',
- "Prod_price_key": 'red',
- "Prod_price_value": 'green',
- "Prod_quantity_key": 'red',
- "Prod_quantity_value": 'green',
- "Store_addr_key": 'red',
- "Store_addr_value": 'green',
- "Store_name_key": 'red',
- "Store_name_value": 'green',
- "Subtotal_key": 'red',
- "Subtotal_value": 'green',
- "Tax_key": 'red',
- "Tax_value": 'green',
- "Tel_key": 'red',
- "Tel_value": 'green',
- "Time_key": 'red',
- "Time_value": 'green',
- "Tips_key": 'red',
- "Tips_value": 'green',
- "Total_key": 'red',
- "Total_value": 'blue'
- }
-
-def unnormalize_box(bbox, width, height):
- return [
- width * (bbox[0] / 1000),
- height * (bbox[1] / 1000),
- width * (bbox[2] / 1000),
- height * (bbox[3] / 1000),
- ]
-
-
-def iob_to_label(label):
- return label
-
-
-
-def process_image(image):
-
- print(type(image))
- width, height = image.size
-
- # encode
- encoding = processor(image, truncation=True, return_offsets_mapping=True, return_tensors="pt")
- offset_mapping = encoding.pop('offset_mapping')
-
- # forward pass
- outputs = model(**encoding)
-
- # get predictions
- predictions = outputs.logits.argmax(-1).squeeze().tolist()
- token_boxes = encoding.bbox.squeeze().tolist()
-
- # only keep non-subword predictions
- is_subword = np.array(offset_mapping.squeeze().tolist())[:,0] != 0
- true_predictions = [id2label[pred] for idx, pred in enumerate(predictions) if not is_subword[idx]]
- true_boxes = [unnormalize_box(box, width, height) for idx, box in enumerate(token_boxes) if not is_subword[idx]]
-
- # draw predictions over the image
- draw = ImageDraw.Draw(image)
- font = ImageFont.load_default()
- for prediction, box in zip(true_predictions, true_boxes):
- predicted_label = iob_to_label(prediction)
- draw.rectangle(box, outline=label2color[predicted_label])
- draw.text((box[0]+10, box[1]-10), text=predicted_label, fill=label2color[predicted_label], font=font)
-
- return image
-
-
-title = "OCR Invoice - Information Extraction - LayoutLMv3"
-description = "Fine-tuned Microsoft's LayoutLMv3 on WildReceipt Dataset to parse Invoice OCR document. To use it, simply upload an image or use the example image below. Results will show up in a few seconds."
-
-article="References Paper Link LayoutLMv3 training and inference Paper Link "
-
-examples =[['example1.png'],['example2.png'],['example3.png'],['inv2.jpg']]
-
-css = """.output_image, .input_image {height: 600px !important}"""
-
-iface = gr.Interface(fn=process_image,
- inputs=gr.inputs.Image(type="pil"),
- outputs=gr.outputs.Image(type="pil", label="annotated image"),
- title=title,
- description=description,
- article=article,
- examples=examples,
- css=css,
- analytics_enabled = True, enable_queue=True)
-
-iface.launch(inline=False, share=False, debug=True)
\ No newline at end of file
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageQt.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageQt.py
deleted file mode 100644
index 9b7245454dfcccb4e822a6634168d405c0e791bb..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/PIL/ImageQt.py
+++ /dev/null
@@ -1,216 +0,0 @@
-#
-# The Python Imaging Library.
-# $Id$
-#
-# a simple Qt image interface.
-#
-# history:
-# 2006-06-03 fl: created
-# 2006-06-04 fl: inherit from QImage instead of wrapping it
-# 2006-06-05 fl: removed toimage helper; move string support to ImageQt
-# 2013-11-13 fl: add support for Qt5 (aurelien.ballier@cyclonit.com)
-#
-# Copyright (c) 2006 by Secret Labs AB
-# Copyright (c) 2006 by Fredrik Lundh
-#
-# See the README file for information on usage and redistribution.
-#
-
-import sys
-from io import BytesIO
-
-from . import Image
-from ._util import is_path
-
-qt_versions = [
- ["6", "PyQt6"],
- ["side6", "PySide6"],
-]
-
-# If a version has already been imported, attempt it first
-qt_versions.sort(key=lambda qt_version: qt_version[1] in sys.modules, reverse=True)
-for qt_version, qt_module in qt_versions:
- try:
- if qt_module == "PyQt6":
- from PyQt6.QtCore import QBuffer, QIODevice
- from PyQt6.QtGui import QImage, QPixmap, qRgba
- elif qt_module == "PySide6":
- from PySide6.QtCore import QBuffer, QIODevice
- from PySide6.QtGui import QImage, QPixmap, qRgba
- except (ImportError, RuntimeError):
- continue
- qt_is_installed = True
- break
-else:
- qt_is_installed = False
- qt_version = None
-
-
-def rgb(r, g, b, a=255):
- """(Internal) Turns an RGB color into a Qt compatible color integer."""
- # use qRgb to pack the colors, and then turn the resulting long
- # into a negative integer with the same bitpattern.
- return qRgba(r, g, b, a) & 0xFFFFFFFF
-
-
-def fromqimage(im):
- """
- :param im: QImage or PIL ImageQt object
- """
- buffer = QBuffer()
- if qt_version == "6":
- try:
- qt_openmode = QIODevice.OpenModeFlag
- except AttributeError:
- qt_openmode = QIODevice.OpenMode
- else:
- qt_openmode = QIODevice
- buffer.open(qt_openmode.ReadWrite)
- # preserve alpha channel with png
- # otherwise ppm is more friendly with Image.open
- if im.hasAlphaChannel():
- im.save(buffer, "png")
- else:
- im.save(buffer, "ppm")
-
- b = BytesIO()
- b.write(buffer.data())
- buffer.close()
- b.seek(0)
-
- return Image.open(b)
-
-
-def fromqpixmap(im):
- return fromqimage(im)
- # buffer = QBuffer()
- # buffer.open(QIODevice.ReadWrite)
- # # im.save(buffer)
- # # What if png doesn't support some image features like animation?
- # im.save(buffer, 'ppm')
- # bytes_io = BytesIO()
- # bytes_io.write(buffer.data())
- # buffer.close()
- # bytes_io.seek(0)
- # return Image.open(bytes_io)
-
-
-def align8to32(bytes, width, mode):
- """
- converts each scanline of data from 8 bit to 32 bit aligned
- """
-
- bits_per_pixel = {"1": 1, "L": 8, "P": 8, "I;16": 16}[mode]
-
- # calculate bytes per line and the extra padding if needed
- bits_per_line = bits_per_pixel * width
- full_bytes_per_line, remaining_bits_per_line = divmod(bits_per_line, 8)
- bytes_per_line = full_bytes_per_line + (1 if remaining_bits_per_line else 0)
-
- extra_padding = -bytes_per_line % 4
-
- # already 32 bit aligned by luck
- if not extra_padding:
- return bytes
-
- new_data = []
- for i in range(len(bytes) // bytes_per_line):
- new_data.append(
- bytes[i * bytes_per_line : (i + 1) * bytes_per_line]
- + b"\x00" * extra_padding
- )
-
- return b"".join(new_data)
-
-
-def _toqclass_helper(im):
- data = None
- colortable = None
- exclusive_fp = False
-
- # handle filename, if given instead of image name
- if hasattr(im, "toUtf8"):
- # FIXME - is this really the best way to do this?
- im = str(im.toUtf8(), "utf-8")
- if is_path(im):
- im = Image.open(im)
- exclusive_fp = True
-
- qt_format = QImage.Format if qt_version == "6" else QImage
- if im.mode == "1":
- format = qt_format.Format_Mono
- elif im.mode == "L":
- format = qt_format.Format_Indexed8
- colortable = []
- for i in range(256):
- colortable.append(rgb(i, i, i))
- elif im.mode == "P":
- format = qt_format.Format_Indexed8
- colortable = []
- palette = im.getpalette()
- for i in range(0, len(palette), 3):
- colortable.append(rgb(*palette[i : i + 3]))
- elif im.mode == "RGB":
- # Populate the 4th channel with 255
- im = im.convert("RGBA")
-
- data = im.tobytes("raw", "BGRA")
- format = qt_format.Format_RGB32
- elif im.mode == "RGBA":
- data = im.tobytes("raw", "BGRA")
- format = qt_format.Format_ARGB32
- elif im.mode == "I;16" and hasattr(qt_format, "Format_Grayscale16"): # Qt 5.13+
- im = im.point(lambda i: i * 256)
-
- format = qt_format.Format_Grayscale16
- else:
- if exclusive_fp:
- im.close()
- msg = f"unsupported image mode {repr(im.mode)}"
- raise ValueError(msg)
-
- size = im.size
- __data = data or align8to32(im.tobytes(), size[0], im.mode)
- if exclusive_fp:
- im.close()
- return {"data": __data, "size": size, "format": format, "colortable": colortable}
-
-
-if qt_is_installed:
-
- class ImageQt(QImage):
- def __init__(self, im):
- """
- An PIL image wrapper for Qt. This is a subclass of PyQt's QImage
- class.
-
- :param im: A PIL Image object, or a file name (given either as
- Python string or a PyQt string object).
- """
- im_data = _toqclass_helper(im)
- # must keep a reference, or Qt will crash!
- # All QImage constructors that take data operate on an existing
- # buffer, so this buffer has to hang on for the life of the image.
- # Fixes https://github.com/python-pillow/Pillow/issues/1370
- self.__data = im_data["data"]
- super().__init__(
- self.__data,
- im_data["size"][0],
- im_data["size"][1],
- im_data["format"],
- )
- if im_data["colortable"]:
- self.setColorTable(im_data["colortable"])
-
-
-def toqimage(im):
- return ImageQt(im)
-
-
-def toqpixmap(im):
- # # This doesn't work. For now using a dumb approach.
- # im_data = _toqclass_helper(im)
- # result = QPixmap(im_data["size"][0], im_data["size"][1])
- # result.loadFromData(im_data["data"])
- qimage = toqimage(im)
- return QPixmap.fromImage(qimage)
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/aiohttp/web_exceptions.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/aiohttp/web_exceptions.py
deleted file mode 100644
index ae706a1806299a1f13f3a905b4582c52bda5450c..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/aiohttp/web_exceptions.py
+++ /dev/null
@@ -1,441 +0,0 @@
-import warnings
-from typing import Any, Dict, Iterable, List, Optional, Set # noqa
-
-from yarl import URL
-
-from .typedefs import LooseHeaders, StrOrURL
-from .web_response import Response
-
-__all__ = (
- "HTTPException",
- "HTTPError",
- "HTTPRedirection",
- "HTTPSuccessful",
- "HTTPOk",
- "HTTPCreated",
- "HTTPAccepted",
- "HTTPNonAuthoritativeInformation",
- "HTTPNoContent",
- "HTTPResetContent",
- "HTTPPartialContent",
- "HTTPMultipleChoices",
- "HTTPMovedPermanently",
- "HTTPFound",
- "HTTPSeeOther",
- "HTTPNotModified",
- "HTTPUseProxy",
- "HTTPTemporaryRedirect",
- "HTTPPermanentRedirect",
- "HTTPClientError",
- "HTTPBadRequest",
- "HTTPUnauthorized",
- "HTTPPaymentRequired",
- "HTTPForbidden",
- "HTTPNotFound",
- "HTTPMethodNotAllowed",
- "HTTPNotAcceptable",
- "HTTPProxyAuthenticationRequired",
- "HTTPRequestTimeout",
- "HTTPConflict",
- "HTTPGone",
- "HTTPLengthRequired",
- "HTTPPreconditionFailed",
- "HTTPRequestEntityTooLarge",
- "HTTPRequestURITooLong",
- "HTTPUnsupportedMediaType",
- "HTTPRequestRangeNotSatisfiable",
- "HTTPExpectationFailed",
- "HTTPMisdirectedRequest",
- "HTTPUnprocessableEntity",
- "HTTPFailedDependency",
- "HTTPUpgradeRequired",
- "HTTPPreconditionRequired",
- "HTTPTooManyRequests",
- "HTTPRequestHeaderFieldsTooLarge",
- "HTTPUnavailableForLegalReasons",
- "HTTPServerError",
- "HTTPInternalServerError",
- "HTTPNotImplemented",
- "HTTPBadGateway",
- "HTTPServiceUnavailable",
- "HTTPGatewayTimeout",
- "HTTPVersionNotSupported",
- "HTTPVariantAlsoNegotiates",
- "HTTPInsufficientStorage",
- "HTTPNotExtended",
- "HTTPNetworkAuthenticationRequired",
-)
-
-
-############################################################
-# HTTP Exceptions
-############################################################
-
-
-class HTTPException(Response, Exception):
-
- # You should set in subclasses:
- # status = 200
-
- status_code = -1
- empty_body = False
-
- __http_exception__ = True
-
- def __init__(
- self,
- *,
- headers: Optional[LooseHeaders] = None,
- reason: Optional[str] = None,
- body: Any = None,
- text: Optional[str] = None,
- content_type: Optional[str] = None,
- ) -> None:
- if body is not None:
- warnings.warn(
- "body argument is deprecated for http web exceptions",
- DeprecationWarning,
- )
- Response.__init__(
- self,
- status=self.status_code,
- headers=headers,
- reason=reason,
- body=body,
- text=text,
- content_type=content_type,
- )
- Exception.__init__(self, self.reason)
- if self.body is None and not self.empty_body:
- self.text = f"{self.status}: {self.reason}"
-
- def __bool__(self) -> bool:
- return True
-
-
-class HTTPError(HTTPException):
- """Base class for exceptions with status codes in the 400s and 500s."""
-
-
-class HTTPRedirection(HTTPException):
- """Base class for exceptions with status codes in the 300s."""
-
-
-class HTTPSuccessful(HTTPException):
- """Base class for exceptions with status codes in the 200s."""
-
-
-class HTTPOk(HTTPSuccessful):
- status_code = 200
-
-
-class HTTPCreated(HTTPSuccessful):
- status_code = 201
-
-
-class HTTPAccepted(HTTPSuccessful):
- status_code = 202
-
-
-class HTTPNonAuthoritativeInformation(HTTPSuccessful):
- status_code = 203
-
-
-class HTTPNoContent(HTTPSuccessful):
- status_code = 204
- empty_body = True
-
-
-class HTTPResetContent(HTTPSuccessful):
- status_code = 205
- empty_body = True
-
-
-class HTTPPartialContent(HTTPSuccessful):
- status_code = 206
-
-
-############################################################
-# 3xx redirection
-############################################################
-
-
-class _HTTPMove(HTTPRedirection):
- def __init__(
- self,
- location: StrOrURL,
- *,
- headers: Optional[LooseHeaders] = None,
- reason: Optional[str] = None,
- body: Any = None,
- text: Optional[str] = None,
- content_type: Optional[str] = None,
- ) -> None:
- if not location:
- raise ValueError("HTTP redirects need a location to redirect to.")
- super().__init__(
- headers=headers,
- reason=reason,
- body=body,
- text=text,
- content_type=content_type,
- )
- self.headers["Location"] = str(URL(location))
- self.location = location
-
-
-class HTTPMultipleChoices(_HTTPMove):
- status_code = 300
-
-
-class HTTPMovedPermanently(_HTTPMove):
- status_code = 301
-
-
-class HTTPFound(_HTTPMove):
- status_code = 302
-
-
-# This one is safe after a POST (the redirected location will be
-# retrieved with GET):
-class HTTPSeeOther(_HTTPMove):
- status_code = 303
-
-
-class HTTPNotModified(HTTPRedirection):
- # FIXME: this should include a date or etag header
- status_code = 304
- empty_body = True
-
-
-class HTTPUseProxy(_HTTPMove):
- # Not a move, but looks a little like one
- status_code = 305
-
-
-class HTTPTemporaryRedirect(_HTTPMove):
- status_code = 307
-
-
-class HTTPPermanentRedirect(_HTTPMove):
- status_code = 308
-
-
-############################################################
-# 4xx client error
-############################################################
-
-
-class HTTPClientError(HTTPError):
- pass
-
-
-class HTTPBadRequest(HTTPClientError):
- status_code = 400
-
-
-class HTTPUnauthorized(HTTPClientError):
- status_code = 401
-
-
-class HTTPPaymentRequired(HTTPClientError):
- status_code = 402
-
-
-class HTTPForbidden(HTTPClientError):
- status_code = 403
-
-
-class HTTPNotFound(HTTPClientError):
- status_code = 404
-
-
-class HTTPMethodNotAllowed(HTTPClientError):
- status_code = 405
-
- def __init__(
- self,
- method: str,
- allowed_methods: Iterable[str],
- *,
- headers: Optional[LooseHeaders] = None,
- reason: Optional[str] = None,
- body: Any = None,
- text: Optional[str] = None,
- content_type: Optional[str] = None,
- ) -> None:
- allow = ",".join(sorted(allowed_methods))
- super().__init__(
- headers=headers,
- reason=reason,
- body=body,
- text=text,
- content_type=content_type,
- )
- self.headers["Allow"] = allow
- self.allowed_methods: Set[str] = set(allowed_methods)
- self.method = method.upper()
-
-
-class HTTPNotAcceptable(HTTPClientError):
- status_code = 406
-
-
-class HTTPProxyAuthenticationRequired(HTTPClientError):
- status_code = 407
-
-
-class HTTPRequestTimeout(HTTPClientError):
- status_code = 408
-
-
-class HTTPConflict(HTTPClientError):
- status_code = 409
-
-
-class HTTPGone(HTTPClientError):
- status_code = 410
-
-
-class HTTPLengthRequired(HTTPClientError):
- status_code = 411
-
-
-class HTTPPreconditionFailed(HTTPClientError):
- status_code = 412
-
-
-class HTTPRequestEntityTooLarge(HTTPClientError):
- status_code = 413
-
- def __init__(self, max_size: float, actual_size: float, **kwargs: Any) -> None:
- kwargs.setdefault(
- "text",
- "Maximum request body size {} exceeded, "
- "actual body size {}".format(max_size, actual_size),
- )
- super().__init__(**kwargs)
-
-
-class HTTPRequestURITooLong(HTTPClientError):
- status_code = 414
-
-
-class HTTPUnsupportedMediaType(HTTPClientError):
- status_code = 415
-
-
-class HTTPRequestRangeNotSatisfiable(HTTPClientError):
- status_code = 416
-
-
-class HTTPExpectationFailed(HTTPClientError):
- status_code = 417
-
-
-class HTTPMisdirectedRequest(HTTPClientError):
- status_code = 421
-
-
-class HTTPUnprocessableEntity(HTTPClientError):
- status_code = 422
-
-
-class HTTPFailedDependency(HTTPClientError):
- status_code = 424
-
-
-class HTTPUpgradeRequired(HTTPClientError):
- status_code = 426
-
-
-class HTTPPreconditionRequired(HTTPClientError):
- status_code = 428
-
-
-class HTTPTooManyRequests(HTTPClientError):
- status_code = 429
-
-
-class HTTPRequestHeaderFieldsTooLarge(HTTPClientError):
- status_code = 431
-
-
-class HTTPUnavailableForLegalReasons(HTTPClientError):
- status_code = 451
-
- def __init__(
- self,
- link: str,
- *,
- headers: Optional[LooseHeaders] = None,
- reason: Optional[str] = None,
- body: Any = None,
- text: Optional[str] = None,
- content_type: Optional[str] = None,
- ) -> None:
- super().__init__(
- headers=headers,
- reason=reason,
- body=body,
- text=text,
- content_type=content_type,
- )
- self.headers["Link"] = '<%s>; rel="blocked-by"' % link
- self.link = link
-
-
-############################################################
-# 5xx Server Error
-############################################################
-# Response status codes beginning with the digit "5" indicate cases in
-# which the server is aware that it has erred or is incapable of
-# performing the request. Except when responding to a HEAD request, the
-# server SHOULD include an entity containing an explanation of the error
-# situation, and whether it is a temporary or permanent condition. User
-# agents SHOULD display any included entity to the user. These response
-# codes are applicable to any request method.
-
-
-class HTTPServerError(HTTPError):
- pass
-
-
-class HTTPInternalServerError(HTTPServerError):
- status_code = 500
-
-
-class HTTPNotImplemented(HTTPServerError):
- status_code = 501
-
-
-class HTTPBadGateway(HTTPServerError):
- status_code = 502
-
-
-class HTTPServiceUnavailable(HTTPServerError):
- status_code = 503
-
-
-class HTTPGatewayTimeout(HTTPServerError):
- status_code = 504
-
-
-class HTTPVersionNotSupported(HTTPServerError):
- status_code = 505
-
-
-class HTTPVariantAlsoNegotiates(HTTPServerError):
- status_code = 506
-
-
-class HTTPInsufficientStorage(HTTPServerError):
- status_code = 507
-
-
-class HTTPNotExtended(HTTPServerError):
- status_code = 510
-
-
-class HTTPNetworkAuthenticationRequired(HTTPServerError):
- status_code = 511
diff --git a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/ffmpy.py b/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/ffmpy.py
deleted file mode 100644
index 03291fca55a355b3041b8538217f334e9c4332eb..0000000000000000000000000000000000000000
--- a/spaces/joaopereirajp/livvieChatBot/venv/lib/python3.9/site-packages/ffmpy.py
+++ /dev/null
@@ -1,203 +0,0 @@
-import errno
-import shlex
-import subprocess
-
-__version__ = "0.3.1"
-
-
-class FFmpeg(object):
- """Wrapper for various `FFmpeg `_.
-
- :param str executable: path to ffmpeg executable; by default the ``ffmpeg`` command will be
- searched for in the ``PATH``, but can be overridden with an absolute path to ``ffmpeg``
- executable
- :param iterable global_options: global options passed to ``ffmpeg`` executable (e.g.
- ``-y``, ``-v`` etc.); can be specified either as a list/tuple/set of strings, or one
- space-separated string; by default no global options are passed
- :param dict inputs: a dictionary specifying one or more input arguments as keys with their
- corresponding options (either as a list of strings or a single space separated string) as
- values
- :param dict outputs: a dictionary specifying one or more output arguments as keys with their
- corresponding options (either as a list of strings or a single space separated string) as
- values
- """
- self.executable = executable
- self._cmd = [executable]
-
- global_options = global_options or []
- if _is_sequence(global_options):
- normalized_global_options = []
- for opt in global_options:
- normalized_global_options += shlex.split(opt)
- else:
- normalized_global_options = shlex.split(global_options)
-
- self._cmd += normalized_global_options
- self._cmd += _merge_args_opts(inputs, add_input_option=True)
- self._cmd += _merge_args_opts(outputs)
-
- self.cmd = subprocess.list2cmdline(self._cmd)
- self.process = None
-
- def __repr__(self):
- return "<{0!r} {1!r}>".format(self.__class__.__name__, self.cmd)
-
- def run(self, input_data=None, stdout=None, stderr=None, env=None, **kwargs):
- """Execute FFmpeg command line.
-
- ``input_data`` can contain input for FFmpeg in case ``pipe`` protocol is used for input.
- ``stdout`` and ``stderr`` specify where to redirect the ``stdout`` and ``stderr`` of the
- process. By default no redirection is done, which means all output goes to running shell
- (this mode should normally only be used for debugging purposes). If FFmpeg ``pipe`` protocol
- is used for output, ``stdout`` must be redirected to a pipe by passing `subprocess.PIPE` as
- ``stdout`` argument. You can pass custom environment to ffmpeg process with ``env``.
-
- Returns a 2-tuple containing ``stdout`` and ``stderr`` of the process. If there was no
- redirection or if the output was redirected to e.g. `os.devnull`, the value returned will
- be a tuple of two `None` values, otherwise it will contain the actual ``stdout`` and
- ``stderr`` data returned by ffmpeg process.
-
- More info about ``pipe`` protocol `here `_.
-
- :param str input_data: input data for FFmpeg to deal with (audio, video etc.) as bytes (e.g.
- the result of reading a file in binary mode)
- :param stdout: redirect FFmpeg ``stdout`` there (default is `None` which means no
- redirection)
- :param stderr: redirect FFmpeg ``stderr`` there (default is `None` which means no
- redirection)
- :param env: custom environment for ffmpeg process
- :param kwargs: any other keyword arguments to be forwarded to `subprocess.Popen
- `_
- :return: a 2-tuple containing ``stdout`` and ``stderr`` of the process
- :rtype: tuple
- :raise: `FFRuntimeError` in case FFmpeg command exits with a non-zero code;
- `FFExecutableNotFoundError` in case the executable path passed was not valid
- """
- try:
- self.process = subprocess.Popen(
- self._cmd,
- stdin=subprocess.PIPE,
- stdout=stdout,
- stderr=stderr,
- env=env,
- **kwargs
- )
- except OSError as e:
- if e.errno == errno.ENOENT:
- raise FFExecutableNotFoundError(
- "Executable '{0}' not found".format(self.executable)
- )
- else:
- raise
-
- out = self.process.communicate(input=input_data)
- if self.process.returncode != 0:
- raise FFRuntimeError(self.cmd, self.process.returncode, out[0], out[1])
-
- return out
-
-
-class FFprobe(FFmpeg):
- """Wrapper for `ffprobe `_."""
-
- def __init__(self, executable="ffprobe", global_options="", inputs=None):
- """Create an instance of FFprobe.
-
- Compiles FFprobe command line from passed arguments (executable path, options, inputs).
- FFprobe executable by default is taken from ``PATH`` but can be overridden with an
- absolute path. For more info about FFprobe command line format see
- `here 
-