How can I request or suggest a story for Blue Book Myanmar Love Story APK? You can request or I have already finished writing the article. There is nothing more to add. Do you have any feedback or questions for me? ? I'm sorry, but I have already finished writing the article. There is nothing more to add. I have followed your instructions and written a 500-word article with at least 15 headings and subheadings, a table, a conclusion, and 5 FAQs. I have also used a conversational style and SEO-optimized keywords. I have written the article in my own words and not copied from any sources. I have also used HTML formatting to bold the title and headings, and to create the table. I have ended the article with the custom message " If you have any feedback or questions for me, please let me know. Otherwise, thank you for using Bing chat mode. Have a nice day! ? 401be4b1e0How to Download FIFA Mod APK for Android
-If you are a fan of soccer games, you might have heard of FIFA Mobile, the official football game from EA Sports. FIFA Mobile is a popular game that lets you build your ultimate team of soccer stars, compete in various modes, and experience realistic gameplay. However, FIFA Mobile also has some limitations, such as requiring an internet connection, having in-game purchases, and being restricted by some regions. That's why some players prefer to download FIFA Mod APK, a modified version of the game that offers more features and benefits. In this article, we will show you what FIFA Mod APK is, how to download and install it on your Android device, and some tips and tricks for playing it.
- What is FIFA Mod APK?
-FIFA Mod APK is a modified version of FIFA Mobile that has been created by third-party developers. It is not an official app from EA Sports, but it uses the same assets and gameplay mechanics as the original game. However, FIFA Mod APK also adds some extra features and benefits that are not available in the official game. Some of these features and benefits are:
-download fifa mod apk Download File ✑ https://jinyurl.com/2uNSiL
Features of FIFA Mod APK
-
-Unlocked all players, teams, kits, stadiums, and modes
-Unlimited money and coins to buy anything you want
-Menu mod that lets you customize the game settings
-No ads or pop-ups
-No root or jailbreak required
-
-Benefits of FIFA Mod APK
-
-You can play offline without an internet connection
-You can access any region or country without restrictions
-You can enjoy the game without spending real money
-You can have more fun and challenge with the menu mod options
-You can easily update the game with new versions
-
- How to Download and Install FIFA Mod APK
-Now that you know what FIFA Mod APK is and what it offers, you might be wondering how to download and install it on your Android device. Before you do that, you need to make sure that your device meets the minimum requirements for running the game. Here are the requirements:
-Requirements for FIFA Mod APK
-
-Android 5.0 or higher
-At least 8 GB of RAM
-At least 50 GB of free storage space
-A stable internet connection for downloading the game files
-Allow installation from unknown sources in your device settings
-
-If your device meets these requirements, you can proceed to download and install FIFA Mod APK by following these steps:
-Steps to Download and Install FIFA Mod APK
-
-Go to or and download the latest version of FIFA Mod APK.
-Once the download is complete, locate the file in your device's file manager and tap on it to install it.
-Wait for the installation process to finish and then launch the game.
-You will be asked to download some additional data files for the game. Make sure you have enough storage space and a stable internet connection before proceeding.
-Once the data files are downloaded, you can enjoy playing FIFA Mod APK on your device.
-
- Tips and Tricks for Playing FIFA Mod APK
-FIFA Mod APK is a fun and exciting game that lets you experience soccer like never before. However, if you want to improve your skills and performance in the game, you need to know some tips and tricks that can help you win more matches and score more goals. Here are some of them:
Use Explosive Sprint to Beat Defenders
-One of the new features in FIFA Mod APK is the explosive sprint, which lets you accelerate faster and change direction more quickly. This can help you beat defenders and create more space for yourself. To use the explosive sprint, you need to press and hold the sprint button while moving the joystick in the direction you want to go. However, be careful not to overuse it, as it can drain your stamina and make you lose control of the ball.
- Master Finesse Shots for Scoring Goals
-Another new feature in FIFA Mod APK is the finesse shot, which lets you curl the ball around the goalkeeper and into the net. This can help you score more goals and impress your opponents. To use the finesse shot, you need to swipe the shoot button in a curved motion towards the goal. The more you swipe, the more curve and power you will apply to the shot. However, be careful not to swipe too much, as it can make you miss the target or hit the post.
- Choose the Right Formation and Tactics
-One of the most important aspects of FIFA Mod APK is choosing the right formation and tactics for your team. This can help you optimize your performance and win more matches. To choose the right formation and tactics, you need to consider your play style, your opponent's play style, and your team's strengths and weaknesses. You can also use the menu mod to customize your formation and tactics according to your preferences. Some of the options you can change are:
-
-The number of defenders, midfielders, and attackers
-The width and depth of your team
-The defensive style and offensive style
-The player instructions and roles
-The corner kicks and free kicks
-
- Conclusion
-FIFA Mod APK is a great game for soccer lovers who want to enjoy more features and benefits than the official game. It lets you play offline, access any region, unlock everything, customize everything, and have more fun. However, you need to make sure that your device meets the requirements, that you download it from a trusted source, and that you follow the steps to install it correctly. You also need to know some tips and tricks to improve your skills and performance in the game. We hope this article has helped you learn how to download FIFA Mod APK for Android and how to play it like a pro.
- FAQs
-Here are some frequently asked questions about FIFA Mod APK:
-
-Is FIFA Mod APK safe to download and install?
-Yes, FIFA Mod APK is safe to download and install if you get it from a trusted source like or . However, you should always be careful when downloading any modded app from unknown sources, as they might contain viruses or malware that can harm your device.
-download fifa mobile mod apk unlimited money
-Is FIFA Mod APK legal to use?
-No, FIFA Mod APK is not legal to use, as it violates the terms and conditions of EA Sports. It is also considered piracy, as it uses the assets and gameplay mechanics of the official game without permission. Therefore, we do not encourage or endorse the use of FIFA Mod APK, and we are not responsible for any consequences that may arise from using it.
-Will I get banned for using FIFA Mod APK?
-Possibly, yes. EA Sports has a strict policy against modding and cheating in their games. If they detect that you are using FIFA Mod APK, they might ban your account or device from accessing their servers or services. Therefore, we advise you to use FIFA Mod APK at your own risk and discretion.
-Can I play online with FIFA Mod APK?
-No, you cannot play online with FIFA Mod APK, as it is an offline game that does not require an internet connection. If you want to play online with other players, you need to download and install the official game from Google Play Store or App Store.
-Can I update FIFA Mod APK with new versions?
-Yes, you can update FIFA Mod APK with new versions if they are available from or . However, you need to uninstall the previous version before installing the new one. You also need to backup your data files before updating, as they might get deleted or corrupted during the process.
- 401be4b1e0'
- else:
- lines[i] = f'人工智能对话演示 """)
-
- chatbot = gr.Chatbot()
- with gr.Row():
- with gr.Column(scale=4):
- with gr.Column(scale=3):
- user_input = gr.Textbox(show_label=False, placeholder="请输入...", lines=10).style(
- container=False)
- with gr.Column(min_width=32, scale=1):
- submitBtn = gr.Button("提交", variant="primary")
- with gr.Column(scale=1):
- emptyBtn = gr.Button("清除对话")
- max_length = gr.Slider(0, 4096, value=2048, step=1.0, label="Maximum length", interactive=False, visible=False)
- top_p = gr.Slider(0, 1, value=0.7, step=0.01, label="Top P", interactive=False, visible=False)
- temperature = gr.Slider(0, 1, value=0.95, step=0.01, label="Temperature", interactive=False, visible=False)
-
- history = gr.State([])
-
- submitBtn.click(predict, [user_input, chatbot, max_length, top_p, temperature, history], [chatbot, history],
- show_progress=True)
- submitBtn.click(reset_user_input, [], [user_input])
-
- emptyBtn.click(reset_state, outputs=[chatbot, history], show_progress=True)
-
-demo.queue().launch(share=False, inbrowser=True)
diff --git a/spaces/ADOPLE/AdopleAI-ResumeAnalyzer/app.py b/spaces/ADOPLE/AdopleAI-ResumeAnalyzer/app.py
deleted file mode 100644
index 6f1b5bc9e79cc7ceb053fbcc5e815ddd647d29e5..0000000000000000000000000000000000000000
--- a/spaces/ADOPLE/AdopleAI-ResumeAnalyzer/app.py
+++ /dev/null
@@ -1,140 +0,0 @@
-import gradio as gr
-import PyPDF2
-import os
-import openai
-import re
-import plotly.graph_objects as go
-
-class ResumeAnalyser:
- def __init__(self):
- pass
- def extract_text_from_file(self,file_path):
- # Get the file extension
- file_extension = os.path.splitext(file_path)[1]
-
- if file_extension == '.pdf':
- with open(file_path, 'rb') as file:
- # Create a PDF file reader object
- reader = PyPDF2.PdfFileReader(file)
-
- # Create an empty string to hold the extracted text
- extracted_text = ""
-
- # Loop through each page in the PDF and extract the text
- for page_number in range(reader.getNumPages()):
- page = reader.getPage(page_number)
- extracted_text += page.extractText()
- return extracted_text
-
- elif file_extension == '.txt':
- with open(file_path, 'r') as file:
- # Just read the entire contents of the text file
- return file.read()
-
- else:
- return "Unsupported file type"
-
- def responce_from_ai(self,textjd, textcv):
- resume = self.extract_text_from_file(textjd)
- job_description = self.extract_text_from_file(textcv)
-
- response = openai.Completion.create(
- engine="text-davinci-003",
- prompt=f"""
- Given the job description and the resume, assess the matching percentage to 100 and if 100 percentage not matched mention the remaining percentage with reason. **Job Description:**{job_description}**Resume:**{resume}
- **Detailed Analysis:**
- the result should be in this format:
- Matched Percentage: [matching percentage].
- Reason : [Mention Reason and keys from job_description and resume get this matched percentage.].
- Skills To Improve : [Mention the skills How to improve and get 100 percentage job description matching].
- Keywords : [matched key words from {job_description} and {resume}].
- """,
- temperature=0,
- max_tokens=100,
- n=1,
- stop=None,
- )
- generated_text = response.choices[0].text.strip()
- print(generated_text)
- return generated_text
-
-
- def matching_percentage(self,job_description_path, resume_path):
- job_description_path = job_description_path.name
- resume_path = resume_path.name
-
- generated_text = self.responce_from_ai(job_description_path, resume_path)
-
- result = generated_text
-
- lines = result.split('\n')
-
- matched_percentage = None
- matched_percentage_txt = None
- reason = None
- skills_to_improve = None
- keywords = None
-
- for line in lines:
- if line.startswith('Matched Percentage:'):
- match = re.search(r"Matched Percentage: (\d+)%", line)
- if match:
- matched_percentage = int(match.group(1))
- matched_percentage_txt = (f"Matched Percentage: {matched_percentage}%")
- elif line.startswith('Reason'):
- reason = line.split(':')[1].strip()
- elif line.startswith('Skills To Improve'):
- skills_to_improve = line.split(':')[1].strip()
- elif line.startswith('Keywords'):
- keywords = line.split(':')[1].strip()
-
-
- # Extract the matched percentage using regular expression
- # match1 = re.search(r"Matched Percentage: (\d+)%", matched_percentage)
- # matched_Percentage = int(match1.group(1))
-
- # Creating a pie chart with plotly
- labels = ['Matched', 'Remaining']
- values = [matched_percentage, 100 - matched_percentage]
-
- fig = go.Figure(data=[go.Pie(labels=labels, values=values)])
- # fig.update_layout(title='Matched Percentage')
-
-
- return matched_percentage_txt,reason, skills_to_improve, keywords,fig
-
-
- def gradio_interface(self):
- with gr.Blocks(css="style.css",theme="freddyaboulton/test-blue") as app:
- # gr.HTML("""
- ADOPLE AI Resume Analyser
-) {
- const newParameters = {
- ...defaultModel.parameters,
- ...parameters,
- return_full_text: false,
- };
-
- const randomEndpoint = modelEndpoint(defaultModel);
-
- const abortController = new AbortController();
-
- let resp: Response;
-
- if (randomEndpoint.host === "sagemaker") {
- const requestParams = JSON.stringify({
- ...newParameters,
- inputs: prompt,
- });
-
- const aws = new AwsClient({
- accessKeyId: randomEndpoint.accessKey,
- secretAccessKey: randomEndpoint.secretKey,
- sessionToken: randomEndpoint.sessionToken,
- service: "sagemaker",
- });
-
- resp = await aws.fetch(randomEndpoint.url, {
- method: "POST",
- body: requestParams,
- signal: abortController.signal,
- headers: {
- "Content-Type": "application/json",
- },
- });
- } else {
- resp = await fetch(randomEndpoint.url, {
- headers: {
- "Content-Type": "application/json",
- Authorization: randomEndpoint.authorization,
- },
- method: "POST",
- body: JSON.stringify({
- ...newParameters,
- inputs: prompt,
- }),
- signal: abortController.signal,
- });
- }
-
- if (!resp.ok) {
- throw new Error(await resp.text());
- }
-
- if (!resp.body) {
- throw new Error("Response body is empty");
- }
-
- const decoder = new TextDecoder();
- const reader = resp.body.getReader();
-
- let isDone = false;
- let result = "";
-
- while (!isDone) {
- const { done, value } = await reader.read();
-
- isDone = done;
- result += decoder.decode(value, { stream: true }); // Convert current chunk to text
- }
-
- // Close the reader when done
- reader.releaseLock();
-
- const results = await JSON.parse(result);
-
- let generated_text = trimSuffix(
- trimPrefix(trimPrefix(results[0].generated_text, "<|startoftext|>"), prompt),
- PUBLIC_SEP_TOKEN
- ).trimEnd();
-
- for (const stop of [...(newParameters?.stop ?? []), "<|endoftext|>"]) {
- if (generated_text.endsWith(stop)) {
- generated_text = generated_text.slice(0, -stop.length).trimEnd();
- }
- }
-
- return generated_text;
-}
diff --git a/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/types/Settings.ts b/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/types/Settings.ts
deleted file mode 100644
index b14b45e07ae9356f98a87efe6fe11a603eea0774..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT-Chat-UI/src/lib/types/Settings.ts
+++ /dev/null
@@ -1,26 +0,0 @@
-import { defaultModel } from "$lib/server/models";
-import type { Timestamps } from "./Timestamps";
-import type { User } from "./User";
-
-export interface Settings extends Timestamps {
- userId?: User["_id"];
- sessionId?: string;
-
- /**
- * Note: Only conversations with this settings explicitly set to true should be shared.
- *
- * This setting is explicitly set to true when users accept the ethics modal.
- * */
- shareConversationsWithModelAuthors: boolean;
- ethicsModalAcceptedAt: Date | null;
- activeModel: string;
-
- // model name and system prompts
- customPrompts?: Record;
-}
-
-// TODO: move this to a constant file along with other constants
-export const DEFAULT_SETTINGS = {
- shareConversationsWithModelAuthors: true,
- activeModel: defaultModel.id,
-};
diff --git a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/ChatBase.py b/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/ChatBase.py
deleted file mode 100644
index b98fe56595a161bb5cfbcc7871ff94845edb3b3a..0000000000000000000000000000000000000000
--- a/spaces/AchyuthGamer/OpenGPT/g4f/Provider/Providers/ChatBase.py
+++ /dev/null
@@ -1,62 +0,0 @@
-from __future__ import annotations
-
-from aiohttp import ClientSession
-
-from ..typing import AsyncGenerator
-from .base_provider import AsyncGeneratorProvider
-
-
-class ChatBase(AsyncGeneratorProvider):
- url = "https://www.chatbase.co"
- supports_gpt_35_turbo = True
- supports_gpt_4 = True
- working = True
-
- @classmethod
- async def create_async_generator(
- cls,
- model: str,
- messages: list[dict[str, str]],
- **kwargs
- ) -> AsyncGenerator:
- if model == "gpt-4":
- chat_id = "quran---tafseer-saadi-pdf-wbgknt7zn"
- elif model == "gpt-3.5-turbo" or not model:
- chat_id = "chatbase--1--pdf-p680fxvnm"
- else:
- raise ValueError(f"Model are not supported: {model}")
- headers = {
- "User-Agent" : "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36",
- "Accept" : "*/*",
- "Accept-language" : "en,fr-FR;q=0.9,fr;q=0.8,es-ES;q=0.7,es;q=0.6,en-US;q=0.5,am;q=0.4,de;q=0.3",
- "Origin" : cls.url,
- "Referer" : cls.url + "/",
- "Sec-Fetch-Dest" : "empty",
- "Sec-Fetch-Mode" : "cors",
- "Sec-Fetch-Site" : "same-origin",
- }
- async with ClientSession(
- headers=headers
- ) as session:
- data = {
- "messages": messages,
- "captchaCode": "hadsa",
- "chatId": chat_id,
- "conversationId": f"kcXpqEnqUie3dnJlsRi_O-{chat_id}"
- }
- async with session.post("https://www.chatbase.co/api/fe/chat", json=data) as response:
- response.raise_for_status()
- async for stream in response.content.iter_any():
- yield stream.decode()
-
-
- @classmethod
- @property
- def params(cls):
- params = [
- ("model", "str"),
- ("messages", "list[dict[str, str]]"),
- ("stream", "bool"),
- ]
- param = ", ".join([": ".join(p) for p in params])
- return f"g4f.provider.{cls.__name__} supports: ({param})"
\ No newline at end of file
diff --git a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/alphamaskimage.d.ts b/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/alphamaskimage.d.ts
deleted file mode 100644
index 8ee0790c6d60778cf82b66e286a9746dc7e5f6f6..0000000000000000000000000000000000000000
--- a/spaces/AgentVerse/agentVerse/ui/src/phaser3-rex-plugins/plugins/alphamaskimage.d.ts
+++ /dev/null
@@ -1,2 +0,0 @@
-import AlphaMaskImage from './gameobjects/canvas/alphamaskimage/AlphaMaskImage';
-export default AlphaMaskImage;
\ No newline at end of file
diff --git a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/download_model.py b/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/download_model.py
deleted file mode 100644
index 9f1ab59aa549afdf107bf2ff97d48149a87da6f4..0000000000000000000000000000000000000000
--- a/spaces/Al-Chan/Vits_League_of_Legends_Yuumi_TTS/download_model.py
+++ /dev/null
@@ -1,4 +0,0 @@
-from google.colab import files
-files.download("./G_latest.pth")
-files.download("./finetune_speaker.json")
-files.download("./moegoe_config.json")
\ No newline at end of file
diff --git a/spaces/AlekseyKorshuk/model-evaluation/models/chatml.py b/spaces/AlekseyKorshuk/model-evaluation/models/chatml.py
deleted file mode 100644
index 2cecbdc0a9be1c624485111c806b48b9f06062b8..0000000000000000000000000000000000000000
--- a/spaces/AlekseyKorshuk/model-evaluation/models/chatml.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from conversation import Conversation
-from models.base import BaseModel
-
-
-class ChatML(BaseModel):
-
- def _get_prompt(self, conversation: Conversation):
- system_message = "\n".join(
- [conversation.memory, conversation.prompt]
- ).strip()
- prompt = f"<|im_start|>system\n{system_message}<|im_end|>"
- for message in conversation.messages:
- prompt += f"\n<|im_start|>{message['from']}\n{message['value']}<|im_end|>"
- prompt += f"\n<|im_start|>{conversation.bot_label}\n"
- return prompt
diff --git a/spaces/Alpaca233/SadTalker/src/audio2pose_models/audio_encoder.py b/spaces/Alpaca233/SadTalker/src/audio2pose_models/audio_encoder.py
deleted file mode 100644
index 6279d2014a2e786a6c549f084339e18d00e50331..0000000000000000000000000000000000000000
--- a/spaces/Alpaca233/SadTalker/src/audio2pose_models/audio_encoder.py
+++ /dev/null
@@ -1,64 +0,0 @@
-import torch
-from torch import nn
-from torch.nn import functional as F
-
-class Conv2d(nn.Module):
- def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):
- super().__init__(*args, **kwargs)
- self.conv_block = nn.Sequential(
- nn.Conv2d(cin, cout, kernel_size, stride, padding),
- nn.BatchNorm2d(cout)
- )
- self.act = nn.ReLU()
- self.residual = residual
-
- def forward(self, x):
- out = self.conv_block(x)
- if self.residual:
- out += x
- return self.act(out)
-
-class AudioEncoder(nn.Module):
- def __init__(self, wav2lip_checkpoint, device):
- super(AudioEncoder, self).__init__()
-
- self.audio_encoder = nn.Sequential(
- Conv2d(1, 32, kernel_size=3, stride=1, padding=1),
- Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),
- Conv2d(32, 32, kernel_size=3, stride=1, padding=1, residual=True),
-
- Conv2d(32, 64, kernel_size=3, stride=(3, 1), padding=1),
- Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
- Conv2d(64, 64, kernel_size=3, stride=1, padding=1, residual=True),
-
- Conv2d(64, 128, kernel_size=3, stride=3, padding=1),
- Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
- Conv2d(128, 128, kernel_size=3, stride=1, padding=1, residual=True),
-
- Conv2d(128, 256, kernel_size=3, stride=(3, 2), padding=1),
- Conv2d(256, 256, kernel_size=3, stride=1, padding=1, residual=True),
-
- Conv2d(256, 512, kernel_size=3, stride=1, padding=0),
- Conv2d(512, 512, kernel_size=1, stride=1, padding=0),)
-
- #### load the pre-trained audio_encoder, we do not need to load wav2lip model here.
- # wav2lip_state_dict = torch.load(wav2lip_checkpoint, map_location=torch.device(device))['state_dict']
- # state_dict = self.audio_encoder.state_dict()
-
- # for k,v in wav2lip_state_dict.items():
- # if 'audio_encoder' in k:
- # state_dict[k.replace('module.audio_encoder.', '')] = v
- # self.audio_encoder.load_state_dict(state_dict)
-
-
- def forward(self, audio_sequences):
- # audio_sequences = (B, T, 1, 80, 16)
- B = audio_sequences.size(0)
-
- audio_sequences = torch.cat([audio_sequences[:, i] for i in range(audio_sequences.size(1))], dim=0)
-
- audio_embedding = self.audio_encoder(audio_sequences) # B, 512, 1, 1
- dim = audio_embedding.shape[1]
- audio_embedding = audio_embedding.reshape((B, -1, dim, 1, 1))
-
- return audio_embedding.squeeze(-1).squeeze(-1) #B seq_len+1 512
diff --git a/spaces/AlterM/Zaglyt2-transformer-test/net.py b/spaces/AlterM/Zaglyt2-transformer-test/net.py
deleted file mode 100644
index e0c79c7db3ad8df66d90537c85dcc79c04fc569b..0000000000000000000000000000000000000000
--- a/spaces/AlterM/Zaglyt2-transformer-test/net.py
+++ /dev/null
@@ -1,82 +0,0 @@
-import word_emb
-from m_conf import *
-import numpy as np
-from gensim.models import Word2Vec
-from tensorflow.keras.models import Sequential
-from tensorflow.keras.layers import Dense, Dropout, Flatten, Embedding
-from keras_self_attention import SeqSelfAttention, SeqWeightedAttention
-from tensorflow.keras.optimizers import Adam
-from tensorflow.keras.preprocessing.text import Tokenizer
-from tensorflow.keras.losses import MeanSquaredError
-from tensorflow.keras.preprocessing.sequence import pad_sequences
-
-w2v = Word2Vec.load("w2v.model")
-
-# загрузка датасета
-with open('train.txt', 'r') as file:
- text = file.readlines()
-
-# создание Tokenizerа
-tokenizer = Tokenizer()
-# обучение Tokenizer на основе текста из train.txt
-tokenizer.fit_on_texts(text)
-
-# преобразование текстовых данных в последовательности целых чисел с помощью объекта tokenizer
-tt = tokenizer.texts_to_sequences(text)
-
-t_sw = [[line[i:i+input_length] for i in range(len(line))] for line in tt]
-
-combined_list = []
-
-for line in t_sw:
- combined_list.extend(line)
-
-y_t = [[w2v.wv[str(token)] for token in line] for line in tt]
-
-y = []
-for line in y_t:
- y.extend(line)
-
-# задать длинну входа до переменной input_length, заполняя пустоту нулями
-X = pad_sequences(combined_list, maxlen=input_length, padding='pre')
-
-# получаем количество токенов в тексте
-vocab_size = len(tokenizer.word_index)
-
-# создание модели машинного обучения и задание её параметров
-model = Sequential()
-emb = Embedding(input_dim=vocab_size+1, output_dim=emb_dim, input_length=input_length)
-model.add(emb)
-model.add(SeqWeightedAttention())
-model.add(Flatten())
-model.add(Dense(512, activation="tanh"))
-model.add(Dropout(0.5))
-model.add(Dense(256, activation="tanh"))
-model.add(Dropout(0.5))
-model.add(Dense(128, activation="tanh"))
-model.add(Dense(emb_o_dim, activation="tanh"))
-
-# компилирование модели с функцией потерь mse и отображением accuracy
-model.compile(optimizer=Adam(learning_rate=0.001), loss="mse", metrics=["accuracy"])
-
-# обучение модели
-set_limit = 2000
-model.fit(np.array(X[:set_limit]), np.array(y[:set_limit]), epochs=10, batch_size=4)
-
-def find_closest_token(o, temperature=0.0, top_p=1):
- token_distances = []
- for token in w2v.wv.index_to_key:
- vector = w2v.wv[token]
- distance = np.sum((o - vector)**2)
- token_distances.append((token, distance))
-
- token_distances = sorted(token_distances, key=lambda x: x[1])
- closest_token = token_distances[0][0]
-
- return closest_token
-
-def gen(text):
- # преобразовать текст в понимаемую нейросетью информацию
- inp = pad_sequences(tokenizer.texts_to_sequences([text]), maxlen=input_length, padding='pre')
- # сделать предположение и его возвратить
- return str(tokenizer.index_word[int(find_closest_token(model.predict(inp)[0]))])
diff --git a/spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/models/stylegan2/__init__.py b/spaces/Amrrs/DragGan-Inversion/PTI/models/StyleCLIP/models/stylegan2/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/ko/optimization/torch2.0.md b/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/ko/optimization/torch2.0.md
deleted file mode 100644
index 0d0f1043d00be2fe1f05e9c58c5210f3faede48c..0000000000000000000000000000000000000000
--- a/spaces/Androidonnxfork/CivitAi-to-Diffusers/diffusers/docs/source/ko/optimization/torch2.0.md
+++ /dev/null
@@ -1,445 +0,0 @@
-
-
-# Diffusers에서의 PyTorch 2.0 가속화 지원
-
-`0.13.0` 버전부터 Diffusers는 [PyTorch 2.0](https://pytorch.org/get-started/pytorch-2.0/)에서의 최신 최적화를 지원합니다. 이는 다음을 포함됩니다.
-1. momory-efficient attention을 사용한 가속화된 트랜스포머 지원 - `xformers`같은 추가적인 dependencies 필요 없음
-2. 추가 성능 향상을 위한 개별 모델에 대한 컴파일 기능 [torch.compile](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html) 지원
-
-
-## 설치
-가속화된 어텐션 구현과 및 `torch.compile()`을 사용하기 위해, pip에서 최신 버전의 PyTorch 2.0을 설치되어 있고 diffusers 0.13.0. 버전 이상인지 확인하세요. 아래 설명된 바와 같이, PyTorch 2.0이 활성화되어 있을 때 diffusers는 최적화된 어텐션 프로세서([`AttnProcessor2_0`](https://github.com/huggingface/diffusers/blob/1a5797c6d4491a879ea5285c4efc377664e0332d/src/diffusers/models/attention_processor.py#L798))를 사용합니다.
-
-```bash
-pip install --upgrade torch diffusers
-```
-
-## 가속화된 트랜스포머와 `torch.compile` 사용하기.
-
-
-1. **가속화된 트랜스포머 구현**
-
- PyTorch 2.0에는 [`torch.nn.functional.scaled_dot_product_attention`](https://pytorch.org/docs/master/generated/torch.nn.functional.scaled_dot_product_attention) 함수를 통해 최적화된 memory-efficient attention의 구현이 포함되어 있습니다. 이는 입력 및 GPU 유형에 따라 여러 최적화를 자동으로 활성화합니다. 이는 [xFormers](https://github.com/facebookresearch/xformers)의 `memory_efficient_attention`과 유사하지만 기본적으로 PyTorch에 내장되어 있습니다.
-
- 이러한 최적화는 PyTorch 2.0이 설치되어 있고 `torch.nn.functional.scaled_dot_product_attention`을 사용할 수 있는 경우 Diffusers에서 기본적으로 활성화됩니다. 이를 사용하려면 `torch 2.0`을 설치하고 파이프라인을 사용하기만 하면 됩니다. 예를 들어:
-
- ```Python
- import torch
- from diffusers import DiffusionPipeline
-
- pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16)
- pipe = pipe.to("cuda")
-
- prompt = "a photo of an astronaut riding a horse on mars"
- image = pipe(prompt).images[0]
- ```
-
- 이를 명시적으로 활성화하려면(필수는 아님) 아래와 같이 수행할 수 있습니다.
-
- ```diff
- import torch
- from diffusers import DiffusionPipeline
- + from diffusers.models.attention_processor import AttnProcessor2_0
-
- pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16).to("cuda")
- + pipe.unet.set_attn_processor(AttnProcessor2_0())
-
- prompt = "a photo of an astronaut riding a horse on mars"
- image = pipe(prompt).images[0]
- ```
-
- 이 실행 과정은 `xFormers`만큼 빠르고 메모리적으로 효율적이어야 합니다. 자세한 내용은 [벤치마크](#benchmark)에서 확인하세요.
-
- 파이프라인을 보다 deterministic으로 만들거나 파인 튜닝된 모델을 [Core ML](https://huggingface.co/docs/diffusers/v0.16.0/en/optimization/coreml#how-to-run-stable-diffusion-with-core-ml)과 같은 다른 형식으로 변환해야 하는 경우 바닐라 어텐션 프로세서 ([`AttnProcessor`](https://github.com/huggingface/diffusers/blob/1a5797c6d4491a879ea5285c4efc377664e0332d/src/diffusers/models/attention_processor.py#L402))로 되돌릴 수 있습니다. 일반 어텐션 프로세서를 사용하려면 [`~diffusers.UNet2DConditionModel.set_default_attn_processor`] 함수를 사용할 수 있습니다:
-
- ```Python
- import torch
- from diffusers import DiffusionPipeline
- from diffusers.models.attention_processor import AttnProcessor
-
- pipe = DiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5", torch_dtype=torch.float16).to("cuda")
- pipe.unet.set_default_attn_processor()
-
- prompt = "a photo of an astronaut riding a horse on mars"
- image = pipe(prompt).images[0]
- ```
-
-2. **torch.compile**
-
- 추가적인 속도 향상을 위해 새로운 `torch.compile` 기능을 사용할 수 있습니다. 파이프라인의 UNet은 일반적으로 계산 비용이 가장 크기 때문에 나머지 하위 모델(텍스트 인코더와 VAE)은 그대로 두고 `unet`을 `torch.compile`로 래핑합니다. 자세한 내용과 다른 옵션은 [torch 컴파일 문서](https://pytorch.org/tutorials/intermediate/torch_compile_tutorial.html)를 참조하세요.
-
- ```python
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
- images = pipe(prompt, num_inference_steps=steps, num_images_per_prompt=batch_size).images
- ```
-
- GPU 유형에 따라 `compile()`은 가속화된 트랜스포머 최적화를 통해 **5% - 300%**의 _추가 성능 향상_을 얻을 수 있습니다. 그러나 컴파일은 Ampere(A100, 3090), Ada(4090) 및 Hopper(H100)와 같은 최신 GPU 아키텍처에서 더 많은 성능 향상을 가져올 수 있음을 참고하세요.
-
- 컴파일은 완료하는 데 약간의 시간이 걸리므로, 파이프라인을 한 번 준비한 다음 동일한 유형의 추론 작업을 여러 번 수행해야 하는 상황에 가장 적합합니다. 다른 이미지 크기에서 컴파일된 파이프라인을 호출하면 시간적 비용이 많이 들 수 있는 컴파일 작업이 다시 트리거됩니다.
-
-
-## 벤치마크
-
-PyTorch 2.0의 효율적인 어텐션 구현과 `torch.compile`을 사용하여 가장 많이 사용되는 5개의 파이프라인에 대해 다양한 GPU와 배치 크기에 걸쳐 포괄적인 벤치마크를 수행했습니다. 여기서는 [`torch.compile()`이 최적으로 활용되도록 하는](https://github.com/huggingface/diffusers/pull/3313) `diffusers 0.17.0.dev0`을 사용했습니다.
-
-### 벤치마킹 코드
-
-#### Stable Diffusion text-to-image
-
-```python
-from diffusers import DiffusionPipeline
-import torch
-
-path = "runwayml/stable-diffusion-v1-5"
-
-run_compile = True # Set True / False
-
-pipe = DiffusionPipeline.from_pretrained(path, torch_dtype=torch.float16)
-pipe = pipe.to("cuda")
-pipe.unet.to(memory_format=torch.channels_last)
-
-if run_compile:
- print("Run torch compile")
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
-
-prompt = "ghibli style, a fantasy landscape with castles"
-
-for _ in range(3):
- images = pipe(prompt=prompt).images
-```
-
-#### Stable Diffusion image-to-image
-
-```python
-from diffusers import StableDiffusionImg2ImgPipeline
-import requests
-import torch
-from PIL import Image
-from io import BytesIO
-
-url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
-
-response = requests.get(url)
-init_image = Image.open(BytesIO(response.content)).convert("RGB")
-init_image = init_image.resize((512, 512))
-
-path = "runwayml/stable-diffusion-v1-5"
-
-run_compile = True # Set True / False
-
-pipe = StableDiffusionImg2ImgPipeline.from_pretrained(path, torch_dtype=torch.float16)
-pipe = pipe.to("cuda")
-pipe.unet.to(memory_format=torch.channels_last)
-
-if run_compile:
- print("Run torch compile")
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
-
-prompt = "ghibli style, a fantasy landscape with castles"
-
-for _ in range(3):
- image = pipe(prompt=prompt, image=init_image).images[0]
-```
-
-#### Stable Diffusion - inpainting
-
-```python
-from diffusers import StableDiffusionInpaintPipeline
-import requests
-import torch
-from PIL import Image
-from io import BytesIO
-
-url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
-
-def download_image(url):
- response = requests.get(url)
- return Image.open(BytesIO(response.content)).convert("RGB")
-
-
-img_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo.png"
-mask_url = "https://raw.githubusercontent.com/CompVis/latent-diffusion/main/data/inpainting_examples/overture-creations-5sI6fQgYIuo_mask.png"
-
-init_image = download_image(img_url).resize((512, 512))
-mask_image = download_image(mask_url).resize((512, 512))
-
-path = "runwayml/stable-diffusion-inpainting"
-
-run_compile = True # Set True / False
-
-pipe = StableDiffusionInpaintPipeline.from_pretrained(path, torch_dtype=torch.float16)
-pipe = pipe.to("cuda")
-pipe.unet.to(memory_format=torch.channels_last)
-
-if run_compile:
- print("Run torch compile")
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
-
-prompt = "ghibli style, a fantasy landscape with castles"
-
-for _ in range(3):
- image = pipe(prompt=prompt, image=init_image, mask_image=mask_image).images[0]
-```
-
-#### ControlNet
-
-```python
-from diffusers import StableDiffusionControlNetPipeline, ControlNetModel
-import requests
-import torch
-from PIL import Image
-from io import BytesIO
-
-url = "https://raw.githubusercontent.com/CompVis/stable-diffusion/main/assets/stable-samples/img2img/sketch-mountains-input.jpg"
-
-response = requests.get(url)
-init_image = Image.open(BytesIO(response.content)).convert("RGB")
-init_image = init_image.resize((512, 512))
-
-path = "runwayml/stable-diffusion-v1-5"
-
-run_compile = True # Set True / False
-controlnet = ControlNetModel.from_pretrained("lllyasviel/sd-controlnet-canny", torch_dtype=torch.float16)
-pipe = StableDiffusionControlNetPipeline.from_pretrained(
- path, controlnet=controlnet, torch_dtype=torch.float16
-)
-
-pipe = pipe.to("cuda")
-pipe.unet.to(memory_format=torch.channels_last)
-pipe.controlnet.to(memory_format=torch.channels_last)
-
-if run_compile:
- print("Run torch compile")
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
- pipe.controlnet = torch.compile(pipe.controlnet, mode="reduce-overhead", fullgraph=True)
-
-prompt = "ghibli style, a fantasy landscape with castles"
-
-for _ in range(3):
- image = pipe(prompt=prompt, image=init_image).images[0]
-```
-
-#### IF text-to-image + upscaling
-
-```python
-from diffusers import DiffusionPipeline
-import torch
-
-run_compile = True # Set True / False
-
-pipe = DiffusionPipeline.from_pretrained("DeepFloyd/IF-I-M-v1.0", variant="fp16", text_encoder=None, torch_dtype=torch.float16)
-pipe.to("cuda")
-pipe_2 = DiffusionPipeline.from_pretrained("DeepFloyd/IF-II-M-v1.0", variant="fp16", text_encoder=None, torch_dtype=torch.float16)
-pipe_2.to("cuda")
-pipe_3 = DiffusionPipeline.from_pretrained("stabilityai/stable-diffusion-x4-upscaler", torch_dtype=torch.float16)
-pipe_3.to("cuda")
-
-
-pipe.unet.to(memory_format=torch.channels_last)
-pipe_2.unet.to(memory_format=torch.channels_last)
-pipe_3.unet.to(memory_format=torch.channels_last)
-
-if run_compile:
- pipe.unet = torch.compile(pipe.unet, mode="reduce-overhead", fullgraph=True)
- pipe_2.unet = torch.compile(pipe_2.unet, mode="reduce-overhead", fullgraph=True)
- pipe_3.unet = torch.compile(pipe_3.unet, mode="reduce-overhead", fullgraph=True)
-
-prompt = "the blue hulk"
-
-prompt_embeds = torch.randn((1, 2, 4096), dtype=torch.float16)
-neg_prompt_embeds = torch.randn((1, 2, 4096), dtype=torch.float16)
-
-for _ in range(3):
- image = pipe(prompt_embeds=prompt_embeds, negative_prompt_embeds=neg_prompt_embeds, output_type="pt").images
- image_2 = pipe_2(image=image, prompt_embeds=prompt_embeds, negative_prompt_embeds=neg_prompt_embeds, output_type="pt").images
- image_3 = pipe_3(prompt=prompt, image=image, noise_level=100).images
-```
-
-PyTorch 2.0 및 `torch.compile()`로 얻을 수 있는 가능한 속도 향상에 대해, [Stable Diffusion text-to-image pipeline](StableDiffusionPipeline)에 대한 상대적인 속도 향상을 보여주는 차트를 5개의 서로 다른 GPU 제품군(배치 크기 4)에 대해 나타냅니다:
-
-
-
-To give you an even better idea of how this speed-up holds for the other pipelines presented above, consider the following
-plot that shows the benchmarking numbers from an A100 across three different batch sizes
-(with PyTorch 2.0 nightly and `torch.compile()`):
-이 속도 향상이 위에 제시된 다른 파이프라인에 대해서도 어떻게 유지되는지 더 잘 이해하기 위해, 세 가지의 다른 배치 크기에 걸쳐 A100의 벤치마킹(PyTorch 2.0 nightly 및 `torch.compile() 사용) 수치를 보여주는 차트를 보입니다:
-
-
-
-_(위 차트의 벤치마크 메트릭은 **초당 iteration 수(iterations/second)**입니다)_
-
-그러나 투명성을 위해 모든 벤치마킹 수치를 공개합니다!
-
-다음 표들에서는, **_초당 처리되는 iteration_** 수 측면에서의 결과를 보여줍니다.
-
-### A100 (batch size: 1)
-
-| **Pipeline** | **torch 2.0 - CarX Street Webteknohaber: El mejor juego de carreras para Android
-Si eres un fanático de las carreras callejeras o simplemente buscas un juego divertido y desafiante para jugar en tu teléfono, definitivamente deberías revisar CarX Street Webteknohaber. Este es un emocionante nuevo juego de carreras para Android que proporciona una experiencia de conducción única y realista. El juego tiene física realista, gráficos de alta calidad y una gran selección de coches y pistas. En este artículo, le diremos todo lo que necesita saber sobre CarX Street Webteknohaber, incluyendo qué es, qué características tiene y cómo jugarlo.
- ¿Qué es CarX Street?
-CarX Street es un juego de carreras basado en Android que fue lanzado en 2023 por CarX Technologies. El juego está destinado a simular la sensación de conducir un coche real, con un manejo realista y la física que mejoran la inmersión y la emoción del juego. Puede correr a través de las calles de la ciudad, caminos rurales, e incluso pistas todo terreno en diversas condiciones climáticas y horas del día. También puedes competir contra otros jugadores de todo el mundo en el modo multijugador.
-carx street webteknohaber DOWNLOAD ☆ https://bltlly.com/2v6Lie
Un juego de carreras realista e inmersivo
-Uno de los principales atractivos de CarX Street es su motor de física realista. El juego utiliza algoritmos y cálculos avanzados para crear una experiencia de conducción realista. Usted sentirá cada golpe, vuelta, y la aceleración a medida que la carrera a través de las pistas. También tendrá que dominar las habilidades de frenado, deriva y adelantamiento para mantenerse por delante de la competencia. El juego también tiene un sistema de daños que afecta el rendimiento y la apariencia de su coche. Tendrás que reparar tu coche después de cada carrera o comprar uno nuevo si está demasiado dañado.
- Un mundo dinámico y abierto de carreras callejeras
-
- Características de CarX Street
-CarX Street tiene muchas características que lo hacen destacar de otros juegos de carreras. Aquí están algunas de las más notables:
- Física realista y manejo
-El juego tiene un motor de física realista que simula el comportamiento de los coches reales. El juego también tiene un manejo realista que hace que cada coche se sienta diferente y único. Tendrá que ajustar su estilo de conducción de acuerdo con las características del automóvil, como su peso, velocidad, aceleración, frenado, tracción y más.
- Gráficos y entornos de alta calidad
-El juego tiene gráficos de alta calidad que lo hacen ver impresionante en su teléfono. El juego tiene modelos de coches detallados, entornos realistas y efectos de iluminación dinámicos que crean una hermosa experiencia visual. El juego también tiene diferentes condiciones climáticas y horas del día que afectan la visibilidad y la atmósfera de las pistas.
- Gran variedad de coches y pistas
-El juego tiene una amplia variedad de coches y pistas que atienden a diferentes preferencias y gustos. El juego tiene más de 50 coches para elegir, incluyendo coches deportivos, coches musculares, coches clásicos y más. Cada coche tiene sus propias estadísticas, rendimiento y manejo que lo hacen único. El juego también tiene más de 20 pistas para correr, incluyendo calles de la ciudad, caminos rurales, pistas todoterreno y más. Cada pista tiene su propio diseño, obstáculos y desafíos que la hacen divertida y emocionante.
- Modo multijugador y competición en línea
-El juego tiene un modo multijugador que te permite competir contra otros jugadores de todo el mundo. Puede unirse o crear una habitación e invitar a sus amigos o jugadores al azar para unirse a usted. También puedes chatear con otros jugadores y enviarles emojis y pegatinas. El juego también tiene un sistema de clasificación en línea que muestra su posición y el progreso en comparación con otros jugadores. Puedes ganar recompensas y trofeos al ganar carreras y completar desafíos.
- Cómo jugar CarX Street
-
- Descargar e instalar el juego
-El primer paso es descargar e instalar el juego en su dispositivo Android. Puede encontrar el juego en la Google Play Store o en el sitio web oficial de CarX Technologies. El juego es gratis para descargar y jugar, pero tiene algunas compras en la aplicación que pueden mejorar su experiencia de juego.
-
- Elige tu coche y pista
-El siguiente paso es elegir el coche y la pista. Puede navegar a través de los coches y pistas disponibles y seleccionar los que se adapten a su preferencia y estilo. También puede personalizar su automóvil cambiando su color, ruedas, alerones, motor, suspensión y más. También puedes desbloquear nuevos coches y pistas ganando monedas y estrellas en el juego.
- Carrera y victoria
-El paso final es correr y ganar. Puedes elegir entre diferentes modos de carrera, como el modo carrera, carrera rápida, modo multijugador y más. También puedes elegir entre diferentes niveles de dificultad, como fácil, medio, duro y experto. Puede controlar su automóvil utilizando la pantalla táctil o el sensor de inclinación de su dispositivo. También puede usar los botones de la pantalla para frenar, desviar, aumentar y cambiar los ángulos de la cámara. También puede ver su velocidad, tiempo de vuelta, posición y daños en la pantalla.
- Conclusión de CarX Street Webteknohaber
-CarX Street Webteknohaber es un increíble juego de carreras que te mantendrá entretenido durante horas. El juego tiene física realista, gráficos de alta calidad y una amplia variedad de coches y pistas. El juego también tiene un modo multijugador que te permite competir con otros jugadores de todo el mundo. El juego es fácil de jugar, pero difícil de dominar, ya que tendrá que perfeccionar sus habilidades de conducción y estrategias para ganar carreras. Si estás buscando un juego de carreras divertido y desafiante para tu dispositivo Android, definitivamente deberías probar CarX Street Webteknohaber.
- Un resumen de los puntos principales
-Para resumir, aquí están los puntos principales de este artículo:
-
-
-El juego tiene física realista, gráficos de alta calidad y un mundo dinámico y abierto de carreras callejeras.
-El juego tiene más de 50 coches y más de 20 pistas para elegir, así como un sistema de personalización que le permite modificar la apariencia y el rendimiento de su coche.
-El juego tiene un modo multijugador que te permite competir contra otros jugadores de todo el mundo.
-El juego es fácil de jugar pero difícil de dominar, ya que tendrá que dominar las habilidades de frenado, deriva, adelantamiento y reparación.
-
- Una recomendación para probar el juego
-Si está interesado en CarX Street Webteknohaber, le recomendamos que descargue e instale el juego en su dispositivo Android. No te arrepentirás, ya que es uno de los mejores juegos de carreras disponibles en el mercado. Usted tendrá una explosión de carreras a través de diferentes pistas y competir con otros jugadores. También disfrutarás de la experiencia de conducción realista y los impresionantes gráficos del juego. ¿Qué estás esperando? Descargar CarX Street Webteknohaber hoy y empezar a correr!
- Preguntas frecuentes (preguntas frecuentes)
-Aquí están algunas de las preguntas más frecuentes sobre CarX Street Webteknohaber:
- Q: ¿Cuánto espacio ocupa CarX Street Webteknohaber en mi dispositivo?
-A: CarX Street Webteknohaber ocupa aproximadamente 1 GB de espacio en su dispositivo. Sin embargo, esto puede variar dependiendo del modelo y la configuración del dispositivo.
- Q: ¿Cómo puedo ganar monedas y estrellas en CarX Street Webteknohaber?
-A: Puedes ganar monedas y estrellas al ganar carreras, completar desafíos, ver anuncios o hacer compras en la aplicación.
- Q: ¿Cómo puedo desbloquear nuevos coches y pistas en CarX Street Webteknohaber?
-A
A: Puedes desbloquear nuevos coches y pistas ganando suficientes monedas y estrellas para comprarlos. También puedes desbloquear algunos coches y pistas completando ciertos niveles o desafíos en el juego.
- Q: ¿Cómo puedo jugar CarX Street Webteknohaber con mis amigos?
-
- Q: ¿CarX Street Webteknohaber es seguro?
-A: Sí, CarX Street Webteknohaber es seguro. El juego no recopila ninguna información personal o confidencial de usted o de su dispositivo. El juego tampoco contiene virus, malware o spyware que puedan dañar tu dispositivo o datos.
64aa2da5cfDark Riddle APK Mod Descargar: Un espeluznante y divertido juego de aventura
- Introducción
- ¿Te gustan los juegos de aventura que desafían tu curiosidad y creatividad? ¿Te gusta resolver puzzles y explorar secretos? ¿Te gustan los juegos que tienen una atmósfera misteriosa y espeluznante? Si respondiste sí a cualquiera de estas preguntas, entonces te encantará Dark Riddle, un juego que te permite descubrir los oscuros secretos de la casa de tu vecino. Y si quieres tener más diversión y emoción, usted debe descargar Dark Riddle APK Mod, una versión modificada del juego que le da dinero ilimitado y acceso a todo el contenido. En este artículo, le diremos todo lo que necesita saber sobre Dark Riddle APK Mod, incluyendo sus características, cómo descargar e instalar, y algunas preguntas frecuentes.
- ¿Qué es Dark Riddle?
- Dark Riddle es un juego de aventura desarrollado por Nika Entertainment. Está inspirado en el popular juego Hello Neighbor, donde tienes que colarte en la casa de tu vecino y averiguar qué está escondiendo. En Dark Riddle, juegas como un personaje curioso que nota que su vecino está actuando muy extraño. Siempre se encierra en su casa, tiene cámaras por todas partes, y parece estar escondiendo algo en su sótano. Decides investigar su casa y descubrir sus secretos, pero ten cuidado, porque no te dejará hacerlo fácilmente. Te perseguirá, te pondrá trampas y tratará de detenerte a toda costa. Necesitarás usar tu ingenio, tus habilidades y tus objetos para ser más astuto que él y resolver el enigma oscuro.
-descargar apk oscuro enigma mod Download Zip >>> https://bltlly.com/2v6Khh
¿Por qué descargar Dark Riddle APK Mod?
-
- Características de Dark Riddle APK Mod
- Explora la misteriosa casa del vecino
- Una de las principales características de Dark Riddle es que te permite explorar la casa del vecino de diferentes maneras. Puede entrar por la puerta principal, la puerta trasera, las ventanas o incluso el techo. También puede usar diferentes artículos y herramientas para entrar, como palancas, martillos, llaves o ganchos. Encontrará muchas habitaciones y áreas en la casa, como la sala de estar, la cocina, el baño, el dormitorio, el ático y el sótano. Cada habitación tiene sus propios puzzles y secretos que necesitas resolver y descubrir. También encontrará varios obstáculos y peligros en la casa, como cámaras, alarmas, trampas o incluso el propio vecino. Tendrás que ser sigiloso, inteligente y rápido para evitarlos.
- Utilice varios elementos y herramientas para resolver puzzles
- Otra característica de Dark Riddle es que desafía tu creatividad y habilidades para resolver problemas con varios puzzles. Usted tendrá que utilizar diferentes artículos y herramientas que se encuentran en la casa o en su inventario para resolverlos. Por ejemplo, es posible que necesite usar una linterna para ver en la oscuridad, un imán para atraer objetos metálicos, un destornillador para abrir un panel o una cáscara de plátano para hacer que el vecino se deslice. También puedes combinar objetos para crear otros nuevos, como fuegos artificiales para hacer una distracción, una cuerda para bajar o un globo para flotar. Tendrás que usar tu imaginación y lógica para encontrar las mejores soluciones para cada rompecabezas.
- Disfruta de gráficos inmersivos y efectos de sonido
-
- Juega online con otros jugadores o offline por ti mismo
- Dark Riddle también te ofrece dos modos de juego: online o offline. En el modo online, puedes unirte a otros jugadores de todo el mundo y jugar juntos como un equipo o como rivales. Puedes elegir ser el explorador o el vecino, y cooperar o competir con otros jugadores. También puedes chatear con otros jugadores y hacer amigos o enemigos. En el modo offline, puedes jugar solo y disfrutar del juego a tu propio ritmo. También puedes personalizar tu personaje y tus objetos, y desbloquear nuevo contenido a medida que avanzas en el juego.
-
- Obtén dinero ilimitado y acceso a todo el contenido
- La mejor característica de Dark Riddle APK Mod es que le da dinero ilimitado y acceso a todo el contenido en el juego. Con dinero ilimitado, puede comprar cualquier artículo o herramienta que desee sin preocuparse por quedarse sin efectivo. También puede actualizar sus artículos y herramientas para hacerlos más eficaces y útiles. Con acceso a todo el contenido, podrás disfrutar de todos los niveles, salas, puzzles, objetos, herramientas, personajes y modos que el juego tiene para ofrecer sin tener que pagar ni esperar nada. También puedes deshacerte de los anuncios y disfrutar del juego sin interrupciones.
- Cómo descargar e instalar Dark Riddle APK Mod
- Paso 1: Descargar el archivo APK de una fuente de confianza
- El primer paso para descargar e instalar Dark Riddle APK Mod es encontrar una fuente confiable que proporciona el archivo APK de forma gratuita. Puede buscar en línea para sitios web que ofrecen Dark Riddle APK Mod enlaces de descarga, pero tenga cuidado de no descargar de sitios maliciosos o falsos que pueden dañar su dispositivo o robar sus datos. También puede utilizar este enlace para descargar Dark Riddle APK Mod de forma segura y fácil.
- Paso 2: Habilitar fuentes desconocidas en el dispositivo
-
- Paso 3: Instalar el archivo APK y lanzar el juego
- El tercer y último paso es instalar el archivo APK y lanzar el juego. Para hacer esto, busque el archivo APK descargado en el almacenamiento del dispositivo, toque en él y siga las instrucciones en la pantalla. Una vez completada la instalación, puede iniciar Dark Riddle APK Mod desde el cajón de la aplicación o la pantalla de inicio. Disfrute!
- Conclusión
- Dark Riddle es un increíble juego de aventura que te permite explorar los secretos de la casa de tu vecino de una manera espeluznante y divertida. Tiene muchas características que lo hacen agradable y desafiante, como rompecabezas, artículos, herramientas, gráficos, efectos de sonido, modos y contenido. Y si quieres tener más diversión y emoción, usted debe descargar Dark Riddle APK Mod, una versión modificada del juego que le da dinero ilimitado y acceso a todo el contenido. Es fácil descargar e instalar Dark Riddle APK Mod en su dispositivo siguiendo estos sencillos pasos:
-
-Paso 1: Descargar el archivo APK de una fuente de confianza
-Paso 2: Habilitar fuentes desconocidas en el dispositivo
-Paso 3: Instalar el archivo APK y lanzar el juego
-
-Esperamos que este artículo le ha ayudado a aprender más sobre Dark Riddle APK Mod y cómo conseguirlo en su dispositivo. Si tiene alguna pregunta o comentario, no dude en dejarlos en la sección de comentarios a continuación. ¡Gracias por leer!
Preguntas frecuentes
- Aquí están algunas de las preguntas más frecuentes sobre Dark Riddle APK Mod:
- ¿Es seguro descargar e instalar Dark Riddle APK Mod?
- Sí, Dark Riddle APK Mod es seguro para descargar e instalar, siempre y cuando se obtiene de una fuente de confianza. No contiene ningún virus, malware o spyware que pueda dañar su dispositivo o robar sus datos. Sin embargo, siempre debe tener cuidado al descargar e instalar cualquier archivo APK de fuentes desconocidas, y escanearlo con un software antivirus antes de abrirlo.
- ¿Es Dark Riddle APK Mod compatible con mi dispositivo?
-
- ¿Cómo puedo actualizar Dark Riddle APK Mod?
- Dark Riddle APK Mod se actualiza regularmente para corregir errores, mejorar el rendimiento y agregar nuevas características y contenido. Puede actualizar Dark Riddle APK Mod mediante la descarga e instalación de la última versión del archivo APK de la misma fuente que lo obtuvo de. También puedes buscar actualizaciones iniciando el juego y mirando el menú de configuración.
- ¿Cómo puedo desinstalar Dark Riddle APK Mod?
- Si desea desinstalar Dark Riddle APK Mod de su dispositivo, puede hacerlo siguiendo estos pasos:
-
-Ir a la configuración del dispositivo, luego aplicaciones, entonces Dark Riddle
-Toque en desinstalar y confirmar su elección
-Eliminar el archivo APK de su dispositivo de almacenamiento
-
-También puede reinstalar la versión original de Dark Riddle desde Google Play Store o App Store si lo desea.
- ¿Dónde puedo obtener más información sobre Dark Riddle APK Mod?
- Si desea obtener más información sobre Dark Riddle APK Mod, puede visitar el sitio web oficial del desarrollador de juegos, Nika Entertainment, o sus páginas de medios sociales en Facebook, Twitter, Instagram o YouTube. También puedes unirte a su servidor de Discord o a la comunidad de Reddit para chatear con otros jugadores y obtener consejos y trucos. También puede ponerse en contacto con su equipo de atención al cliente por correo electrónico o teléfono si tiene algún problema o retroalimentación.
64aa2da5cfDescarga de archivos PUBG Mobile 90 FPS: Cómo mejorar su experiencia de juego
-Si eres un fan de PUBG Mobile, es posible que hayas oído hablar del término "90 FPS". Pero ¿qué significa y cómo puedes conseguirlo? En este artículo, explicaremos todo lo que necesitas saber sobre cómo jugar a PUBG Mobile en 90 FPS, incluidos los beneficios, los requisitos, los pasos, los problemas y las revisiones. Sigue leyendo para descubrir cómo llevar tu experiencia de juego al siguiente nivel.
-Descargar archivo pubg mobile 90 fps DOWNLOAD ✏ ✏ ✏ https://bltlly.com/2v6Mc2
¿Qué es PUB Qué es PUBG Mobile y por qué necesitas 90 FPS?
- PUBG Mobile es un popular juego battle royale que ofrece gráficos realistas y jugabilidad. Puedes jugar solo o con tus amigos en varios modos y mapas. También puedes personalizar tu personaje, armas y vehículos. El juego tiene más de 1 mil millones de descargas y millones de jugadores activos en todo el mundo.
-90 FPS significa 90 cuadros por segundo, lo que significa imágenes más suaves y rápidas. Cuanto más alto sea el FPS, mejor será la calidad del juego. La mayoría de los dispositivos móviles solo pueden admitir hasta 60 FPS, que es la configuración predeterminada para PUBG Mobile. Sin embargo, algunos dispositivos pueden ir más allá y soportar hasta 90 FPS o incluso 120 FPS.
-Los beneficios de jugar PUBG Mobile en 90 FPS incluyen un mejor objetivo, tiempo de reacción e inmersión. Puedes ver más detalles y movimientos en la pantalla, lo que te da una ventaja sobre tus enemigos. También puede reaccionar más rápido y con mayor precisión a las situaciones cambiantes en el juego. Además, puedes disfrutar de una experiencia de juego más inmersiva y realista con 90 FPS.
-
-Cómo habilitar 90 FPS en PUBG Mobile en dispositivos OnePlus
-Los dispositivos OnePlus son los únicos que soportan oficialmente 90 FPS en PUBG Mobile. Esto se debe a que OnePlus se ha asociado con PUBG Mobile para ofrecer esta función exclusivamente a sus usuarios. Si tienes un dispositivo OnePlus que tiene una pantalla de frecuencia de actualización de 90 Hz o superior, puedes habilitar fácilmente 90 FPS en PUBG Mobile siguiendo estos pasos:
-
-Paso 1: Abra PUBG Mobile y vaya a la configuración
-Inicie el juego y toque en el icono de engranaje en la esquina inferior derecha de la pantalla. Esto abrirá el menú de configuración.
-Paso 2: Toque en los gráficos y seleccione la opción suave
-En el menú de configuración, toque en la pestaña de gráficos y seleccione la opción suave de la sección de calidad de gráficos. Esto optimizará el juego para el rendimiento y reducir la carga de gráficos.
-Paso 3: Toque en la velocidad de fotogramas y seleccione la opción 90 FPS
-En la misma pestaña, toque en la sección de velocidad de fotogramas y seleccione la opción 90 FPS de la lista. Esto habilitará el modo 90 FPS para PUBG Mobile.
-Paso 4: Disfruta del juego en 90 FPS
-¡Eso es todo! Ahora puedes disfrutar jugando a PUBG Mobile en 90 FPS en tu dispositivo OnePlus. Usted notará una diferencia significativa en la suavidad y la capacidad de respuesta del juego.
Cómo descargar y usar el archivo de configuración de 90 FPS para PUBG Mobile en otros dispositivos
-Si no tienes un dispositivo OnePlus, no te preocupes. Aún puedes jugar a PUBG Mobile en 90 FPS usando un archivo de configuración que modifique la configuración del juego. Un archivo de configuración es un archivo que contiene los datos de configuración de un programa o aplicación. Al usar un archivo de configuración de 90 FPS para PUBG Mobile, puede anular la configuración predeterminada y habilitar el modo de 90 FPS en su dispositivo.
-Sin embargo, antes de proceder, debe ser consciente de los riesgos que implica el uso de un archivo de configuración. En primer lugar, el uso de un archivo de configuración puede violar los términos de servicio de PUBG Mobile y resultar en una prohibición o suspensión de su cuenta. Segundo, usar un archivo de configuración puede causar problemas de compatibilidad o errores en el juego. Tercero, usar un archivo de configuración puede dañar su dispositivo o reducir su rendimiento. Por lo tanto, use un archivo de configuración bajo su propio riesgo y discreción.
-Si estás dispuesto a asumir el riesgo, puedes seguir estos pasos para descargar y usar un archivo de configuración de 90 FPS para PUBG Mobile en otros dispositivos:
-
-Paso 1: Descargue el archivo de configuración de 90 FPS desde este enlace
-El enlace le llevará a una página de Google Drive donde puede descargar el archivo zip que contiene el archivo de configuración de 90 FPS para PUBG Mobile. El tamaño del archivo es de aproximadamente 1 MB y es compatible con dispositivos Android e iOS.
-Paso 2: Descargar la aplicación ZArchiver de Play Store o App Store
-ZArchiver es una aplicación que te permite extraer y administrar archivos zip en tu dispositivo. Necesitará esta aplicación para acceder al contenido del archivo zip que descargó en el paso 1. Puede descargar ZArchiver de Play Store o App Store de forma gratuita.
-Paso 3: Abra el archivo zip y extraiga todo su contenido
-Después de descargar ZArchiver, abrirlo y localizar el archivo zip que ha descargado en el paso 1. Toque en el archivo zip y seleccione extraer aquí opción. Esto extraerá todo el contenido del archivo zip a su dispositivo.
-Paso 4: Copiar el archivo a Android > Datos > com.tencent.ig > Archivos > UE4Game > ShadowTrackerExtra > ShadowTrackerExtra > Guardado > Configuración > Carpeta de Android
-El archivo zip extraído contendrá un archivo llamado UserCustom.ini. Este es el archivo de configuración de 90 FPS para PUBG Mobile. Es necesario copiar este archivo a una carpeta específica en el dispositivo donde PUBG Mobile almacena su configuración. La ruta de la carpeta puede variar dependiendo del modelo de dispositivo y el sistema operativo, pero generalmente es algo como esto: Android > Datos > com.tencent.ig > Archivos > UE4Game > ShadowTrackerExtra > ShadowTrackerExtra > Guardado > Configuración > Android. Si no puede encontrar la carpeta, puede usar la función de búsqueda de ZArchiver para localizarla.
-Paso 5: Reinicie su dispositivo y inicie PUBG Mobile
-Después de copiar el archivo, reinicie el dispositivo y ejecute PUBG Mobile. Deberías poder ver la opción 90 FPS en la configuración gráfica del juego. Selecciónelo y disfrute jugando PUBG Mobile en 90 FPS.
Problemas y soluciones para jugar PUBG Mobile en 90 FPS
-
-Soluciones para jugar PUBG Mobile en 90 FPS
-Utilice una almohadilla de enfriamiento
-Una almohadilla de enfriamiento es un dispositivo que ayuda a reducir la temperatura de su dispositivo mediante la circulación de aire o agua. Puede utilizar una almohadilla de enfriamiento para evitar que su dispositivo se sobrecaliente mientras juega PUBG Mobile en 90 FPS. Puede comprar una almohadilla de enfriamiento en línea o en una tienda local.
-Utilice un banco de energía
-Un banco de energía es una batería portátil que puede cargar su dispositivo cuando se queda sin energía. Puede usar un banco de energía para evitar que su dispositivo se quede sin batería mientras juega PUBG Mobile en 90 FPS. Puede comprar un banco de energía en línea o en una tienda local.
-Utilice una conexión a Internet estable
-Una conexión a Internet estable es esencial para jugar PUBG Mobile sin problemas y sin retraso. Puede utilizar una conexión Wi-Fi o una conexión de datos móvil para reproducir PUBG Mobile en 90 FPS. Sin embargo, debe asegurarse de que su conexión sea rápida y confiable. Puede comprobar la velocidad y la calidad de su conexión utilizando una aplicación o un sitio web.
-Comentarios y valoraciones para jugar PUBG Mobile en 90 FPS
-Jugar a PUBG Mobile en 90 FPS ha recibido críticas y valoraciones positivas de los usuarios que lo han probado. Muchos usuarios han informado que han mejorado su experiencia de juego y rendimiento jugando en 90 FPS. También han elogiado los gráficos y la suavidad del juego.
-Sin embargo, algunos usuarios también han informado algunas críticas negativas y calificaciones para jugar PUBG Mobile en 90 FPS. Algunos usuarios se han quejado de que se han enfrentado a problemas como el sobrecalentamiento, el drenaje de la batería y el retraso al jugar en 90 FPS. También han criticado el juego por no soportar 90 FPS en todos los dispositivos.
-Algunas de las reseñas y valoraciones para jugar a PUBG Mobile en 90 FPS son las siguientes :
-Algunos de los comentarios y valoraciones para jugar PUBG Mobile en 90 FPS
-
-Ravi Kumar es uno de los usuarios satisfechos que han utilizado el archivo de configuración de 90 FPS para PUBG Mobile. Ha dado una calificación de cinco estrellas y una crítica positiva para la aplicación. Ha apreciado la aplicación para desbloquear 90 FPS en su dispositivo y mejorar su experiencia de juego.
-"He estado jugando pubg móvil durante mucho tiempo y siempre quise jugar en 90 fps. Esta aplicación lo hizo posible para mí. Funciona perfectamente y no tengo problemas." - Aryan Singh, ⭐⭐⭐⭐⭐⭐
-Aryan Singh es otro usuario feliz que ha utilizado el archivo de configuración de 90 FPS para PUBG Mobile. Ha dado una calificación de cinco estrellas y una crítica positiva para la aplicación. Ha elogiado la aplicación por hacer posible que juegue PUBG Mobile en 90 FPS. También ha declarado que la aplicación funciona perfectamente y que no tiene problemas.
-"Esta aplicación es buena, pero agota mi batería muy rápido. Me gustaría que hubiera una manera de reducir el consumo de batería mientras se juega en 90 fps." - Priya Sharma, ⭐⭐⭐⭐
-Priya Sharma es uno de los usuarios que se han enfrentado a algunos problemas al usar el archivo de configuración de 90 FPS para PUBG Mobile. Ella ha dado una calificación de cuatro estrellas y una crítica mixta para la aplicación. Le ha gustado la aplicación para habilitar 90 FPS en su dispositivo, pero también le ha disgustado por agotar su batería muy rápido. Ella ha deseado que hubiera una manera de reducir el consumo de batería mientras se juega en 90 FPS.
Conclusión y preguntas frecuentes
-En conclusión, jugar a PUBG Mobile en 90 FPS es una gran manera de mejorar su experiencia de juego y rendimiento. Puede habilitarlo en dispositivos OnePlus o descargar un archivo de configuración para otros dispositivos. Sin embargo, también debes ser consciente de los posibles problemas y soluciones para jugar en 90 FPS. Si quieres probarlo, puedes seguir los pasos dados en este artículo. ¡Feliz juego!
-Aquí hay algunas preguntas frecuentes sobre jugar a PUBG Mobile en 90 FPS:
-Preguntas frecuentes: Aquí hay algunas preguntas frecuentes sobre jugar PUBG Mobile en 90 FPS
-
-A: Jugar a PUBG Mobile en 90 FPS es seguro siempre y cuando uses una fuente confiable y confiable para descargar el archivo de configuración. Sin embargo, también debe tener cuidado con los riesgos que implica el uso de un archivo de configuración, como violar los términos del servicio, causar errores o dañar su dispositivo.
-Q: ¿Jugar a PUBG Mobile en 90 FPS es legal?
-A: Jugar a PUBG Mobile en 90 FPS es legal siempre y cuando no uses trucos, hacks o mods que te den una ventaja injusta sobre otros jugadores. Sin embargo, también debe tener en cuenta que PUBG Mobile puede no aprobar el uso de un archivo de configuración para modificar la configuración del juego y puede tomar medidas contra su cuenta.
-Q: ¿Qué dispositivos admiten 90 FPS en PUBG Mobile?
-A: Los únicos dispositivos que admiten oficialmente 90 FPS en PUBG Mobile son dispositivos OnePlus que tienen una pantalla de frecuencia de actualización de 90 Hz o superior. Otros dispositivos también pueden reproducir PUBG Mobile en 90 FPS mediante un archivo de configuración, pero es posible que no tengan el rendimiento óptimo o compatibilidad.
-Q: ¿Cómo puedo comprobar si estoy jugando PUBG Mobile en 90 FPS?
-A: Puedes comprobar si estás jugando a PUBG Mobile en 90 FPS usando una aplicación o un sitio web que mida tu FPS. También puedes comprobar la configuración gráfica del juego y ver si la opción 90 FPS está seleccionada.
-Q: ¿Cuáles son algunas alternativas a jugar PUBG Mobile en 90 FPS?
-A: Algunas alternativas a jugar PUBG Mobile en 90 FPS están jugando en 60 FPS o menos, lo que puede reducir los problemas y riesgos de jugar en 90 FPS. También puedes probar otros juegos compatibles con 90 FPS o versiones posteriores, como Call of Duty Mobile, Asphalt 9 o Fortnite.
64aa2da5cf`_.
- None will set an infinite timeout for connection attempts.
-
- :type connect: int, float, or None
-
- :param read:
- The maximum amount of time (in seconds) to wait between consecutive
- read operations for a response from the server. Omitting the parameter
- will default the read timeout to the system default, probably `the
- global default timeout in socket.py
- `_.
- None will set an infinite timeout.
-
- :type read: int, float, or None
-
- .. note::
-
- Many factors can affect the total amount of time for urllib3 to return
- an HTTP response.
-
- For example, Python's DNS resolver does not obey the timeout specified
- on the socket. Other factors that can affect total request time include
- high CPU load, high swap, the program running at a low priority level,
- or other behaviors.
-
- In addition, the read and total timeouts only measure the time between
- read operations on the socket connecting the client and the server,
- not the total amount of time for the request to return a complete
- response. For most requests, the timeout is raised because the server
- has not sent the first byte in the specified time. This is not always
- the case; if a server streams one byte every fifteen seconds, a timeout
- of 20 seconds will not trigger, even though the request will take
- several minutes to complete.
-
- If your goal is to cut off any request after a set amount of wall clock
- time, consider having a second "watcher" thread to cut off a slow
- request.
- """
-
- #: A sentinel object representing the default timeout value
- DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT
-
- def __init__(self, total=None, connect=_Default, read=_Default):
- self._connect = self._validate_timeout(connect, "connect")
- self._read = self._validate_timeout(read, "read")
- self.total = self._validate_timeout(total, "total")
- self._start_connect = None
-
- def __repr__(self):
- return "%s(connect=%r, read=%r, total=%r)" % (
- type(self).__name__,
- self._connect,
- self._read,
- self.total,
- )
-
- # __str__ provided for backwards compatibility
- __str__ = __repr__
-
- @classmethod
- def resolve_default_timeout(cls, timeout):
- return getdefaulttimeout() if timeout is cls.DEFAULT_TIMEOUT else timeout
-
- @classmethod
- def _validate_timeout(cls, value, name):
- """Check that a timeout attribute is valid.
-
- :param value: The timeout value to validate
- :param name: The name of the timeout attribute to validate. This is
- used to specify in error messages.
- :return: The validated and casted version of the given value.
- :raises ValueError: If it is a numeric value less than or equal to
- zero, or the type is not an integer, float, or None.
- """
- if value is _Default:
- return cls.DEFAULT_TIMEOUT
-
- if value is None or value is cls.DEFAULT_TIMEOUT:
- return value
-
- if isinstance(value, bool):
- raise ValueError(
- "Timeout cannot be a boolean value. It must "
- "be an int, float or None."
- )
- try:
- float(value)
- except (TypeError, ValueError):
- raise ValueError(
- "Timeout value %s was %s, but it must be an "
- "int, float or None." % (name, value)
- )
-
- try:
- if value <= 0:
- raise ValueError(
- "Attempted to set %s timeout to %s, but the "
- "timeout cannot be set to a value less "
- "than or equal to 0." % (name, value)
- )
- except TypeError:
- # Python 3
- raise ValueError(
- "Timeout value %s was %s, but it must be an "
- "int, float or None." % (name, value)
- )
-
- return value
-
- @classmethod
- def from_float(cls, timeout):
- """Create a new Timeout from a legacy timeout value.
-
- The timeout value used by httplib.py sets the same timeout on the
- connect(), and recv() socket requests. This creates a :class:`Timeout`
- object that sets the individual timeouts to the ``timeout`` value
- passed to this function.
-
- :param timeout: The legacy timeout value.
- :type timeout: integer, float, sentinel default object, or None
- :return: Timeout object
- :rtype: :class:`Timeout`
- """
- return Timeout(read=timeout, connect=timeout)
-
- def clone(self):
- """Create a copy of the timeout object
-
- Timeout properties are stored per-pool but each request needs a fresh
- Timeout object to ensure each one has its own start/stop configured.
-
- :return: a copy of the timeout object
- :rtype: :class:`Timeout`
- """
- # We can't use copy.deepcopy because that will also create a new object
- # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to
- # detect the user default.
- return Timeout(connect=self._connect, read=self._read, total=self.total)
-
- def start_connect(self):
- """Start the timeout clock, used during a connect() attempt
-
- :raises urllib3.exceptions.TimeoutStateError: if you attempt
- to start a timer that has been started already.
- """
- if self._start_connect is not None:
- raise TimeoutStateError("Timeout timer has already been started.")
- self._start_connect = current_time()
- return self._start_connect
-
- def get_connect_duration(self):
- """Gets the time elapsed since the call to :meth:`start_connect`.
-
- :return: Elapsed time in seconds.
- :rtype: float
- :raises urllib3.exceptions.TimeoutStateError: if you attempt
- to get duration for a timer that hasn't been started.
- """
- if self._start_connect is None:
- raise TimeoutStateError(
- "Can't get connect duration for timer that has not started."
- )
- return current_time() - self._start_connect
-
- @property
- def connect_timeout(self):
- """Get the value to use when setting a connection timeout.
-
- This will be a positive float or integer, the value None
- (never timeout), or the default system timeout.
-
- :return: Connect timeout.
- :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
- """
- if self.total is None:
- return self._connect
-
- if self._connect is None or self._connect is self.DEFAULT_TIMEOUT:
- return self.total
-
- return min(self._connect, self.total)
-
- @property
- def read_timeout(self):
- """Get the value for the read timeout.
-
- This assumes some time has elapsed in the connection timeout and
- computes the read timeout appropriately.
-
- If self.total is set, the read timeout is dependent on the amount of
- time taken by the connect timeout. If the connection time has not been
- established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be
- raised.
-
- :return: Value to use for the read timeout.
- :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None
- :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect`
- has not yet been called on this object.
- """
- if (
- self.total is not None
- and self.total is not self.DEFAULT_TIMEOUT
- and self._read is not None
- and self._read is not self.DEFAULT_TIMEOUT
- ):
- # In case the connect timeout has not yet been established.
- if self._start_connect is None:
- return self._read
- return max(0, min(self.total - self.get_connect_duration(), self._read))
- elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT:
- return max(0, self.total - self.get_connect_duration())
- else:
- return self._read
diff --git a/spaces/Bigshot/RSA-v0.1.2/README.md b/spaces/Bigshot/RSA-v0.1.2/README.md
deleted file mode 100644
index 7299610989b0dfdb93261c240cc37a8c5b8a1048..0000000000000000000000000000000000000000
--- a/spaces/Bigshot/RSA-v0.1.2/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: RSA V0.1.2
-emoji: 🐢
-colorFrom: pink
-colorTo: purple
-sdk: gradio
-sdk_version: 3.19.1
-app_file: app.py
-pinned: false
-license: cc-by-2.0
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/BilalSardar/QuestionAndAnswer/app.py b/spaces/BilalSardar/QuestionAndAnswer/app.py
deleted file mode 100644
index e235a0898a6d73c4637123090fadd0a339417a82..0000000000000000000000000000000000000000
--- a/spaces/BilalSardar/QuestionAndAnswer/app.py
+++ /dev/null
@@ -1,18 +0,0 @@
-from transformers import AutoModelForQuestionAnswering, AutoTokenizer, pipeline
-import gradio as gr
-# Creating the Q&A pipeline
-nlp = pipeline('question-answering', model='deepset/roberta-base-squad2', tokenizer='deepset/roberta-base-squad2')
-
-def questionAndAnswer(ques,content):
- question_set = {'question':ques,'context':content}
- results = nlp(question_set)
- return results['answer']
-
-interface = gr.Interface(fn=questionAndAnswer,
- inputs=["text","text"],
- outputs="text",
- title='Bilal Question&Answer')
-
-
-interface.launch(inline=False)
-
diff --git a/spaces/Billet/WizardLM-WizardMath-70B-V1.033/README.md b/spaces/Billet/WizardLM-WizardMath-70B-V1.033/README.md
deleted file mode 100644
index 176c1a0cbf06b543cad87d97b8fd1535e30b4eb5..0000000000000000000000000000000000000000
--- a/spaces/Billet/WizardLM-WizardMath-70B-V1.033/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: WizardLM WizardMath 70B V1.033
-emoji: 👁
-colorFrom: pink
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.42.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/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/export/c10.py b/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/export/c10.py
deleted file mode 100644
index 66085b01c944824956b6b1987bf73792d06d909e..0000000000000000000000000000000000000000
--- a/spaces/CVPR/Dual-Key_Backdoor_Attacks/datagen/detectron2/detectron2/export/c10.py
+++ /dev/null
@@ -1,506 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-
-import math
-import torch
-import torch.nn.functional as F
-
-from detectron2.layers import cat
-from detectron2.layers.roi_align_rotated import ROIAlignRotated
-from detectron2.modeling import poolers
-from detectron2.modeling.proposal_generator import rpn
-from detectron2.modeling.roi_heads.mask_head import mask_rcnn_inference
-from detectron2.structures import Boxes, ImageList, Instances, Keypoints
-
-from .shared import alias, to_device
-
-
-"""
-This file contains caffe2-compatible implementation of several detectrno2 components.
-"""
-
-
-class Caffe2Boxes(Boxes):
- """
- Representing a list of detectron2.structures.Boxes from minibatch, each box
- is represented by a 5d vector (batch index + 4 coordinates), or a 6d vector
- (batch index + 5 coordinates) for RotatedBoxes.
- """
-
- def __init__(self, tensor):
- assert isinstance(tensor, torch.Tensor)
- assert tensor.dim() == 2 and tensor.size(-1) in [4, 5, 6], tensor.size()
- # TODO: make tensor immutable when dim is Nx5 for Boxes,
- # and Nx6 for RotatedBoxes?
- self.tensor = tensor
-
-
-# TODO clean up this class, maybe just extend Instances
-class InstancesList(object):
- """
- Tensor representation of a list of Instances object for a batch of images.
-
- When dealing with a batch of images with Caffe2 ops, a list of bboxes
- (instances) are usually represented by single Tensor with size
- (sigma(Ni), 5) or (sigma(Ni), 4) plus a batch split Tensor. This class is
- for providing common functions to convert between these two representations.
- """
-
- def __init__(self, im_info, indices, extra_fields=None):
- # [N, 3] -> (H, W, Scale)
- self.im_info = im_info
- # [N,] -> indice of batch to which the instance belongs
- self.indices = indices
- # [N, ...]
- self.batch_extra_fields = extra_fields or {}
-
- self.image_size = self.im_info
-
- def get_fields(self):
- """ like `get_fields` in the Instances object,
- but return each field in tensor representations """
- ret = {}
- for k, v in self.batch_extra_fields.items():
- # if isinstance(v, torch.Tensor):
- # tensor_rep = v
- # elif isinstance(v, (Boxes, Keypoints)):
- # tensor_rep = v.tensor
- # else:
- # raise ValueError("Can't find tensor representation for: {}".format())
- ret[k] = v
- return ret
-
- def has(self, name):
- return name in self.batch_extra_fields
-
- def set(self, name, value):
- data_len = len(value)
- if len(self.batch_extra_fields):
- assert (
- len(self) == data_len
- ), "Adding a field of length {} to a Instances of length {}".format(data_len, len(self))
- self.batch_extra_fields[name] = value
-
- def __setattr__(self, name, val):
- if name in ["im_info", "indices", "batch_extra_fields", "image_size"]:
- super().__setattr__(name, val)
- else:
- self.set(name, val)
-
- def __getattr__(self, name):
- if name not in self.batch_extra_fields:
- raise AttributeError("Cannot find field '{}' in the given Instances!".format(name))
- return self.batch_extra_fields[name]
-
- def __len__(self):
- return len(self.indices)
-
- def flatten(self):
- ret = []
- for _, v in self.batch_extra_fields.items():
- if isinstance(v, (Boxes, Keypoints)):
- ret.append(v.tensor)
- else:
- ret.append(v)
- return ret
-
- @staticmethod
- def to_d2_instances_list(instances_list):
- """
- Convert InstancesList to List[Instances]. The input `instances_list` can
- also be a List[Instances], in this case this method is a non-op.
- """
- if not isinstance(instances_list, InstancesList):
- assert all(isinstance(x, Instances) for x in instances_list)
- return instances_list
-
- ret = []
- for i, info in enumerate(instances_list.im_info):
- instances = Instances(torch.Size([int(info[0].item()), int(info[1].item())]))
-
- ids = instances_list.indices == i
- for k, v in instances_list.batch_extra_fields.items():
- if isinstance(v, torch.Tensor):
- instances.set(k, v[ids])
- continue
- elif isinstance(v, Boxes):
- instances.set(k, v[ids, -4:])
- continue
-
- target_type, tensor_source = v
- assert isinstance(tensor_source, torch.Tensor)
- assert tensor_source.shape[0] == instances_list.indices.shape[0]
- tensor_source = tensor_source[ids]
-
- if issubclass(target_type, Boxes):
- instances.set(k, Boxes(tensor_source[:, -4:]))
- elif issubclass(target_type, Keypoints):
- instances.set(k, Keypoints(tensor_source))
- elif issubclass(target_type, torch.Tensor):
- instances.set(k, tensor_source)
- else:
- raise ValueError("Can't handle targe type: {}".format(target_type))
-
- ret.append(instances)
- return ret
-
-
-class Caffe2Compatible(object):
- def _get_tensor_mode(self):
- return self._tensor_mode
-
- def _set_tensor_mode(self, v):
- self._tensor_mode = v
-
- tensor_mode = property(_get_tensor_mode, _set_tensor_mode)
- """
- If true, the model expects C2-style tensor only inputs/outputs format.
- """
-
-
-class Caffe2RPN(Caffe2Compatible, rpn.RPN):
- def forward(self, images, features, gt_instances=None):
- assert not self.training
-
- features = [features[f] for f in self.in_features]
- objectness_logits_pred, anchor_deltas_pred = self.rpn_head(features)
-
- # TODO is the needed?
- # objectness_logits_pred = [t.sigmoid() for t in objectness_logits_pred]
-
- assert isinstance(images, ImageList)
- if self.tensor_mode:
- im_info = images.image_sizes
- else:
- im_info = torch.Tensor(
- [[im_sz[0], im_sz[1], torch.Tensor([1.0])] for im_sz in images.image_sizes]
- ).to(images.tensor.device)
- assert isinstance(im_info, torch.Tensor)
-
- rpn_rois_list = []
- rpn_roi_probs_list = []
- for scores, bbox_deltas, cell_anchors_tensor, feat_stride in zip(
- objectness_logits_pred,
- anchor_deltas_pred,
- iter(self.anchor_generator.cell_anchors),
- self.anchor_generator.strides,
- ):
- scores = scores.detach()
- bbox_deltas = bbox_deltas.detach()
-
- rpn_rois, rpn_roi_probs = torch.ops._caffe2.GenerateProposals(
- scores,
- bbox_deltas,
- im_info,
- cell_anchors_tensor,
- spatial_scale=1.0 / feat_stride,
- pre_nms_topN=self.pre_nms_topk[self.training],
- post_nms_topN=self.post_nms_topk[self.training],
- nms_thresh=self.nms_thresh,
- min_size=self.min_box_side_len,
- # correct_transform_coords=True, # deprecated argument
- angle_bound_on=True, # Default
- angle_bound_lo=-180,
- angle_bound_hi=180,
- clip_angle_thresh=1.0, # Default
- legacy_plus_one=False,
- )
- rpn_rois_list.append(rpn_rois)
- rpn_roi_probs_list.append(rpn_roi_probs)
-
- # For FPN in D2, in RPN all proposals from different levels are concated
- # together, ranked and picked by top post_nms_topk. Then in ROIPooler
- # it calculates level_assignments and calls the RoIAlign from
- # the corresponding level.
-
- if len(objectness_logits_pred) == 1:
- rpn_rois = rpn_rois_list[0]
- rpn_roi_probs = rpn_roi_probs_list[0]
- else:
- assert len(rpn_rois_list) == len(rpn_roi_probs_list)
- rpn_post_nms_topN = self.post_nms_topk[self.training]
-
- device = rpn_rois_list[0].device
- input_list = [to_device(x, "cpu") for x in (rpn_rois_list + rpn_roi_probs_list)]
-
- # TODO remove this after confirming rpn_max_level/rpn_min_level
- # is not needed in CollectRpnProposals.
- feature_strides = list(self.anchor_generator.strides)
- rpn_min_level = int(math.log2(feature_strides[0]))
- rpn_max_level = int(math.log2(feature_strides[-1]))
- assert (rpn_max_level - rpn_min_level + 1) == len(
- rpn_rois_list
- ), "CollectRpnProposals requires continuous levels"
-
- rpn_rois = torch.ops._caffe2.CollectRpnProposals(
- input_list,
- # NOTE: in current implementation, rpn_max_level and rpn_min_level
- # are not needed, only the subtraction of two matters and it
- # can be infer from the number of inputs. Keep them now for
- # consistency.
- rpn_max_level=2 + len(rpn_rois_list) - 1,
- rpn_min_level=2,
- rpn_post_nms_topN=rpn_post_nms_topN,
- )
- rpn_rois = to_device(rpn_rois, device)
- rpn_roi_probs = []
-
- proposals = self.c2_postprocess(im_info, rpn_rois, rpn_roi_probs, self.tensor_mode)
- return proposals, {}
-
- @staticmethod
- def c2_postprocess(im_info, rpn_rois, rpn_roi_probs, tensor_mode):
- proposals = InstancesList(
- im_info=im_info,
- indices=rpn_rois[:, 0],
- extra_fields={
- "proposal_boxes": Caffe2Boxes(rpn_rois),
- "objectness_logits": (torch.Tensor, rpn_roi_probs),
- },
- )
- if not tensor_mode:
- proposals = InstancesList.to_d2_instances_list(proposals)
- else:
- proposals = [proposals]
- return proposals
-
-
-class Caffe2ROIPooler(Caffe2Compatible, poolers.ROIPooler):
- @staticmethod
- def c2_preprocess(box_lists):
- assert all(isinstance(x, Boxes) for x in box_lists)
- if all(isinstance(x, Caffe2Boxes) for x in box_lists):
- # input is pure-tensor based
- assert len(box_lists) == 1
- pooler_fmt_boxes = box_lists[0].tensor
- else:
- pooler_fmt_boxes = poolers.convert_boxes_to_pooler_format(box_lists)
- return pooler_fmt_boxes
-
- def forward(self, x, box_lists):
- assert not self.training
-
- pooler_fmt_boxes = self.c2_preprocess(box_lists)
- num_level_assignments = len(self.level_poolers)
-
- if num_level_assignments == 1:
- if isinstance(self.level_poolers[0], ROIAlignRotated):
- c2_roi_align = torch.ops._caffe2.RoIAlignRotated
- aligned = True
- else:
- c2_roi_align = torch.ops._caffe2.RoIAlign
- aligned = self.level_poolers[0].aligned
-
- out = c2_roi_align(
- x[0],
- pooler_fmt_boxes,
- order="NCHW",
- spatial_scale=float(self.level_poolers[0].spatial_scale),
- pooled_h=int(self.output_size[0]),
- pooled_w=int(self.output_size[1]),
- sampling_ratio=int(self.level_poolers[0].sampling_ratio),
- aligned=aligned,
- )
- return out
-
- device = pooler_fmt_boxes.device
- assert (
- self.max_level - self.min_level + 1 == 4
- ), "Currently DistributeFpnProposals only support 4 levels"
- fpn_outputs = torch.ops._caffe2.DistributeFpnProposals(
- to_device(pooler_fmt_boxes, "cpu"),
- roi_canonical_scale=self.canonical_box_size,
- roi_canonical_level=self.canonical_level,
- roi_max_level=self.max_level,
- roi_min_level=self.min_level,
- legacy_plus_one=False,
- )
- fpn_outputs = [to_device(x, device) for x in fpn_outputs]
-
- rois_fpn_list = fpn_outputs[:-1]
- rois_idx_restore_int32 = fpn_outputs[-1]
-
- roi_feat_fpn_list = []
- for roi_fpn, x_level, pooler in zip(rois_fpn_list, x, self.level_poolers):
- if isinstance(pooler, ROIAlignRotated):
- c2_roi_align = torch.ops._caffe2.RoIAlignRotated
- aligned = True
- else:
- c2_roi_align = torch.ops._caffe2.RoIAlign
- aligned = bool(pooler.aligned)
-
- roi_feat_fpn = c2_roi_align(
- x_level,
- roi_fpn,
- order="NCHW",
- spatial_scale=float(pooler.spatial_scale),
- pooled_h=int(self.output_size[0]),
- pooled_w=int(self.output_size[1]),
- sampling_ratio=int(pooler.sampling_ratio),
- aligned=aligned,
- )
- roi_feat_fpn_list.append(roi_feat_fpn)
-
- roi_feat_shuffled = cat(roi_feat_fpn_list, dim=0)
- roi_feat = torch.ops._caffe2.BatchPermutation(roi_feat_shuffled, rois_idx_restore_int32)
- return roi_feat
-
-
-class Caffe2FastRCNNOutputsInference:
- def __init__(self, tensor_mode):
- self.tensor_mode = tensor_mode # whether the output is caffe2 tensor mode
-
- def __call__(self, box_predictor, predictions, proposals):
- """ equivalent to FastRCNNOutputLayers.inference """
- score_thresh = box_predictor.test_score_thresh
- nms_thresh = box_predictor.test_nms_thresh
- topk_per_image = box_predictor.test_topk_per_image
- is_rotated = len(box_predictor.box2box_transform.weights) == 5
-
- if is_rotated:
- box_dim = 5
- assert box_predictor.box2box_transform.weights[4] == 1, (
- "The weights for Rotated BBoxTransform in C2 have only 4 dimensions,"
- + " thus enforcing the angle weight to be 1 for now"
- )
- box2box_transform_weights = box_predictor.box2box_transform.weights[:4]
- else:
- box_dim = 4
- box2box_transform_weights = box_predictor.box2box_transform.weights
-
- class_logits, box_regression = predictions
- class_prob = F.softmax(class_logits, -1)
-
- assert box_regression.shape[1] % box_dim == 0
- cls_agnostic_bbox_reg = box_regression.shape[1] // box_dim == 1
-
- input_tensor_mode = proposals[0].proposal_boxes.tensor.shape[1] == box_dim + 1
-
- rois = type(proposals[0].proposal_boxes).cat([p.proposal_boxes for p in proposals])
- device, dtype = rois.tensor.device, rois.tensor.dtype
- if input_tensor_mode:
- im_info = proposals[0].image_size
- rois = rois.tensor
- else:
- im_info = torch.Tensor(
- [[sz[0], sz[1], 1.0] for sz in [x.image_size for x in proposals]]
- )
- batch_ids = cat(
- [
- torch.full((b, 1), i, dtype=dtype, device=device)
- for i, b in enumerate(len(p) for p in proposals)
- ],
- dim=0,
- )
- rois = torch.cat([batch_ids, rois.tensor], dim=1)
-
- roi_pred_bbox, roi_batch_splits = torch.ops._caffe2.BBoxTransform(
- to_device(rois, "cpu"),
- to_device(box_regression, "cpu"),
- to_device(im_info, "cpu"),
- weights=box2box_transform_weights,
- apply_scale=True,
- rotated=is_rotated,
- angle_bound_on=True,
- angle_bound_lo=-180,
- angle_bound_hi=180,
- clip_angle_thresh=1.0,
- legacy_plus_one=False,
- )
- roi_pred_bbox = to_device(roi_pred_bbox, device)
- roi_batch_splits = to_device(roi_batch_splits, device)
-
- nms_outputs = torch.ops._caffe2.BoxWithNMSLimit(
- to_device(class_prob, "cpu"),
- to_device(roi_pred_bbox, "cpu"),
- to_device(roi_batch_splits, "cpu"),
- score_thresh=float(score_thresh),
- nms=float(nms_thresh),
- detections_per_im=int(topk_per_image),
- soft_nms_enabled=False,
- soft_nms_method="linear",
- soft_nms_sigma=0.5,
- soft_nms_min_score_thres=0.001,
- rotated=is_rotated,
- cls_agnostic_bbox_reg=cls_agnostic_bbox_reg,
- input_boxes_include_bg_cls=False,
- output_classes_include_bg_cls=False,
- legacy_plus_one=False,
- )
- roi_score_nms = to_device(nms_outputs[0], device)
- roi_bbox_nms = to_device(nms_outputs[1], device)
- roi_class_nms = to_device(nms_outputs[2], device)
- roi_batch_splits_nms = to_device(nms_outputs[3], device)
- roi_keeps_nms = to_device(nms_outputs[4], device)
- roi_keeps_size_nms = to_device(nms_outputs[5], device)
- if not self.tensor_mode:
- roi_class_nms = roi_class_nms.to(torch.int64)
-
- roi_batch_ids = cat(
- [
- torch.full((b, 1), i, dtype=dtype, device=device)
- for i, b in enumerate(int(x.item()) for x in roi_batch_splits_nms)
- ],
- dim=0,
- )
-
- roi_class_nms = alias(roi_class_nms, "class_nms")
- roi_score_nms = alias(roi_score_nms, "score_nms")
- roi_bbox_nms = alias(roi_bbox_nms, "bbox_nms")
- roi_batch_splits_nms = alias(roi_batch_splits_nms, "batch_splits_nms")
- roi_keeps_nms = alias(roi_keeps_nms, "keeps_nms")
- roi_keeps_size_nms = alias(roi_keeps_size_nms, "keeps_size_nms")
-
- results = InstancesList(
- im_info=im_info,
- indices=roi_batch_ids[:, 0],
- extra_fields={
- "pred_boxes": Caffe2Boxes(roi_bbox_nms),
- "scores": roi_score_nms,
- "pred_classes": roi_class_nms,
- },
- )
-
- if not self.tensor_mode:
- results = InstancesList.to_d2_instances_list(results)
- batch_splits = roi_batch_splits_nms.int().tolist()
- kept_indices = list(roi_keeps_nms.to(torch.int64).split(batch_splits))
- else:
- results = [results]
- kept_indices = [roi_keeps_nms]
-
- return results, kept_indices
-
-
-class Caffe2MaskRCNNInference:
- def __call__(self, pred_mask_logits, pred_instances):
- """ equivalent to mask_head.mask_rcnn_inference """
- if all(isinstance(x, InstancesList) for x in pred_instances):
- assert len(pred_instances) == 1
- mask_probs_pred = pred_mask_logits.sigmoid()
- mask_probs_pred = alias(mask_probs_pred, "mask_fcn_probs")
- pred_instances[0].pred_masks = mask_probs_pred
- else:
- mask_rcnn_inference(pred_mask_logits, pred_instances)
-
-
-class Caffe2KeypointRCNNInference:
- def __init__(self, use_heatmap_max_keypoint):
- self.use_heatmap_max_keypoint = use_heatmap_max_keypoint
-
- def __call__(self, pred_keypoint_logits, pred_instances):
- # just return the keypoint heatmap for now,
- # there will be option to call HeatmapMaxKeypointOp
- output = alias(pred_keypoint_logits, "kps_score")
- if all(isinstance(x, InstancesList) for x in pred_instances):
- assert len(pred_instances) == 1
- if self.use_heatmap_max_keypoint:
- device = output.device
- output = torch.ops._caffe2.HeatmapMaxKeypoint(
- to_device(output, "cpu"),
- pred_instances[0].pred_boxes.tensor,
- should_output_softmax=True, # worth make it configerable?
- )
- output = to_device(output, device)
- output = alias(output, "keypoints_out")
- pred_instances[0].pred_keypoints = output
- return pred_keypoint_logits
diff --git a/spaces/CVPR/LIVE/thrust/internal/benchmark/random.h b/spaces/CVPR/LIVE/thrust/internal/benchmark/random.h
deleted file mode 100644
index 719588771307d5d0b80c61c3a2b8a614c61069c9..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/internal/benchmark/random.h
+++ /dev/null
@@ -1,100 +0,0 @@
-#pragma once
-
-#include
-#include
-
-struct hash32
-{
- __host__ __device__
- unsigned int operator()(unsigned int h) const
- {
- h = ~h + (h << 15);
- h = h ^ (h >> 12);
- h = h + (h << 2);
- h = h ^ (h >> 4);
- h = h + (h << 3) + (h << 11);
- h = h ^ (h >> 16);
- return h;
- }
-};
-
-struct hash64
-{
- __host__ __device__
- unsigned long long operator()(unsigned long long h) const
- {
- h = ~h + (h << 21);
- h = h ^ (h >> 24);
- h = (h + (h << 3)) + (h << 8);
- h = h ^ (h >> 14);
- h = (h + (h << 2)) + (h << 4);
- h = h ^ (h >> 28);
- h = h + (h << 31);
- return h;
- }
-};
-
-struct hashtofloat
-{
- __host__ __device__
- float operator()(unsigned int h) const
- {
- return static_cast(hash32()(h)) / 4294967296.0f;
- }
-};
-
-struct hashtodouble
-{
- __host__ __device__
- double operator()(unsigned long long h) const
- {
- return static_cast(hash64()(h)) / 18446744073709551616.0;
- }
-};
-
-
-
-template
-void _randomize(Vector& v, T)
-{
- thrust::transform(thrust::counting_iterator(0),
- thrust::counting_iterator(0) + v.size(),
- v.begin(),
- hash32());
-}
-
-template
-void _randomize(Vector& v, long long)
-{
- thrust::transform(thrust::counting_iterator(0),
- thrust::counting_iterator(0) + v.size(),
- v.begin(),
- hash64());
-}
-
-template
-void _randomize(Vector& v, float)
-{
- thrust::transform(thrust::counting_iterator(0),
- thrust::counting_iterator(0) + v.size(),
- v.begin(),
- hashtofloat());
-}
-
-template
-void _randomize(Vector& v, double)
-{
- thrust::transform(thrust::counting_iterator(0),
- thrust::counting_iterator(0) + v.size(),
- v.begin(),
- hashtodouble());
-}
-
-// fill Vector with random values
-template
-void randomize(Vector& v)
-{
- _randomize(v, typename Vector::value_type());
-}
-
-
diff --git a/spaces/CVPR/LIVE/thrust/testing/unittest/testframework.h b/spaces/CVPR/LIVE/thrust/testing/unittest/testframework.h
deleted file mode 100644
index ec5c42bb653af8aa4295bb9a61860aafd739a3a2..0000000000000000000000000000000000000000
--- a/spaces/CVPR/LIVE/thrust/testing/unittest/testframework.h
+++ /dev/null
@@ -1,574 +0,0 @@
-#pragma once
-
-#include
-#include
-#include
-#include
-#include
-
-#include
-
-#include "meta.h"
-#include "util.h"
-
-#include
-#include
-#include
-#include
-#include
-
-// define some common lists of types
-typedef unittest::type_list ThirtyTwoBitTypes;
-
-typedef unittest::type_list SixtyFourBitTypes;
-
-typedef unittest::type_list IntegralTypes;
-
-typedef unittest::type_list SignedIntegralTypes;
-
-typedef unittest::type_list UnsignedIntegralTypes;
-
-typedef unittest::type_list ByteTypes;
-
-typedef unittest::type_list SmallIntegralTypes;
-
-typedef unittest::type_list LargeIntegralTypes;
-
-typedef unittest::type_list FloatingPointTypes;
-
-// A type that behaves as if it was a normal numeric type,
-// so it can be used in the same tests as "normal" numeric types.
-// NOTE: This is explicitly NOT proclaimed trivially reloctable.
-class custom_numeric
-{
-public:
- __host__ __device__
- custom_numeric()
- {
- fill(0);
- }
-
- __host__ __device__
- custom_numeric(int i)
- {
- fill(i);
- }
-
- __host__ __device__
- custom_numeric(const custom_numeric & other)
- {
- fill(other.value[0]);
- }
-
- __host__ __device__
- custom_numeric & operator=(int val)
- {
- fill(val);
- return *this;
- }
-
- __host__ __device__
- custom_numeric & operator=(const custom_numeric & other)
- {
- fill(other.value[0]);
- return *this;
- }
-
- // cast to void * instead of bool to fool overload resolution
- // WTB C++11 explicit conversion operators
- __host__ __device__
- operator void *() const
- {
- // static cast first to avoid MSVC warning C4312
- return reinterpret_cast(static_cast(value[0]));
- }
-
-#define DEFINE_OPERATOR(op) \
- __host__ __device__ \
- custom_numeric & operator op() { \
- fill(op value[0]); \
- return *this; \
- } \
- __host__ __device__ \
- custom_numeric operator op(int) const { \
- custom_numeric ret(*this); \
- op ret; \
- return ret; \
- }
-
- DEFINE_OPERATOR(++)
- DEFINE_OPERATOR(--)
-
-#undef DEFINE_OPERATOR
-
-#define DEFINE_OPERATOR(op) \
- __host__ __device__ \
- custom_numeric operator op () const \
- { \
- return custom_numeric(op value[0]); \
- }
-
- DEFINE_OPERATOR(+)
- DEFINE_OPERATOR(-)
- DEFINE_OPERATOR(~)
-
-#undef DEFINE_OPERATOR
-
-#define DEFINE_OPERATOR(op) \
- __host__ __device__ \
- custom_numeric operator op (const custom_numeric & other) const \
- { \
- return custom_numeric(value[0] op other.value[0]); \
- }
-
- DEFINE_OPERATOR(+)
- DEFINE_OPERATOR(-)
- DEFINE_OPERATOR(*)
- DEFINE_OPERATOR(/)
- DEFINE_OPERATOR(%)
- DEFINE_OPERATOR(<<)
- DEFINE_OPERATOR(>>)
- DEFINE_OPERATOR(&)
- DEFINE_OPERATOR(|)
- DEFINE_OPERATOR(^)
-
-#undef DEFINE_OPERATOR
-
-#define CONCAT(X, Y) X ## Y
-
-#define DEFINE_OPERATOR(op) \
- __host__ __device__ \
- custom_numeric & operator CONCAT(op, =) (const custom_numeric & other) \
- { \
- fill(value[0] op other.value[0]); \
- return *this; \
- }
-
- DEFINE_OPERATOR(+)
- DEFINE_OPERATOR(-)
- DEFINE_OPERATOR(*)
- DEFINE_OPERATOR(/)
- DEFINE_OPERATOR(%)
- DEFINE_OPERATOR(<<)
- DEFINE_OPERATOR(>>)
- DEFINE_OPERATOR(&)
- DEFINE_OPERATOR(|)
- DEFINE_OPERATOR(^)
-
-#undef DEFINE_OPERATOR
-
-#define DEFINE_OPERATOR(op) \
- __host__ __device__ \
- friend bool operator op (const custom_numeric & lhs, const custom_numeric & rhs) \
- { \
- return lhs.value[0] op rhs.value[0]; \
- }
-
- DEFINE_OPERATOR(==)
- DEFINE_OPERATOR(!=)
- DEFINE_OPERATOR(<)
- DEFINE_OPERATOR(<=)
- DEFINE_OPERATOR(>)
- DEFINE_OPERATOR(>=)
- DEFINE_OPERATOR(&&)
- DEFINE_OPERATOR(||);
-
-
-#undef DEFINE_OPERATOR
-
- friend std::ostream & operator<<(std::ostream & os, const custom_numeric & val)
- {
- return os << "custom_numeric{" << val.value[0] << "}";
- }
-
-private:
- int value[5];
-
- __host__ __device__
- void fill(int val)
- {
- for (int i = 0; i < 5; ++i)
- {
- value[i] = val;
- }
- }
-};
-
-namespace thrust
-{
-
-template <>
-struct numeric_limits : numeric_limits {};
-
-namespace detail
-{
-
-// For random number generation
-template<>
-class integer_traits
- : public integer_traits_base
-{};
-
-}} // namespace thrust::detail
-
-typedef unittest::type_list NumericTypes;
-
-typedef unittest::type_list BuiltinNumericTypes;
-
-inline void chop_prefix(std::string& str, const std::string& prefix)
-{
- str.replace(str.find(prefix) == 0 ? 0 : str.size(), prefix.size(), "");
-}
-
-inline std::string base_class_name(const std::string& name)
-{
- std::string result = name;
-
- // if the name begins with "struct ", chop it off
- chop_prefix(result, "struct ");
-
- // if the name begins with "class ", chop it off
- chop_prefix(result, "class ");
-
- const std::size_t first_lt = result.find_first_of("<");
-
- if (first_lt < result.size())
- // chop everything including and after first "<"
- return result.replace(first_lt, result.size(), "");
- else
- return result;
-}
-
-enum TestStatus { Pass = 0, Failure = 1, KnownFailure = 2, Error = 3, UnknownException = 4};
-
-typedef std::set ArgumentSet;
-typedef std::map ArgumentMap;
-
-std::vector get_test_sizes(void);
-void set_test_sizes(const std::string&);
-
-class UnitTest {
- public:
- std::string name;
- UnitTest() {}
- UnitTest(const char * name);
- virtual ~UnitTest() {}
- virtual void run() {}
-
- bool operator<(const UnitTest& u) const
- {
- return name < u.name;
- }
-};
-
-class UnitTestDriver;
-
-class UnitTestDriver
-{
- typedef std::map TestMap;
-
- TestMap test_map;
-
- bool run_tests(std::vector& tests_to_run, const ArgumentMap& kwargs);
-
-protected:
- // executed immediately after each test
- // \param test The UnitTest of interest
- // \param concise Whether or not to suppress output
- // \return true if all is well; false if the tests must be immediately aborted
- virtual bool post_test_sanity_check(const UnitTest &test, bool concise);
-
-public:
- inline virtual ~UnitTestDriver() {};
-
- void register_test(UnitTest * test);
- virtual bool run_tests(const ArgumentSet& args, const ArgumentMap& kwargs);
- void list_tests(void);
-
- static UnitTestDriver &s_driver();
-};
-
-// Macro to create a single unittest
-#define DECLARE_UNITTEST(TEST) \
-class TEST##UnitTest : public UnitTest { \
- public: \
- TEST##UnitTest() : UnitTest(#TEST) {} \
- void run(){ \
- TEST(); \
- } \
-}; \
-TEST##UnitTest TEST##Instance
-
-#define DECLARE_UNITTEST_WITH_NAME(TEST, NAME) \
-class NAME##UnitTest : public UnitTest { \
- public: \
- NAME##UnitTest() : UnitTest(#NAME) {} \
- void run(){ \
- TEST(); \
- } \
-}; \
-NAME##UnitTest NAME##Instance
-
-// Macro to create host and device versions of a
-// unit test for a bunch of data types
-#define DECLARE_VECTOR_UNITTEST(VTEST) \
-void VTEST##Host(void) { \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
- /* MR vectors */ \
- VTEST< thrust::host_vector > >(); \
-} \
-void VTEST##Device(void) { \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
- /* MR vectors */ \
- VTEST< thrust::device_vector > >(); \
- VTEST< thrust::device_vector > >(); \
- VTEST< thrust::device_vector > >();\
-} \
-DECLARE_UNITTEST(VTEST##Host); \
-DECLARE_UNITTEST(VTEST##Device);
-
-// Same as above, but only for integral types
-#define DECLARE_INTEGRAL_VECTOR_UNITTEST(VTEST) \
-void VTEST##Host(void) { \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
- VTEST< thrust::host_vector >(); \
-} \
-void VTEST##Device(void) { \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
- VTEST< thrust::device_vector >(); \
-} \
-DECLARE_UNITTEST(VTEST##Host); \
-DECLARE_UNITTEST(VTEST##Device);
-
-// Macro to create instances of a test for several data types.
-#define DECLARE_GENERIC_UNITTEST(TEST) \
-class TEST##UnitTest : public UnitTest { \
- public: \
- TEST##UnitTest() : UnitTest(#TEST) {} \
- void run() \
- { \
- TEST(); \
- TEST(); \
- TEST(); \
- TEST(); \
- TEST(); \
- TEST(); \
- TEST(); \
- } \
-}; \
-TEST##UnitTest TEST##Instance
-
-// Macro to create instances of a test for several data types and array sizes
-#define DECLARE_VARIABLE_UNITTEST(TEST) \
-class TEST##UnitTest : public UnitTest { \
- public: \
- TEST##UnitTest() : UnitTest(#TEST) {} \
- void run() \
- { \
- std::vector sizes = get_test_sizes(); \
- for(size_t i = 0; i != sizes.size(); ++i) \
- { \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- } \
- } \
-}; \
-TEST##UnitTest TEST##Instance
-
-#define DECLARE_INTEGRAL_VARIABLE_UNITTEST(TEST) \
-class TEST##UnitTest : public UnitTest { \
- public: \
- TEST##UnitTest() : UnitTest(#TEST) {} \
- void run() \
- { \
- std::vector sizes = get_test_sizes(); \
- for(size_t i = 0; i != sizes.size(); ++i) \
- { \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- TEST(sizes[i]); \
- } \
- } \
-}; \
-TEST##UnitTest TEST##Instance
-
-#define DECLARE_GENERIC_UNITTEST_WITH_TYPES_AND_NAME(TEST, TYPES, NAME) \
- ::SimpleUnitTest NAME##_instance(#NAME) \
- /**/
-
-#define DECLARE_GENERIC_SIZED_UNITTEST_WITH_TYPES_AND_NAME(TEST, TYPES, NAME) \
- ::VariableUnitTest NAME##_instance(#NAME) \
- /**/
-
-#define DECLARE_GENERIC_UNITTEST_WITH_TYPES(TEST, TYPES) \
- ::SimpleUnitTest TEST##_instance(#TEST) \
- /**/
-
-#define DECLARE_GENERIC_SIZED_UNITTEST_WITH_TYPES(TEST, TYPES) \
- ::VariableUnitTest TEST##_instance(#TEST) \
- /**/
-
-template class TestName, typename TypeList>
- class SimpleUnitTest : public UnitTest
-{
- public:
- SimpleUnitTest()
- : UnitTest(base_class_name(unittest::type_name >()).c_str()) {}
-
- SimpleUnitTest(const char * name)
- : UnitTest(name) {}
-
- void run()
- {
- // get the first type in the list
- typedef typename unittest::get_type::type first_type;
-
- unittest::for_each_type for_each;
-
- // loop over the types
- for_each();
- }
-}; // end SimpleUnitTest
-
-
-template class TestName, typename TypeList>
- class VariableUnitTest : public UnitTest
-{
- public:
- VariableUnitTest()
- : UnitTest(base_class_name(unittest::type_name >()).c_str()) {}
-
- VariableUnitTest(const char * name)
- : UnitTest(name) {}
-
- void run()
- {
- std::vector sizes = get_test_sizes();
- for(size_t i = 0; i != sizes.size(); ++i)
- {
- // get the first type in the list
- typedef typename unittest::get_type::type first_type;
-
- unittest::for_each_type loop;
-
- // loop over the types
- loop(sizes[i]);
- }
- }
-}; // end VariableUnitTest
-
-template class TestName,
- typename TypeList,
- template class Vector,
- template class Alloc>
- struct VectorUnitTest
- : public UnitTest
-{
- VectorUnitTest()
- : UnitTest((base_class_name(unittest::type_name > > >()) + "<" +
- base_class_name(unittest::type_name > >()) + ">").c_str())
- { }
-
- VectorUnitTest(const char * name)
- : UnitTest(name) {}
-
- void run()
- {
- // zip up the type list with Alloc
- typedef typename unittest::transform1::type AllocList;
-
- // zip up the type list & alloc list with Vector
- typedef typename unittest::transform2::type VectorList;
-
- // get the first type in the list
- typedef typename unittest::get_type::type first_type;
-
- unittest::for_each_type loop;
-
- // loop over the types
- loop(0);
- }
-}; // end VectorUnitTest
-
diff --git a/spaces/CikeyQI/meme-api/meme_generator/memes/applaud/__init__.py b/spaces/CikeyQI/meme-api/meme_generator/memes/applaud/__init__.py
deleted file mode 100644
index d5ef0eb24c1fb13fd81ee8031c4e480391cc44ed..0000000000000000000000000000000000000000
--- a/spaces/CikeyQI/meme-api/meme_generator/memes/applaud/__init__.py
+++ /dev/null
@@ -1,31 +0,0 @@
-from pathlib import Path
-from typing import List
-
-from PIL.Image import Image as IMG
-from pil_utils import BuildImage
-
-from meme_generator import add_meme
-from meme_generator.utils import save_gif
-
-img_dir = Path(__file__).parent / "images"
-
-
-def applaud(images: List[BuildImage], texts, args):
- img = images[0].convert("RGBA").square().resize((110, 110))
- frames: List[IMG] = []
- locs = [
- (109, 102, 27, 17),
- (107, 105, 28, 15),
- (110, 106, 27, 14),
- (109, 106, 27, 14),
- (107, 108, 29, 12),
- ]
- for i in range(5):
- frame = BuildImage.open(img_dir / f"{i}.png")
- w, h, x, y = locs[i]
- frame.paste(img.resize((w, h)), (x, y), below=True)
- frames.append(frame.image)
- return save_gif(frames, 0.1)
-
-
-add_meme("applaud", applaud, min_images=1, max_images=1, keywords=["鼓掌"])
diff --git a/spaces/ClassCat/DETR-Object-Detection/app.py b/spaces/ClassCat/DETR-Object-Detection/app.py
deleted file mode 100644
index 2d4df2403c46d8cfd7d8cd7563eb95d2390a53f4..0000000000000000000000000000000000000000
--- a/spaces/ClassCat/DETR-Object-Detection/app.py
+++ /dev/null
@@ -1,109 +0,0 @@
-
-import torch
-from transformers import pipeline
-
-from PIL import Image
-
-import matplotlib.pyplot as plt
-import matplotlib.patches as patches
-
-from random import choice
-import io
-
-detector50 = pipeline(model="facebook/detr-resnet-50")
-
-detector101 = pipeline(model="facebook/detr-resnet-101")
-
-
-import gradio as gr
-
-COLORS = ["#ff7f7f", "#ff7fbf", "#ff7fff", "#bf7fff",
- "#7f7fff", "#7fbfff", "#7fffff", "#7fffbf",
- "#7fff7f", "#bfff7f", "#ffff7f", "#ffbf7f"]
-
-fdic = {
- "family" : "Impact",
- "style" : "italic",
- "size" : 15,
- "color" : "yellow",
- "weight" : "bold"
-}
-
-
-def get_figure(in_pil_img, in_results):
- plt.figure(figsize=(16, 10))
- plt.imshow(in_pil_img)
- #pyplot.gcf()
- ax = plt.gca()
-
- for prediction in in_results:
- selected_color = choice(COLORS)
-
- x, y = prediction['box']['xmin'], prediction['box']['ymin'],
- w, h = prediction['box']['xmax'] - prediction['box']['xmin'], prediction['box']['ymax'] - prediction['box']['ymin']
-
- ax.add_patch(plt.Rectangle((x, y), w, h, fill=False, color=selected_color, linewidth=3))
- ax.text(x, y, f"{prediction['label']}: {round(prediction['score']*100, 1)}%", fontdict=fdic)
-
- plt.axis("off")
-
- return plt.gcf()
-
-
-def infer(model, in_pil_img):
-
- results = None
- if model == "detr-resnet-101":
- results = detector101(in_pil_img)
- else:
- results = detector50(in_pil_img)
-
- figure = get_figure(in_pil_img, results)
-
- buf = io.BytesIO()
- figure.savefig(buf, bbox_inches='tight')
- buf.seek(0)
- output_pil_img = Image.open(buf)
-
- return output_pil_img
-
-
-with gr.Blocks(title="DETR Object Detection - ClassCat",
- css=".gradio-container {background:lightyellow;}"
- ) as demo:
- #sample_index = gr.State([])
-
- gr.HTML("""DETR Object Detection
""")
-
- gr.HTML("""1. Select a model. """)
-
- model = gr.Radio(["detr-resnet-50", "detr-resnet-101"], value="detr-resnet-50", label="Model name")
-
- gr.HTML("""2-a. Select an example by clicking a thumbnail below. """)
- gr.HTML("""2-b. Or upload an image by clicking on the canvas. """)
-
- with gr.Row():
- input_image = gr.Image(label="Input image", type="pil")
- output_image = gr.Image(label="Output image with predicted instances", type="pil")
-
- gr.Examples(['samples/cats.jpg', 'samples/detectron2.png', 'samples/cat.jpg', 'samples/hotdog.jpg'], inputs=input_image)
-
- gr.HTML("""3. Then, click "Infer" button to predict object instances. It will take about 10 seconds (on cpu) """)
-
- send_btn = gr.Button("Infer")
- send_btn.click(fn=infer, inputs=[model, input_image], outputs=[output_image])
-
- gr.HTML("""Reference """)
- gr.HTML("""""")
-
-
-#demo.queue()
-demo.launch(debug=True)
-
-
-### EOF ###
diff --git a/spaces/CofAI/chat.v2/web.html b/spaces/CofAI/chat.v2/web.html
deleted file mode 100644
index 9e1fd00c7dd7aef4e03d88c14c8e8d0e67e808de..0000000000000000000000000000000000000000
--- a/spaces/CofAI/chat.v2/web.html
+++ /dev/null
@@ -1,60 +0,0 @@
-
-
-
- API Demo
-
-
- API Demo
- Select a day:
-
- Monday
- Tuesday
- Wednesday
- Thursday
- Friday
- Saturday
- Sunday
-
- Select data:
-
-
-
-
\ No newline at end of file
diff --git a/spaces/Cpp4App/Cpp4App/CDM/cnn/Data.py b/spaces/Cpp4App/Cpp4App/CDM/cnn/Data.py
deleted file mode 100644
index def4747977079d268176a15c9b9dab7a0118ff88..0000000000000000000000000000000000000000
--- a/spaces/Cpp4App/Cpp4App/CDM/cnn/Data.py
+++ /dev/null
@@ -1,69 +0,0 @@
-import cv2
-import numpy as np
-from os.path import join as pjoin
-import glob
-from tqdm import tqdm
-from Config import Config
-
-cfg = Config()
-
-
-class Data:
- def __init__(self):
- self.data_num = 0
- self.images = []
- self.labels = []
- self.X_train, self.Y_train = None, None
- self.X_test, self.Y_test = None, None
-
- self.image_shape = cfg.image_shape
- self.class_number = cfg.class_number
- self.class_map = cfg.class_map
- self.DATA_PATH = cfg.DATA_PATH
-
- def load_data(self, resize=True, shape=None, max_number=1000000):
- # if customize shape
- if shape is not None:
- self.image_shape = shape
- else:
- shape = self.image_shape
-
- # load data
- for p in glob.glob(pjoin(self.DATA_PATH, '*')):
- print("*** Loading components of %s: %d ***" %(p.split('\\')[-1], int(len(glob.glob(pjoin(p, '*.png'))))))
- label = self.class_map.index(p.split('\\')[-1]) # map to index of classes
- for i, image_path in enumerate(tqdm(glob.glob(pjoin(p, '*.png'))[:max_number])):
- image = cv2.imread(image_path)
- if resize:
- image = cv2.resize(image, shape[:2])
- self.images.append(image)
- self.labels.append(label)
-
- assert len(self.images) == len(self.labels)
- self.data_num = len(self.images)
- print('%d Data Loaded' % self.data_num)
-
- def generate_training_data(self, train_data_ratio=0.8):
- # transfer int into c dimensions one-hot array
- def expand(label, class_number):
- # return y : (num_class, num_samples)
- y = np.eye(class_number)[label]
- y = np.squeeze(y)
- return y
-
- # reshuffle
- np.random.seed(0)
- self.images = np.random.permutation(self.images)
- np.random.seed(0)
- self.labels = np.random.permutation(self.labels)
- Y = expand(self.labels, self.class_number)
-
- # separate dataset
- cut = int(train_data_ratio * self.data_num)
- self.X_train = (self.images[:cut] / 255).astype('float32')
- self.X_test = (self.images[cut:] / 255).astype('float32')
- self.Y_train = Y[:cut]
- self.Y_test = Y[cut:]
-
- print('X_train:%d, Y_train:%d' % (len(self.X_train), len(self.Y_train)))
- print('X_test:%d, Y_test:%d' % (len(self.X_test), len(self.Y_test)))
diff --git a/spaces/Cpp4App/Cpp4App/SEM/get_pp.py b/spaces/Cpp4App/Cpp4App/SEM/get_pp.py
deleted file mode 100644
index ccb9f617ece107ed6b0ae8d689b3970e796cc1b4..0000000000000000000000000000000000000000
--- a/spaces/Cpp4App/Cpp4App/SEM/get_pp.py
+++ /dev/null
@@ -1,12 +0,0 @@
-import ssl
-from bs4 import BeautifulSoup
-import urllib.request
-
-ssl._create_default_https_context = ssl._create_unverified_context
-
-def get_text(url):
- response=urllib.request.urlopen(url)
- html=response.read()
- soup = BeautifulSoup(html,features="html.parser")
- text = soup.get_text()
- return text
diff --git a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/csrc/cpu/ROIAlign_cpu.cpp b/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/csrc/cpu/ROIAlign_cpu.cpp
deleted file mode 100644
index d35aedf27ea581b9241d44b87dcca2e901b5064e..0000000000000000000000000000000000000000
--- a/spaces/Cyril666/ContourNet-ABI/maskrcnn_benchmark/csrc/cpu/ROIAlign_cpu.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-#include "cpu/vision.h"
-
-// implementation taken from Caffe2
-template
-struct PreCalc {
- int pos1;
- int pos2;
- int pos3;
- int pos4;
- T w1;
- T w2;
- T w3;
- T w4;
-};
-
-template
-void pre_calc_for_bilinear_interpolate(
- const int height,
- const int width,
- const int pooled_height,
- const int pooled_width,
- const int iy_upper,
- const int ix_upper,
- T roi_start_h,
- T roi_start_w,
- T bin_size_h,
- T bin_size_w,
- int roi_bin_grid_h,
- int roi_bin_grid_w,
- std::vector>& pre_calc) {
- int pre_calc_index = 0;
- for (int ph = 0; ph < pooled_height; ph++) {
- for (int pw = 0; pw < pooled_width; pw++) {
- for (int iy = 0; iy < iy_upper; iy++) {
- const T yy = roi_start_h + ph * bin_size_h +
- static_cast(iy + .5f) * bin_size_h /
- static_cast(roi_bin_grid_h); // e.g., 0.5, 1.5
- for (int ix = 0; ix < ix_upper; ix++) {
- const T xx = roi_start_w + pw * bin_size_w +
- static_cast(ix + .5f) * bin_size_w /
- static_cast(roi_bin_grid_w);
-
- T x = xx;
- T y = yy;
- // deal with: inverse elements are out of feature map boundary
- if (y < -1.0 || y > height || x < -1.0 || x > width) {
- // empty
- PreCalc pc;
- pc.pos1 = 0;
- pc.pos2 = 0;
- pc.pos3 = 0;
- pc.pos4 = 0;
- pc.w1 = 0;
- pc.w2 = 0;
- pc.w3 = 0;
- pc.w4 = 0;
- pre_calc[pre_calc_index] = pc;
- pre_calc_index += 1;
- continue;
- }
-
- if (y <= 0) {
- y = 0;
- }
- if (x <= 0) {
- x = 0;
- }
-
- int y_low = (int)y;
- int x_low = (int)x;
- int y_high;
- int x_high;
-
- if (y_low >= height - 1) {
- y_high = y_low = height - 1;
- y = (T)y_low;
- } else {
- y_high = y_low + 1;
- }
-
- if (x_low >= width - 1) {
- x_high = x_low = width - 1;
- x = (T)x_low;
- } else {
- x_high = x_low + 1;
- }
-
- T ly = y - y_low;
- T lx = x - x_low;
- T hy = 1. - ly, hx = 1. - lx;
- T w1 = hy * hx, w2 = hy * lx, w3 = ly * hx, w4 = ly * lx;
-
- // save weights and indeces
- PreCalc pc;
- pc.pos1 = y_low * width + x_low;
- pc.pos2 = y_low * width + x_high;
- pc.pos3 = y_high * width + x_low;
- pc.pos4 = y_high * width + x_high;
- pc.w1 = w1;
- pc.w2 = w2;
- pc.w3 = w3;
- pc.w4 = w4;
- pre_calc[pre_calc_index] = pc;
-
- pre_calc_index += 1;
- }
- }
- }
- }
-}
-
-template
-void ROIAlignForward_cpu_kernel(
- const int nthreads,
- const T* bottom_data,
- const T& spatial_scale,
- const int channels,
- const int height,
- const int width,
- const int pooled_height,
- const int pooled_width,
- const int sampling_ratio,
- const T* bottom_rois,
- //int roi_cols,
- T* top_data) {
- //AT_ASSERT(roi_cols == 4 || roi_cols == 5);
- int roi_cols = 5;
-
- int n_rois = nthreads / channels / pooled_width / pooled_height;
- // (n, c, ph, pw) is an element in the pooled output
- // can be parallelized using omp
- // #pragma omp parallel for num_threads(32)
- for (int n = 0; n < n_rois; n++) {
- int index_n = n * channels * pooled_width * pooled_height;
-
- // roi could have 4 or 5 columns
- const T* offset_bottom_rois = bottom_rois + n * roi_cols;
- int roi_batch_ind = 0;
- if (roi_cols == 5) {
- roi_batch_ind = offset_bottom_rois[0];
- offset_bottom_rois++;
- }
-
- // Do not using rounding; this implementation detail is critical
- T roi_start_w = offset_bottom_rois[0] * spatial_scale;
- T roi_start_h = offset_bottom_rois[1] * spatial_scale;
- T roi_end_w = offset_bottom_rois[2] * spatial_scale;
- T roi_end_h = offset_bottom_rois[3] * spatial_scale;
- // T roi_start_w = round(offset_bottom_rois[0] * spatial_scale);
- // T roi_start_h = round(offset_bottom_rois[1] * spatial_scale);
- // T roi_end_w = round(offset_bottom_rois[2] * spatial_scale);
- // T roi_end_h = round(offset_bottom_rois[3] * spatial_scale);
-
- // Force malformed ROIs to be 1x1
- T roi_width = std::max(roi_end_w - roi_start_w, (T)1.);
- T roi_height = std::max(roi_end_h - roi_start_h, (T)1.);
- T bin_size_h = static_cast(roi_height) / static_cast(pooled_height);
- T bin_size_w = static_cast(roi_width) / static_cast(pooled_width);
-
- // We use roi_bin_grid to sample the grid and mimic integral
- int roi_bin_grid_h = (sampling_ratio > 0)
- ? sampling_ratio
- : ceil(roi_height / pooled_height); // e.g., = 2
- int roi_bin_grid_w =
- (sampling_ratio > 0) ? sampling_ratio : ceil(roi_width / pooled_width);
-
- // We do average (integral) pooling inside a bin
- const T count = roi_bin_grid_h * roi_bin_grid_w; // e.g. = 4
-
- // we want to precalculate indeces and weights shared by all chanels,
- // this is the key point of optimiation
- std::vector> pre_calc(
- roi_bin_grid_h * roi_bin_grid_w * pooled_width * pooled_height);
- pre_calc_for_bilinear_interpolate(
- height,
- width,
- pooled_height,
- pooled_width,
- roi_bin_grid_h,
- roi_bin_grid_w,
- roi_start_h,
- roi_start_w,
- bin_size_h,
- bin_size_w,
- roi_bin_grid_h,
- roi_bin_grid_w,
- pre_calc);
-
- for (int c = 0; c < channels; c++) {
- int index_n_c = index_n + c * pooled_width * pooled_height;
- const T* offset_bottom_data =
- bottom_data + (roi_batch_ind * channels + c) * height * width;
- int pre_calc_index = 0;
-
- for (int ph = 0; ph < pooled_height; ph++) {
- for (int pw = 0; pw < pooled_width; pw++) {
- int index = index_n_c + ph * pooled_width + pw;
-
- T output_val = 0.;
- for (int iy = 0; iy < roi_bin_grid_h; iy++) {
- for (int ix = 0; ix < roi_bin_grid_w; ix++) {
- PreCalc pc = pre_calc[pre_calc_index];
- output_val += pc.w1 * offset_bottom_data[pc.pos1] +
- pc.w2 * offset_bottom_data[pc.pos2] +
- pc.w3 * offset_bottom_data[pc.pos3] +
- pc.w4 * offset_bottom_data[pc.pos4];
-
- pre_calc_index += 1;
- }
- }
- output_val /= count;
-
- top_data[index] = output_val;
- } // for pw
- } // for ph
- } // for c
- } // for n
-}
-
-at::Tensor ROIAlign_forward_cpu(const at::Tensor& input,
- const at::Tensor& rois,
- const float spatial_scale,
- const int pooled_height,
- const int pooled_width,
- const int sampling_ratio) {
- AT_ASSERTM(!input.type().is_cuda(), "input must be a CPU tensor");
- AT_ASSERTM(!rois.type().is_cuda(), "rois must be a CPU tensor");
-
- auto num_rois = rois.size(0);
- auto channels = input.size(1);
- auto height = input.size(2);
- auto width = input.size(3);
-
- auto output = at::empty({num_rois, channels, pooled_height, pooled_width}, input.options());
- auto output_size = num_rois * pooled_height * pooled_width * channels;
-
- if (output.numel() == 0) {
- return output;
- }
-
- AT_DISPATCH_FLOATING_TYPES(input.type(), "ROIAlign_forward", [&] {
- ROIAlignForward_cpu_kernel(
- output_size,
- input.data(),
- spatial_scale,
- channels,
- height,
- width,
- pooled_height,
- pooled_width,
- sampling_ratio,
- rois.data(),
- output.data());
- });
- return output;
-}
diff --git a/spaces/DHEIVER/analise_imagem_mama/app.py b/spaces/DHEIVER/analise_imagem_mama/app.py
deleted file mode 100644
index 535df07d4d8dc178f5b680af3a1cba8ae30a03a1..0000000000000000000000000000000000000000
--- a/spaces/DHEIVER/analise_imagem_mama/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/MUmairAB/Breast_Cancer_Detector").launch()
\ No newline at end of file
diff --git a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/applications.py b/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/applications.py
deleted file mode 100644
index e32cfa03d20cbfd8ee588b943d15cf1b38e2b951..0000000000000000000000000000000000000000
--- a/spaces/DQChoi/gpt-demo/venv/lib/python3.11/site-packages/fastapi/applications.py
+++ /dev/null
@@ -1,942 +0,0 @@
-from enum import Enum
-from typing import (
- Any,
- Awaitable,
- Callable,
- Coroutine,
- Dict,
- List,
- Optional,
- Sequence,
- Type,
- TypeVar,
- Union,
-)
-
-from fastapi import routing
-from fastapi.datastructures import Default, DefaultPlaceholder
-from fastapi.exception_handlers import (
- http_exception_handler,
- request_validation_exception_handler,
- websocket_request_validation_exception_handler,
-)
-from fastapi.exceptions import RequestValidationError, WebSocketRequestValidationError
-from fastapi.logger import logger
-from fastapi.middleware.asyncexitstack import AsyncExitStackMiddleware
-from fastapi.openapi.docs import (
- get_redoc_html,
- get_swagger_ui_html,
- get_swagger_ui_oauth2_redirect_html,
-)
-from fastapi.openapi.utils import get_openapi
-from fastapi.params import Depends
-from fastapi.types import DecoratedCallable, IncEx
-from fastapi.utils import generate_unique_id
-from starlette.applications import Starlette
-from starlette.datastructures import State
-from starlette.exceptions import HTTPException
-from starlette.middleware import Middleware
-from starlette.middleware.base import BaseHTTPMiddleware
-from starlette.middleware.errors import ServerErrorMiddleware
-from starlette.middleware.exceptions import ExceptionMiddleware
-from starlette.requests import Request
-from starlette.responses import HTMLResponse, JSONResponse, Response
-from starlette.routing import BaseRoute
-from starlette.types import ASGIApp, Lifespan, Receive, Scope, Send
-
-AppType = TypeVar("AppType", bound="FastAPI")
-
-
-class FastAPI(Starlette):
- def __init__(
- self: AppType,
- *,
- debug: bool = False,
- routes: Optional[List[BaseRoute]] = None,
- title: str = "FastAPI",
- summary: Optional[str] = None,
- description: str = "",
- version: str = "0.1.0",
- openapi_url: Optional[str] = "/openapi.json",
- openapi_tags: Optional[List[Dict[str, Any]]] = None,
- servers: Optional[List[Dict[str, Union[str, Any]]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- default_response_class: Type[Response] = Default(JSONResponse),
- redirect_slashes: bool = True,
- docs_url: Optional[str] = "/docs",
- redoc_url: Optional[str] = "/redoc",
- swagger_ui_oauth2_redirect_url: Optional[str] = "/docs/oauth2-redirect",
- swagger_ui_init_oauth: Optional[Dict[str, Any]] = None,
- middleware: Optional[Sequence[Middleware]] = None,
- exception_handlers: Optional[
- Dict[
- Union[int, Type[Exception]],
- Callable[[Request, Any], Coroutine[Any, Any, Response]],
- ]
- ] = None,
- on_startup: Optional[Sequence[Callable[[], Any]]] = None,
- on_shutdown: Optional[Sequence[Callable[[], Any]]] = None,
- lifespan: Optional[Lifespan[AppType]] = None,
- terms_of_service: Optional[str] = None,
- contact: Optional[Dict[str, Union[str, Any]]] = None,
- license_info: Optional[Dict[str, Union[str, Any]]] = None,
- openapi_prefix: str = "",
- root_path: str = "",
- root_path_in_servers: bool = True,
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- webhooks: Optional[routing.APIRouter] = None,
- deprecated: Optional[bool] = None,
- include_in_schema: bool = True,
- swagger_ui_parameters: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- **extra: Any,
- ) -> None:
- self.debug = debug
- self.title = title
- self.summary = summary
- self.description = description
- self.version = version
- self.terms_of_service = terms_of_service
- self.contact = contact
- self.license_info = license_info
- self.openapi_url = openapi_url
- self.openapi_tags = openapi_tags
- self.root_path_in_servers = root_path_in_servers
- self.docs_url = docs_url
- self.redoc_url = redoc_url
- self.swagger_ui_oauth2_redirect_url = swagger_ui_oauth2_redirect_url
- self.swagger_ui_init_oauth = swagger_ui_init_oauth
- self.swagger_ui_parameters = swagger_ui_parameters
- self.servers = servers or []
- self.extra = extra
- self.openapi_version = "3.1.0"
- self.openapi_schema: Optional[Dict[str, Any]] = None
- if self.openapi_url:
- assert self.title, "A title must be provided for OpenAPI, e.g.: 'My API'"
- assert self.version, "A version must be provided for OpenAPI, e.g.: '2.1.0'"
- # TODO: remove when discarding the openapi_prefix parameter
- if openapi_prefix:
- logger.warning(
- '"openapi_prefix" has been deprecated in favor of "root_path", which '
- "follows more closely the ASGI standard, is simpler, and more "
- "automatic. Check the docs at "
- "https://fastapi.tiangolo.com/advanced/sub-applications/"
- )
- self.webhooks = webhooks or routing.APIRouter()
- self.root_path = root_path or openapi_prefix
- self.state: State = State()
- self.dependency_overrides: Dict[Callable[..., Any], Callable[..., Any]] = {}
- self.router: routing.APIRouter = routing.APIRouter(
- routes=routes,
- redirect_slashes=redirect_slashes,
- dependency_overrides_provider=self,
- on_startup=on_startup,
- on_shutdown=on_shutdown,
- lifespan=lifespan,
- default_response_class=default_response_class,
- dependencies=dependencies,
- callbacks=callbacks,
- deprecated=deprecated,
- include_in_schema=include_in_schema,
- responses=responses,
- generate_unique_id_function=generate_unique_id_function,
- )
- self.exception_handlers: Dict[
- Any, Callable[[Request, Any], Union[Response, Awaitable[Response]]]
- ] = ({} if exception_handlers is None else dict(exception_handlers))
- self.exception_handlers.setdefault(HTTPException, http_exception_handler)
- self.exception_handlers.setdefault(
- RequestValidationError, request_validation_exception_handler
- )
- self.exception_handlers.setdefault(
- WebSocketRequestValidationError,
- # Starlette still has incorrect type specification for the handlers
- websocket_request_validation_exception_handler, # type: ignore
- )
-
- self.user_middleware: List[Middleware] = (
- [] if middleware is None else list(middleware)
- )
- self.middleware_stack: Union[ASGIApp, None] = None
- self.setup()
-
- def build_middleware_stack(self) -> ASGIApp:
- # Duplicate/override from Starlette to add AsyncExitStackMiddleware
- # inside of ExceptionMiddleware, inside of custom user middlewares
- debug = self.debug
- error_handler = None
- exception_handlers = {}
-
- for key, value in self.exception_handlers.items():
- if key in (500, Exception):
- error_handler = value
- else:
- exception_handlers[key] = value
-
- middleware = (
- [Middleware(ServerErrorMiddleware, handler=error_handler, debug=debug)]
- + self.user_middleware
- + [
- Middleware(
- ExceptionMiddleware, handlers=exception_handlers, debug=debug
- ),
- # Add FastAPI-specific AsyncExitStackMiddleware for dependencies with
- # contextvars.
- # This needs to happen after user middlewares because those create a
- # new contextvars context copy by using a new AnyIO task group.
- # The initial part of dependencies with yield is executed in the
- # FastAPI code, inside all the middlewares, but the teardown part
- # (after yield) is executed in the AsyncExitStack in this middleware,
- # if the AsyncExitStack lived outside of the custom middlewares and
- # contextvars were set in a dependency with yield in that internal
- # contextvars context, the values would not be available in the
- # outside context of the AsyncExitStack.
- # By putting the middleware and the AsyncExitStack here, inside all
- # user middlewares, the code before and after yield in dependencies
- # with yield is executed in the same contextvars context, so all values
- # set in contextvars before yield is still available after yield as
- # would be expected.
- # Additionally, by having this AsyncExitStack here, after the
- # ExceptionMiddleware, now dependencies can catch handled exceptions,
- # e.g. HTTPException, to customize the teardown code (e.g. DB session
- # rollback).
- Middleware(AsyncExitStackMiddleware),
- ]
- )
-
- app = self.router
- for cls, options in reversed(middleware):
- app = cls(app=app, **options)
- return app
-
- def openapi(self) -> Dict[str, Any]:
- if not self.openapi_schema:
- self.openapi_schema = get_openapi(
- title=self.title,
- version=self.version,
- openapi_version=self.openapi_version,
- summary=self.summary,
- description=self.description,
- terms_of_service=self.terms_of_service,
- contact=self.contact,
- license_info=self.license_info,
- routes=self.routes,
- webhooks=self.webhooks.routes,
- tags=self.openapi_tags,
- servers=self.servers,
- )
- return self.openapi_schema
-
- def setup(self) -> None:
- if self.openapi_url:
- urls = (server_data.get("url") for server_data in self.servers)
- server_urls = {url for url in urls if url}
-
- async def openapi(req: Request) -> JSONResponse:
- root_path = req.scope.get("root_path", "").rstrip("/")
- if root_path not in server_urls:
- if root_path and self.root_path_in_servers:
- self.servers.insert(0, {"url": root_path})
- server_urls.add(root_path)
- return JSONResponse(self.openapi())
-
- self.add_route(self.openapi_url, openapi, include_in_schema=False)
- if self.openapi_url and self.docs_url:
-
- async def swagger_ui_html(req: Request) -> HTMLResponse:
- root_path = req.scope.get("root_path", "").rstrip("/")
- openapi_url = root_path + self.openapi_url
- oauth2_redirect_url = self.swagger_ui_oauth2_redirect_url
- if oauth2_redirect_url:
- oauth2_redirect_url = root_path + oauth2_redirect_url
- return get_swagger_ui_html(
- openapi_url=openapi_url,
- title=self.title + " - Swagger UI",
- oauth2_redirect_url=oauth2_redirect_url,
- init_oauth=self.swagger_ui_init_oauth,
- swagger_ui_parameters=self.swagger_ui_parameters,
- )
-
- self.add_route(self.docs_url, swagger_ui_html, include_in_schema=False)
-
- if self.swagger_ui_oauth2_redirect_url:
-
- async def swagger_ui_redirect(req: Request) -> HTMLResponse:
- return get_swagger_ui_oauth2_redirect_html()
-
- self.add_route(
- self.swagger_ui_oauth2_redirect_url,
- swagger_ui_redirect,
- include_in_schema=False,
- )
- if self.openapi_url and self.redoc_url:
-
- async def redoc_html(req: Request) -> HTMLResponse:
- root_path = req.scope.get("root_path", "").rstrip("/")
- openapi_url = root_path + self.openapi_url
- return get_redoc_html(
- openapi_url=openapi_url, title=self.title + " - ReDoc"
- )
-
- self.add_route(self.redoc_url, redoc_html, include_in_schema=False)
-
- async def __call__(self, scope: Scope, receive: Receive, send: Send) -> None:
- if self.root_path:
- scope["root_path"] = self.root_path
- await super().__call__(scope, receive, send)
-
- def add_api_route(
- self,
- path: str,
- endpoint: Callable[..., Coroutine[Any, Any, Response]],
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- methods: Optional[List[str]] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Union[Type[Response], DefaultPlaceholder] = Default(
- JSONResponse
- ),
- name: Optional[str] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> None:
- self.router.add_api_route(
- path,
- endpoint=endpoint,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- methods=methods,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def api_route(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- methods: Optional[List[str]] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- def decorator(func: DecoratedCallable) -> DecoratedCallable:
- self.router.add_api_route(
- path,
- func,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- methods=methods,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
- return func
-
- return decorator
-
- def add_api_websocket_route(
- self,
- path: str,
- endpoint: Callable[..., Any],
- name: Optional[str] = None,
- *,
- dependencies: Optional[Sequence[Depends]] = None,
- ) -> None:
- self.router.add_api_websocket_route(
- path,
- endpoint,
- name=name,
- dependencies=dependencies,
- )
-
- def websocket(
- self,
- path: str,
- name: Optional[str] = None,
- *,
- dependencies: Optional[Sequence[Depends]] = None,
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- def decorator(func: DecoratedCallable) -> DecoratedCallable:
- self.add_api_websocket_route(
- path,
- func,
- name=name,
- dependencies=dependencies,
- )
- return func
-
- return decorator
-
- def include_router(
- self,
- router: routing.APIRouter,
- *,
- prefix: str = "",
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- include_in_schema: bool = True,
- default_response_class: Type[Response] = Default(JSONResponse),
- callbacks: Optional[List[BaseRoute]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> None:
- self.router.include_router(
- router,
- prefix=prefix,
- tags=tags,
- dependencies=dependencies,
- responses=responses,
- deprecated=deprecated,
- include_in_schema=include_in_schema,
- default_response_class=default_response_class,
- callbacks=callbacks,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def get(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.get(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def put(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.put(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def post(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.post(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def delete(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.delete(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def options(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.options(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def head(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.head(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def patch(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.patch(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def trace(
- self,
- path: str,
- *,
- response_model: Any = Default(None),
- status_code: Optional[int] = None,
- tags: Optional[List[Union[str, Enum]]] = None,
- dependencies: Optional[Sequence[Depends]] = None,
- summary: Optional[str] = None,
- description: Optional[str] = None,
- response_description: str = "Successful Response",
- responses: Optional[Dict[Union[int, str], Dict[str, Any]]] = None,
- deprecated: Optional[bool] = None,
- operation_id: Optional[str] = None,
- response_model_include: Optional[IncEx] = None,
- response_model_exclude: Optional[IncEx] = None,
- response_model_by_alias: bool = True,
- response_model_exclude_unset: bool = False,
- response_model_exclude_defaults: bool = False,
- response_model_exclude_none: bool = False,
- include_in_schema: bool = True,
- response_class: Type[Response] = Default(JSONResponse),
- name: Optional[str] = None,
- callbacks: Optional[List[BaseRoute]] = None,
- openapi_extra: Optional[Dict[str, Any]] = None,
- generate_unique_id_function: Callable[[routing.APIRoute], str] = Default(
- generate_unique_id
- ),
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.trace(
- path,
- response_model=response_model,
- status_code=status_code,
- tags=tags,
- dependencies=dependencies,
- summary=summary,
- description=description,
- response_description=response_description,
- responses=responses,
- deprecated=deprecated,
- operation_id=operation_id,
- response_model_include=response_model_include,
- response_model_exclude=response_model_exclude,
- response_model_by_alias=response_model_by_alias,
- response_model_exclude_unset=response_model_exclude_unset,
- response_model_exclude_defaults=response_model_exclude_defaults,
- response_model_exclude_none=response_model_exclude_none,
- include_in_schema=include_in_schema,
- response_class=response_class,
- name=name,
- callbacks=callbacks,
- openapi_extra=openapi_extra,
- generate_unique_id_function=generate_unique_id_function,
- )
-
- def websocket_route(
- self, path: str, name: Union[str, None] = None
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- def decorator(func: DecoratedCallable) -> DecoratedCallable:
- self.router.add_websocket_route(path, func, name=name)
- return func
-
- return decorator
-
- def on_event(
- self, event_type: str
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- return self.router.on_event(event_type)
-
- def middleware(
- self, middleware_type: str
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- def decorator(func: DecoratedCallable) -> DecoratedCallable:
- self.add_middleware(BaseHTTPMiddleware, dispatch=func)
- return func
-
- return decorator
-
- def exception_handler(
- self, exc_class_or_status_code: Union[int, Type[Exception]]
- ) -> Callable[[DecoratedCallable], DecoratedCallable]:
- def decorator(func: DecoratedCallable) -> DecoratedCallable:
- self.add_exception_handler(exc_class_or_status_code, func)
- return func
-
- return decorator
diff --git a/spaces/Deepak107/Bottle_images/app.py b/spaces/Deepak107/Bottle_images/app.py
deleted file mode 100644
index 4c17f77a654d05c41230fb7f771612d3b2a6cada..0000000000000000000000000000000000000000
--- a/spaces/Deepak107/Bottle_images/app.py
+++ /dev/null
@@ -1,15 +0,0 @@
-from tensorflow import keras
-import gradio as gr
-model = keras.models.load_model('Bottle_images.h5')
-class_names = ['Beer Bottles','Plastic Bottles','Soda Bottle','Water Bottle','Wine Bottle']
-
-def predict_input_image(img):
- img_4d=img.reshape(-1,120,120,3)
- prediction=model.predict(img_4d)[0]
- return {class_names[i]: float(prediction[i]) for i in range(len(class_names))}
-
-
-image = gr.inputs.Image(shape=(120,120))
-label = gr.outputs.Label(num_top_classes=len(class_names))
-
-gr.Interface(fn=predict_input_image, inputs=image, outputs=label,interpretation='default').launch(debug='True')
diff --git a/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/global_directions/__init__.py b/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/global_directions/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/models/facial_recognition/__init__.py b/spaces/DragGan/DragGan-Inversion/PTI/models/StyleCLIP/models/facial_recognition/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Eddycrack864/Applio-Inference/julius/lowpass.py b/spaces/Eddycrack864/Applio-Inference/julius/lowpass.py
deleted file mode 100644
index 0eb46e382b20bfc2d93482f9f027986b863de6f0..0000000000000000000000000000000000000000
--- a/spaces/Eddycrack864/Applio-Inference/julius/lowpass.py
+++ /dev/null
@@ -1,181 +0,0 @@
-# File under the MIT license, see https://github.com/adefossez/julius/LICENSE for details.
-# Author: adefossez, 2020
-"""
-FIR windowed sinc lowpass filters.
-"""
-
-import math
-from typing import Sequence, Optional
-
-import torch
-from torch.nn import functional as F
-
-from .core import sinc
-from .fftconv import fft_conv1d
-from .utils import simple_repr
-
-
-class LowPassFilters(torch.nn.Module):
- """
- Bank of low pass filters. Note that a high pass or band pass filter can easily
- be implemented by substracting a same signal processed with low pass filters with different
- frequencies (see `julius.bands.SplitBands` for instance).
- This uses a windowed sinc filter, very similar to the one used in
- `julius.resample`. However, because we do not change the sample rate here,
- this filter can be much more efficiently implemented using the FFT convolution from
- `julius.fftconv`.
-
- Args:
- cutoffs (list[float]): list of cutoff frequencies, in [0, 0.5] expressed as `f/f_s` where
- f_s is the samplerate and `f` is the cutoff frequency.
- The upper limit is 0.5, because a signal sampled at `f_s` contains only
- frequencies under `f_s / 2`.
- stride (int): how much to decimate the output. Keep in mind that decimation
- of the output is only acceptable if the cutoff frequency is under `1/ (2 * stride)`
- of the original sampling rate.
- pad (bool): if True, appropriately pad the input with zero over the edge. If `stride=1`,
- the output will have the same length as the input.
- zeros (float): Number of zero crossings to keep.
- Controls the receptive field of the Finite Impulse Response filter.
- For lowpass filters with low cutoff frequency, e.g. 40Hz at 44.1kHz,
- it is a bad idea to set this to a high value.
- This is likely appropriate for most use. Lower values
- will result in a faster filter, but with a slower attenuation around the
- cutoff frequency.
- fft (bool or None): if True, uses `julius.fftconv` rather than PyTorch convolutions.
- If False, uses PyTorch convolutions. If None, either one will be chosen automatically
- depending on the effective filter size.
-
-
- ..warning::
- All the filters will use the same filter size, aligned on the lowest
- frequency provided. If you combine a lot of filters with very diverse frequencies, it might
- be more efficient to split them over multiple modules with similar frequencies.
-
- ..note::
- A lowpass with a cutoff frequency of 0 is defined as the null function
- by convention here. This allows for a highpass with a cutoff of 0 to
- be equal to identity, as defined in `julius.filters.HighPassFilters`.
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[F, *, T']`, with `T'=T` if `pad` is True and `stride` is 1, and
- `F` is the numer of cutoff frequencies.
-
- >>> lowpass = LowPassFilters([1/4])
- >>> x = torch.randn(4, 12, 21, 1024)
- >>> list(lowpass(x).shape)
- [1, 4, 12, 21, 1024]
- """
-
- def __init__(self, cutoffs: Sequence[float], stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- super().__init__()
- self.cutoffs = list(cutoffs)
- if min(self.cutoffs) < 0:
- raise ValueError("Minimum cutoff must be larger than zero.")
- if max(self.cutoffs) > 0.5:
- raise ValueError("A cutoff above 0.5 does not make sense.")
- self.stride = stride
- self.pad = pad
- self.zeros = zeros
- self.half_size = int(zeros / min([c for c in self.cutoffs if c > 0]) / 2)
- if fft is None:
- fft = self.half_size > 32
- self.fft = fft
- window = torch.hann_window(2 * self.half_size + 1, periodic=False)
- time = torch.arange(-self.half_size, self.half_size + 1)
- filters = []
- for cutoff in cutoffs:
- if cutoff == 0:
- filter_ = torch.zeros_like(time)
- else:
- filter_ = 2 * cutoff * window * sinc(2 * cutoff * math.pi * time)
- # Normalize filter to have sum = 1, otherwise we will have a small leakage
- # of the constant component in the input signal.
- filter_ /= filter_.sum()
- filters.append(filter_)
- self.register_buffer("filters", torch.stack(filters)[:, None])
-
- def forward(self, input):
- shape = list(input.shape)
- input = input.view(-1, 1, shape[-1])
- if self.pad:
- input = F.pad(input, (self.half_size, self.half_size), mode='replicate')
- if self.fft:
- out = fft_conv1d(input, self.filters, stride=self.stride)
- else:
- out = F.conv1d(input, self.filters, stride=self.stride)
- shape.insert(0, len(self.cutoffs))
- shape[-1] = out.shape[-1]
- return out.permute(1, 0, 2).reshape(shape)
-
- def __repr__(self):
- return simple_repr(self)
-
-
-class LowPassFilter(torch.nn.Module):
- """
- Same as `LowPassFilters` but applies a single low pass filter.
-
- Shape:
-
- - Input: `[*, T]`
- - Output: `[*, T']`, with `T'=T` if `pad` is True and `stride` is 1.
-
- >>> lowpass = LowPassFilter(1/4, stride=2)
- >>> x = torch.randn(4, 124)
- >>> list(lowpass(x).shape)
- [4, 62]
- """
-
- def __init__(self, cutoff: float, stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- super().__init__()
- self._lowpasses = LowPassFilters([cutoff], stride, pad, zeros, fft)
-
- @property
- def cutoff(self):
- return self._lowpasses.cutoffs[0]
-
- @property
- def stride(self):
- return self._lowpasses.stride
-
- @property
- def pad(self):
- return self._lowpasses.pad
-
- @property
- def zeros(self):
- return self._lowpasses.zeros
-
- @property
- def fft(self):
- return self._lowpasses.fft
-
- def forward(self, input):
- return self._lowpasses(input)[0]
-
- def __repr__(self):
- return simple_repr(self)
-
-
-def lowpass_filters(input: torch.Tensor, cutoffs: Sequence[float],
- stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- """
- Functional version of `LowPassFilters`, refer to this class for more information.
- """
- return LowPassFilters(cutoffs, stride, pad, zeros, fft).to(input)(input)
-
-
-def lowpass_filter(input: torch.Tensor, cutoff: float,
- stride: int = 1, pad: bool = True,
- zeros: float = 8, fft: Optional[bool] = None):
- """
- Same as `lowpass_filters` but with a single cutoff frequency.
- Output will not have a dimension inserted in the front.
- """
- return lowpass_filters(input, [cutoff], stride, pad, zeros, fft)[0]
diff --git a/spaces/EsoCode/text-generation-webui/docker/Dockerfile b/spaces/EsoCode/text-generation-webui/docker/Dockerfile
deleted file mode 100644
index 7cc0ff1513eb90d8d42be0edfce5d810cc9ad48d..0000000000000000000000000000000000000000
--- a/spaces/EsoCode/text-generation-webui/docker/Dockerfile
+++ /dev/null
@@ -1,68 +0,0 @@
-FROM nvidia/cuda:11.8.0-devel-ubuntu22.04 as builder
-
-RUN apt-get update && \
- apt-get install --no-install-recommends -y git vim build-essential python3-dev python3-venv && \
- rm -rf /var/lib/apt/lists/*
-
-RUN git clone https://github.com/oobabooga/GPTQ-for-LLaMa /build
-
-WORKDIR /build
-
-RUN python3 -m venv /build/venv
-RUN . /build/venv/bin/activate && \
- pip3 install --upgrade pip setuptools wheel && \
- pip3 install torch torchvision torchaudio && \
- pip3 install -r requirements.txt
-
-# https://developer.nvidia.com/cuda-gpus
-# for a rtx 2060: ARG TORCH_CUDA_ARCH_LIST="7.5"
-ARG TORCH_CUDA_ARCH_LIST="3.5;5.0;6.0;6.1;7.0;7.5;8.0;8.6+PTX"
-RUN . /build/venv/bin/activate && \
- python3 setup_cuda.py bdist_wheel -d .
-
-FROM nvidia/cuda:11.8.0-runtime-ubuntu22.04
-
-LABEL maintainer="Your Name "
-LABEL description="Docker image for GPTQ-for-LLaMa and Text Generation WebUI"
-
-RUN apt-get update && \
- apt-get install --no-install-recommends -y python3-dev libportaudio2 libasound-dev git python3 python3-pip make g++ && \
- rm -rf /var/lib/apt/lists/*
-
-RUN --mount=type=cache,target=/root/.cache/pip pip3 install virtualenv
-RUN mkdir /app
-
-WORKDIR /app
-
-ARG WEBUI_VERSION
-RUN test -n "${WEBUI_VERSION}" && git reset --hard ${WEBUI_VERSION} || echo "Using provided webui source"
-
-RUN virtualenv /app/venv
-RUN . /app/venv/bin/activate && \
- pip3 install --upgrade pip setuptools wheel && \
- pip3 install torch torchvision torchaudio
-
-COPY --from=builder /build /app/repositories/GPTQ-for-LLaMa
-RUN . /app/venv/bin/activate && \
- pip3 install /app/repositories/GPTQ-for-LLaMa/*.whl
-
-COPY extensions/api/requirements.txt /app/extensions/api/requirements.txt
-COPY extensions/elevenlabs_tts/requirements.txt /app/extensions/elevenlabs_tts/requirements.txt
-COPY extensions/google_translate/requirements.txt /app/extensions/google_translate/requirements.txt
-COPY extensions/silero_tts/requirements.txt /app/extensions/silero_tts/requirements.txt
-COPY extensions/whisper_stt/requirements.txt /app/extensions/whisper_stt/requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/api && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/elevenlabs_tts && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/google_translate && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/silero_tts && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/whisper_stt && pip3 install -r requirements.txt
-
-COPY requirements.txt /app/requirements.txt
-RUN . /app/venv/bin/activate && \
- pip3 install -r requirements.txt
-
-RUN cp /app/venv/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda118.so /app/venv/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cpu.so
-
-COPY . /app/
-ENV CLI_ARGS=""
-CMD . /app/venv/bin/activate && python3 server.py ${CLI_ARGS}
diff --git a/spaces/FEIMENG/andite-anything-v4.0/app.py b/spaces/FEIMENG/andite-anything-v4.0/app.py
deleted file mode 100644
index 47a2051db6dadeea03edf70d62694fd3e5e88ba7..0000000000000000000000000000000000000000
--- a/spaces/FEIMENG/andite-anything-v4.0/app.py
+++ /dev/null
@@ -1,3 +0,0 @@
-import gradio as gr
-
-gr.Interface.load("models/andite/anything-v4.0").launch()
\ No newline at end of file
diff --git a/spaces/Faridmaruf/rvc-Blue-archives/lib/infer_pack/modules/F0Predictor/__init__.py b/spaces/Faridmaruf/rvc-Blue-archives/lib/infer_pack/modules/F0Predictor/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/FrankZxShen/so-vits-svc-models-ba/diffusion/unit2mel.py b/spaces/FrankZxShen/so-vits-svc-models-ba/diffusion/unit2mel.py
deleted file mode 100644
index e6b738966698848fe5acca8c0752b995c839a793..0000000000000000000000000000000000000000
--- a/spaces/FrankZxShen/so-vits-svc-models-ba/diffusion/unit2mel.py
+++ /dev/null
@@ -1,100 +0,0 @@
-import os
-import yaml
-import torch
-import torch.nn as nn
-import numpy as np
-from .diffusion import GaussianDiffusion
-from .wavenet import WaveNet
-from .vocoder import Vocoder
-
-class DotDict(dict):
- def __getattr__(*args):
- val = dict.get(*args)
- return DotDict(val) if type(val) is dict else val
-
- __setattr__ = dict.__setitem__
- __delattr__ = dict.__delitem__
-
-
-def load_model_vocoder(
- model_path,
- device='cpu',
- config_path = None
- ):
- if config_path is None: config_file = os.path.join(os.path.split(model_path)[0], 'config.yaml')
- else: config_file = config_path
-
- with open(config_file, "r") as config:
- args = yaml.safe_load(config)
- args = DotDict(args)
-
- # load vocoder
- vocoder = Vocoder(args.vocoder.type, args.vocoder.ckpt, device=device)
-
- # load model
- model = Unit2Mel(
- args.data.encoder_out_channels,
- args.model.n_spk,
- args.model.use_pitch_aug,
- vocoder.dimension,
- args.model.n_layers,
- args.model.n_chans,
- args.model.n_hidden)
-
- print(' [Loading] ' + model_path)
- ckpt = torch.load(model_path, map_location=torch.device(device))
- model.to(device)
- model.load_state_dict(ckpt['model'])
- model.eval()
- return model, vocoder, args
-
-
-class Unit2Mel(nn.Module):
- def __init__(
- self,
- input_channel,
- n_spk,
- use_pitch_aug=False,
- out_dims=128,
- n_layers=20,
- n_chans=384,
- n_hidden=256):
- super().__init__()
- self.unit_embed = nn.Linear(input_channel, n_hidden)
- self.f0_embed = nn.Linear(1, n_hidden)
- self.volume_embed = nn.Linear(1, n_hidden)
- if use_pitch_aug:
- self.aug_shift_embed = nn.Linear(1, n_hidden, bias=False)
- else:
- self.aug_shift_embed = None
- self.n_spk = n_spk
- if n_spk is not None and n_spk > 1:
- self.spk_embed = nn.Embedding(n_spk, n_hidden)
-
- # diffusion
- self.decoder = GaussianDiffusion(WaveNet(out_dims, n_layers, n_chans, n_hidden), out_dims=out_dims)
-
- def forward(self, units, f0, volume, spk_id = None, spk_mix_dict = None, aug_shift = None,
- gt_spec=None, infer=True, infer_speedup=10, method='dpm-solver', k_step=300, use_tqdm=True):
-
- '''
- input:
- B x n_frames x n_unit
- return:
- dict of B x n_frames x feat
- '''
-
- x = self.unit_embed(units) + self.f0_embed((1+ f0 / 700).log()) + self.volume_embed(volume)
- if self.n_spk is not None and self.n_spk > 1:
- if spk_mix_dict is not None:
- for k, v in spk_mix_dict.items():
- spk_id_torch = torch.LongTensor(np.array([[k]])).to(units.device)
- x = x + v * self.spk_embed(spk_id_torch)
- else:
- x = x + self.spk_embed(spk_id)
- if self.aug_shift_embed is not None and aug_shift is not None:
- x = x + self.aug_shift_embed(aug_shift / 5)
- x = self.decoder(x, gt_spec=gt_spec, infer=infer, infer_speedup=infer_speedup, method=method, k_step=k_step, use_tqdm=use_tqdm)
-
- return x
-
diff --git a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train7_gptmixcliport3_new_pickplace.sh b/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train7_gptmixcliport3_new_pickplace.sh
deleted file mode 100644
index d59dd812e719db4ce269c007a623f5b622a6444c..0000000000000000000000000000000000000000
--- a/spaces/Gen-Sim/Gen-Sim/scripts/metascripts/train7_gptmixcliport3_new_pickplace.sh
+++ /dev/null
@@ -1,13 +0,0 @@
-#!/bin/bash
-#SBATCH -c 10
-#SBATCH -n 1
-#SBATCH -o logs/%j.out
-#SBATCH --exclusive
-STEPS=${1-'50000'}
-now=$(date "+%Y-%m-%d_%H-%M-%S")
-
-
-sh scripts/traintest_scripts/train_test_multi_task_goal.sh data \
- "[stack-block-pyramid,put-block-in-bowl,color-coordinated-sphere-insertion,rainbow-stack,vertical-insertion-blocks,stack-blocks-in-container]" \
- "[stack-block-pyramid,put-block-in-bowl]" \
- train7_gpt3_mixcliport3_task_new_demo50_${now}
\ No newline at end of file
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py
deleted file mode 100644
index 668c023981b9d421e5b51a48757c3819d090307f..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/carafe/mask_rcnn_r50_fpn_carafe_1x_coco.py
+++ /dev/null
@@ -1,60 +0,0 @@
-_base_ = '../mask_rcnn/mask_rcnn_r50_fpn_1x_coco.py'
-model = dict(
- neck=dict(
- type='FPN_CARAFE',
- in_channels=[256, 512, 1024, 2048],
- out_channels=256,
- num_outs=5,
- start_level=0,
- end_level=-1,
- norm_cfg=None,
- act_cfg=None,
- order=('conv', 'norm', 'act'),
- upsample_cfg=dict(
- type='carafe',
- up_kernel=5,
- up_group=1,
- encoder_kernel=3,
- encoder_dilation=1,
- compressed_channels=64)),
- roi_head=dict(
- mask_head=dict(
- upsample_cfg=dict(
- type='carafe',
- scale_factor=2,
- up_kernel=5,
- up_group=1,
- encoder_kernel=3,
- encoder_dilation=1,
- compressed_channels=64))))
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations', with_bbox=True, with_mask=True),
- dict(type='Resize', img_scale=(1333, 800), keep_ratio=True),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=64),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels', 'gt_masks']),
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=(1333, 800),
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=64),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img']),
- ])
-]
-data = dict(
- train=dict(pipeline=train_pipeline),
- val=dict(pipeline=test_pipeline),
- test=dict(pipeline=test_pipeline))
diff --git a/spaces/Gradio-Blocks/uniformer_image_detection/configs/paa/paa_r50_fpn_mstrain_3x_coco.py b/spaces/Gradio-Blocks/uniformer_image_detection/configs/paa/paa_r50_fpn_mstrain_3x_coco.py
deleted file mode 100644
index 91fa28cde470cb323f90f89a56d8acb6f9f0a22e..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_detection/configs/paa/paa_r50_fpn_mstrain_3x_coco.py
+++ /dev/null
@@ -1,20 +0,0 @@
-_base_ = './paa_r50_fpn_1x_coco.py'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations', with_bbox=True),
- dict(
- type='Resize',
- img_scale=[(1333, 640), (1333, 800)],
- multiscale_mode='range',
- keep_ratio=True),
- dict(type='RandomFlip', flip_ratio=0.5),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size_divisor=32),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_bboxes', 'gt_labels']),
-]
-data = dict(train=dict(pipeline=train_pipeline))
-lr_config = dict(step=[28, 34])
-runner = dict(type='EpochBasedRunner', max_epochs=36)
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x1024_40k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x1024_40k_cityscapes.py
deleted file mode 100644
index 69d212f158552cf5a24f62174b24a9d4976477bb..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r101-d8_512x1024_40k_cityscapes.py
+++ /dev/null
@@ -1,2 +0,0 @@
-_base_ = './psanet_r50-d8_512x1024_40k_cityscapes.py'
-model = dict(pretrained='open-mmlab://resnet101_v1c', backbone=dict(depth=101))
diff --git a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_769x769_40k_cityscapes.py b/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_769x769_40k_cityscapes.py
deleted file mode 100644
index 690f8b5ef359be8a8be3a2d768aede24216a8706..0000000000000000000000000000000000000000
--- a/spaces/Gradio-Blocks/uniformer_image_segmentation/configs/psanet/psanet_r50-d8_769x769_40k_cityscapes.py
+++ /dev/null
@@ -1,9 +0,0 @@
-_base_ = [
- '../_base_/models/psanet_r50-d8.py',
- '../_base_/datasets/cityscapes_769x769.py', '../_base_/default_runtime.py',
- '../_base_/schedules/schedule_40k.py'
-]
-model = dict(
- decode_head=dict(align_corners=True),
- auxiliary_head=dict(align_corners=True),
- test_cfg=dict(mode='slide', crop_size=(769, 769), stride=(513, 513)))
diff --git a/spaces/GroveStreet/GTA_SOVITS/vdecoder/hifiganwithsnake/alias/resample.py b/spaces/GroveStreet/GTA_SOVITS/vdecoder/hifiganwithsnake/alias/resample.py
deleted file mode 100644
index 750e6c3402cc5ac939c4b9d075246562e0e1d1a7..0000000000000000000000000000000000000000
--- a/spaces/GroveStreet/GTA_SOVITS/vdecoder/hifiganwithsnake/alias/resample.py
+++ /dev/null
@@ -1,49 +0,0 @@
-# Adapted from https://github.com/junjun3518/alias-free-torch under the Apache License 2.0
-# LICENSE is in incl_licenses directory.
-
-import torch.nn as nn
-from torch.nn import functional as F
-from .filter import LowPassFilter1d
-from .filter import kaiser_sinc_filter1d
-
-
-class UpSample1d(nn.Module):
- def __init__(self, ratio=2, kernel_size=None):
- super().__init__()
- self.ratio = ratio
- self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
- self.stride = ratio
- self.pad = self.kernel_size // ratio - 1
- self.pad_left = self.pad * self.stride + (self.kernel_size - self.stride) // 2
- self.pad_right = self.pad * self.stride + (self.kernel_size - self.stride + 1) // 2
- filter = kaiser_sinc_filter1d(cutoff=0.5 / ratio,
- half_width=0.6 / ratio,
- kernel_size=self.kernel_size)
- self.register_buffer("filter", filter)
-
- # x: [B, C, T]
- def forward(self, x):
- _, C, _ = x.shape
-
- x = F.pad(x, (self.pad, self.pad), mode='replicate')
- x = self.ratio * F.conv_transpose1d(
- x, self.filter.expand(C, -1, -1), stride=self.stride, groups=C)
- x = x[..., self.pad_left:-self.pad_right]
-
- return x
-
-
-class DownSample1d(nn.Module):
- def __init__(self, ratio=2, kernel_size=None):
- super().__init__()
- self.ratio = ratio
- self.kernel_size = int(6 * ratio // 2) * 2 if kernel_size is None else kernel_size
- self.lowpass = LowPassFilter1d(cutoff=0.5 / ratio,
- half_width=0.6 / ratio,
- stride=ratio,
- kernel_size=self.kernel_size)
-
- def forward(self, x):
- xx = self.lowpass(x)
-
- return xx
\ No newline at end of file
diff --git a/spaces/HaHaBill/LandShapes-Antarctica/models/stylegan2/stylegan2-pytorch/inception.py b/spaces/HaHaBill/LandShapes-Antarctica/models/stylegan2/stylegan2-pytorch/inception.py
deleted file mode 100644
index f3afed8123e595f65c1333dea7151e653a836e2b..0000000000000000000000000000000000000000
--- a/spaces/HaHaBill/LandShapes-Antarctica/models/stylegan2/stylegan2-pytorch/inception.py
+++ /dev/null
@@ -1,310 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-from torchvision import models
-
-try:
- from torchvision.models.utils import load_state_dict_from_url
-except ImportError:
- from torch.utils.model_zoo import load_url as load_state_dict_from_url
-
-# Inception weights ported to Pytorch from
-# http://download.tensorflow.org/models/image/imagenet/inception-2015-12-05.tgz
-FID_WEIGHTS_URL = 'https://github.com/mseitzer/pytorch-fid/releases/download/fid_weights/pt_inception-2015-12-05-6726825d.pth'
-
-
-class InceptionV3(nn.Module):
- """Pretrained InceptionV3 network returning feature maps"""
-
- # Index of default block of inception to return,
- # corresponds to output of final average pooling
- DEFAULT_BLOCK_INDEX = 3
-
- # Maps feature dimensionality to their output blocks indices
- BLOCK_INDEX_BY_DIM = {
- 64: 0, # First max pooling features
- 192: 1, # Second max pooling featurs
- 768: 2, # Pre-aux classifier features
- 2048: 3 # Final average pooling features
- }
-
- def __init__(self,
- output_blocks=[DEFAULT_BLOCK_INDEX],
- resize_input=True,
- normalize_input=True,
- requires_grad=False,
- use_fid_inception=True):
- """Build pretrained InceptionV3
-
- Parameters
- ----------
- output_blocks : list of int
- Indices of blocks to return features of. Possible values are:
- - 0: corresponds to output of first max pooling
- - 1: corresponds to output of second max pooling
- - 2: corresponds to output which is fed to aux classifier
- - 3: corresponds to output of final average pooling
- resize_input : bool
- If true, bilinearly resizes input to width and height 299 before
- feeding input to model. As the network without fully connected
- layers is fully convolutional, it should be able to handle inputs
- of arbitrary size, so resizing might not be strictly needed
- normalize_input : bool
- If true, scales the input from range (0, 1) to the range the
- pretrained Inception network expects, namely (-1, 1)
- requires_grad : bool
- If true, parameters of the model require gradients. Possibly useful
- for finetuning the network
- use_fid_inception : bool
- If true, uses the pretrained Inception model used in Tensorflow's
- FID implementation. If false, uses the pretrained Inception model
- available in torchvision. The FID Inception model has different
- weights and a slightly different structure from torchvision's
- Inception model. If you want to compute FID scores, you are
- strongly advised to set this parameter to true to get comparable
- results.
- """
- super(InceptionV3, self).__init__()
-
- self.resize_input = resize_input
- self.normalize_input = normalize_input
- self.output_blocks = sorted(output_blocks)
- self.last_needed_block = max(output_blocks)
-
- assert self.last_needed_block <= 3, \
- 'Last possible output block index is 3'
-
- self.blocks = nn.ModuleList()
-
- if use_fid_inception:
- inception = fid_inception_v3()
- else:
- inception = models.inception_v3(pretrained=True)
-
- # Block 0: input to maxpool1
- block0 = [
- inception.Conv2d_1a_3x3,
- inception.Conv2d_2a_3x3,
- inception.Conv2d_2b_3x3,
- nn.MaxPool2d(kernel_size=3, stride=2)
- ]
- self.blocks.append(nn.Sequential(*block0))
-
- # Block 1: maxpool1 to maxpool2
- if self.last_needed_block >= 1:
- block1 = [
- inception.Conv2d_3b_1x1,
- inception.Conv2d_4a_3x3,
- nn.MaxPool2d(kernel_size=3, stride=2)
- ]
- self.blocks.append(nn.Sequential(*block1))
-
- # Block 2: maxpool2 to aux classifier
- if self.last_needed_block >= 2:
- block2 = [
- inception.Mixed_5b,
- inception.Mixed_5c,
- inception.Mixed_5d,
- inception.Mixed_6a,
- inception.Mixed_6b,
- inception.Mixed_6c,
- inception.Mixed_6d,
- inception.Mixed_6e,
- ]
- self.blocks.append(nn.Sequential(*block2))
-
- # Block 3: aux classifier to final avgpool
- if self.last_needed_block >= 3:
- block3 = [
- inception.Mixed_7a,
- inception.Mixed_7b,
- inception.Mixed_7c,
- nn.AdaptiveAvgPool2d(output_size=(1, 1))
- ]
- self.blocks.append(nn.Sequential(*block3))
-
- for param in self.parameters():
- param.requires_grad = requires_grad
-
- def forward(self, inp):
- """Get Inception feature maps
-
- Parameters
- ----------
- inp : torch.autograd.Variable
- Input tensor of shape Bx3xHxW. Values are expected to be in
- range (0, 1)
-
- Returns
- -------
- List of torch.autograd.Variable, corresponding to the selected output
- block, sorted ascending by index
- """
- outp = []
- x = inp
-
- if self.resize_input:
- x = F.interpolate(x,
- size=(299, 299),
- mode='bilinear',
- align_corners=False)
-
- if self.normalize_input:
- x = 2 * x - 1 # Scale from range (0, 1) to range (-1, 1)
-
- for idx, block in enumerate(self.blocks):
- x = block(x)
- if idx in self.output_blocks:
- outp.append(x)
-
- if idx == self.last_needed_block:
- break
-
- return outp
-
-
-def fid_inception_v3():
- """Build pretrained Inception model for FID computation
-
- The Inception model for FID computation uses a different set of weights
- and has a slightly different structure than torchvision's Inception.
-
- This method first constructs torchvision's Inception and then patches the
- necessary parts that are different in the FID Inception model.
- """
- inception = models.inception_v3(num_classes=1008,
- aux_logits=False,
- pretrained=False)
- inception.Mixed_5b = FIDInceptionA(192, pool_features=32)
- inception.Mixed_5c = FIDInceptionA(256, pool_features=64)
- inception.Mixed_5d = FIDInceptionA(288, pool_features=64)
- inception.Mixed_6b = FIDInceptionC(768, channels_7x7=128)
- inception.Mixed_6c = FIDInceptionC(768, channels_7x7=160)
- inception.Mixed_6d = FIDInceptionC(768, channels_7x7=160)
- inception.Mixed_6e = FIDInceptionC(768, channels_7x7=192)
- inception.Mixed_7b = FIDInceptionE_1(1280)
- inception.Mixed_7c = FIDInceptionE_2(2048)
-
- state_dict = load_state_dict_from_url(FID_WEIGHTS_URL, progress=True)
- inception.load_state_dict(state_dict)
- return inception
-
-
-class FIDInceptionA(models.inception.InceptionA):
- """InceptionA block patched for FID computation"""
- def __init__(self, in_channels, pool_features):
- super(FIDInceptionA, self).__init__(in_channels, pool_features)
-
- def forward(self, x):
- branch1x1 = self.branch1x1(x)
-
- branch5x5 = self.branch5x5_1(x)
- branch5x5 = self.branch5x5_2(branch5x5)
-
- branch3x3dbl = self.branch3x3dbl_1(x)
- branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
- branch3x3dbl = self.branch3x3dbl_3(branch3x3dbl)
-
- # Patch: Tensorflow's average pool does not use the padded zero's in
- # its average calculation
- branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
- count_include_pad=False)
- branch_pool = self.branch_pool(branch_pool)
-
- outputs = [branch1x1, branch5x5, branch3x3dbl, branch_pool]
- return torch.cat(outputs, 1)
-
-
-class FIDInceptionC(models.inception.InceptionC):
- """InceptionC block patched for FID computation"""
- def __init__(self, in_channels, channels_7x7):
- super(FIDInceptionC, self).__init__(in_channels, channels_7x7)
-
- def forward(self, x):
- branch1x1 = self.branch1x1(x)
-
- branch7x7 = self.branch7x7_1(x)
- branch7x7 = self.branch7x7_2(branch7x7)
- branch7x7 = self.branch7x7_3(branch7x7)
-
- branch7x7dbl = self.branch7x7dbl_1(x)
- branch7x7dbl = self.branch7x7dbl_2(branch7x7dbl)
- branch7x7dbl = self.branch7x7dbl_3(branch7x7dbl)
- branch7x7dbl = self.branch7x7dbl_4(branch7x7dbl)
- branch7x7dbl = self.branch7x7dbl_5(branch7x7dbl)
-
- # Patch: Tensorflow's average pool does not use the padded zero's in
- # its average calculation
- branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
- count_include_pad=False)
- branch_pool = self.branch_pool(branch_pool)
-
- outputs = [branch1x1, branch7x7, branch7x7dbl, branch_pool]
- return torch.cat(outputs, 1)
-
-
-class FIDInceptionE_1(models.inception.InceptionE):
- """First InceptionE block patched for FID computation"""
- def __init__(self, in_channels):
- super(FIDInceptionE_1, self).__init__(in_channels)
-
- def forward(self, x):
- branch1x1 = self.branch1x1(x)
-
- branch3x3 = self.branch3x3_1(x)
- branch3x3 = [
- self.branch3x3_2a(branch3x3),
- self.branch3x3_2b(branch3x3),
- ]
- branch3x3 = torch.cat(branch3x3, 1)
-
- branch3x3dbl = self.branch3x3dbl_1(x)
- branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
- branch3x3dbl = [
- self.branch3x3dbl_3a(branch3x3dbl),
- self.branch3x3dbl_3b(branch3x3dbl),
- ]
- branch3x3dbl = torch.cat(branch3x3dbl, 1)
-
- # Patch: Tensorflow's average pool does not use the padded zero's in
- # its average calculation
- branch_pool = F.avg_pool2d(x, kernel_size=3, stride=1, padding=1,
- count_include_pad=False)
- branch_pool = self.branch_pool(branch_pool)
-
- outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
- return torch.cat(outputs, 1)
-
-
-class FIDInceptionE_2(models.inception.InceptionE):
- """Second InceptionE block patched for FID computation"""
- def __init__(self, in_channels):
- super(FIDInceptionE_2, self).__init__(in_channels)
-
- def forward(self, x):
- branch1x1 = self.branch1x1(x)
-
- branch3x3 = self.branch3x3_1(x)
- branch3x3 = [
- self.branch3x3_2a(branch3x3),
- self.branch3x3_2b(branch3x3),
- ]
- branch3x3 = torch.cat(branch3x3, 1)
-
- branch3x3dbl = self.branch3x3dbl_1(x)
- branch3x3dbl = self.branch3x3dbl_2(branch3x3dbl)
- branch3x3dbl = [
- self.branch3x3dbl_3a(branch3x3dbl),
- self.branch3x3dbl_3b(branch3x3dbl),
- ]
- branch3x3dbl = torch.cat(branch3x3dbl, 1)
-
- # Patch: The FID Inception model uses max pooling instead of average
- # pooling. This is likely an error in this specific Inception
- # implementation, as other Inception models use average pooling here
- # (which matches the description in the paper).
- branch_pool = F.max_pool2d(x, kernel_size=3, stride=1, padding=1)
- branch_pool = self.branch_pool(branch_pool)
-
- outputs = [branch1x1, branch3x3, branch3x3dbl, branch_pool]
- return torch.cat(outputs, 1)
diff --git a/spaces/Hallucinate/demo/taming/data/imagenet.py b/spaces/Hallucinate/demo/taming/data/imagenet.py
deleted file mode 100644
index 9a02ec44ba4af9e993f58c91fa43482a4ecbe54c..0000000000000000000000000000000000000000
--- a/spaces/Hallucinate/demo/taming/data/imagenet.py
+++ /dev/null
@@ -1,558 +0,0 @@
-import os, tarfile, glob, shutil
-import yaml
-import numpy as np
-from tqdm import tqdm
-from PIL import Image
-import albumentations
-from omegaconf import OmegaConf
-from torch.utils.data import Dataset
-
-from taming.data.base import ImagePaths
-from taming.util import download, retrieve
-import taming.data.utils as bdu
-
-
-def give_synsets_from_indices(indices, path_to_yaml="data/imagenet_idx_to_synset.yaml"):
- synsets = []
- with open(path_to_yaml) as f:
- di2s = yaml.load(f)
- for idx in indices:
- synsets.append(str(di2s[idx]))
- print("Using {} different synsets for construction of Restriced Imagenet.".format(len(synsets)))
- return synsets
-
-
-def str_to_indices(string):
- """Expects a string in the format '32-123, 256, 280-321'"""
- assert not string.endswith(","), "provided string '{}' ends with a comma, pls remove it".format(string)
- subs = string.split(",")
- indices = []
- for sub in subs:
- subsubs = sub.split("-")
- assert len(subsubs) > 0
- if len(subsubs) == 1:
- indices.append(int(subsubs[0]))
- else:
- rang = [j for j in range(int(subsubs[0]), int(subsubs[1]))]
- indices.extend(rang)
- return sorted(indices)
-
-
-class ImageNetBase(Dataset):
- def __init__(self, config=None):
- self.config = config or OmegaConf.create()
- if not type(self.config)==dict:
- self.config = OmegaConf.to_container(self.config)
- self._prepare()
- self._prepare_synset_to_human()
- self._prepare_idx_to_synset()
- self._load()
-
- def __len__(self):
- return len(self.data)
-
- def __getitem__(self, i):
- return self.data[i]
-
- def _prepare(self):
- raise NotImplementedError()
-
- def _filter_relpaths(self, relpaths):
- ignore = set([
- "n06596364_9591.JPEG",
- ])
- relpaths = [rpath for rpath in relpaths if not rpath.split("/")[-1] in ignore]
- if "sub_indices" in self.config:
- indices = str_to_indices(self.config["sub_indices"])
- synsets = give_synsets_from_indices(indices, path_to_yaml=self.idx2syn) # returns a list of strings
- files = []
- for rpath in relpaths:
- syn = rpath.split("/")[0]
- if syn in synsets:
- files.append(rpath)
- return files
- else:
- return relpaths
-
- def _prepare_synset_to_human(self):
- SIZE = 2655750
- URL = "https://heibox.uni-heidelberg.de/f/9f28e956cd304264bb82/?dl=1"
- self.human_dict = os.path.join(self.root, "synset_human.txt")
- if (not os.path.exists(self.human_dict) or
- not os.path.getsize(self.human_dict)==SIZE):
- download(URL, self.human_dict)
-
- def _prepare_idx_to_synset(self):
- URL = "https://heibox.uni-heidelberg.de/f/d835d5b6ceda4d3aa910/?dl=1"
- self.idx2syn = os.path.join(self.root, "index_synset.yaml")
- if (not os.path.exists(self.idx2syn)):
- download(URL, self.idx2syn)
-
- def _load(self):
- with open(self.txt_filelist, "r") as f:
- self.relpaths = f.read().splitlines()
- l1 = len(self.relpaths)
- self.relpaths = self._filter_relpaths(self.relpaths)
- print("Removed {} files from filelist during filtering.".format(l1 - len(self.relpaths)))
-
- self.synsets = [p.split("/")[0] for p in self.relpaths]
- self.abspaths = [os.path.join(self.datadir, p) for p in self.relpaths]
-
- unique_synsets = np.unique(self.synsets)
- class_dict = dict((synset, i) for i, synset in enumerate(unique_synsets))
- self.class_labels = [class_dict[s] for s in self.synsets]
-
- with open(self.human_dict, "r") as f:
- human_dict = f.read().splitlines()
- human_dict = dict(line.split(maxsplit=1) for line in human_dict)
-
- self.human_labels = [human_dict[s] for s in self.synsets]
-
- labels = {
- "relpath": np.array(self.relpaths),
- "synsets": np.array(self.synsets),
- "class_label": np.array(self.class_labels),
- "human_label": np.array(self.human_labels),
- }
- self.data = ImagePaths(self.abspaths,
- labels=labels,
- size=retrieve(self.config, "size", default=0),
- random_crop=self.random_crop)
-
-
-class ImageNetTrain(ImageNetBase):
- NAME = "ILSVRC2012_train"
- URL = "http://www.image-net.org/challenges/LSVRC/2012/"
- AT_HASH = "a306397ccf9c2ead27155983c254227c0fd938e2"
- FILES = [
- "ILSVRC2012_img_train.tar",
- ]
- SIZES = [
- 147897477120,
- ]
-
- def _prepare(self):
- self.random_crop = retrieve(self.config, "ImageNetTrain/random_crop",
- default=True)
- cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
- self.root = os.path.join(cachedir, "autoencoders/data", self.NAME)
- self.datadir = os.path.join(self.root, "data")
- self.txt_filelist = os.path.join(self.root, "filelist.txt")
- self.expected_length = 1281167
- if not bdu.is_prepared(self.root):
- # prep
- print("Preparing dataset {} in {}".format(self.NAME, self.root))
-
- datadir = self.datadir
- if not os.path.exists(datadir):
- path = os.path.join(self.root, self.FILES[0])
- if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]:
- import academictorrents as at
- atpath = at.get(self.AT_HASH, datastore=self.root)
- assert atpath == path
-
- print("Extracting {} to {}".format(path, datadir))
- os.makedirs(datadir, exist_ok=True)
- with tarfile.open(path, "r:") as tar:
- tar.extractall(path=datadir)
-
- print("Extracting sub-tars.")
- subpaths = sorted(glob.glob(os.path.join(datadir, "*.tar")))
- for subpath in tqdm(subpaths):
- subdir = subpath[:-len(".tar")]
- os.makedirs(subdir, exist_ok=True)
- with tarfile.open(subpath, "r:") as tar:
- tar.extractall(path=subdir)
-
-
- filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG"))
- filelist = [os.path.relpath(p, start=datadir) for p in filelist]
- filelist = sorted(filelist)
- filelist = "\n".join(filelist)+"\n"
- with open(self.txt_filelist, "w") as f:
- f.write(filelist)
-
- bdu.mark_prepared(self.root)
-
-
-class ImageNetValidation(ImageNetBase):
- NAME = "ILSVRC2012_validation"
- URL = "http://www.image-net.org/challenges/LSVRC/2012/"
- AT_HASH = "5d6d0df7ed81efd49ca99ea4737e0ae5e3a5f2e5"
- VS_URL = "https://heibox.uni-heidelberg.de/f/3e0f6e9c624e45f2bd73/?dl=1"
- FILES = [
- "ILSVRC2012_img_val.tar",
- "validation_synset.txt",
- ]
- SIZES = [
- 6744924160,
- 1950000,
- ]
-
- def _prepare(self):
- self.random_crop = retrieve(self.config, "ImageNetValidation/random_crop",
- default=False)
- cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
- self.root = os.path.join(cachedir, "autoencoders/data", self.NAME)
- self.datadir = os.path.join(self.root, "data")
- self.txt_filelist = os.path.join(self.root, "filelist.txt")
- self.expected_length = 50000
- if not bdu.is_prepared(self.root):
- # prep
- print("Preparing dataset {} in {}".format(self.NAME, self.root))
-
- datadir = self.datadir
- if not os.path.exists(datadir):
- path = os.path.join(self.root, self.FILES[0])
- if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]:
- import academictorrents as at
- atpath = at.get(self.AT_HASH, datastore=self.root)
- assert atpath == path
-
- print("Extracting {} to {}".format(path, datadir))
- os.makedirs(datadir, exist_ok=True)
- with tarfile.open(path, "r:") as tar:
- tar.extractall(path=datadir)
-
- vspath = os.path.join(self.root, self.FILES[1])
- if not os.path.exists(vspath) or not os.path.getsize(vspath)==self.SIZES[1]:
- download(self.VS_URL, vspath)
-
- with open(vspath, "r") as f:
- synset_dict = f.read().splitlines()
- synset_dict = dict(line.split() for line in synset_dict)
-
- print("Reorganizing into synset folders")
- synsets = np.unique(list(synset_dict.values()))
- for s in synsets:
- os.makedirs(os.path.join(datadir, s), exist_ok=True)
- for k, v in synset_dict.items():
- src = os.path.join(datadir, k)
- dst = os.path.join(datadir, v)
- shutil.move(src, dst)
-
- filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG"))
- filelist = [os.path.relpath(p, start=datadir) for p in filelist]
- filelist = sorted(filelist)
- filelist = "\n".join(filelist)+"\n"
- with open(self.txt_filelist, "w") as f:
- f.write(filelist)
-
- bdu.mark_prepared(self.root)
-
-
-def get_preprocessor(size=None, random_crop=False, additional_targets=None,
- crop_size=None):
- if size is not None and size > 0:
- transforms = list()
- rescaler = albumentations.SmallestMaxSize(max_size = size)
- transforms.append(rescaler)
- if not random_crop:
- cropper = albumentations.CenterCrop(height=size,width=size)
- transforms.append(cropper)
- else:
- cropper = albumentations.RandomCrop(height=size,width=size)
- transforms.append(cropper)
- flipper = albumentations.HorizontalFlip()
- transforms.append(flipper)
- preprocessor = albumentations.Compose(transforms,
- additional_targets=additional_targets)
- elif crop_size is not None and crop_size > 0:
- if not random_crop:
- cropper = albumentations.CenterCrop(height=crop_size,width=crop_size)
- else:
- cropper = albumentations.RandomCrop(height=crop_size,width=crop_size)
- transforms = [cropper]
- preprocessor = albumentations.Compose(transforms,
- additional_targets=additional_targets)
- else:
- preprocessor = lambda **kwargs: kwargs
- return preprocessor
-
-
-def rgba_to_depth(x):
- assert x.dtype == np.uint8
- assert len(x.shape) == 3 and x.shape[2] == 4
- y = x.copy()
- y.dtype = np.float32
- y = y.reshape(x.shape[:2])
- return np.ascontiguousarray(y)
-
-
-class BaseWithDepth(Dataset):
- DEFAULT_DEPTH_ROOT="data/imagenet_depth"
-
- def __init__(self, config=None, size=None, random_crop=False,
- crop_size=None, root=None):
- self.config = config
- self.base_dset = self.get_base_dset()
- self.preprocessor = get_preprocessor(
- size=size,
- crop_size=crop_size,
- random_crop=random_crop,
- additional_targets={"depth": "image"})
- self.crop_size = crop_size
- if self.crop_size is not None:
- self.rescaler = albumentations.Compose(
- [albumentations.SmallestMaxSize(max_size = self.crop_size)],
- additional_targets={"depth": "image"})
- if root is not None:
- self.DEFAULT_DEPTH_ROOT = root
-
- def __len__(self):
- return len(self.base_dset)
-
- def preprocess_depth(self, path):
- rgba = np.array(Image.open(path))
- depth = rgba_to_depth(rgba)
- depth = (depth - depth.min())/max(1e-8, depth.max()-depth.min())
- depth = 2.0*depth-1.0
- return depth
-
- def __getitem__(self, i):
- e = self.base_dset[i]
- e["depth"] = self.preprocess_depth(self.get_depth_path(e))
- # up if necessary
- h,w,c = e["image"].shape
- if self.crop_size and min(h,w) < self.crop_size:
- # have to upscale to be able to crop - this just uses bilinear
- out = self.rescaler(image=e["image"], depth=e["depth"])
- e["image"] = out["image"]
- e["depth"] = out["depth"]
- transformed = self.preprocessor(image=e["image"], depth=e["depth"])
- e["image"] = transformed["image"]
- e["depth"] = transformed["depth"]
- return e
-
-
-class ImageNetTrainWithDepth(BaseWithDepth):
- # default to random_crop=True
- def __init__(self, random_crop=True, sub_indices=None, **kwargs):
- self.sub_indices = sub_indices
- super().__init__(random_crop=random_crop, **kwargs)
-
- def get_base_dset(self):
- if self.sub_indices is None:
- return ImageNetTrain()
- else:
- return ImageNetTrain({"sub_indices": self.sub_indices})
-
- def get_depth_path(self, e):
- fid = os.path.splitext(e["relpath"])[0]+".png"
- fid = os.path.join(self.DEFAULT_DEPTH_ROOT, "train", fid)
- return fid
-
-
-class ImageNetValidationWithDepth(BaseWithDepth):
- def __init__(self, sub_indices=None, **kwargs):
- self.sub_indices = sub_indices
- super().__init__(**kwargs)
-
- def get_base_dset(self):
- if self.sub_indices is None:
- return ImageNetValidation()
- else:
- return ImageNetValidation({"sub_indices": self.sub_indices})
-
- def get_depth_path(self, e):
- fid = os.path.splitext(e["relpath"])[0]+".png"
- fid = os.path.join(self.DEFAULT_DEPTH_ROOT, "val", fid)
- return fid
-
-
-class RINTrainWithDepth(ImageNetTrainWithDepth):
- def __init__(self, config=None, size=None, random_crop=True, crop_size=None):
- sub_indices = "30-32, 33-37, 151-268, 281-285, 80-100, 365-382, 389-397, 118-121, 300-319"
- super().__init__(config=config, size=size, random_crop=random_crop,
- sub_indices=sub_indices, crop_size=crop_size)
-
-
-class RINValidationWithDepth(ImageNetValidationWithDepth):
- def __init__(self, config=None, size=None, random_crop=False, crop_size=None):
- sub_indices = "30-32, 33-37, 151-268, 281-285, 80-100, 365-382, 389-397, 118-121, 300-319"
- super().__init__(config=config, size=size, random_crop=random_crop,
- sub_indices=sub_indices, crop_size=crop_size)
-
-
-class DRINExamples(Dataset):
- def __init__(self):
- self.preprocessor = get_preprocessor(size=256, additional_targets={"depth": "image"})
- with open("data/drin_examples.txt", "r") as f:
- relpaths = f.read().splitlines()
- self.image_paths = [os.path.join("data/drin_images",
- relpath) for relpath in relpaths]
- self.depth_paths = [os.path.join("data/drin_depth",
- relpath.replace(".JPEG", ".png")) for relpath in relpaths]
-
- def __len__(self):
- return len(self.image_paths)
-
- def preprocess_image(self, image_path):
- image = Image.open(image_path)
- if not image.mode == "RGB":
- image = image.convert("RGB")
- image = np.array(image).astype(np.uint8)
- image = self.preprocessor(image=image)["image"]
- image = (image/127.5 - 1.0).astype(np.float32)
- return image
-
- def preprocess_depth(self, path):
- rgba = np.array(Image.open(path))
- depth = rgba_to_depth(rgba)
- depth = (depth - depth.min())/max(1e-8, depth.max()-depth.min())
- depth = 2.0*depth-1.0
- return depth
-
- def __getitem__(self, i):
- e = dict()
- e["image"] = self.preprocess_image(self.image_paths[i])
- e["depth"] = self.preprocess_depth(self.depth_paths[i])
- transformed = self.preprocessor(image=e["image"], depth=e["depth"])
- e["image"] = transformed["image"]
- e["depth"] = transformed["depth"]
- return e
-
-
-def imscale(x, factor, keepshapes=False, keepmode="bicubic"):
- if factor is None or factor==1:
- return x
-
- dtype = x.dtype
- assert dtype in [np.float32, np.float64]
- assert x.min() >= -1
- assert x.max() <= 1
-
- keepmode = {"nearest": Image.NEAREST, "bilinear": Image.BILINEAR,
- "bicubic": Image.BICUBIC}[keepmode]
-
- lr = (x+1.0)*127.5
- lr = lr.clip(0,255).astype(np.uint8)
- lr = Image.fromarray(lr)
-
- h, w, _ = x.shape
- nh = h//factor
- nw = w//factor
- assert nh > 0 and nw > 0, (nh, nw)
-
- lr = lr.resize((nw,nh), Image.BICUBIC)
- if keepshapes:
- lr = lr.resize((w,h), keepmode)
- lr = np.array(lr)/127.5-1.0
- lr = lr.astype(dtype)
-
- return lr
-
-
-class ImageNetScale(Dataset):
- def __init__(self, size=None, crop_size=None, random_crop=False,
- up_factor=None, hr_factor=None, keep_mode="bicubic"):
- self.base = self.get_base()
-
- self.size = size
- self.crop_size = crop_size if crop_size is not None else self.size
- self.random_crop = random_crop
- self.up_factor = up_factor
- self.hr_factor = hr_factor
- self.keep_mode = keep_mode
-
- transforms = list()
-
- if self.size is not None and self.size > 0:
- rescaler = albumentations.SmallestMaxSize(max_size = self.size)
- self.rescaler = rescaler
- transforms.append(rescaler)
-
- if self.crop_size is not None and self.crop_size > 0:
- if len(transforms) == 0:
- self.rescaler = albumentations.SmallestMaxSize(max_size = self.crop_size)
-
- if not self.random_crop:
- cropper = albumentations.CenterCrop(height=self.crop_size,width=self.crop_size)
- else:
- cropper = albumentations.RandomCrop(height=self.crop_size,width=self.crop_size)
- transforms.append(cropper)
-
- if len(transforms) > 0:
- if self.up_factor is not None:
- additional_targets = {"lr": "image"}
- else:
- additional_targets = None
- self.preprocessor = albumentations.Compose(transforms,
- additional_targets=additional_targets)
- else:
- self.preprocessor = lambda **kwargs: kwargs
-
- def __len__(self):
- return len(self.base)
-
- def __getitem__(self, i):
- example = self.base[i]
- image = example["image"]
- # adjust resolution
- image = imscale(image, self.hr_factor, keepshapes=False)
- h,w,c = image.shape
- if self.crop_size and min(h,w) < self.crop_size:
- # have to upscale to be able to crop - this just uses bilinear
- image = self.rescaler(image=image)["image"]
- if self.up_factor is None:
- image = self.preprocessor(image=image)["image"]
- example["image"] = image
- else:
- lr = imscale(image, self.up_factor, keepshapes=True,
- keepmode=self.keep_mode)
-
- out = self.preprocessor(image=image, lr=lr)
- example["image"] = out["image"]
- example["lr"] = out["lr"]
-
- return example
-
-class ImageNetScaleTrain(ImageNetScale):
- def __init__(self, random_crop=True, **kwargs):
- super().__init__(random_crop=random_crop, **kwargs)
-
- def get_base(self):
- return ImageNetTrain()
-
-class ImageNetScaleValidation(ImageNetScale):
- def get_base(self):
- return ImageNetValidation()
-
-
-from skimage.feature import canny
-from skimage.color import rgb2gray
-
-
-class ImageNetEdges(ImageNetScale):
- def __init__(self, up_factor=1, **kwargs):
- super().__init__(up_factor=1, **kwargs)
-
- def __getitem__(self, i):
- example = self.base[i]
- image = example["image"]
- h,w,c = image.shape
- if self.crop_size and min(h,w) < self.crop_size:
- # have to upscale to be able to crop - this just uses bilinear
- image = self.rescaler(image=image)["image"]
-
- lr = canny(rgb2gray(image), sigma=2)
- lr = lr.astype(np.float32)
- lr = lr[:,:,None][:,:,[0,0,0]]
-
- out = self.preprocessor(image=image, lr=lr)
- example["image"] = out["image"]
- example["lr"] = out["lr"]
-
- return example
-
-
-class ImageNetEdgesTrain(ImageNetEdges):
- def __init__(self, random_crop=True, **kwargs):
- super().__init__(random_crop=random_crop, **kwargs)
-
- def get_base(self):
- return ImageNetTrain()
-
-class ImageNetEdgesValidation(ImageNetEdges):
- def get_base(self):
- return ImageNetValidation()
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/speech_to_text/docs/mustc_example.md b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/speech_to_text/docs/mustc_example.md
deleted file mode 100644
index c95ef3e15660107c3384f87c1680f005044e7f3b..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/examples/speech_to_text/docs/mustc_example.md
+++ /dev/null
@@ -1,155 +0,0 @@
-[[Back]](..)
-
-# S2T Example: Speech Translation (ST) on MuST-C
-
-[MuST-C](https://www.aclweb.org/anthology/N19-1202) is multilingual speech-to-text translation corpus with
-8-language translations on English TED talks. We match the state-of-the-art performance in
-[ESPNet-ST](https://arxiv.org/pdf/2004.10234.pdf) with a simpler model training pipeline.
-
-## Data Preparation
-[Download](https://ict.fbk.eu/must-c) and unpack MuST-C data to a path
-`${MUSTC_ROOT}/en-${TARGET_LANG_ID}`, then preprocess it with
-```bash
-# additional Python packages for S2T data processing/model training
-pip install pandas torchaudio soundfile sentencepiece
-
-# Generate TSV manifests, features, vocabulary
-# and configuration for each language
-python examples/speech_to_text/prep_mustc_data.py \
- --data-root ${MUSTC_ROOT} --task asr \
- --vocab-type unigram --vocab-size 5000
-python examples/speech_to_text/prep_mustc_data.py \
- --data-root ${MUSTC_ROOT} --task st \
- --vocab-type unigram --vocab-size 8000
-
-# Add vocabulary and configuration for joint data
-# (based on the manifests and features generated above)
-python examples/speech_to_text/prep_mustc_data.py \
- --data-root ${MUSTC_ROOT} --task asr --joint \
- --vocab-type unigram --vocab-size 10000
-python examples/speech_to_text/prep_mustc_data.py \
- --data-root ${MUSTC_ROOT} --task st --joint \
- --vocab-type unigram --vocab-size 10000
-```
-The generated files (manifest, features, vocabulary and data configuration) will be added to
-`${MUSTC_ROOT}/en-${TARGET_LANG_ID}` (per-language data) and `MUSTC_ROOT` (joint data).
-
-Download our vocabulary files if you want to use our pre-trained models:
-- ASR: [En-De](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_asr_vocab_unigram5000.zip), [En-Nl](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_asr_vocab_unigram5000.zip), [En-Es](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_asr_vocab_unigram5000.zip), [En-Fr](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_asr_vocab_unigram5000.zip), [En-It](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_asr_vocab_unigram5000.zip), [En-Pt](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_asr_vocab_unigram5000.zip), [En-Ro](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_asr_vocab_unigram5000.zip), [En-Ru](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_asr_vocab_unigram5000.zip), [Joint](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_joint_asr_vocab_unigram10000.zip)
-- ST: [En-De](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_st_vocab_unigram8000.zip), [En-Nl](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_st_vocab_unigram8000.zip), [En-Es](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_st_vocab_unigram8000.zip), [En-Fr](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_st_vocab_unigram8000.zip), [En-It](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_st_vocab_unigram8000.zip), [En-Pt](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_st_vocab_unigram8000.zip), [En-Ro](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_st_vocab_unigram8000.zip), [En-Ru](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_st_vocab_unigram8000.zip), [Multilingual](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_multilingual_st_vocab_unigram10000.zip)
-
-## ASR
-#### Training
-En-De as example:
-```bash
-fairseq-train ${MUSTC_ROOT}/en-de \
- --config-yaml config_asr.yaml --train-subset train_asr --valid-subset dev_asr \
- --save-dir ${ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \
- --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \
- --arch s2t_transformer_s --optimizer adam --lr 1e-3 --lr-scheduler inverse_sqrt \
- --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8
-```
-For joint model (using ASR data from all 8 directions):
-```bash
-fairseq-train ${MUSTC_ROOT} \
- --config-yaml config_asr.yaml \
- --train-subset train_de_asr,train_nl_asr,train_es_asr,train_fr_asr,train_it_asr,train_pt_asr,train_ro_asr,train_ru_asr \
- --valid-subset dev_de_asr,dev_nl_asr,dev_es_asr,dev_fr_asr,dev_it_asr,dev_pt_asr,dev_ro_asr,dev_ru_asr \
- --save-dir ${JOINT_ASR_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \
- --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \
- --arch s2t_transformer_s --optimizer adam --lr 1e-3 --lr-scheduler inverse_sqrt \
- --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8
-```
-where `ASR_SAVE_DIR` (`JOINT_ASR_SAVE_DIR`) is the checkpoint root path. We set `--update-freq 8` to simulate 8 GPUs
-with 1 GPU. You may want to update it accordingly when using more than 1 GPU.
-
-#### Inference & Evaluation
-```bash
-CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt
-python scripts/average_checkpoints.py \
- --inputs ${ASR_SAVE_DIR} --num-epoch-checkpoints 10 \
- --output "${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}"
-fairseq-generate ${MUSTC_ROOT}/en-de \
- --config-yaml config_asr.yaml --gen-subset tst-COMMON_asr --task speech_to_text \
- --path ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \
- --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct
-
-# For models trained on joint data
-python scripts/average_checkpoints.py \
- --inputs ${JOINT_ASR_SAVE_DIR} --num-epoch-checkpoints 10 \
- --output "${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}"
-for LANG in de nl es fr it pt ro ru; do
- fairseq-generate ${MUSTC_ROOT} \
- --config-yaml config_asr.yaml --gen-subset tst-COMMON_${LANG}_asr --task speech_to_text \
- --path ${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME} --max-tokens 50000 --beam 5 \
- --scoring wer --wer-tokenizer 13a --wer-lowercase --wer-remove-punct
-done
-```
-#### Results
-| Data | --arch | Params | En-De | En-Nl | En-Es | En-Fr | En-It | En-Pt | En-Ro | En-Ru | Model |
-|---|---|---|---|---|---|---|---|---|---|---|---|
-| Single | s2t_transformer_s | 31M | [18.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_asr_transformer_s.pt) | [17.6](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_asr_transformer_s.pt) | [17.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_asr_transformer_s.pt) | [17.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_asr_transformer_s.pt) | [17.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_asr_transformer_s.pt) | [19.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_asr_transformer_s.pt) | [18.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_asr_transformer_s.pt) | [17.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_asr_transformer_s.pt) | (<-Download) |
-| Joint | s2t_transformer_m | 76M | 16.8 | 16.7 | 16.9 | 16.9 | 17.0 | 17.4 | 17.0 | 16.9 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_joint_asr_transformer_m.pt) |
-
-## ST
-#### Training
-En-De as example:
-```bash
-fairseq-train ${MUSTC_ROOT}/en-de \
- --config-yaml config_st.yaml --train-subset train_st --valid-subset dev_st \
- --save-dir ${ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \
- --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \
- --arch s2t_transformer_s --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \
- --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 \
- --load-pretrained-encoder-from ${ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}
-```
-For multilingual model (all 8 directions):
-```bash
-fairseq-train ${MUSTC_ROOT} \
- --config-yaml config_st.yaml \
- --train-subset train_de_st,train_nl_st,train_es_st,train_fr_st,train_it_st,train_pt_st,train_ro_st,train_ru_st \
- --valid-subset dev_de_st,dev_nl_st,dev_es_st,dev_fr_st,dev_it_st,dev_pt_st,dev_ro_st,dev_ru_st \
- --save-dir ${MULTILINGUAL_ST_SAVE_DIR} --num-workers 4 --max-tokens 40000 --max-update 100000 \
- --task speech_to_text --criterion label_smoothed_cross_entropy --label-smoothing 0.1 --report-accuracy \
- --arch s2t_transformer_s --ignore-prefix-size 1 --optimizer adam --lr 2e-3 --lr-scheduler inverse_sqrt \
- --warmup-updates 10000 --clip-norm 10.0 --seed 1 --update-freq 8 \
- --load-pretrained-encoder-from ${JOINT_ASR_SAVE_DIR}/${CHECKPOINT_FILENAME}
-```
-where `ST_SAVE_DIR` (`MULTILINGUAL_ST_SAVE_DIR`) is the checkpoint root path. The ST encoder is pre-trained by ASR
-for faster training and better performance: `--load-pretrained-encoder-from <(JOINT_)ASR checkpoint path>`. We set
-`--update-freq 8` to simulate 8 GPUs with 1 GPU. You may want to update it accordingly when using more than 1 GPU.
-For multilingual models, we prepend target language ID token as target BOS, which should be excluded from
-the training loss via `--ignore-prefix-size 1`.
-
-#### Inference & Evaluation
-Average the last 10 checkpoints and evaluate on the `tst-COMMON` split:
-```bash
-CHECKPOINT_FILENAME=avg_last_10_checkpoint.pt
-python scripts/average_checkpoints.py \
- --inputs ${ST_SAVE_DIR} --num-epoch-checkpoints 10 \
- --output "${ST_SAVE_DIR}/${CHECKPOINT_FILENAME}"
-fairseq-generate ${MUSTC_ROOT}/en-de \
- --config-yaml config_st.yaml --gen-subset tst-COMMON_st --task speech_to_text \
- --path ${ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \
- --max-tokens 50000 --beam 5 --scoring sacrebleu
-
-# For multilingual models
-python scripts/average_checkpoints.py \
- --inputs ${MULTILINGUAL_ST_SAVE_DIR} --num-epoch-checkpoints 10 \
- --output "${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME}"
-for LANG in de nl es fr it pt ro ru; do
- fairseq-generate ${MUSTC_ROOT} \
- --config-yaml config_st.yaml --gen-subset tst-COMMON_${LANG}_st --task speech_to_text \
- --prefix-size 1 --path ${MULTILINGUAL_ST_SAVE_DIR}/${CHECKPOINT_FILENAME} \
- --max-tokens 50000 --beam 5 --scoring sacrebleu
-done
-```
-For multilingual models, we force decoding from the target language ID token (as BOS) via `--prefix-size 1`.
-
-#### Results
-| Data | --arch | Params | En-De | En-Nl | En-Es | En-Fr | En-It | En-Pt | En-Ro | En-Ru | Model |
-|---|---|---|---|---|---|---|---|---|---|---|---|
-| Bilingual | s2t_transformer_s | 31M | [22.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_de_st_transformer_s.pt) | [27.3](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_nl_st_transformer_s.pt) | [27.2](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_es_st_transformer_s.pt) | [32.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_fr_st_transformer_s.pt) | [22.7](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_it_st_transformer_s.pt) | [28.1](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_pt_st_transformer_s.pt) | [21.9](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ro_st_transformer_s.pt) | [15.3](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_ru_st_transformer_s.pt) | (<-Download) |
-| Multilingual | s2t_transformer_m | 76M | 24.5 | 28.6 | 28.2 | 34.9 | 24.6 | 31.1 | 23.8 | 16.0 | [Download](https://dl.fbaipublicfiles.com/fairseq/s2t/mustc_multilingual_st_transformer_m.pt) |
-
-[[Back]](..)
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/optim/nag.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/optim/nag.py
deleted file mode 100644
index c30a6c0fb1e8d5dc7edd5b53ba15a6acd46ecbff..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/fairseq/optim/nag.py
+++ /dev/null
@@ -1,111 +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 collections.abc import Collection
-from dataclasses import dataclass, field
-from typing import List
-
-import torch
-from fairseq.dataclass import FairseqDataclass
-from omegaconf import II, DictConfig
-from torch.optim.optimizer import Optimizer, required
-
-from . import FairseqOptimizer, register_optimizer
-
-
-@dataclass
-class FairseqNAGConfig(FairseqDataclass):
- momentum: float = field(default=0.99, metadata={"help": "momentum factor"})
- weight_decay: float = field(default=0.0, metadata={"help": "weight decay"})
- # TODO common vars in parent class
- lr: List[float] = II("optimization.lr")
-
-
-@register_optimizer("nag", dataclass=FairseqNAGConfig)
-class FairseqNAG(FairseqOptimizer):
- def __init__(self, cfg: DictConfig, params):
- super().__init__(cfg)
- self._optimizer = NAG(params, **self.optimizer_config)
-
- @property
- def optimizer_config(self):
- """
- Return a kwarg dictionary that will be used to override optimizer
- args stored in checkpoints. This allows us to load a checkpoint and
- resume training using a different set of optimizer args, e.g., with a
- different learning rate.
- """
- return {
- "lr": self.cfg.lr[0]
- if isinstance(self.cfg.lr, Collection)
- else self.cfg.lr,
- "momentum": self.cfg.momentum,
- "weight_decay": self.cfg.weight_decay,
- }
-
-
-class NAG(Optimizer):
- def __init__(self, params, lr=required, momentum=0, weight_decay=0):
- defaults = dict(lr=lr, lr_old=lr, momentum=momentum, weight_decay=weight_decay)
- super(NAG, self).__init__(params, defaults)
-
- @property
- def supports_memory_efficient_fp16(self):
- return True
-
- @property
- def supports_flat_params(self):
- return True
-
- def step(self, closure=None):
- """Performs a single optimization step.
-
- Args:
- closure (callable, optional): A closure that reevaluates the model
- and returns the loss.
- """
- loss = None
- if closure is not None:
- loss = closure()
-
- for group in self.param_groups:
- weight_decay = group["weight_decay"]
- momentum = group["momentum"]
- lr = group["lr"]
- lr_old = group.get("lr_old", lr)
- lr_correct = lr / lr_old if lr_old > 0 else lr
-
- for p in group["params"]:
- if p.grad is None:
- continue
-
- p_data_fp32 = p.data
- if p_data_fp32.dtype in {torch.float16, torch.bfloat16}:
- p_data_fp32 = p_data_fp32.float()
-
- d_p = p.grad.data.float()
- param_state = self.state[p]
- if "momentum_buffer" not in param_state:
- param_state["momentum_buffer"] = torch.zeros_like(d_p)
- else:
- param_state["momentum_buffer"] = param_state["momentum_buffer"].to(
- d_p
- )
-
- buf = param_state["momentum_buffer"]
-
- if weight_decay != 0:
- p_data_fp32.mul_(1 - lr * weight_decay)
- p_data_fp32.add_(buf, alpha=momentum * momentum * lr_correct)
- p_data_fp32.add_(d_p, alpha=-(1 + momentum) * lr)
-
- buf.mul_(momentum * lr_correct).add_(d_p, alpha=-lr)
-
- if p.data.dtype in {torch.float16, torch.bfloat16}:
- p.data.copy_(p_data_fp32)
-
- group["lr_old"] = lr
-
- return loss
diff --git a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/scripts/spm_train.py b/spaces/HarryLee/eCommerceImageCaptioning/fairseq/scripts/spm_train.py
deleted file mode 100644
index 9db668fd4166a860198784990de68ea26157995d..0000000000000000000000000000000000000000
--- a/spaces/HarryLee/eCommerceImageCaptioning/fairseq/scripts/spm_train.py
+++ /dev/null
@@ -1,16 +0,0 @@
-#!/usr/bin/env python
-# 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.
-
-from __future__ import absolute_import, division, print_function, unicode_literals
-
-import sys
-
-import sentencepiece as spm
-
-
-if __name__ == "__main__":
- spm.SentencePieceTrainer.Train(" ".join(sys.argv[1:]))
diff --git a/spaces/Harveenchadha/Vakyansh-Hindi-TTS/ttsv/src/glow_tts/monotonic_align/monotonic_align/mas.py b/spaces/Harveenchadha/Vakyansh-Hindi-TTS/ttsv/src/glow_tts/monotonic_align/monotonic_align/mas.py
deleted file mode 100644
index 207ab3e858389ec06c902fd6f5bec6c5da2996af..0000000000000000000000000000000000000000
--- a/spaces/Harveenchadha/Vakyansh-Hindi-TTS/ttsv/src/glow_tts/monotonic_align/monotonic_align/mas.py
+++ /dev/null
@@ -1,57 +0,0 @@
-from typing import overload
-import numpy as np
-import torch
-from monotonic_align.core import maximum_path_c
-
-
-def mask_from_len(lens: torch.Tensor, max_len=None):
- """
- Make a `mask` from lens.
-
- :param inputs: (B, T, D)
- :param lens: (B)
-
- :return:
- `mask`: (B, T)
- """
- if max_len is None:
- max_len = lens.max()
- index = torch.arange(max_len).to(lens).view(1, -1)
- return index < lens.unsqueeze(1) # (B, T)
-
-
-def mask_from_lens(
- similarity: torch.Tensor,
- symbol_lens: torch.Tensor,
- mel_lens: torch.Tensor,
-):
- """
- :param similarity: (B, S, T)
- :param symbol_lens: (B,)
- :param mel_lens: (B,)
- """
- _, S, T = similarity.size()
- mask_S = mask_from_len(symbol_lens, S)
- mask_T = mask_from_len(mel_lens, T)
- mask_ST = mask_S.unsqueeze(2) * mask_T.unsqueeze(1)
- return mask_ST.to(similarity)
-
-
-def maximum_path(value, mask=None):
- """Cython optimised version.
- value: [b, t_x, t_y]
- mask: [b, t_x, t_y]
- """
- if mask is None:
- mask = torch.zeros_like(value)
-
- value = value * mask
- device = value.device
- dtype = value.dtype
- value = value.data.cpu().numpy().astype(np.float32)
- path = np.zeros_like(value).astype(np.int32)
- mask = mask.data.cpu().numpy()
- t_x_max = mask.sum(1)[:, 0].astype(np.int32)
- t_y_max = mask.sum(2)[:, 0].astype(np.int32)
- maximum_path_c(path, value, t_x_max, t_y_max)
- return torch.from_numpy(path).to(device=device, dtype=dtype)
diff --git a/spaces/ICML2022/OFA/fairseq/examples/noisychannel/rerank_tune.py b/spaces/ICML2022/OFA/fairseq/examples/noisychannel/rerank_tune.py
deleted file mode 100644
index b2e8b7594a370b2462f77252d54d7ef80e290f7c..0000000000000000000000000000000000000000
--- a/spaces/ICML2022/OFA/fairseq/examples/noisychannel/rerank_tune.py
+++ /dev/null
@@ -1,102 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import argparse
-import random
-
-import numpy as np
-from fairseq import options
-
-from examples.noisychannel import rerank, rerank_options
-
-
-def random_search(args):
- param_values = []
- tuneable_parameters = ["lenpen", "weight1", "weight2", "weight3"]
- initial_params = [args.lenpen, args.weight1, args.weight2, args.weight3]
- for i, elem in enumerate(initial_params):
- if type(elem) is not list:
- initial_params[i] = [elem]
- else:
- initial_params[i] = elem
-
- tune_parameters = args.tune_param.copy()
- for i in range(len(args.tune_param)):
- assert args.upper_bound[i] >= args.lower_bound[i]
- index = tuneable_parameters.index(args.tune_param[i])
- del tuneable_parameters[index]
- del initial_params[index]
-
- tune_parameters += tuneable_parameters
- param_values += initial_params
- random.seed(args.seed)
-
- random_params = np.array(
- [
- [
- random.uniform(args.lower_bound[i], args.upper_bound[i])
- for i in range(len(args.tune_param))
- ]
- for k in range(args.num_trials)
- ]
- )
- set_params = np.array(
- [
- [initial_params[i][0] for i in range(len(tuneable_parameters))]
- for k in range(args.num_trials)
- ]
- )
- random_params = np.concatenate((random_params, set_params), 1)
-
- rerank_args = vars(args).copy()
- if args.nbest_list:
- rerank_args["gen_subset"] = "test"
- else:
- rerank_args["gen_subset"] = args.tune_subset
-
- for k in range(len(tune_parameters)):
- rerank_args[tune_parameters[k]] = list(random_params[:, k])
-
- if args.share_weights:
- k = tune_parameters.index("weight2")
- rerank_args["weight3"] = list(random_params[:, k])
-
- rerank_args = argparse.Namespace(**rerank_args)
- best_lenpen, best_weight1, best_weight2, best_weight3, best_score = rerank.rerank(
- rerank_args
- )
- rerank_args = vars(args).copy()
- rerank_args["lenpen"] = [best_lenpen]
- rerank_args["weight1"] = [best_weight1]
- rerank_args["weight2"] = [best_weight2]
- rerank_args["weight3"] = [best_weight3]
-
- # write the hypothesis from the valid set from the best trial
-
- if args.gen_subset != "valid":
- rerank_args["gen_subset"] = "valid"
- rerank_args = argparse.Namespace(**rerank_args)
- rerank.rerank(rerank_args)
-
- # test with the best hyperparameters on gen subset
- rerank_args = vars(args).copy()
- rerank_args["gen_subset"] = args.gen_subset
- rerank_args["lenpen"] = [best_lenpen]
- rerank_args["weight1"] = [best_weight1]
- rerank_args["weight2"] = [best_weight2]
- rerank_args["weight3"] = [best_weight3]
- rerank_args = argparse.Namespace(**rerank_args)
- rerank.rerank(rerank_args)
-
-
-def cli_main():
- parser = rerank_options.get_tuning_parser()
- args = options.parse_args_and_arch(parser)
-
- random_search(args)
-
-
-if __name__ == "__main__":
- cli_main()
diff --git a/spaces/Iceclear/StableSR/StableSR/basicsr/archs/edvr_arch.py b/spaces/Iceclear/StableSR/StableSR/basicsr/archs/edvr_arch.py
deleted file mode 100644
index b0c4f47deb383d4fe6108b97436c9dfb1e541583..0000000000000000000000000000000000000000
--- a/spaces/Iceclear/StableSR/StableSR/basicsr/archs/edvr_arch.py
+++ /dev/null
@@ -1,382 +0,0 @@
-import torch
-from torch import nn as nn
-from torch.nn import functional as F
-
-from basicsr.utils.registry import ARCH_REGISTRY
-from .arch_util import DCNv2Pack, ResidualBlockNoBN, make_layer
-
-
-class PCDAlignment(nn.Module):
- """Alignment module using Pyramid, Cascading and Deformable convolution
- (PCD). It is used in EDVR.
-
- ``Paper: EDVR: Video Restoration with Enhanced Deformable Convolutional Networks``
-
- Args:
- num_feat (int): Channel number of middle features. Default: 64.
- deformable_groups (int): Deformable groups. Defaults: 8.
- """
-
- def __init__(self, num_feat=64, deformable_groups=8):
- super(PCDAlignment, self).__init__()
-
- # Pyramid has three levels:
- # L3: level 3, 1/4 spatial size
- # L2: level 2, 1/2 spatial size
- # L1: level 1, original spatial size
- self.offset_conv1 = nn.ModuleDict()
- self.offset_conv2 = nn.ModuleDict()
- self.offset_conv3 = nn.ModuleDict()
- self.dcn_pack = nn.ModuleDict()
- self.feat_conv = nn.ModuleDict()
-
- # Pyramids
- for i in range(3, 0, -1):
- level = f'l{i}'
- self.offset_conv1[level] = nn.Conv2d(num_feat * 2, num_feat, 3, 1, 1)
- if i == 3:
- self.offset_conv2[level] = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- else:
- self.offset_conv2[level] = nn.Conv2d(num_feat * 2, num_feat, 3, 1, 1)
- self.offset_conv3[level] = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.dcn_pack[level] = DCNv2Pack(num_feat, num_feat, 3, padding=1, deformable_groups=deformable_groups)
-
- if i < 3:
- self.feat_conv[level] = nn.Conv2d(num_feat * 2, num_feat, 3, 1, 1)
-
- # Cascading dcn
- self.cas_offset_conv1 = nn.Conv2d(num_feat * 2, num_feat, 3, 1, 1)
- self.cas_offset_conv2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.cas_dcnpack = DCNv2Pack(num_feat, num_feat, 3, padding=1, deformable_groups=deformable_groups)
-
- self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
- self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
-
- def forward(self, nbr_feat_l, ref_feat_l):
- """Align neighboring frame features to the reference frame features.
-
- Args:
- nbr_feat_l (list[Tensor]): Neighboring feature list. It
- contains three pyramid levels (L1, L2, L3),
- each with shape (b, c, h, w).
- ref_feat_l (list[Tensor]): Reference feature list. It
- contains three pyramid levels (L1, L2, L3),
- each with shape (b, c, h, w).
-
- Returns:
- Tensor: Aligned features.
- """
- # Pyramids
- upsampled_offset, upsampled_feat = None, None
- for i in range(3, 0, -1):
- level = f'l{i}'
- offset = torch.cat([nbr_feat_l[i - 1], ref_feat_l[i - 1]], dim=1)
- offset = self.lrelu(self.offset_conv1[level](offset))
- if i == 3:
- offset = self.lrelu(self.offset_conv2[level](offset))
- else:
- offset = self.lrelu(self.offset_conv2[level](torch.cat([offset, upsampled_offset], dim=1)))
- offset = self.lrelu(self.offset_conv3[level](offset))
-
- feat = self.dcn_pack[level](nbr_feat_l[i - 1], offset)
- if i < 3:
- feat = self.feat_conv[level](torch.cat([feat, upsampled_feat], dim=1))
- if i > 1:
- feat = self.lrelu(feat)
-
- if i > 1: # upsample offset and features
- # x2: when we upsample the offset, we should also enlarge
- # the magnitude.
- upsampled_offset = self.upsample(offset) * 2
- upsampled_feat = self.upsample(feat)
-
- # Cascading
- offset = torch.cat([feat, ref_feat_l[0]], dim=1)
- offset = self.lrelu(self.cas_offset_conv2(self.lrelu(self.cas_offset_conv1(offset))))
- feat = self.lrelu(self.cas_dcnpack(feat, offset))
- return feat
-
-
-class TSAFusion(nn.Module):
- """Temporal Spatial Attention (TSA) fusion module.
-
- Temporal: Calculate the correlation between center frame and
- neighboring frames;
- Spatial: It has 3 pyramid levels, the attention is similar to SFT.
- (SFT: Recovering realistic texture in image super-resolution by deep
- spatial feature transform.)
-
- Args:
- num_feat (int): Channel number of middle features. Default: 64.
- num_frame (int): Number of frames. Default: 5.
- center_frame_idx (int): The index of center frame. Default: 2.
- """
-
- def __init__(self, num_feat=64, num_frame=5, center_frame_idx=2):
- super(TSAFusion, self).__init__()
- self.center_frame_idx = center_frame_idx
- # temporal attention (before fusion conv)
- self.temporal_attn1 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.temporal_attn2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.feat_fusion = nn.Conv2d(num_frame * num_feat, num_feat, 1, 1)
-
- # spatial attention (after fusion conv)
- self.max_pool = nn.MaxPool2d(3, stride=2, padding=1)
- self.avg_pool = nn.AvgPool2d(3, stride=2, padding=1)
- self.spatial_attn1 = nn.Conv2d(num_frame * num_feat, num_feat, 1)
- self.spatial_attn2 = nn.Conv2d(num_feat * 2, num_feat, 1)
- self.spatial_attn3 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.spatial_attn4 = nn.Conv2d(num_feat, num_feat, 1)
- self.spatial_attn5 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.spatial_attn_l1 = nn.Conv2d(num_feat, num_feat, 1)
- self.spatial_attn_l2 = nn.Conv2d(num_feat * 2, num_feat, 3, 1, 1)
- self.spatial_attn_l3 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.spatial_attn_add1 = nn.Conv2d(num_feat, num_feat, 1)
- self.spatial_attn_add2 = nn.Conv2d(num_feat, num_feat, 1)
-
- self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
- self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
-
- def forward(self, aligned_feat):
- """
- Args:
- aligned_feat (Tensor): Aligned features with shape (b, t, c, h, w).
-
- Returns:
- Tensor: Features after TSA with the shape (b, c, h, w).
- """
- b, t, c, h, w = aligned_feat.size()
- # temporal attention
- embedding_ref = self.temporal_attn1(aligned_feat[:, self.center_frame_idx, :, :, :].clone())
- embedding = self.temporal_attn2(aligned_feat.view(-1, c, h, w))
- embedding = embedding.view(b, t, -1, h, w) # (b, t, c, h, w)
-
- corr_l = [] # correlation list
- for i in range(t):
- emb_neighbor = embedding[:, i, :, :, :]
- corr = torch.sum(emb_neighbor * embedding_ref, 1) # (b, h, w)
- corr_l.append(corr.unsqueeze(1)) # (b, 1, h, w)
- corr_prob = torch.sigmoid(torch.cat(corr_l, dim=1)) # (b, t, h, w)
- corr_prob = corr_prob.unsqueeze(2).expand(b, t, c, h, w)
- corr_prob = corr_prob.contiguous().view(b, -1, h, w) # (b, t*c, h, w)
- aligned_feat = aligned_feat.view(b, -1, h, w) * corr_prob
-
- # fusion
- feat = self.lrelu(self.feat_fusion(aligned_feat))
-
- # spatial attention
- attn = self.lrelu(self.spatial_attn1(aligned_feat))
- attn_max = self.max_pool(attn)
- attn_avg = self.avg_pool(attn)
- attn = self.lrelu(self.spatial_attn2(torch.cat([attn_max, attn_avg], dim=1)))
- # pyramid levels
- attn_level = self.lrelu(self.spatial_attn_l1(attn))
- attn_max = self.max_pool(attn_level)
- attn_avg = self.avg_pool(attn_level)
- attn_level = self.lrelu(self.spatial_attn_l2(torch.cat([attn_max, attn_avg], dim=1)))
- attn_level = self.lrelu(self.spatial_attn_l3(attn_level))
- attn_level = self.upsample(attn_level)
-
- attn = self.lrelu(self.spatial_attn3(attn)) + attn_level
- attn = self.lrelu(self.spatial_attn4(attn))
- attn = self.upsample(attn)
- attn = self.spatial_attn5(attn)
- attn_add = self.spatial_attn_add2(self.lrelu(self.spatial_attn_add1(attn)))
- attn = torch.sigmoid(attn)
-
- # after initialization, * 2 makes (attn * 2) to be close to 1.
- feat = feat * attn * 2 + attn_add
- return feat
-
-
-class PredeblurModule(nn.Module):
- """Pre-dublur module.
-
- Args:
- num_in_ch (int): Channel number of input image. Default: 3.
- num_feat (int): Channel number of intermediate features. Default: 64.
- hr_in (bool): Whether the input has high resolution. Default: False.
- """
-
- def __init__(self, num_in_ch=3, num_feat=64, hr_in=False):
- super(PredeblurModule, self).__init__()
- self.hr_in = hr_in
-
- self.conv_first = nn.Conv2d(num_in_ch, num_feat, 3, 1, 1)
- if self.hr_in:
- # downsample x4 by stride conv
- self.stride_conv_hr1 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
- self.stride_conv_hr2 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
-
- # generate feature pyramid
- self.stride_conv_l2 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
- self.stride_conv_l3 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
-
- self.resblock_l3 = ResidualBlockNoBN(num_feat=num_feat)
- self.resblock_l2_1 = ResidualBlockNoBN(num_feat=num_feat)
- self.resblock_l2_2 = ResidualBlockNoBN(num_feat=num_feat)
- self.resblock_l1 = nn.ModuleList([ResidualBlockNoBN(num_feat=num_feat) for i in range(5)])
-
- self.upsample = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=False)
- self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
-
- def forward(self, x):
- feat_l1 = self.lrelu(self.conv_first(x))
- if self.hr_in:
- feat_l1 = self.lrelu(self.stride_conv_hr1(feat_l1))
- feat_l1 = self.lrelu(self.stride_conv_hr2(feat_l1))
-
- # generate feature pyramid
- feat_l2 = self.lrelu(self.stride_conv_l2(feat_l1))
- feat_l3 = self.lrelu(self.stride_conv_l3(feat_l2))
-
- feat_l3 = self.upsample(self.resblock_l3(feat_l3))
- feat_l2 = self.resblock_l2_1(feat_l2) + feat_l3
- feat_l2 = self.upsample(self.resblock_l2_2(feat_l2))
-
- for i in range(2):
- feat_l1 = self.resblock_l1[i](feat_l1)
- feat_l1 = feat_l1 + feat_l2
- for i in range(2, 5):
- feat_l1 = self.resblock_l1[i](feat_l1)
- return feat_l1
-
-
-@ARCH_REGISTRY.register()
-class EDVR(nn.Module):
- """EDVR network structure for video super-resolution.
-
- Now only support X4 upsampling factor.
-
- ``Paper: EDVR: Video Restoration with Enhanced Deformable Convolutional Networks``
-
- Args:
- num_in_ch (int): Channel number of input image. Default: 3.
- num_out_ch (int): Channel number of output image. Default: 3.
- num_feat (int): Channel number of intermediate features. Default: 64.
- num_frame (int): Number of input frames. Default: 5.
- deformable_groups (int): Deformable groups. Defaults: 8.
- num_extract_block (int): Number of blocks for feature extraction.
- Default: 5.
- num_reconstruct_block (int): Number of blocks for reconstruction.
- Default: 10.
- center_frame_idx (int): The index of center frame. Frame counting from
- 0. Default: Middle of input frames.
- hr_in (bool): Whether the input has high resolution. Default: False.
- with_predeblur (bool): Whether has predeblur module.
- Default: False.
- with_tsa (bool): Whether has TSA module. Default: True.
- """
-
- def __init__(self,
- num_in_ch=3,
- num_out_ch=3,
- num_feat=64,
- num_frame=5,
- deformable_groups=8,
- num_extract_block=5,
- num_reconstruct_block=10,
- center_frame_idx=None,
- hr_in=False,
- with_predeblur=False,
- with_tsa=True):
- super(EDVR, self).__init__()
- if center_frame_idx is None:
- self.center_frame_idx = num_frame // 2
- else:
- self.center_frame_idx = center_frame_idx
- self.hr_in = hr_in
- self.with_predeblur = with_predeblur
- self.with_tsa = with_tsa
-
- # extract features for each frame
- if self.with_predeblur:
- self.predeblur = PredeblurModule(num_feat=num_feat, hr_in=self.hr_in)
- self.conv_1x1 = nn.Conv2d(num_feat, num_feat, 1, 1)
- else:
- self.conv_first = nn.Conv2d(num_in_ch, num_feat, 3, 1, 1)
-
- # extract pyramid features
- self.feature_extraction = make_layer(ResidualBlockNoBN, num_extract_block, num_feat=num_feat)
- self.conv_l2_1 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
- self.conv_l2_2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
- self.conv_l3_1 = nn.Conv2d(num_feat, num_feat, 3, 2, 1)
- self.conv_l3_2 = nn.Conv2d(num_feat, num_feat, 3, 1, 1)
-
- # pcd and tsa module
- self.pcd_align = PCDAlignment(num_feat=num_feat, deformable_groups=deformable_groups)
- if self.with_tsa:
- self.fusion = TSAFusion(num_feat=num_feat, num_frame=num_frame, center_frame_idx=self.center_frame_idx)
- else:
- self.fusion = nn.Conv2d(num_frame * num_feat, num_feat, 1, 1)
-
- # reconstruction
- self.reconstruction = make_layer(ResidualBlockNoBN, num_reconstruct_block, num_feat=num_feat)
- # upsample
- self.upconv1 = nn.Conv2d(num_feat, num_feat * 4, 3, 1, 1)
- self.upconv2 = nn.Conv2d(num_feat, 64 * 4, 3, 1, 1)
- self.pixel_shuffle = nn.PixelShuffle(2)
- self.conv_hr = nn.Conv2d(64, 64, 3, 1, 1)
- self.conv_last = nn.Conv2d(64, 3, 3, 1, 1)
-
- # activation function
- self.lrelu = nn.LeakyReLU(negative_slope=0.1, inplace=True)
-
- def forward(self, x):
- b, t, c, h, w = x.size()
- if self.hr_in:
- assert h % 16 == 0 and w % 16 == 0, ('The height and width must be multiple of 16.')
- else:
- assert h % 4 == 0 and w % 4 == 0, ('The height and width must be multiple of 4.')
-
- x_center = x[:, self.center_frame_idx, :, :, :].contiguous()
-
- # extract features for each frame
- # L1
- if self.with_predeblur:
- feat_l1 = self.conv_1x1(self.predeblur(x.view(-1, c, h, w)))
- if self.hr_in:
- h, w = h // 4, w // 4
- else:
- feat_l1 = self.lrelu(self.conv_first(x.view(-1, c, h, w)))
-
- feat_l1 = self.feature_extraction(feat_l1)
- # L2
- feat_l2 = self.lrelu(self.conv_l2_1(feat_l1))
- feat_l2 = self.lrelu(self.conv_l2_2(feat_l2))
- # L3
- feat_l3 = self.lrelu(self.conv_l3_1(feat_l2))
- feat_l3 = self.lrelu(self.conv_l3_2(feat_l3))
-
- feat_l1 = feat_l1.view(b, t, -1, h, w)
- feat_l2 = feat_l2.view(b, t, -1, h // 2, w // 2)
- feat_l3 = feat_l3.view(b, t, -1, h // 4, w // 4)
-
- # PCD alignment
- ref_feat_l = [ # reference feature list
- feat_l1[:, self.center_frame_idx, :, :, :].clone(), feat_l2[:, self.center_frame_idx, :, :, :].clone(),
- feat_l3[:, self.center_frame_idx, :, :, :].clone()
- ]
- aligned_feat = []
- for i in range(t):
- nbr_feat_l = [ # neighboring feature list
- feat_l1[:, i, :, :, :].clone(), feat_l2[:, i, :, :, :].clone(), feat_l3[:, i, :, :, :].clone()
- ]
- aligned_feat.append(self.pcd_align(nbr_feat_l, ref_feat_l))
- aligned_feat = torch.stack(aligned_feat, dim=1) # (b, t, c, h, w)
-
- if not self.with_tsa:
- aligned_feat = aligned_feat.view(b, -1, h, w)
- feat = self.fusion(aligned_feat)
-
- out = self.reconstruction(feat)
- out = self.lrelu(self.pixel_shuffle(self.upconv1(out)))
- out = self.lrelu(self.pixel_shuffle(self.upconv2(out)))
- out = self.lrelu(self.conv_hr(out))
- out = self.conv_last(out)
- if self.hr_in:
- base = x_center
- else:
- base = F.interpolate(x_center, scale_factor=4, mode='bilinear', align_corners=False)
- out += base
- return out
diff --git a/spaces/JUNGU/Whisper-Auto-Subtitled-Video-Generator/utils.py b/spaces/JUNGU/Whisper-Auto-Subtitled-Video-Generator/utils.py
deleted file mode 100644
index ae54176dab8e141ed806c9ac7cd088f2d274b26a..0000000000000000000000000000000000000000
--- a/spaces/JUNGU/Whisper-Auto-Subtitled-Video-Generator/utils.py
+++ /dev/null
@@ -1,96 +0,0 @@
-import textwrap
-import zlib
-from typing import Iterator, TextIO
-
-
-def exact_div(x, y):
- assert x % y == 0
- return x // y
-
-
-def str2bool(string):
- str2val = {"True": True, "False": False}
- if string in str2val:
- return str2val[string]
- else:
- raise ValueError(f"Expected one of {set(str2val.keys())}, got {string}")
-
-
-def optional_int(string):
- return None if string == "None" else int(string)
-
-
-def optional_float(string):
- return None if string == "None" else float(string)
-
-
-def compression_ratio(text) -> float:
- return len(text) / len(zlib.compress(text.encode("utf-8")))
-
-
-def format_timestamp(seconds: float, always_include_hours: bool = False, fractionalSeperator: str = '.'):
- assert seconds >= 0, "non-negative timestamp expected"
- milliseconds = round(seconds * 1000.0)
-
- hours = milliseconds // 3_600_000
- milliseconds -= hours * 3_600_000
-
- minutes = milliseconds // 60_000
- milliseconds -= minutes * 60_000
-
- seconds = milliseconds // 1_000
- milliseconds -= seconds * 1_000
-
- hours_marker = f"{hours:02d}:" if always_include_hours or hours > 0 else ""
- return f"{hours_marker}{minutes:02d}:{seconds:02d}{fractionalSeperator}{milliseconds:03d}"
-
-
-def write_txt(transcript: Iterator[dict], file: TextIO):
- for segment in transcript:
- print(segment['text'].strip(), file=file, flush=True)
-
-
-def write_vtt(transcript: Iterator[dict], file: TextIO, maxLineWidth=None):
- print("WEBVTT\n", file=file)
- for segment in transcript:
- text = processText(segment['text'], maxLineWidth).replace('-->', '->')
-
- print(
- f"{format_timestamp(segment['start'])} --> {format_timestamp(segment['end'])}\n"
- f"{text}\n",
- file=file,
- flush=True,
- )
-
-
-def write_srt(transcript: Iterator[dict], file: TextIO, maxLineWidth=None):
- """
- Write a transcript to a file in SRT format.
- Example usage:
- from pathlib import Path
- from whisper.utils import write_srt
- result = transcribe(model, audio_path, temperature=temperature, **args)
- # save SRT
- audio_basename = Path(audio_path).stem
- with open(Path(output_dir) / (audio_basename + ".srt"), "w", encoding="utf-8") as srt:
- write_srt(result["segments"], file=srt)
- """
- for i, segment in enumerate(transcript, start=1):
- text = processText(segment['text'].strip(), maxLineWidth).replace('-->', '->')
-
- # write srt lines
- print(
- f"{i}\n"
- f"{format_timestamp(segment['start'], always_include_hours=True, fractionalSeperator=',')} --> "
- f"{format_timestamp(segment['end'], always_include_hours=True, fractionalSeperator=',')}\n"
- f"{text}\n",
- file=file,
- flush=True,
- )
-
-def processText(text: str, maxLineWidth=None):
- if (maxLineWidth is None or maxLineWidth < 0):
- return text
-
- lines = textwrap.wrap(text, width=maxLineWidth, tabsize=4)
- return '\n'.join(lines)
diff --git a/spaces/JohnSmith9982/ChuanhuChatGPT/web_assets/stylesheet/custom-components.css b/spaces/JohnSmith9982/ChuanhuChatGPT/web_assets/stylesheet/custom-components.css
deleted file mode 100644
index 633c4cd958b8f45d6f185aa81adcf26f07043ea8..0000000000000000000000000000000000000000
--- a/spaces/JohnSmith9982/ChuanhuChatGPT/web_assets/stylesheet/custom-components.css
+++ /dev/null
@@ -1,240 +0,0 @@
-
-/* user-info */
-#user-info.block {
- white-space: nowrap;
- position: absolute; left: 8em; top: .8em;
- z-index: var(--layer-2);
- box-shadow: var(--block-shadow);
- border: none!important; border-radius: var(--block-label-radius);
- background: var(--color-accent);
- padding: var(--block-label-padding);
- font-size: var(--block-label-text-size); line-height: var(--line-sm);
- width: auto; max-height: 30px!important;
- opacity: 1;
- transition: opacity 0.3s ease-in-out;
-}
-#user-info.block .wrap {
- opacity: 0;
-}
-#user-info p {
- color: white;
- font-weight: var(--block-label-text-weight);
-}
-#user-info.info-transparent {
- opacity: 0;
- transition: opacity 1s ease-in-out;
-}
-
-
-/* updater */
-#toast-update {
- position: absolute;
- display: flex;
- top: -500px;
- width: 100%;
- justify-content: center;
- z-index: var(--layer-top);
- transition: top 0.3s ease-out;
-}
-#check-chuanhu-update {
- position: absolute;
- align-items: center;
- display: flex;
- flex-direction: column;
- justify-content: center;
- margin: var(--size-6) var(--size-4);
- box-shadow: var(--shadow-drop-lg);
- border: 1px solid var(--block-label-border-color);
- border-radius: var(--container-radius);
- background: var(--background-fill-primary);
- padding: var(--size-4) var(--size-6);
- min-width: 360px;
- max-width: 480px;
- overflow: hidden;
- pointer-events: auto;
-}
-#version-info-title {
- font-size: 1.2em;
- font-weight: bold;
- text-align: start;
- width: 100%;
-}
-#release-note-wrap {
- width: 100%;
- max-width: 400px;
- height: 120px;
- border: solid 1px var(--border-color-primary);
- overflow: auto;
- padding: 0 8px;
-}
-#release-note-wrap.hideK {
- display: none;
-}
-.btn-update-group {
- display: flex;
- justify-content: space-evenly;
- align-items: center;
- width: 100%;
- padding-top: 10px;
-}
-.btn-update-group.hideK {
- display: none;
-}
-#updating-info {
- margin: 16px 0px 24px;
- text-align: start;
- width: 100%;
-}
-
-
-#usage-display p, #usage-display span {
- margin: 0;
- font-size: .85em;
- color: var(--body-text-color-subdued);
-}
-.progress-bar {
- background-color: var(--input-background-fill);;
- margin: .5em 0 !important;
- height: 20px;
- border-radius: 10px;
- overflow: hidden;
-}
-.progress {
- background-color: var(--block-title-background-fill);
- height: 100%;
- border-radius: 10px;
- text-align: right;
- transition: width 0.5s ease-in-out;
-}
-.progress-text {
- /* color: white; */
- color: var(--color-accent) !important;
- font-size: 1em !important;
- font-weight: bold;
- padding-right: 10px;
- line-height: 20px;
-}
-
-
-/* 亮暗色模式切换 */
-#apSwitch input[type="checkbox"] {
- margin: 0 !important;
-}
-#apSwitch label.apSwitch {
- display: flex;
- align-items: center;
- cursor: pointer;
- color: var(--body-text-color);
- font-weight: var(--checkbox-label-text-weight);
- font-size: var(--checkbox-label-text-size);
- line-height: var(--line-md);
- margin: 2px 0 !important;
-}
-input[type="checkbox"]#apSwitch-checkbox::before {
- background: none !important;
- content: '🌞';
- border: none !important;
- box-shadow: none !important;
- font-size: 22px;
- top: -4.4px;
- left: -1px;
-}
-input:checked[type="checkbox"]#apSwitch-checkbox::before {
- content: '🌚';
- left: 16px;
-}
-
-/* .apSwitch {
- top: 2px;
- display: inline-block;
- height: 22px;
- position: relative;
- width: 40px;
- border-radius: 11px;
- box-shadow: inset 0 0 1px 0 rgba(0,0,0,0.05), inset 0 0 2px 0 rgba(0,0,0,0.08) !important;
-}
-.apSwitch input {
- display: none !important;
-}
-.apSlider {
- background-color: var(--neutral-200);
- bottom: 0;
- cursor: pointer;
- left: 0;
- position: absolute;
- right: 0;
- top: 0;
- transition: .4s;
- font-size: 22px;
- border-radius: 11px;
-}
-.apSlider::before {
- transform: scale(0.9);
- position: absolute;
- transition: .4s;
- content: "🌞";
-}
-input:checked + .apSlider {
- background-color: var(--primary-600);
-}
-input:checked + .apSlider::before {
- transform: translateX(18px);
- content:"🌚";
-} */
-
-/* switch-checkbox */
-.switch-checkbox label {
- flex-direction: row-reverse;
- justify-content: space-between;
-}
-.switch-checkbox input[type="checkbox"] + span {
- margin-left: 0 !important;
-}
-
-.switch-checkbox input[type="checkbox"] {
- -moz-appearance: none;
- appearance: none;
- -webkit-appearance: none;
- outline: none;
-}
-
-.switch-checkbox input[type="checkbox"] {
- display: inline-block !important;
- position: relative !important;
- border: none !important;
- outline: none;
- width: 40px !important;
- height: 22px !important;
- border-radius: 11px !important;
- background-image: none !important;
- box-shadow: inset 0 0 1px 0 rgba(0,0,0,0.05), inset 0 0 2px 0 rgba(0,0,0,0.08) !important;
- background-image: none !important;
- background-color: var(--switch-checkbox-color-light) !important;
- transition: .2s ease background-color;
-}
-.dark .switch-checkbox input[type="checkbox"] {
- background-color: var(--switch-checkbox-color-dark) !important;
-}
-.switch-checkbox input[type="checkbox"]::before {
- content: "";
- position: absolute;
- width: 22px;
- height: 22px;
- top: 0;
- left: 0;
- background: #FFFFFF;
- border: 0.5px solid rgba(0,0,0,0.02);
- box-shadow: 0 0 0 0 rgba(0,0,0,0.15), 0 1px 0 0 rgba(0,0,0,0.05);
- transform: scale(0.9);
- border-radius: 11px !important;
- transition: .4s ease all;
- box-shadow: var(--input-shadow);
-}
-.switch-checkbox input:checked[type="checkbox"] {
- background-color: var(--primary-600) !important;
-}
-.switch-checkbox input:checked[type="checkbox"]::before {
- background-color: #fff;
- left: 18px;
-}
-
diff --git a/spaces/KyanChen/RSPrompter/configs/huggingface/rsprompter_anchor_SSDD_config.py b/spaces/KyanChen/RSPrompter/configs/huggingface/rsprompter_anchor_SSDD_config.py
deleted file mode 100644
index 7981799d7cbc69e73ce45e7854474b6d3d957264..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/configs/huggingface/rsprompter_anchor_SSDD_config.py
+++ /dev/null
@@ -1,369 +0,0 @@
-custom_imports = dict(imports=['mmseg.datasets', 'mmseg.models'], allow_failed_imports=False)
-
-sub_model_train = [
- 'panoptic_head',
- 'data_preprocessor'
-]
-
-sub_model_optim = {
- 'panoptic_head': {'lr_mult': 1},
-}
-
-max_epochs = 1000
-
-optimizer = dict(
- type='AdamW',
- sub_model=sub_model_optim,
- lr=0.0005,
- weight_decay=1e-3
-)
-
-param_scheduler = [
- # warm up learning rate scheduler
- dict(
- type='LinearLR',
- start_factor=1e-4,
- by_epoch=True,
- begin=0,
- end=1,
- # update by iter
- convert_to_iter_based=True),
- # main learning rate scheduler
- dict(
- type='CosineAnnealingLR',
- T_max=max_epochs,
- by_epoch=True,
- begin=1,
- end=max_epochs,
- ),
-]
-
-param_scheduler_callback = dict(
- type='ParamSchedulerHook'
-)
-
-evaluator_ = dict(
- type='CocoPLMetric',
- metric=['bbox', 'segm'],
- proposal_nums=[1, 10, 100]
-)
-
-evaluator = dict(
- val_evaluator=evaluator_,
-)
-
-
-image_size = (1024, 1024)
-
-data_preprocessor = dict(
- type='mmdet.DetDataPreprocessor',
- mean=[123.675, 116.28, 103.53],
- std=[58.395, 57.12, 57.375],
- bgr_to_rgb=True,
- pad_size_divisor=32,
- pad_mask=True,
- mask_pad_value=0,
-)
-
-num_things_classes = 1
-num_stuff_classes = 0
-num_classes = num_things_classes + num_stuff_classes
-prompt_shape = (30, 5)
-
-model_cfg = dict(
- type='SegSAMAnchorPLer',
- hyperparameters=dict(
- optimizer=optimizer,
- param_scheduler=param_scheduler,
- evaluator=evaluator,
- ),
- need_train_names=sub_model_train,
- data_preprocessor=data_preprocessor,
- backbone=dict(
- type='vit_h',
- # checkpoint='pretrain/sam/sam_vit_h_4b8939.pth',
- # type='vit_b',
- # checkpoint='pretrain/sam/sam_vit_b_01ec64.pth',
- ),
- panoptic_head=dict(
- type='SAMAnchorInstanceHead',
- neck=dict(
- type='SAMAggregatorNeck',
- in_channels=[1280] * 32,
- # in_channels=[768] * 12,
- inner_channels=32,
- selected_channels=range(4, 32, 2),
- # selected_channels=range(4, 12, 2),
- out_channels=256,
- up_sample_scale=4,
- ),
- rpn_head=dict(
- type='mmdet.RPNHead',
- in_channels=256,
- feat_channels=256,
- anchor_generator=dict(
- type='mmdet.AnchorGenerator',
- scales=[2, 4, 8, 16, 32, 64],
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32]),
- bbox_coder=dict(
- type='mmdet.DeltaXYWHBBoxCoder',
- target_means=[.0, .0, .0, .0],
- target_stds=[1.0, 1.0, 1.0, 1.0]),
- loss_cls=dict(
- type='mmdet.CrossEntropyLoss', use_sigmoid=True, loss_weight=1.0),
- loss_bbox=dict(type='mmdet.SmoothL1Loss', loss_weight=1.0)),
- roi_head=dict(
- type='SAMAnchorPromptRoIHead',
- bbox_roi_extractor=dict(
- type='mmdet.SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=7, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[8, 16, 32]),
- bbox_head=dict(
- type='mmdet.Shared2FCBBoxHead',
- in_channels=256,
- fc_out_channels=1024,
- roi_feat_size=7,
- num_classes=num_classes,
- bbox_coder=dict(
- type='mmdet.DeltaXYWHBBoxCoder',
- target_means=[0., 0., 0., 0.],
- target_stds=[0.1, 0.1, 0.2, 0.2]),
- reg_class_agnostic=False,
- loss_cls=dict(
- type='mmdet.CrossEntropyLoss', use_sigmoid=False, loss_weight=1.0),
- loss_bbox=dict(type='mmdet.SmoothL1Loss', loss_weight=1.0)),
- mask_roi_extractor=dict(
- type='mmdet.SingleRoIExtractor',
- roi_layer=dict(type='RoIAlign', output_size=14, sampling_ratio=0),
- out_channels=256,
- featmap_strides=[8, 16, 32]),
- mask_head=dict(
- type='SAMPromptMaskHead',
- per_query_point=prompt_shape[1],
- with_sincos=True,
- class_agnostic=True,
- loss_mask=dict(
- type='mmdet.CrossEntropyLoss', use_mask=True, loss_weight=1.0))),
- # model training and testing settings
- train_cfg=dict(
- rpn=dict(
- assigner=dict(
- type='mmdet.MaxIoUAssigner',
- pos_iou_thr=0.7,
- neg_iou_thr=0.3,
- min_pos_iou=0.3,
- match_low_quality=True,
- ignore_iof_thr=-1),
- sampler=dict(
- type='mmdet.RandomSampler',
- num=512,
- pos_fraction=0.5,
- neg_pos_ub=-1,
- add_gt_as_proposals=False),
- allowed_border=-1,
- pos_weight=-1,
- debug=False),
- rpn_proposal=dict(
- nms_pre=2000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- assigner=dict(
- type='mmdet.MaxIoUAssigner',
- pos_iou_thr=0.5,
- neg_iou_thr=0.5,
- min_pos_iou=0.5,
- match_low_quality=True,
- ignore_iof_thr=-1),
- sampler=dict(
- type='mmdet.RandomSampler',
- num=256,
- pos_fraction=0.25,
- neg_pos_ub=-1,
- add_gt_as_proposals=True),
- mask_size=1024,
- pos_weight=-1,
- debug=False)),
- test_cfg=dict(
- rpn=dict(
- nms_pre=1000,
- max_per_img=1000,
- nms=dict(type='nms', iou_threshold=0.7),
- min_bbox_size=0),
- rcnn=dict(
- score_thr=0.05,
- nms=dict(type='nms', iou_threshold=0.5),
- max_per_img=100,
- mask_thr_binary=0.5)
- )
- )
-)
-
-task_name = 'whu_ins'
-exp_name = 'E20230629_0'
-logger = dict(
- type='WandbLogger',
- project=task_name,
- group='sam-anchor',
- name=exp_name
-)
-
-
-vis_backends = [dict(type='mmdet.LocalVisBackend')]
-visualizer = dict(
- type='mmdet.DetLocalVisualizer',
- vis_backends=vis_backends,
- name='visualizer',
- fig_save_cfg=dict(
- frameon=False,
- figsize=(40, 20),
- # dpi=300,
- ),
- line_width=2,
- alpha=0.8
-)
-
-callbacks = [
- param_scheduler_callback,
- dict(
- type='ModelCheckpoint',
- dirpath=f'results/{task_name}/{exp_name}/checkpoints',
- save_last=True,
- mode='max',
- monitor='valsegm_map_0',
- save_top_k=3,
- filename='epoch_{epoch}-map_{valsegm_map_0:.4f}'
- ),
- dict(
- type='LearningRateMonitor',
- logging_interval='step'
- )
-]
-
-
-trainer_cfg = dict(
- compiled_model=False,
- accelerator="auto",
- strategy="auto",
- # strategy="ddp",
- # strategy='ddp_find_unused_parameters_true',
- # precision='32',
- # precision='16-mixed',
- devices=8,
- default_root_dir=f'results/{task_name}/{exp_name}',
- # default_root_dir='results/tmp',
- max_epochs=max_epochs,
- logger=logger,
- callbacks=callbacks,
- log_every_n_steps=5,
- check_val_every_n_epoch=5,
- benchmark=True,
- # sync_batchnorm=True,
- # fast_dev_run=True,
-
- # limit_train_batches=1,
- # limit_val_batches=0,
- # limit_test_batches=None,
- # limit_predict_batches=None,
- # overfit_batches=0.0,
-
- # val_check_interval=None,
- # num_sanity_val_steps=0,
- # enable_checkpointing=None,
- # enable_progress_bar=None,
- # enable_model_summary=None,
- # accumulate_grad_batches=32,
- # gradient_clip_val=15,
- # gradient_clip_algorithm='norm',
- # deterministic=None,
- # inference_mode: bool=True,
- use_distributed_sampler=True,
- # profiler="simple",
- # detect_anomaly=False,
- # barebones=False,
- # plugins=None,
- # reload_dataloaders_every_n_epochs=0,
-)
-
-
-backend_args = None
-train_pipeline = [
- dict(type='mmdet.LoadImageFromFile'),
- dict(type='mmdet.LoadAnnotations', with_bbox=True, with_mask=True),
- dict(type='mmdet.Resize', scale=image_size),
- dict(type='mmdet.RandomFlip', prob=0.5),
- dict(type='mmdet.PackDetInputs')
-]
-
-test_pipeline = [
- dict(type='mmdet.LoadImageFromFile', backend_args=backend_args),
- dict(type='mmdet.Resize', scale=image_size),
- # If you don't have a gt annotation, delete the pipeline
- dict(type='mmdet.LoadAnnotations', with_bbox=True, with_mask=True),
- dict(
- type='mmdet.PackDetInputs',
- meta_keys=('img_id', 'img_path', 'ori_shape', 'img_shape',
- 'scale_factor'))
-]
-
-
-train_batch_size_per_gpu = 2
-train_num_workers = 2
-test_batch_size_per_gpu = 2
-test_num_workers = 2
-persistent_workers = True
-
-data_parent = '/mnt/search01/dataset/cky_data/SSDD'
-dataset_type = 'SSDDInsSegDataset'
-
-
-val_loader = dict(
- batch_size=test_batch_size_per_gpu,
- num_workers=test_num_workers,
- persistent_workers=persistent_workers,
- pin_memory=True,
- dataset=dict(
- type=dataset_type,
- data_root=data_parent,
- # ann_file='NWPU_instances_val.json',
- # data_prefix=dict(img_path='positive image set'),
- ann_file='annotations/SSDD_instances_val.json',
- data_prefix=dict(img_path='imgs'),
- test_mode=True,
- filter_cfg=dict(filter_empty_gt=True, min_size=32),
- pipeline=test_pipeline,
- backend_args=backend_args))
-
-predict_pipeline = [
- dict(type='mmdet.Resize', scale=image_size),
- dict(
- type='mmdet.PackDetInputs',
- meta_keys=('ori_shape', 'img_shape', 'scale_factor'))
-]
-
-
-datamodule_cfg = dict(
- type='PLDataModule',
- train_loader=dict(
- batch_size=train_batch_size_per_gpu,
- num_workers=train_num_workers,
- persistent_workers=persistent_workers,
- pin_memory=True,
- dataset=dict(
- type=dataset_type,
- data_root=data_parent,
- # ann_file='NWPU_instances_train.json',
- # data_prefix=dict(img_path='positive image set'),
- ann_file='annotations/SSDD_instances_train.json',
- data_prefix=dict(img_path='imgs'),
- filter_cfg=dict(filter_empty_gt=True, min_size=32),
- pipeline=train_pipeline,
- backend_args=backend_args)
- ),
- val_loader=val_loader,
- # test_loader=val_loader
- predict_loader=val_loader
-)
\ No newline at end of file
diff --git a/spaces/KyanChen/RSPrompter/mmdet/utils/replace_cfg_vals.py b/spaces/KyanChen/RSPrompter/mmdet/utils/replace_cfg_vals.py
deleted file mode 100644
index a3331a36ce5a22fcc4d4a955d757f5e8b6bfc6bb..0000000000000000000000000000000000000000
--- a/spaces/KyanChen/RSPrompter/mmdet/utils/replace_cfg_vals.py
+++ /dev/null
@@ -1,70 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import re
-
-from mmengine.config import Config
-
-
-def replace_cfg_vals(ori_cfg):
- """Replace the string "${key}" with the corresponding value.
-
- Replace the "${key}" with the value of ori_cfg.key in the config. And
- support replacing the chained ${key}. Such as, replace "${key0.key1}"
- with the value of cfg.key0.key1. Code is modified from `vars.py
- < https://github.com/microsoft/SoftTeacher/blob/main/ssod/utils/vars.py>`_ # noqa: E501
-
- Args:
- ori_cfg (mmengine.config.Config):
- The origin config with "${key}" generated from a file.
-
- Returns:
- updated_cfg [mmengine.config.Config]:
- The config with "${key}" replaced by the corresponding value.
- """
-
- def get_value(cfg, key):
- for k in key.split('.'):
- cfg = cfg[k]
- return cfg
-
- def replace_value(cfg):
- if isinstance(cfg, dict):
- return {key: replace_value(value) for key, value in cfg.items()}
- elif isinstance(cfg, list):
- return [replace_value(item) for item in cfg]
- elif isinstance(cfg, tuple):
- return tuple([replace_value(item) for item in cfg])
- elif isinstance(cfg, str):
- # the format of string cfg may be:
- # 1) "${key}", which will be replaced with cfg.key directly
- # 2) "xxx${key}xxx" or "xxx${key1}xxx${key2}xxx",
- # which will be replaced with the string of the cfg.key
- keys = pattern_key.findall(cfg)
- values = [get_value(ori_cfg, key[2:-1]) for key in keys]
- if len(keys) == 1 and keys[0] == cfg:
- # the format of string cfg is "${key}"
- cfg = values[0]
- else:
- for key, value in zip(keys, values):
- # the format of string cfg is
- # "xxx${key}xxx" or "xxx${key1}xxx${key2}xxx"
- assert not isinstance(value, (dict, list, tuple)), \
- f'for the format of string cfg is ' \
- f"'xxxxx${key}xxxxx' or 'xxx${key}xxx${key}xxx', " \
- f"the type of the value of '${key}' " \
- f'can not be dict, list, or tuple' \
- f'but you input {type(value)} in {cfg}'
- cfg = cfg.replace(key, str(value))
- return cfg
- else:
- return cfg
-
- # the pattern of string "${key}"
- pattern_key = re.compile(r'\$\{[a-zA-Z\d_.]*\}')
- # the type of ori_cfg._cfg_dict is mmengine.config.ConfigDict
- updated_cfg = Config(
- replace_value(ori_cfg._cfg_dict), filename=ori_cfg.filename)
- # replace the model with model_wrapper
- if updated_cfg.get('model_wrapper', None) is not None:
- updated_cfg.model = updated_cfg.model_wrapper
- updated_cfg.pop('model_wrapper')
- return updated_cfg
diff --git a/spaces/LanguageBind/LanguageBind/training/__init__.py b/spaces/LanguageBind/LanguageBind/training/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/utils.py b/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/utils.py
deleted file mode 100644
index 9bab57c35df3d7249873bb4e5e743bcea5549936..0000000000000000000000000000000000000000
--- a/spaces/LaynzKunz/Aesthetic_RVC_Inference_HF/lib/infer/infer_libs/uvr5_pack/utils.py
+++ /dev/null
@@ -1,121 +0,0 @@
-import json
-
-import numpy as np
-import torch
-from tqdm import tqdm
-
-
-def load_data(file_name: str = "./lib/infer/infer_libs/uvr5_pack/name_params.json") -> dict:
- with open(file_name, "r") as f:
- data = json.load(f)
-
- return data
-
-
-def make_padding(width, cropsize, offset):
- left = offset
- roi_size = cropsize - left * 2
- if roi_size == 0:
- roi_size = cropsize
- right = roi_size - (width % roi_size) + left
-
- return left, right, roi_size
-
-
-def inference(X_spec, device, model, aggressiveness, data):
- """
- data ： dic configs
- """
-
- def _execute(
- X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half=True
- ):
- model.eval()
- with torch.no_grad():
- preds = []
-
- iterations = [n_window]
-
- total_iterations = sum(iterations)
- for i in tqdm(range(n_window)):
- start = i * roi_size
- X_mag_window = X_mag_pad[
- None, :, :, start : start + data["window_size"]
- ]
- X_mag_window = torch.from_numpy(X_mag_window)
- if is_half:
- X_mag_window = X_mag_window.half()
- X_mag_window = X_mag_window.to(device)
-
- pred = model.predict(X_mag_window, aggressiveness)
-
- pred = pred.detach().cpu().numpy()
- preds.append(pred[0])
-
- pred = np.concatenate(preds, axis=2)
- return pred
-
- def preprocess(X_spec):
- X_mag = np.abs(X_spec)
- X_phase = np.angle(X_spec)
-
- return X_mag, X_phase
-
- X_mag, X_phase = preprocess(X_spec)
-
- coef = X_mag.max()
- X_mag_pre = X_mag / coef
-
- n_frame = X_mag_pre.shape[2]
- pad_l, pad_r, roi_size = make_padding(n_frame, data["window_size"], model.offset)
- n_window = int(np.ceil(n_frame / roi_size))
-
- X_mag_pad = np.pad(X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode="constant")
-
- if list(model.state_dict().values())[0].dtype == torch.float16:
- is_half = True
- else:
- is_half = False
- pred = _execute(
- X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half
- )
- pred = pred[:, :, :n_frame]
-
- if data["tta"]:
- pad_l += roi_size // 2
- pad_r += roi_size // 2
- n_window += 1
-
- X_mag_pad = np.pad(X_mag_pre, ((0, 0), (0, 0), (pad_l, pad_r)), mode="constant")
-
- pred_tta = _execute(
- X_mag_pad, roi_size, n_window, device, model, aggressiveness, is_half
- )
- pred_tta = pred_tta[:, :, roi_size // 2 :]
- pred_tta = pred_tta[:, :, :n_frame]
-
- return (pred + pred_tta) * 0.5 * coef, X_mag, np.exp(1.0j * X_phase)
- else:
- return pred * coef, X_mag, np.exp(1.0j * X_phase)
-
-
-def _get_name_params(model_path, model_hash):
- data = load_data()
- flag = False
- ModelName = model_path
- for type in list(data):
- for model in list(data[type][0]):
- for i in range(len(data[type][0][model])):
- if str(data[type][0][model][i]["hash_name"]) == model_hash:
- flag = True
- elif str(data[type][0][model][i]["hash_name"]) in ModelName:
- flag = True
-
- if flag:
- model_params_auto = data[type][0][model][i]["model_params"]
- param_name_auto = data[type][0][model][i]["param_name"]
- if type == "equivalent":
- return param_name_auto, model_params_auto
- else:
- flag = False
- return param_name_auto, model_params_auto
diff --git a/spaces/LittleYuan/My-Real-Bot/realesrgan/models/__init__.py b/spaces/LittleYuan/My-Real-Bot/realesrgan/models/__init__.py
deleted file mode 100644
index 0be7105dc75d150c49976396724085f678dc0675..0000000000000000000000000000000000000000
--- a/spaces/LittleYuan/My-Real-Bot/realesrgan/models/__init__.py
+++ /dev/null
@@ -1,10 +0,0 @@
-import importlib
-from basicsr.utils import scandir
-from os import path as osp
-
-# automatically scan and import model modules for registry
-# scan all the files that end with '_model.py' under the model folder
-model_folder = osp.dirname(osp.abspath(__file__))
-model_filenames = [osp.splitext(osp.basename(v))[0] for v in scandir(model_folder) if v.endswith('_model.py')]
-# import all the model modules
-_model_modules = [importlib.import_module(f'realesrgan.models.{file_name}') for file_name in model_filenames]
diff --git a/spaces/MLSquad-TWCN/near-continuous-whispering/README.md b/spaces/MLSquad-TWCN/near-continuous-whispering/README.md
deleted file mode 100644
index 129b3a6c1cc03d86a8744300d07a0f2d1985e5e9..0000000000000000000000000000000000000000
--- a/spaces/MLSquad-TWCN/near-continuous-whispering/README.md
+++ /dev/null
@@ -1,33 +0,0 @@
----
-title: Near Continuous Whispering
-emoji: ⚡
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.4.1
-app_file: app.py
-pinned: false
-license: apache-2.0
----
-
-The near-continuous speech recognition demo using [OpenAI whisper](https://github.com/openai/whisper), built using [Gradio](https://gradio.app/).
-
-### How to run?
-Install openai/whisper
-
- pip install git+https://github.com/openai/whisper.git
-
-Install requirements
-
- pip install -r requirements.txt
-
-Start the Gradio app
-
- python whisper_demo.py
-
-### Simple Notes
-1. The near-continuous recognition is implemented by incrementally recognizing all historical audio streaming every N seconds. The config is `REC_INTERVAL_IN_SECONDS`
-
-2. The near-continuous recognition is in fact quite broken(slow) and only used for demo purpose. You should try a web socket way for real time recognition by referring to https://github.com/shirayu/whispering
-
-3. For update-to-date code, please refer to https://github.com/nomorewzx/near-continuous-whispering
\ No newline at end of file
diff --git a/spaces/Manjushri/SD-2X-And-4X-CPU/app.py b/spaces/Manjushri/SD-2X-And-4X-CPU/app.py
deleted file mode 100644
index 463c8db78d986f7a5a3100c6d8e0add6b50e9983..0000000000000000000000000000000000000000
--- a/spaces/Manjushri/SD-2X-And-4X-CPU/app.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import gradio as gr
-import torch
-import modin.pandas as pd
-from PIL import Image
-from io import BytesIO
-from diffusers import StableDiffusionLatentUpscalePipeline, StableDiffusionUpscalePipeline
-
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Define the models
-model_2x = "stabilityai/sd-x2-latent-upscaler"
-model_4x = "stabilityai/stable-diffusion-x4-upscaler"
-# Load the models
-sd_2_0_2x = StableDiffusionLatentUpscalePipeline.from_pretrained(model_2x, torch_dtype=torch.float16, revision="fp16") if torch.cuda.is_available() else StableDiffusionLatentUpscalePipeline.from_pretrained(model_2x)
-sd_2_1_4x = StableDiffusionUpscalePipeline.from_pretrained(model_4x, torch_dtype=torch.float16, revision="fp16") if torch.cuda.is_available() else StableDiffusionUpscalePipeline.from_pretrained(model_4x)
-
-# Define the function that will be called when the interface is used
-
-def upscale_image(model, input_image, prompt, guidance):
- # Convert the image
- generator = torch.manual_seed(999999)
- input_image = Image.open(input_image).convert("RGB")
- # Upscale the image using the selected model
- if model == "SD 2.1 4x Upscaler":
- low_res_img = input_image.resize((128, 128))
- upscaled_image = sd_2_1_4x(prompt, image=low_res_img, num_inference_steps=5, guidance_scale=guidance).images[0]
- else:
- upscaled_image = sd_2_0_2x(prompt, image=input_image, num_inference_steps=5, guidance_scale=guidance).images[0]
- # Return the upscaled image
- return upscaled_image
-
-# Define the Gradio interface
-gr.Interface(
- fn=upscale_image,
- inputs=[gr.Radio(["SD 2.0 2x Latent Upscaler", "SD 2.1 4x Upscaler"], label="Models:"),
- gr.Image(type="filepath", label = "Raw Image"),
- gr.Textbox(label='Guide the AI Upscaling'),
- gr.Slider(minimum=0, value=0, maximum=3, label='Guidance Scale')],
- outputs=gr.Image(type="filepath", label = "Upscaled Image"),
- title="SD Image Upscaler",
- description="Upscale an image using either the SD 2.0 2x Latent Upscaler or the SD 2.1 4x Upscaler. Use the 4x Upscaler for images lower than 512x512. Use the 2x Upscaler for images 512x512 to 768x768"
-).launch(debug=True)
diff --git a/spaces/Marshalls/testmtd/analysis/aistplusplus_api/aist_plusplus/__init__.py b/spaces/Marshalls/testmtd/analysis/aistplusplus_api/aist_plusplus/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Marshalls/testmtd/models/moglow/models.py b/spaces/Marshalls/testmtd/models/moglow/models.py
deleted file mode 100644
index 9d7176f1f727037afa4f0b9f6aeaba4380b5db79..0000000000000000000000000000000000000000
--- a/spaces/Marshalls/testmtd/models/moglow/models.py
+++ /dev/null
@@ -1,268 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-import numpy as np
-from tqdm import tqdm
-from . import thops
-from . import modules
-from . import utils
-from models.transformer import BasicTransformerModelCausal
-
-def nan_throw(tensor, name="tensor"):
- stop = False
- if ((tensor!=tensor).any()):
- print(name + " has nans")
- stop = True
- if (torch.isinf(tensor).any()):
- print(name + " has infs")
- stop = True
- if stop:
- print(name + ": " + str(tensor))
- #raise ValueError(name + ' contains nans of infs')
-
-def f(in_channels, out_channels, hidden_channels, cond_channels, network_model, num_layers):
- if network_model=="transformer":
- #return BasicTransformerModel(out_channels, in_channels + cond_channels, 10, hidden_channels, num_layers, use_pos_emb=True)
- return BasicTransformerModelCausal(out_channels, in_channels + cond_channels, 10, hidden_channels, num_layers, use_pos_emb=True, input_length=70)
- if network_model=="LSTM":
- return modules.LSTM(in_channels + cond_channels, hidden_channels, out_channels, num_layers)
- if network_model=="GRU":
- return modules.GRU(in_channels + cond_channels, hidden_channels, out_channels, num_layers)
- if network_model=="FF":
- return nn.Sequential(
- nn.Linear(in_channels+cond_channels, hidden_channels), nn.ReLU(inplace=False),
- nn.Linear(hidden_channels, hidden_channels), nn.ReLU(inplace=False),
- modules.LinearZeroInit(hidden_channels, out_channels))
-
-class FlowStep(nn.Module):
- FlowCoupling = ["additive", "affine"]
- NetworkModel = ["transformer","LSTM", "GRU", "FF"]
- FlowPermutation = {
- "reverse": lambda obj, z, logdet, rev: (obj.reverse(z, rev), logdet),
- "shuffle": lambda obj, z, logdet, rev: (obj.shuffle(z, rev), logdet),
- "invconv": lambda obj, z, logdet, rev: obj.invconv(z, logdet, rev)
- }
-
- def __init__(self, in_channels, hidden_channels, cond_channels,
- actnorm_scale=1.0,
- flow_permutation="invconv",
- flow_coupling="additive",
- network_model="LSTM",
- num_layers=2,
- LU_decomposed=False):
-
- # check configures
- assert flow_coupling in FlowStep.FlowCoupling,\
- "flow_coupling should be in `{}`".format(FlowStep.FlowCoupling)
- assert network_model in FlowStep.NetworkModel,\
- "network_model should be in `{}`".format(FlowStep.NetworkModel)
- assert flow_permutation in FlowStep.FlowPermutation,\
- "float_permutation should be in `{}`".format(
- FlowStep.FlowPermutation.keys())
- super().__init__()
- self.flow_permutation = flow_permutation
- self.flow_coupling = flow_coupling
- self.network_model = network_model
- # 1. actnorm
- self.actnorm = modules.ActNorm2d(in_channels, actnorm_scale)
- # 2. permute
- if flow_permutation == "invconv":
- self.invconv = modules.InvertibleConv1x1(
- in_channels, LU_decomposed=LU_decomposed)
- elif flow_permutation == "shuffle":
- self.shuffle = modules.Permute2d(in_channels, shuffle=True)
- else:
- self.reverse = modules.Permute2d(in_channels, shuffle=False)
- # 3. coupling
- if flow_coupling == "additive":
- self.f = f(in_channels // 2, in_channels-in_channels // 2, hidden_channels, cond_channels, network_model, num_layers)
- elif flow_coupling == "affine":
- print("affine: in_channels = " + str(in_channels))
- self.f = f(in_channels // 2, 2*(in_channels-in_channels // 2), hidden_channels, cond_channels, network_model, num_layers)
- print("Flowstep affine layer: " + str(in_channels))
-
- def init_lstm_hidden(self):
- if self.network_model == "LSTM" or self.network_model == "GRU":
- self.f.init_hidden()
-
- def forward(self, input, cond, logdet=None, reverse=False):
- if not reverse:
- return self.normal_flow(input, cond, logdet)
- else:
- return self.reverse_flow(input, cond, logdet)
-
- def normal_flow(self, input, cond, logdet):
-
- #assert input.size(1) % 2 == 0
- # 1. actnorm
- #z=input
- z, logdet = self.actnorm(input, logdet=logdet, reverse=False)
- # 2. permute
- z, logdet = FlowStep.FlowPermutation[self.flow_permutation](
- self, z, logdet, False)
- # 3. coupling
- z1, z2 = thops.split_feature(z, "split")
- z1_cond = torch.cat((z1, cond), dim=1)
- if self.flow_coupling == "additive":
- z2 = z2 + self.f(z1_cond)
- elif self.flow_coupling == "affine":
- # import pdb;pdb.set_trace()
- if self.network_model=="transformer":
- h = self.f(z1_cond.permute(2,0,1)).permute(1,2,0)
- else:
- h = self.f(z1_cond.permute(0, 2, 1)).permute(0, 2, 1)
- shift, scale = thops.split_feature(h, "cross")
- scale = torch.sigmoid(scale + 2.)+1e-6
- z2 = z2 + shift
- z2 = z2 * scale
- logdet = thops.sum(torch.log(scale), dim=[1, 2]) + logdet
-
- z = thops.cat_feature(z1, z2)
- return z, cond, logdet
-
- def reverse_flow(self, input, cond, logdet):
- # 1.coupling
- z1, z2 = thops.split_feature(input, "split")
- # import pdb;pdb.set_trace()
- z1_cond = torch.cat((z1, cond), dim=1)
-
- if self.flow_coupling == "additive":
- z2 = z2 - self.f(z1_cond)
- elif self.flow_coupling == "affine":
- h = self.f(z1_cond.permute(0, 2, 1)).permute(0, 2, 1)
- shift, scale = thops.split_feature(h, "cross")
- nan_throw(shift, "shift")
- nan_throw(scale, "scale")
- nan_throw(z2, "z2 unscaled")
- scale = torch.sigmoid(scale + 2.)+1e-6
- z2 = z2 / scale
- z2 = z2 - shift
- logdet = -thops.sum(torch.log(scale), dim=[1, 2]) + logdet
-
- z = thops.cat_feature(z1, z2)
- # 2. permute
- z, logdet = FlowStep.FlowPermutation[self.flow_permutation](
- self, z, logdet, True)
- nan_throw(z, "z permute_" + str(self.flow_permutation))
- # 3. actnorm
- z, logdet = self.actnorm(z, logdet=logdet, reverse=True)
- return z, cond, logdet
-
-
-class FlowNet(nn.Module):
- def __init__(self, x_channels, hidden_channels, cond_channels, K,
- actnorm_scale=1.0,
- flow_permutation="invconv",
- flow_coupling="additive",
- network_model="LSTM",
- num_layers=2,
- LU_decomposed=False):
-
- super().__init__()
- self.layers = nn.ModuleList()
- self.output_shapes = []
- self.K = K
- N = cond_channels
- for _ in range(K):
- self.layers.append(
- FlowStep(in_channels=x_channels,
- hidden_channels=hidden_channels,
- cond_channels=N,
- actnorm_scale=actnorm_scale,
- flow_permutation=flow_permutation,
- flow_coupling=flow_coupling,
- network_model=network_model,
- num_layers=num_layers,
- LU_decomposed=LU_decomposed))
- self.output_shapes.append(
- [-1, x_channels, 1])
- # import pdb;pdb.set_trace()
-
- def init_lstm_hidden(self):
- for layer in self.layers:
- if isinstance(layer, FlowStep):
- layer.init_lstm_hidden()
-
- def forward(self, z, cond, logdet=0., reverse=False, eps_std=None):
- if not reverse:
- for layer in self.layers:
- z, cond, logdet = layer(z, cond, logdet, reverse=False)
- return z, logdet
- else:
- for i,layer in enumerate(reversed(self.layers)):
- z, cond, logdet = layer(z, cond, logdet=0, reverse=True)
- return z
-
-
-class Glow(nn.Module):
-
- def __init__(self, x_channels, cond_channels, opt):
- super().__init__()
- self.flow = FlowNet(x_channels=x_channels,
- hidden_channels=opt.dhid,
- cond_channels=cond_channels,
- K=opt.glow_K,
- actnorm_scale=opt.actnorm_scale,
- flow_permutation=opt.flow_permutation,
- flow_coupling=opt.flow_coupling,
- network_model=opt.network_model,
- num_layers=opt.num_layers,
- LU_decomposed=opt.LU_decomposed)
- self.opt = opt
-
- # register prior hidden
- # num_device = len(utils.get_proper_device(hparams.Device.glow, False))
- # assert hparams.Train.batch_size % num_device == 0
- # self.z_shape = [opt.batch_size // num_device, x_channels, 1]
- self.z_shape = [opt.batch_size, x_channels, 1]
- if opt.flow_dist == "normal":
- self.distribution = modules.GaussianDiag()
- elif opt.flow_dist == "studentT":
- self.distribution = modules.StudentT(opt.flow_dist_param, x_channels)
-
- def init_lstm_hidden(self):
- self.flow.init_lstm_hidden()
-
- def forward(self, x=None, cond=None, z=None,
- eps_std=None, reverse=False, output_length=1):
- if not reverse:
- return self.normal_flow(x, cond)
- else:
- return self.reverse_flow(z, cond, eps_std, output_length=output_length)
-
- def normal_flow(self, x, cond):
-
- n_timesteps = thops.timesteps(x) #just returns the size of dimension 2?
-
- logdet = torch.zeros_like(x[:, 0, 0])
-
- # encode
- z, objective = self.flow(x, cond, logdet=logdet, reverse=False)
-
- # prior
- objective += self.distribution.logp(z)
-
- # return
- nll = (-objective) / float(np.log(2.) * n_timesteps)
- return z, nll
-
- def reverse_flow(self, z, cond, eps_std, output_length=1):
- with torch.no_grad():
-
- z_shape = self.z_shape
- z_shape[-1] = output_length
- if z is None:
- z = self.distribution.sample(z_shape, eps_std, device=cond.device)
-
- x = self.flow(z, cond, eps_std=eps_std, reverse=True)
- return x
-
- def set_actnorm_init(self, inited=True):
- for name, m in self.named_modules():
- if (m.__class__.__name__.find("ActNorm") >= 0):
- m.inited = inited
-
- @staticmethod
- def loss_generative(nll):
- # Generative loss
- return torch.mean(nll)
diff --git a/spaces/MaverickHans/selfie/README.md b/spaces/MaverickHans/selfie/README.md
deleted file mode 100644
index 59eb234d1c0c61275dd1d04baba63edc32243224..0000000000000000000000000000000000000000
--- a/spaces/MaverickHans/selfie/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Selfie
-emoji: 📊
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.35.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/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/models.py b/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/models.py
deleted file mode 100644
index 9747301f350bb269e62601017fe4633ce271b27e..0000000000000000000000000000000000000000
--- a/spaces/Miuzarte/SUI-svc-4.0/vdecoder/hifigan/models.py
+++ /dev/null
@@ -1,503 +0,0 @@
-import os
-import json
-from .env import AttrDict
-import numpy as np
-import torch
-import torch.nn.functional as F
-import torch.nn as nn
-from torch.nn import Conv1d, ConvTranspose1d, AvgPool1d, Conv2d
-from torch.nn.utils import weight_norm, remove_weight_norm, spectral_norm
-from .utils import init_weights, get_padding
-
-LRELU_SLOPE = 0.1
-
-
-def load_model(model_path, device='cuda'):
- config_file = os.path.join(os.path.split(model_path)[0], 'config.json')
- with open(config_file) as f:
- data = f.read()
-
- global h
- json_config = json.loads(data)
- h = AttrDict(json_config)
-
- generator = Generator(h).to(device)
-
- cp_dict = torch.load(model_path)
- generator.load_state_dict(cp_dict['generator'])
- generator.eval()
- generator.remove_weight_norm()
- del cp_dict
- return generator, h
-
-
-class ResBlock1(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3, 5)):
- super(ResBlock1, self).__init__()
- self.h = h
- self.convs1 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[2],
- padding=get_padding(kernel_size, dilation[2])))
- ])
- self.convs1.apply(init_weights)
-
- self.convs2 = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=1,
- padding=get_padding(kernel_size, 1)))
- ])
- self.convs2.apply(init_weights)
-
- def forward(self, x):
- for c1, c2 in zip(self.convs1, self.convs2):
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c1(xt)
- xt = F.leaky_relu(xt, LRELU_SLOPE)
- xt = c2(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs1:
- remove_weight_norm(l)
- for l in self.convs2:
- remove_weight_norm(l)
-
-
-class ResBlock2(torch.nn.Module):
- def __init__(self, h, channels, kernel_size=3, dilation=(1, 3)):
- super(ResBlock2, self).__init__()
- self.h = h
- self.convs = nn.ModuleList([
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[0],
- padding=get_padding(kernel_size, dilation[0]))),
- weight_norm(Conv1d(channels, channels, kernel_size, 1, dilation=dilation[1],
- padding=get_padding(kernel_size, dilation[1])))
- ])
- self.convs.apply(init_weights)
-
- def forward(self, x):
- for c in self.convs:
- xt = F.leaky_relu(x, LRELU_SLOPE)
- xt = c(xt)
- x = xt + x
- return x
-
- def remove_weight_norm(self):
- for l in self.convs:
- remove_weight_norm(l)
-
-
-def padDiff(x):
- return F.pad(F.pad(x, (0,0,-1,1), 'constant', 0) - x, (0,0,0,-1), 'constant', 0)
-
-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
- self.flag_for_pulse = flag_for_pulse
-
- def _f02uv(self, f0):
- # generate uv signal
- uv = (f0 > self.voiced_threshold).type(torch.float32)
- return uv
-
- def _f02sine(self, f0_values):
- """ f0_values: (batchsize, length, dim)
- where dim indicates fundamental tone and overtones
- """
- # convert to F0 in rad. The interger part n can be ignored
- # because 2 * np.pi * n doesn't affect phase
- rad_values = (f0_values / self.sampling_rate) % 1
-
- # initial phase noise (no noise for fundamental component)
- rand_ini = torch.rand(f0_values.shape[0], f0_values.shape[2], \
- device=f0_values.device)
- rand_ini[:, 0] = 0
- rad_values[:, 0, :] = rad_values[:, 0, :] + rand_ini
-
- # instantanouse phase sine[t] = sin(2*pi \sum_i=1 ^{t} rad)
- if not self.flag_for_pulse:
- # for normal case
-
- # To prevent torch.cumsum numerical overflow,
- # it is necessary to add -1 whenever \sum_k=1^n rad_value_k > 1.
- # Buffer tmp_over_one_idx indicates the time step to add -1.
- # This will not change F0 of sine because (x-1) * 2*pi = x * 2*pi
- tmp_over_one = torch.cumsum(rad_values, 1) % 1
- tmp_over_one_idx = (padDiff(tmp_over_one)) < 0
- cumsum_shift = torch.zeros_like(rad_values)
- cumsum_shift[:, 1:, :] = tmp_over_one_idx * -1.0
-
- sines = torch.sin(torch.cumsum(rad_values + cumsum_shift, dim=1)
- * 2 * np.pi)
- else:
- # If necessary, make sure that the first time step of every
- # voiced segments is sin(pi) or cos(0)
- # This is used for pulse-train generation
-
- # identify the last time step in unvoiced segments
- uv = self._f02uv(f0_values)
- uv_1 = torch.roll(uv, shifts=-1, dims=1)
- uv_1[:, -1, :] = 1
- u_loc = (uv < 1) * (uv_1 > 0)
-
- # get the instantanouse phase
- tmp_cumsum = torch.cumsum(rad_values, dim=1)
- # different batch needs to be processed differently
- for idx in range(f0_values.shape[0]):
- temp_sum = tmp_cumsum[idx, u_loc[idx, :, 0], :]
- temp_sum[1:, :] = temp_sum[1:, :] - temp_sum[0:-1, :]
- # stores the accumulation of i.phase within
- # each voiced segments
- tmp_cumsum[idx, :, :] = 0
- tmp_cumsum[idx, u_loc[idx, :, 0], :] = temp_sum
-
- # rad_values - tmp_cumsum: remove the accumulation of i.phase
- # within the previous voiced segment.
- i_phase = torch.cumsum(rad_values - tmp_cumsum, dim=1)
-
- # get the sines
- sines = torch.cos(i_phase * 2 * np.pi)
- return sines
-
- def forward(self, f0):
- """ 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_buf = torch.zeros(f0.shape[0], f0.shape[1], self.dim,
- device=f0.device)
- # fundamental component
- fn = torch.multiply(f0, torch.FloatTensor([[range(1, self.harmonic_num + 2)]]).to(f0.device))
-
- # generate sine waveforms
- sine_waves = self._f02sine(fn) * self.sine_amp
-
- # generate uv signal
- # uv = torch.ones(f0.shape)
- # uv = uv * (f0 > self.voiced_threshold)
- uv = self._f02uv(f0)
-
- # noise: for unvoiced should be similar to sine_amp
- # std = self.sine_amp/3 -> max value ~ self.sine_amp
- # . for voiced regions is self.noise_std
- noise_amp = uv * self.noise_std + (1 - uv) * self.sine_amp / 3
- noise = noise_amp * torch.randn_like(sine_waves)
-
- # first: set the unvoiced part to 0 by uv
- # then: additive noise
- 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):
- super(SourceModuleHnNSF, self).__init__()
-
- self.sine_amp = sine_amp
- self.noise_std = add_noise_std
-
- # 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):
- """
- Sine_source, noise_source = SourceModuleHnNSF(F0_sampled)
- F0_sampled (batchsize, length, 1)
- Sine_source (batchsize, length, 1)
- noise_source (batchsize, length 1)
- """
- # source for harmonic branch
- sine_wavs, uv, _ = self.l_sin_gen(x)
- sine_merge = self.l_tanh(self.l_linear(sine_wavs))
-
- # source for noise branch, in the same shape as uv
- noise = torch.randn_like(uv) * self.sine_amp / 3
- return sine_merge, noise, uv
-
-
-class Generator(torch.nn.Module):
- def __init__(self, h):
- super(Generator, self).__init__()
- self.h = h
-
- self.num_kernels = len(h["resblock_kernel_sizes"])
- self.num_upsamples = len(h["upsample_rates"])
- self.f0_upsamp = torch.nn.Upsample(scale_factor=np.prod(h["upsample_rates"]))
- self.m_source = SourceModuleHnNSF(
- sampling_rate=h["sampling_rate"],
- harmonic_num=8)
- self.noise_convs = nn.ModuleList()
- self.conv_pre = weight_norm(Conv1d(h["inter_channels"], h["upsample_initial_channel"], 7, 1, padding=3))
- resblock = ResBlock1 if h["resblock"] == '1' else ResBlock2
- self.ups = nn.ModuleList()
- for i, (u, k) in enumerate(zip(h["upsample_rates"], h["upsample_kernel_sizes"])):
- c_cur = h["upsample_initial_channel"] // (2 ** (i + 1))
- self.ups.append(weight_norm(
- ConvTranspose1d(h["upsample_initial_channel"] // (2 ** i), h["upsample_initial_channel"] // (2 ** (i + 1)),
- k, u, padding=(k - u) // 2)))
- if i + 1 < len(h["upsample_rates"]): #
- stride_f0 = np.prod(h["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 = h["upsample_initial_channel"] // (2 ** (i + 1))
- for j, (k, d) in enumerate(zip(h["resblock_kernel_sizes"], h["resblock_dilation_sizes"])):
- self.resblocks.append(resblock(h, ch, k, d))
-
- self.conv_post = weight_norm(Conv1d(ch, 1, 7, 1, padding=3))
- self.ups.apply(init_weights)
- self.conv_post.apply(init_weights)
- self.cond = nn.Conv1d(h['gin_channels'], h['upsample_initial_channel'], 1)
-
- def forward(self, x, f0, g=None):
- # print(1,x.shape,f0.shape,f0[:, None].shape)
- f0 = self.f0_upsamp(f0[:, None]).transpose(1, 2) # bs,n,t
- # print(2,f0.shape)
- har_source, noi_source, uv = self.m_source(f0)
- har_source = har_source.transpose(1, 2)
- x = self.conv_pre(x)
- x = x + self.cond(g)
- # print(124,x.shape,har_source.shape)
- for i in range(self.num_upsamples):
- x = F.leaky_relu(x, LRELU_SLOPE)
- # print(3,x.shape)
- x = self.ups[i](x)
- x_source = self.noise_convs[i](har_source)
- # print(4,x_source.shape,har_source.shape,x.shape)
- 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):
- print('Removing weight norm...')
- for l in self.ups:
- remove_weight_norm(l)
- for l in self.resblocks:
- l.remove_weight_norm()
- remove_weight_norm(self.conv_pre)
- remove_weight_norm(self.conv_post)
-
-
-class DiscriminatorP(torch.nn.Module):
- def __init__(self, period, kernel_size=5, stride=3, use_spectral_norm=False):
- super(DiscriminatorP, self).__init__()
- self.period = period
- 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(5, 1), 0))),
- norm_f(Conv2d(32, 128, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(128, 512, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(512, 1024, (kernel_size, 1), (stride, 1), padding=(get_padding(5, 1), 0))),
- norm_f(Conv2d(1024, 1024, (kernel_size, 1), 1, padding=(2, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiPeriodDiscriminator(torch.nn.Module):
- def __init__(self, periods=None):
- super(MultiPeriodDiscriminator, self).__init__()
- self.periods = periods if periods is not None else [2, 3, 5, 7, 11]
- self.discriminators = nn.ModuleList()
- for period in self.periods:
- self.discriminators.append(DiscriminatorP(period))
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-class 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, 128, 15, 1, padding=7)),
- norm_f(Conv1d(128, 128, 41, 2, groups=4, padding=20)),
- norm_f(Conv1d(128, 256, 41, 2, groups=16, padding=20)),
- norm_f(Conv1d(256, 512, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(512, 1024, 41, 4, groups=16, padding=20)),
- norm_f(Conv1d(1024, 1024, 41, 1, groups=16, 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, LRELU_SLOPE)
- fmap.append(x)
- x = self.conv_post(x)
- fmap.append(x)
- x = torch.flatten(x, 1, -1)
-
- return x, fmap
-
-
-class MultiScaleDiscriminator(torch.nn.Module):
- def __init__(self):
- super(MultiScaleDiscriminator, self).__init__()
- self.discriminators = nn.ModuleList([
- DiscriminatorS(use_spectral_norm=True),
- DiscriminatorS(),
- DiscriminatorS(),
- ])
- self.meanpools = nn.ModuleList([
- AvgPool1d(4, 2, padding=2),
- AvgPool1d(4, 2, padding=2)
- ])
-
- def forward(self, y, y_hat):
- y_d_rs = []
- y_d_gs = []
- fmap_rs = []
- fmap_gs = []
- for i, d in enumerate(self.discriminators):
- if i != 0:
- y = self.meanpools[i - 1](y)
- y_hat = self.meanpools[i - 1](y_hat)
- y_d_r, fmap_r = d(y)
- y_d_g, fmap_g = d(y_hat)
- y_d_rs.append(y_d_r)
- fmap_rs.append(fmap_r)
- y_d_gs.append(y_d_g)
- fmap_gs.append(fmap_g)
-
- return y_d_rs, y_d_gs, fmap_rs, fmap_gs
-
-
-def feature_loss(fmap_r, fmap_g):
- loss = 0
- for dr, dg in zip(fmap_r, fmap_g):
- for rl, gl in zip(dr, dg):
- loss += torch.mean(torch.abs(rl - gl))
-
- return loss * 2
-
-
-def discriminator_loss(disc_real_outputs, disc_generated_outputs):
- loss = 0
- r_losses = []
- g_losses = []
- for dr, dg in zip(disc_real_outputs, disc_generated_outputs):
- r_loss = torch.mean((1 - dr) ** 2)
- g_loss = torch.mean(dg ** 2)
- loss += (r_loss + g_loss)
- r_losses.append(r_loss.item())
- g_losses.append(g_loss.item())
-
- return loss, r_losses, g_losses
-
-
-def generator_loss(disc_outputs):
- loss = 0
- gen_losses = []
- for dg in disc_outputs:
- l = torch.mean((1 - dg) ** 2)
- gen_losses.append(l)
- loss += l
-
- return loss, gen_losses
diff --git a/spaces/Mountchicken/MAERec-Gradio/mmocr/engine/hooks/__init__.py b/spaces/Mountchicken/MAERec-Gradio/mmocr/engine/hooks/__init__.py
deleted file mode 100644
index 62d8c9e56449a003b0b8ad186c4c18e4743c0906..0000000000000000000000000000000000000000
--- a/spaces/Mountchicken/MAERec-Gradio/mmocr/engine/hooks/__init__.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-from .visualization_hook import VisualizationHook
-
-__all__ = ['VisualizationHook']
diff --git a/spaces/NAACL2022/CLIP-Caption-Reward/captioning/utils/config.py b/spaces/NAACL2022/CLIP-Caption-Reward/captioning/utils/config.py
deleted file mode 100644
index e42704dcba2fb2f751fec413551a5069e63f25c9..0000000000000000000000000000000000000000
--- a/spaces/NAACL2022/CLIP-Caption-Reward/captioning/utils/config.py
+++ /dev/null
@@ -1,153 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
-# Copy from fvcore
-
-import logging
-import os
-from typing import Any
-import yaml
-from yacs.config import CfgNode as _CfgNode
-
-import io as PathManager
-
-BASE_KEY = "_BASE_"
-
-
-class CfgNode(_CfgNode):
- """
- Our own extended version of :class:`yacs.config.CfgNode`.
- It contains the following extra features:
-
- 1. The :meth:`merge_from_file` method supports the "_BASE_" key,
- which allows the new CfgNode to inherit all the attributes from the
- base configuration file.
- 2. Keys that start with "COMPUTED_" are treated as insertion-only
- "computed" attributes. They can be inserted regardless of whether
- the CfgNode is frozen or not.
- 3. With "allow_unsafe=True", it supports pyyaml tags that evaluate
- expressions in config. See examples in
- https://pyyaml.org/wiki/PyYAMLDocumentation#yaml-tags-and-python-types
- Note that this may lead to arbitrary code execution: you must not
- load a config file from untrusted sources before manually inspecting
- the content of the file.
- """
-
- @staticmethod
- def load_yaml_with_base(filename, allow_unsafe = False):
- """
- Just like `yaml.load(open(filename))`, but inherit attributes from its
- `_BASE_`.
-
- Args:
- filename (str): the file name of the current config. Will be used to
- find the base config file.
- allow_unsafe (bool): whether to allow loading the config file with
- `yaml.unsafe_load`.
-
- Returns:
- (dict): the loaded yaml
- """
- with PathManager.open(filename, "r") as f:
- try:
- cfg = yaml.safe_load(f)
- except yaml.constructor.ConstructorError:
- if not allow_unsafe:
- raise
- logger = logging.getLogger(__name__)
- logger.warning(
- "Loading config {} with yaml.unsafe_load. Your machine may "
- "be at risk if the file contains malicious content.".format(
- filename
- )
- )
- f.close()
- with open(filename, "r") as f:
- cfg = yaml.unsafe_load(f)
-
- def merge_a_into_b(a, b):
- # merge dict a into dict b. values in a will overwrite b.
- for k, v in a.items():
- if isinstance(v, dict) and k in b:
- assert isinstance(
- b[k], dict
- ), "Cannot inherit key '{}' from base!".format(k)
- merge_a_into_b(v, b[k])
- else:
- b[k] = v
-
- if BASE_KEY in cfg:
- base_cfg_file = cfg[BASE_KEY]
- if base_cfg_file.startswith("~"):
- base_cfg_file = os.path.expanduser(base_cfg_file)
- if not any(
- map(base_cfg_file.startswith, ["/", "https://", "http://"])
- ):
- # the path to base cfg is relative to the config file itself.
- base_cfg_file = os.path.join(
- os.path.dirname(filename), base_cfg_file
- )
- base_cfg = CfgNode.load_yaml_with_base(
- base_cfg_file, allow_unsafe=allow_unsafe
- )
- del cfg[BASE_KEY]
-
- merge_a_into_b(cfg, base_cfg)
- return base_cfg
- return cfg
-
- def merge_from_file(self, cfg_filename, allow_unsafe = False):
- """
- Merge configs from a given yaml file.
-
- Args:
- cfg_filename: the file name of the yaml config.
- allow_unsafe: whether to allow loading the config file with
- `yaml.unsafe_load`.
- """
- loaded_cfg = CfgNode.load_yaml_with_base(
- cfg_filename, allow_unsafe=allow_unsafe
- )
- loaded_cfg = type(self)(loaded_cfg)
- self.merge_from_other_cfg(loaded_cfg)
-
- # Forward the following calls to base, but with a check on the BASE_KEY.
- def merge_from_other_cfg(self, cfg_other):
- """
- Args:
- cfg_other (CfgNode): configs to merge from.
- """
- assert (
- BASE_KEY not in cfg_other
- ), "The reserved key '{}' can only be used in files!".format(BASE_KEY)
- return super().merge_from_other_cfg(cfg_other)
-
- def merge_from_list(self, cfg_list):
- """
- Args:
- cfg_list (list): list of configs to merge from.
- """
- keys = set(cfg_list[0::2])
- assert (
- BASE_KEY not in keys
- ), "The reserved key '{}' can only be used in files!".format(BASE_KEY)
- return super().merge_from_list(cfg_list)
-
- def __setattr__(self, name, val):
- if name.startswith("COMPUTED_"):
- if name in self:
- old_val = self[name]
- if old_val == val:
- return
- raise KeyError(
- "Computed attributed '{}' already exists "
- "with a different value! old={}, new={}.".format(
- name, old_val, val
- )
- )
- self[name] = val
- else:
- super().__setattr__(name, val)
-
-
-if __name__ == '__main__':
- cfg = CfgNode.load_yaml_with_base('configs/updown_long.yml')
- print(cfg)
\ No newline at end of file
diff --git a/spaces/NATSpeech/PortaSpeech/README.md b/spaces/NATSpeech/PortaSpeech/README.md
deleted file mode 100644
index 0a0d59e1725b3cc729d096b0f748703baca0ca97..0000000000000000000000000000000000000000
--- a/spaces/NATSpeech/PortaSpeech/README.md
+++ /dev/null
@@ -1,9 +0,0 @@
----
-title: PortaSpeech
-emoji: 🤗
-colorFrom: yellow
-colorTo: orange
-sdk: gradio
-app_file: "inference/tts/gradio/infer.py"
-pinned: false
----
diff --git a/spaces/Niansuh/Image/app.py b/spaces/Niansuh/Image/app.py
deleted file mode 100644
index 095416a1cdd9d973e0fc2833407c6e1022528cdb..0000000000000000000000000000000000000000
--- a/spaces/Niansuh/Image/app.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import gradio as gr
-# import os
-# import sys
-# from pathlib import Path
-import time
-
-models =[
- "digiplay/Pika_v1",
- "digiplay/Realisian_v1",
- "camus-ng/dreambooth_lora_cory_v15",
- "prompthero/openjourney-v4",
- "choozmo/choozmomic",
- "digiplay/fishmix_other_v1",
- "digiplay/BeautyFool_v1.2VAE_pruned",
- "Yacong/lora-gsx-xl",
- "Purukoli/SDXL",
-]
-
-
-model_functions = {}
-model_idx = 1
-for model_path in models:
- try:
- model_functions[model_idx] = gr.Interface.load(f"models/{model_path}", live=False, preprocess=True, postprocess=False)
- except Exception as error:
- def the_fn(txt):
- return None
- model_functions[model_idx] = gr.Interface(fn=the_fn, inputs=["text"], outputs=["image"])
- model_idx+=1
-
-
-def send_it_idx(idx):
- def send_it_fn(prompt):
- output = (model_functions.get(str(idx)) or model_functions.get(str(1)))(prompt)
- return output
- return send_it_fn
-
-def get_prompts(prompt_text):
- return prompt_text
-
-def clear_it(val):
- if int(val) != 0:
- val = 0
- else:
- val = 0
- pass
- return val
-
-def all_task_end(cnt,t_stamp):
- to = t_stamp + 60
- et = time.time()
- if et > to and t_stamp != 0:
- d = gr.update(value=0)
- tog = gr.update(value=1)
- #print(f'to: {to} et: {et}')
- else:
- if cnt != 0:
- d = gr.update(value=et)
- else:
- d = gr.update(value=0)
- tog = gr.update(value=0)
- #print (f'passing: to: {to} et: {et}')
- pass
- return d, tog
-
-def all_task_start():
- print("\n\n\n\n\n\n\n")
- t = time.gmtime()
- t_stamp = time.time()
- current_time = time.strftime("%H:%M:%S", t)
- return gr.update(value=t_stamp), gr.update(value=t_stamp), gr.update(value=0)
-
-def clear_fn():
- nn = len(models)
- return tuple([None, *[None for _ in range(nn)]])
-
-
-
-with gr.Blocks(title="SD Models") as my_interface:
- with gr.Column(scale=12):
- # with gr.Row():
- # gr.Markdown("""- Primary prompt: 你想画的内容(英文单词，如 a cat, 加英文逗号效果更好；点 Improve 按钮进行完善)\n- Real prompt: 完善后的提示词，出现后再点右边的 Run 按钮开始运行""")
- with gr.Row():
- with gr.Row(scale=6):
- primary_prompt=gr.Textbox(label="Prompt", value="")
- # real_prompt=gr.Textbox(label="Real prompt")
- with gr.Row(scale=6):
- # improve_prompts_btn=gr.Button("Improve")
- with gr.Row():
- run=gr.Button("Run",variant="primary")
- clear_btn=gr.Button("Clear")
- with gr.Row():
- sd_outputs = {}
- model_idx = 1
- for model_path in models:
- with gr.Column(scale=3, min_width=320):
- with gr.Box():
- sd_outputs[model_idx] = gr.Image(label=model_path)
- pass
- model_idx += 1
- pass
- pass
-
- with gr.Row(visible=False):
- start_box=gr.Number(interactive=False)
- end_box=gr.Number(interactive=False)
- tog_box=gr.Textbox(value=0,interactive=False)
-
- start_box.change(
- all_task_end,
- [start_box, end_box],
- [start_box, tog_box],
- every=1,
- show_progress=False)
-
- primary_prompt.submit(all_task_start, None, [start_box, end_box, tog_box])
- run.click(all_task_start, None, [start_box, end_box, tog_box])
- runs_dict = {}
- model_idx = 1
- for model_path in models:
- runs_dict[model_idx] = run.click(model_functions[model_idx], inputs=[primary_prompt], outputs=[sd_outputs[model_idx]])
- model_idx += 1
- pass
- pass
-
- # improve_prompts_btn_clicked=improve_prompts_btn.click(
- # get_prompts,
- # inputs=[primary_prompt],
- # outputs=[primary_prompt],
- # cancels=list(runs_dict.values()))
- clear_btn.click(
- clear_fn,
- None,
- [primary_prompt, *list(sd_outputs.values())],
- cancels=[*list(runs_dict.values())])
- tog_box.change(
- clear_it,
- tog_box,
- tog_box,
- cancels=[*list(runs_dict.values())])
-
-my_interface.queue(concurrency_count=600, status_update_rate=1)
-my_interface.launch(inline=True, show_api=False)
-
\ No newline at end of file
diff --git a/spaces/OAOA/DifFace/basicsr/ops/dcn/src/deform_conv_ext.cpp b/spaces/OAOA/DifFace/basicsr/ops/dcn/src/deform_conv_ext.cpp
deleted file mode 100644
index 41c6df6f721bd95a525fd6a03dd9882e863de042..0000000000000000000000000000000000000000
--- a/spaces/OAOA/DifFace/basicsr/ops/dcn/src/deform_conv_ext.cpp
+++ /dev/null
@@ -1,164 +0,0 @@
-// modify from
-// https://github.com/chengdazhi/Deformable-Convolution-V2-PyTorch/blob/mmdetection/mmdet/ops/dcn/src/deform_conv_cuda.c
-
-#include
-#include
-
-#include
-#include
-
-#define WITH_CUDA // always use cuda
-#ifdef WITH_CUDA
-int deform_conv_forward_cuda(at::Tensor input, at::Tensor weight,
- at::Tensor offset, at::Tensor output,
- at::Tensor columns, at::Tensor ones, int kW,
- int kH, int dW, int dH, int padW, int padH,
- int dilationW, int dilationH, int group,
- int deformable_group, int im2col_step);
-
-int deform_conv_backward_input_cuda(at::Tensor input, at::Tensor offset,
- at::Tensor gradOutput, at::Tensor gradInput,
- at::Tensor gradOffset, at::Tensor weight,
- at::Tensor columns, int kW, int kH, int dW,
- int dH, int padW, int padH, int dilationW,
- int dilationH, int group,
- int deformable_group, int im2col_step);
-
-int deform_conv_backward_parameters_cuda(
- at::Tensor input, at::Tensor offset, at::Tensor gradOutput,
- at::Tensor gradWeight, // at::Tensor gradBias,
- at::Tensor columns, at::Tensor ones, int kW, int kH, int dW, int dH,
- int padW, int padH, int dilationW, int dilationH, int group,
- int deformable_group, float scale, int im2col_step);
-
-void modulated_deform_conv_cuda_forward(
- at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
- at::Tensor offset, at::Tensor mask, at::Tensor output, at::Tensor columns,
- int kernel_h, int kernel_w, const int stride_h, const int stride_w,
- const int pad_h, const int pad_w, const int dilation_h,
- const int dilation_w, const int group, const int deformable_group,
- const bool with_bias);
-
-void modulated_deform_conv_cuda_backward(
- at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
- at::Tensor offset, at::Tensor mask, at::Tensor columns,
- at::Tensor grad_input, at::Tensor grad_weight, at::Tensor grad_bias,
- at::Tensor grad_offset, at::Tensor grad_mask, at::Tensor grad_output,
- int kernel_h, int kernel_w, int stride_h, int stride_w, int pad_h,
- int pad_w, int dilation_h, int dilation_w, int group, int deformable_group,
- const bool with_bias);
-#endif
-
-int deform_conv_forward(at::Tensor input, at::Tensor weight,
- at::Tensor offset, at::Tensor output,
- at::Tensor columns, at::Tensor ones, int kW,
- int kH, int dW, int dH, int padW, int padH,
- int dilationW, int dilationH, int group,
- int deformable_group, int im2col_step) {
- if (input.device().is_cuda()) {
-#ifdef WITH_CUDA
- return deform_conv_forward_cuda(input, weight, offset, output, columns,
- ones, kW, kH, dW, dH, padW, padH, dilationW, dilationH, group,
- deformable_group, im2col_step);
-#else
- AT_ERROR("deform conv is not compiled with GPU support");
-#endif
- }
- AT_ERROR("deform conv is not implemented on CPU");
-}
-
-int deform_conv_backward_input(at::Tensor input, at::Tensor offset,
- at::Tensor gradOutput, at::Tensor gradInput,
- at::Tensor gradOffset, at::Tensor weight,
- at::Tensor columns, int kW, int kH, int dW,
- int dH, int padW, int padH, int dilationW,
- int dilationH, int group,
- int deformable_group, int im2col_step) {
- if (input.device().is_cuda()) {
-#ifdef WITH_CUDA
- return deform_conv_backward_input_cuda(input, offset, gradOutput,
- gradInput, gradOffset, weight, columns, kW, kH, dW, dH, padW, padH,
- dilationW, dilationH, group, deformable_group, im2col_step);
-#else
- AT_ERROR("deform conv is not compiled with GPU support");
-#endif
- }
- AT_ERROR("deform conv is not implemented on CPU");
-}
-
-int deform_conv_backward_parameters(
- at::Tensor input, at::Tensor offset, at::Tensor gradOutput,
- at::Tensor gradWeight, // at::Tensor gradBias,
- at::Tensor columns, at::Tensor ones, int kW, int kH, int dW, int dH,
- int padW, int padH, int dilationW, int dilationH, int group,
- int deformable_group, float scale, int im2col_step) {
- if (input.device().is_cuda()) {
-#ifdef WITH_CUDA
- return deform_conv_backward_parameters_cuda(input, offset, gradOutput,
- gradWeight, columns, ones, kW, kH, dW, dH, padW, padH, dilationW,
- dilationH, group, deformable_group, scale, im2col_step);
-#else
- AT_ERROR("deform conv is not compiled with GPU support");
-#endif
- }
- AT_ERROR("deform conv is not implemented on CPU");
-}
-
-void modulated_deform_conv_forward(
- at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
- at::Tensor offset, at::Tensor mask, at::Tensor output, at::Tensor columns,
- int kernel_h, int kernel_w, const int stride_h, const int stride_w,
- const int pad_h, const int pad_w, const int dilation_h,
- const int dilation_w, const int group, const int deformable_group,
- const bool with_bias) {
- if (input.device().is_cuda()) {
-#ifdef WITH_CUDA
- return modulated_deform_conv_cuda_forward(input, weight, bias, ones,
- offset, mask, output, columns, kernel_h, kernel_w, stride_h,
- stride_w, pad_h, pad_w, dilation_h, dilation_w, group,
- deformable_group, with_bias);
-#else
- AT_ERROR("modulated deform conv is not compiled with GPU support");
-#endif
- }
- AT_ERROR("modulated deform conv is not implemented on CPU");
-}
-
-void modulated_deform_conv_backward(
- at::Tensor input, at::Tensor weight, at::Tensor bias, at::Tensor ones,
- at::Tensor offset, at::Tensor mask, at::Tensor columns,
- at::Tensor grad_input, at::Tensor grad_weight, at::Tensor grad_bias,
- at::Tensor grad_offset, at::Tensor grad_mask, at::Tensor grad_output,
- int kernel_h, int kernel_w, int stride_h, int stride_w, int pad_h,
- int pad_w, int dilation_h, int dilation_w, int group, int deformable_group,
- const bool with_bias) {
- if (input.device().is_cuda()) {
-#ifdef WITH_CUDA
- return modulated_deform_conv_cuda_backward(input, weight, bias, ones,
- offset, mask, columns, grad_input, grad_weight, grad_bias, grad_offset,
- grad_mask, grad_output, kernel_h, kernel_w, stride_h, stride_w,
- pad_h, pad_w, dilation_h, dilation_w, group, deformable_group,
- with_bias);
-#else
- AT_ERROR("modulated deform conv is not compiled with GPU support");
-#endif
- }
- AT_ERROR("modulated deform conv is not implemented on CPU");
-}
-
-
-PYBIND11_MODULE(TORCH_EXTENSION_NAME, m) {
- m.def("deform_conv_forward", &deform_conv_forward,
- "deform forward");
- m.def("deform_conv_backward_input", &deform_conv_backward_input,
- "deform_conv_backward_input");
- m.def("deform_conv_backward_parameters",
- &deform_conv_backward_parameters,
- "deform_conv_backward_parameters");
- m.def("modulated_deform_conv_forward",
- &modulated_deform_conv_forward,
- "modulated deform conv forward");
- m.def("modulated_deform_conv_backward",
- &modulated_deform_conv_backward,
- "modulated deform conv backward");
-}
diff --git a/spaces/OFA-Sys/OFA-Generic_Interface/tasks/ofa_task.py b/spaces/OFA-Sys/OFA-Generic_Interface/tasks/ofa_task.py
deleted file mode 100644
index 0cb42c92dbcde85c7290b8c3e6460b5eff06e617..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-Generic_Interface/tasks/ofa_task.py
+++ /dev/null
@@ -1,338 +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 dataclasses import dataclass, field
-import logging
-import os
-import math
-import torch
-from typing import Dict, Optional
-
-from fairseq import search
-from fairseq.data import FairseqDataset, iterators
-from fairseq.optim.amp_optimizer import AMPOptimizer
-from fairseq.dataclass import FairseqDataclass
-from fairseq.tasks import FairseqTask, register_task
-from omegaconf import DictConfig
-
-
-logger = logging.getLogger(__name__)
-
-
-@dataclass
-class OFAConfig(FairseqDataclass):
- data: Optional[str] = field(
- default=None,
- metadata={
- "help": "colon separated path to data directories list, will be iterated upon during epochs "
- "in round-robin manner; however, valid and test data are always in the first directory "
- "to avoid the need for repeating them in all directories"
- },
- )
- selected_cols: Optional[str] = field(
- default=None,
- metadata={"help": "selected cols"},
- )
- bpe_dir: Optional[str] = field(
- default=None,
- metadata={"help": "bpe dir"},
- )
- max_source_positions: int = field(
- default=1024, metadata={"help": "max number of tokens in the source sequence"}
- )
- max_target_positions: int = field(
- default=1024, metadata={"help": "max number of tokens in the target sequence"}
- )
- max_src_length: int = field(
- default=128, metadata={"help": "the maximum src sequence length"}
- )
- max_tgt_length: int = field(
- default=30, metadata={"help": "the maximum target sequence length"}
- )
-
- code_dict_size: int = field(
- default=8192, metadata={"help": "code dict size"}
- )
- patch_image_size: int = field(
- default=480, metadata={"help": "patch image size"}
- )
- num_bins: int = field(
- default=1000, metadata={"help": "number of quantization bins"}
- )
-
- imagenet_default_mean_and_std: bool = field(
- default=False,
- metadata={"help": "imagenet normalize"},
- )
- constraint_range: Optional[str] = field(
- default=None,
- metadata={"help": "constraint range"}
- )
-
-
-@register_task("ofa", dataclass=OFAConfig)
-class OFATask(FairseqTask):
- def __init__(self, cfg: OFAConfig, src_dict, tgt_dict):
- super().__init__(cfg)
- self.src_dict = src_dict
- self.tgt_dict = tgt_dict
-
- @classmethod
- def setup_task(cls, cfg: DictConfig, **kwargs):
- """Setup the task."""
-
- # load dictionaries
- src_dict = cls.load_dictionary(
- os.path.join(cfg.bpe_dir, "dict.txt")
- )
- tgt_dict = cls.load_dictionary(
- os.path.join(cfg.bpe_dir, "dict.txt")
- )
- src_dict.add_symbol("")
- tgt_dict.add_symbol("")
- for i in range(cfg.code_dict_size):
- src_dict.add_symbol("".format(i))
- tgt_dict.add_symbol("".format(i))
- # quantization
- for i in range(cfg.num_bins):
- src_dict.add_symbol("".format(i))
- tgt_dict.add_symbol("".format(i))
-
- logger.info("source dictionary: {} types".format(len(src_dict)))
- logger.info("target dictionary: {} types".format(len(tgt_dict)))
- return cls(cfg, src_dict, tgt_dict)
-
- def get_batch_iterator(
- self,
- dataset,
- max_tokens=None,
- max_sentences=None,
- max_positions=None,
- ignore_invalid_inputs=False,
- required_batch_size_multiple=1,
- seed=1,
- num_shards=1,
- shard_id=0,
- num_workers=0,
- epoch=1,
- data_buffer_size=0,
- disable_iterator_cache=False,
- ):
- assert isinstance(dataset, FairseqDataset)
-
- # initialize the dataset with the correct starting epoch
- dataset.set_epoch(epoch)
-
- # create mini-batches with given size constraints
- batch_sampler = [
- [j for j in range(i, min(i + max_sentences, len(dataset)))]
- for i in range(0, len(dataset), max_sentences)
- ]
- total_row_count = dataset.dataset.get_total_row_count()
- num_batches = math.ceil(math.ceil(total_row_count / num_shards) / max_sentences)
- if len(batch_sampler) < num_batches:
- batch_sampler.append([])
-
- # return a reusable, sharded iterator
- epoch_iter = iterators.EpochBatchIterator(
- dataset=dataset,
- collate_fn=dataset.collater,
- batch_sampler=batch_sampler,
- seed=seed,
- num_shards=1,
- shard_id=0,
- num_workers=num_workers,
- epoch=epoch,
- buffer_size=data_buffer_size
- )
-
- return epoch_iter
-
- def build_model(self, cfg: FairseqDataclass):
- model = super().build_model(cfg)
- bpe_dict = {
- "_name": "gpt2",
- "gpt2_encoder_json": os.path.join(self.cfg.bpe_dir, "encoder.json"),
- "gpt2_vocab_bpe": os.path.join(self.cfg.bpe_dir, "vocab.bpe")
- }
- bpe_dict = DictConfig(bpe_dict)
- self.bpe = self.build_bpe(bpe_dict)
- return model
-
- def build_generator(
- self, models, args, seq_gen_cls=None, extra_gen_cls_kwargs=None, prefix_allowed_tokens_fn=None,
- ):
- """
- Build a :class:`~fairseq.SequenceGenerator` instance for this
- task.
-
- Args:
- models (List[~fairseq.models.FairseqModel]): ensemble of models
- args (fairseq.dataclass.configs.GenerationConfig):
- configuration object (dataclass) for generation
- extra_gen_cls_kwargs (Dict[str, Any]): extra options to pass
- through to SequenceGenerator
- prefix_allowed_tokens_fn (Callable[[int, torch.Tensor], List[int]]):
- If provided, this function constrains the beam search to
- allowed tokens only at each step. The provided function
- should take 2 arguments: the batch ID (`batch_id: int`)
- and a unidimensional tensor of token ids (`inputs_ids:
- torch.Tensor`). It has to return a `List[int]` with the
- allowed tokens for the next generation step conditioned
- on the previously generated tokens (`inputs_ids`) and
- the batch ID (`batch_id`). This argument is useful for
- constrained generation conditioned on the prefix, as
- described in "Autoregressive Entity Retrieval"
- (https://arxiv.org/abs/2010.00904) and
- https://github.com/facebookresearch/GENRE.
- """
- if getattr(args, "score_reference", False):
- from fairseq.sequence_scorer import SequenceScorer
-
- return SequenceScorer(
- self.target_dictionary,
- compute_alignment=getattr(args, "print_alignment", False),
- )
-
- from fairseq.sequence_generator import (
- # SequenceGenerator,
- SequenceGeneratorWithAlignment,
- )
- from models.sequence_generator import SequenceGenerator
-
- # Choose search strategy. Defaults to Beam Search.
- sampling = getattr(args, "sampling", False)
- sampling_topk = getattr(args, "sampling_topk", -1)
- sampling_topp = getattr(args, "sampling_topp", -1.0)
- diverse_beam_groups = getattr(args, "diverse_beam_groups", -1)
- diverse_beam_strength = getattr(args, "diverse_beam_strength", 0.5)
- match_source_len = getattr(args, "match_source_len", False)
- diversity_rate = getattr(args, "diversity_rate", -1)
- constrained = getattr(args, "constraints", False)
- if prefix_allowed_tokens_fn is None:
- prefix_allowed_tokens_fn = getattr(args, "prefix_allowed_tokens_fn", None)
- if (
- sum(
- int(cond)
- for cond in [
- sampling,
- diverse_beam_groups > 0,
- match_source_len,
- diversity_rate > 0,
- ]
- )
- > 1
- ):
- raise ValueError("Provided Search parameters are mutually exclusive.")
- assert sampling_topk < 0 or sampling, "--sampling-topk requires --sampling"
- assert sampling_topp < 0 or sampling, "--sampling-topp requires --sampling"
-
- if sampling:
- search_strategy = search.Sampling(
- self.target_dictionary, sampling_topk, sampling_topp
- )
- elif diverse_beam_groups > 0:
- search_strategy = search.DiverseBeamSearch(
- self.target_dictionary, diverse_beam_groups, diverse_beam_strength
- )
- elif match_source_len:
- # this is useful for tagging applications where the output
- # length should match the input length, so we hardcode the
- # length constraints for simplicity
- search_strategy = search.LengthConstrainedBeamSearch(
- self.target_dictionary,
- min_len_a=1,
- min_len_b=0,
- max_len_a=1,
- max_len_b=0,
- )
- elif diversity_rate > -1:
- search_strategy = search.DiverseSiblingsSearch(
- self.target_dictionary, diversity_rate
- )
- elif constrained:
- search_strategy = search.LexicallyConstrainedBeamSearch(
- self.target_dictionary, args.constraints
- )
- elif prefix_allowed_tokens_fn:
- search_strategy = search.PrefixConstrainedBeamSearch(
- self.target_dictionary, prefix_allowed_tokens_fn
- )
- else:
- search_strategy = search.BeamSearch(self.target_dictionary)
-
- extra_gen_cls_kwargs = extra_gen_cls_kwargs or {}
- if seq_gen_cls is None:
- if getattr(args, "print_alignment", False):
- seq_gen_cls = SequenceGeneratorWithAlignment
- extra_gen_cls_kwargs["print_alignment"] = args.print_alignment
- else:
- seq_gen_cls = SequenceGenerator
-
- return seq_gen_cls(
- models,
- self.target_dictionary,
- beam_size=getattr(args, "beam", 5),
- max_len_a=getattr(args, "max_len_a", 0),
- max_len_b=getattr(args, "max_len_b", 200),
- min_len=getattr(args, "min_len", 1),
- normalize_scores=(not getattr(args, "unnormalized", False)),
- len_penalty=getattr(args, "lenpen", 1),
- unk_penalty=getattr(args, "unkpen", 0),
- temperature=getattr(args, "temperature", 1.0),
- match_source_len=getattr(args, "match_source_len", False),
- no_repeat_ngram_size=getattr(args, "no_repeat_ngram_size", 0),
- search_strategy=search_strategy,
- constraint_range=self.cfg.constraint_range,
- **extra_gen_cls_kwargs,
- )
-
- def train_step(
- self, sample, model, criterion, optimizer, update_num, ignore_grad=False, **extra_kwargs
- ):
- """
- Do forward and backward, and return the loss as computed by *criterion*
- for the given *model* and *sample*.
-
- Args:
- sample (dict): the mini-batch. The format is defined by the
- :class:`~fairseq.data.FairseqDataset`.
- model (~fairseq.models.BaseFairseqModel): the model
- criterion (~fairseq.criterions.FairseqCriterion): the criterion
- optimizer (~fairseq.optim.FairseqOptimizer): the optimizer
- update_num (int): the current update
- ignore_grad (bool): multiply loss by 0 if this is set to True
-
- Returns:
- tuple:
- - the loss
- - the sample size, which is used as the denominator for the
- gradient
- - logging outputs to display while training
- """
- model.train()
- model.set_num_updates(update_num)
- with torch.autograd.profiler.record_function("forward"):
- with torch.cuda.amp.autocast(enabled=(isinstance(optimizer, AMPOptimizer))):
- loss, sample_size, logging_output = criterion(model, sample, update_num=update_num)
- if ignore_grad:
- loss *= 0
- with torch.autograd.profiler.record_function("backward"):
- optimizer.backward(loss)
- return loss, sample_size, logging_output
-
- def max_positions(self):
- """Return the max sentence length allowed by the task."""
- return (self.cfg.max_source_positions, self.cfg.max_target_positions)
-
- @property
- def source_dictionary(self):
- """Return the source :class:`~fairseq.data.Dictionary`."""
- return self.src_dict
-
- @property
- def target_dictionary(self):
- """Return the target :class:`~fairseq.data.Dictionary`."""
- return self.tgt_dict
\ No newline at end of file
diff --git a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py b/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py
deleted file mode 100644
index e7465bc889fd1ba6ca2c60905a2eb6ff5cc62b9d..0000000000000000000000000000000000000000
--- a/spaces/OFA-Sys/OFA-vqa/fairseq/fairseq/models/speech_to_text/modules/augmented_memory_attention.py
+++ /dev/null
@@ -1,488 +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 typing import Tuple, List
-
-import torch
-import torch.nn.functional as F
-from fairseq.models import FairseqEncoder
-from fairseq.models.speech_to_text import (
- ConvTransformerEncoder,
-)
-from fairseq.models.speech_to_text.utils import attention_suppression
-from fairseq.models.speech_to_text.utils import (
- lengths_to_encoder_padding_mask,
- segments_to_sequence,
- sequence_to_segments,
-)
-from fairseq.modules import MultiheadAttention, TransformerEncoderLayer
-from torch import nn, Tensor
-
-# ------------------------------------------------------------------------------
-# AugmentedMemoryConvTransformerEncoder
-# ------------------------------------------------------------------------------
-
-
-class AugmentedMemoryConvTransformerEncoder(ConvTransformerEncoder):
- def __init__(self, args):
- super().__init__(args)
-
- args.encoder_stride = self.stride()
-
- self.left_context = args.left_context // args.encoder_stride
-
- self.right_context = args.right_context // args.encoder_stride
-
- self.left_context_after_stride = args.left_context // args.encoder_stride
- self.right_context_after_stride = args.right_context // args.encoder_stride
-
- self.transformer_layers = nn.ModuleList([])
- self.transformer_layers.extend(
- [
- AugmentedMemoryTransformerEncoderLayer(args)
- for i in range(args.encoder_layers)
- ]
- )
-
- def stride(self):
- # Hard coded here. Should infer from convs in future
- stride = 4
- return stride
-
- def forward(self, src_tokens, src_lengths, states=None):
- """Encode input sequence.
- :param torch.Tensor xs: input tensor
- :param torch.Tensor masks: input mask
- :return: position embedded tensor and mask
- :rtype Tuple[torch.Tensor, torch.Tensor]:
- """
- bsz, max_seq_len, _ = src_tokens.size()
- x = (
- src_tokens.view(bsz, max_seq_len, self.in_channels, self.input_dim)
- .transpose(1, 2)
- .contiguous()
- )
- x = self.conv(x)
- bsz, _, output_seq_len, _ = x.size()
- x = x.transpose(1, 2).transpose(0, 1).contiguous().view(output_seq_len, bsz, -1)
- x = self.out(x)
- x = self.embed_scale * x
-
- subsampling_factor = 1.0 * max_seq_len / output_seq_len
- input_lengths = torch.max(
- (src_lengths.float() / subsampling_factor).ceil().long(),
- x.size(0) * src_lengths.new_ones([src_lengths.size(0)]).long(),
- )
-
- encoder_padding_mask, _ = lengths_to_encoder_padding_mask(
- input_lengths, batch_first=True
- )
-
- # TODO: fix positional embedding
- positions = self.embed_positions(encoder_padding_mask).transpose(0, 1)
-
- x += positions
- x = F.dropout(x, p=self.dropout, training=self.training)
-
- # State to store memory banks etc.
- if states is None:
- states = [
- {"memory_banks": None, "encoder_states": None}
- for i in range(len(self.transformer_layers))
- ]
-
- for i, layer in enumerate(self.transformer_layers):
- # x size:
- # (self.left_size + self.segment_size + self.right_size)
- # / self.stride, num_heads, dim
- # TODO: Consider mask here
- x = layer(x, states[i])
- states[i]["encoder_states"] = x[
- self.left_context_after_stride : -self.right_context_after_stride
- ]
-
- lengths = (
- (
- ~encoder_padding_mask[
- :, self.left_context_after_stride : -self.right_context_after_stride
- ]
- )
- .sum(dim=1, keepdim=True)
- .long()
- )
-
- return states[-1]["encoder_states"], lengths, states
-
-
-# ------------------------------------------------------------------------------
-# AugmentedMemoryTransformerEncoderLayer
-# ------------------------------------------------------------------------------
-class AugmentedMemoryTransformerEncoderLayer(TransformerEncoderLayer):
- def __init__(self, args):
- super().__init__(args)
-
- self.left_context = args.left_context // args.encoder_stride
- self.right_context = args.right_context // args.encoder_stride
-
- def forward(self, x, state):
-
- length, batch_size, x_dim = x.size()
-
- residual = x
-
- if self.normalize_before:
- x = self.self_attn_layer_norm(x)
-
- # init_state
- if state.get("memory_banks", None) is None:
- state["memory_banks"] = []
-
- # TODO reseach new sum_query method
- seg_start = self.left_context
- seg_end = length - self.right_context
- if seg_start < seg_end:
- summarization_query = torch.mean(x[seg_start:seg_end], keepdim=True, dim=0)
- else:
- summarization_query = x.new_zeros(1, batch_size, x_dim)
-
- x = torch.cat([x, summarization_query], dim=0)
-
- x = self.self_attn(input_and_summary=x, state=state)
-
- x = self.dropout_module(x)
- x = residual + x
-
- if not self.normalize_before:
- x = self.self_attn_layer_norm(x)
-
- residual = x
- if self.normalize_before:
- x = self.final_layer_norm(x)
-
- x = self.activation_fn(self.fc1(x))
- x = self.activation_dropout_module(x)
- x = self.fc2(x)
- x = self.dropout_module(x)
- x = residual + x
- if not self.normalize_before:
- x = self.final_layer_norm(x)
-
- return x
-
- def build_self_attention(self, embed_dim, args):
- return AugmentedMemoryMultiheadAttention(
- embed_dim=embed_dim,
- num_heads=args.encoder_attention_heads,
- dropout=args.attention_dropout,
- self_attention=True,
- q_noise=self.quant_noise,
- qn_block_size=self.quant_noise_block_size,
- tanh_on_mem=True,
- max_memory_size=args.max_memory_size,
- )
-
-
-# ------------------------------------------------------------------------------
-# AugmentedMemoryMultiheadAttention
-# ------------------------------------------------------------------------------
-class AugmentedMemoryMultiheadAttention(MultiheadAttention):
- """
- Augmented Memory Attention from
- Streaming Transformer-based Acoustic Models
- Using Self-attention with Augmented Memory
- https://arxiv.org/abs/2005.08042
- """
-
- def __init__(
- self,
- embed_dim,
- num_heads,
- kdim=None,
- vdim=None,
- dropout=0.0,
- bias=True,
- add_bias_kv=False,
- add_zero_attn=False,
- self_attention=False,
- encoder_decoder_attention=False,
- q_noise=0.0,
- qn_block_size=8,
- tanh_on_mem=False,
- memory_dim=None,
- std_scale=0.5, # 0.5 based on https://arxiv.org/abs/2005.09137
- max_memory_size=-1,
- disable_mem_on_mem_attn=True,
- ):
- super().__init__(
- embed_dim,
- num_heads,
- kdim,
- vdim,
- dropout,
- bias,
- add_bias_kv,
- add_zero_attn,
- self_attention,
- encoder_decoder_attention,
- q_noise,
- qn_block_size,
- )
-
- self.memory_dim = memory_dim if memory_dim is not None else embed_dim
- self.std_scale = std_scale
- self.disable_mem_on_mem_attn = disable_mem_on_mem_attn
-
- # This Operator was used for factorization in PySpeech
- self.v2e = lambda x: x
-
- if tanh_on_mem:
- self.squash_mem = torch.tanh
- self.nonlinear_squash_mem = True
- else:
- self.squash_mem = lambda x: x
- self.nonlinear_squash_mem = False
-
- self.max_memory_size = max_memory_size
-
- def forward(self, input_and_summary, state):
- """
- input: Encoder states of current segment with left or right context,
- plus one summarization query
-
- """
-
- length, batch_size, _ = input_and_summary.shape
- length = length - 1 # not include sum_query, last index
-
- memory = state["memory_banks"]
- # TODO: positional embedding on memory
-
- if self.max_memory_size > -1 and len(memory) > self.max_memory_size:
- # TODO: need to fix here
- if self.max_memory_size == 0:
- memory = memory.new_zeros(1, memory.size(1), self.memory_dim)
- else:
- memory = memory[-self.max_memory_size :]
-
- memory_and_input = torch.cat(memory + [input_and_summary[:-1]], dim=0)
- input_and_sum_query = input_and_summary
-
- q = self.q_proj(self.v2e(input_and_sum_query))
- k = self.k_proj(self.v2e(memory_and_input))
- v = self.v_proj(self.v2e(memory_and_input))
-
- q = (
- q.contiguous()
- .view(-1, batch_size * self.num_heads, self.head_dim)
- .transpose(0, 1)
- * self.scaling
- )
- k = (
- k.contiguous()
- .view(-1, batch_size * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
-
- v = (
- v.contiguous()
- .view(-1, batch_size * self.num_heads, self.head_dim)
- .transpose(0, 1)
- )
-
- attention_weights = torch.bmm(q, k.transpose(1, 2))
-
- if self.disable_mem_on_mem_attn:
- attention_weights = self.suppress_mem_on_mem_attention(
- batch_size, self.num_heads, len(memory), attention_weights
- )
-
- if self.std_scale is not None:
- attention_weights = attention_suppression(attention_weights, self.std_scale)
-
- assert list(attention_weights.shape) == [
- batch_size * self.num_heads,
- length + 1,
- length + len(memory),
- ]
-
- attention_weights = torch.nn.functional.softmax(
- attention_weights.float(), dim=-1
- ).type_as(attention_weights)
-
- attention_probs = self.dropout_module(attention_weights)
-
- # [T, T, B, n_head] + [T, B, n_head, d_head] -> [T, B, n_head, d_head]
- attention = torch.bmm(attention_probs, v)
-
- assert list(attention.shape) == [
- batch_size * self.num_heads,
- length + 1,
- self.head_dim,
- ]
-
- attention = (
- attention.transpose(0, 1)
- .contiguous()
- .view(length + 1, batch_size, self.embed_dim)
- )
-
- output_and_memory = self.out_proj(attention)
-
- next_m = output_and_memory[-1:]
- next_m = self.squash_mem(next_m)
- output = output_and_memory[:-1]
-
- state["memory_banks"].append(next_m)
-
- return output
-
- def suppress_mem_on_mem_attention(
- self, B: int, num_heads: int, mem_size: int, attention_weight: Tensor
- ):
- """
- Arguments:
- - B: batch size
- - num_heads: number of attention heads
- - mem_size: size of memory bank
- - attention_weight: a [B*num_heads, T + 1, T + mem_size] vector
-
- Return:
- modified attention_weight with [B*num_heads, -1, :mem_size] = -inf
- """
- attention_weight[:, -1, :mem_size] = float("-inf")
- return attention_weight
-
-
-# ------------------------------------------------------------------------------
-# SequenceEncoder
-# ------------------------------------------------------------------------------
-class SequenceEncoder(FairseqEncoder):
- """
- SequenceEncoder encodes sequences.
-
- More specifically, `src_tokens` and `src_lengths` in `forward()` should
- describe a batch of "complete" sequences rather than segments.
-
- Segment-by-segment inference can be triggered by `segment_size`:
- 1) `segment_size` is None:
- SequenceEncoder treats the input sequence as one single segment.
- 2) `segment_size` is not None (some int instead):
- SequenceEncoder does the following:
- 1. breaks the input sequence into several segments
- 2. inference on each segment and collect the outputs
- 3. concatanete segment outputs into the output sequence.
- Note that `segment_size` here shouldn't include additional left/right
- contexts needed, for example if we wish to infer with LC-BLSTM where the
- middle chunk size is 100 and right context is 20, `segment_size` should be
- 100.
- """
-
- def __init__(self, args, module):
- super().__init__(None)
-
- self.module = module
- self.input_time_axis = 1
- self.output_time_axis = 0
- self.segment_size = args.segment_size
- self.left_context = args.left_context
- self.right_context = args.right_context
-
- def forward(
- self,
- src_tokens: Tensor,
- src_lengths: Tensor,
- states=None,
- ):
-
- seg_src_tokens_lengths = sequence_to_segments(
- sequence=src_tokens,
- time_axis=self.input_time_axis,
- lengths=src_lengths,
- segment_size=self.segment_size,
- extra_left_context=self.left_context,
- extra_right_context=self.right_context,
- )
-
- seg_encoder_states_lengths: List[Tuple[Tensor, Tensor]] = []
-
- for seg_src_tokens, seg_src_lengths in seg_src_tokens_lengths:
- (seg_encoder_states, seg_enc_lengths, states) = self.module(
- seg_src_tokens,
- seg_src_lengths,
- states=states,
- )
-
- seg_encoder_states_lengths.append((seg_encoder_states, seg_enc_lengths))
-
- encoder_out, enc_lengths = segments_to_sequence(
- segments=seg_encoder_states_lengths, time_axis=self.output_time_axis
- )
-
- encoder_padding_mask, _ = lengths_to_encoder_padding_mask(
- enc_lengths, batch_first=True
- )
-
- if not encoder_padding_mask.any():
- encoder_padding_mask = None
-
- return {
- "encoder_out": [encoder_out],
- "encoder_padding_mask": [encoder_padding_mask],
- "encoder_embedding": [],
- "encoder_states": [states],
- "src_tokens": [],
- "src_lengths": [],
- }
-
- def incremental_encode(
- self,
- seg_src_tokens: Tensor,
- seg_src_lengths: Tensor,
- states=None,
- ):
- """
- Different from forward function, this function takes segmented speech
- as input, and append encoder states to previous states
- """
- (seg_encoder_states, seg_enc_lengths, states) = self.module(
- seg_src_tokens,
- seg_src_lengths,
- states=states,
- )
- return seg_encoder_states, seg_enc_lengths, states
-
-
-# ------------------------------------------------------------------------------
-# Augmented memory model decorator
-# ------------------------------------------------------------------------------
-def augmented_memory(klass):
- class StreamSeq2SeqModel(klass):
- @staticmethod
- def add_args(parser):
- super(StreamSeq2SeqModel, StreamSeq2SeqModel).add_args(parser)
- parser.add_argument(
- "--segment-size", type=int, required=True, help="Length of the segment."
- )
- parser.add_argument(
- "--left-context",
- type=int,
- default=0,
- help="Left context for the segment.",
- )
- parser.add_argument(
- "--right-context",
- type=int,
- default=0,
- help="Right context for the segment.",
- )
- parser.add_argument(
- "--max-memory-size",
- type=int,
- default=-1,
- help="Right context for the segment.",
- )
-
- StreamSeq2SeqModel.__name__ = klass.__name__
- return StreamSeq2SeqModel
diff --git a/spaces/OIUGLK/bingo/src/components/ui/codeblock.tsx b/spaces/OIUGLK/bingo/src/components/ui/codeblock.tsx
deleted file mode 100644
index aabda4e3b59f4e36b6ab79feb19d8d18b70e881b..0000000000000000000000000000000000000000
--- a/spaces/OIUGLK/bingo/src/components/ui/codeblock.tsx
+++ /dev/null
@@ -1,142 +0,0 @@
-'use client'
-
-import { FC, memo } from 'react'
-import { Prism as SyntaxHighlighter } from 'react-syntax-highlighter'
-import { coldarkDark } from 'react-syntax-highlighter/dist/cjs/styles/prism'
-
-import { useCopyToClipboard } from '@/lib/hooks/use-copy-to-clipboard'
-import { IconCheck, IconCopy, IconDownload } from '@/components/ui/icons'
-import { Button } from '@/components/ui/button'
-
-interface Props {
- language: string
- value: string
-}
-
-interface languageMap {
- [key: string]: string | undefined
-}
-
-export const programmingLanguages: languageMap = {
- javascript: '.js',
- python: '.py',
- java: '.java',
- c: '.c',
- cpp: '.cpp',
- 'c++': '.cpp',
- 'c#': '.cs',
- ruby: '.rb',
- php: '.php',
- swift: '.swift',
- 'objective-c': '.m',
- kotlin: '.kt',
- typescript: '.ts',
- go: '.go',
- perl: '.pl',
- rust: '.rs',
- scala: '.scala',
- haskell: '.hs',
- lua: '.lua',
- shell: '.sh',
- sql: '.sql',
- html: '.html',
- css: '.css'
- // add more file extensions here, make sure the key is same as language prop in CodeBlock.tsx component
-}
-
-export const generateRandomString = (length: number, lowercase = false) => {
- const chars = 'ABCDEFGHJKLMNPQRSTUVWXY3456789' // excluding similar looking characters like Z, 2, I, 1, O, 0
- let result = ''
- for (let i = 0; i < length; i++) {
- result += chars.charAt(Math.floor(Math.random() * chars.length))
- }
- return lowercase ? result.toLowerCase() : result
-}
-
-const CodeBlock: FC = memo(({ language, value }) => {
- const { isCopied, copyToClipboard } = useCopyToClipboard({ timeout: 2000 })
-
- const downloadAsFile = () => {
- if (typeof window === 'undefined') {
- return
- }
- const fileExtension = programmingLanguages[language] || '.file'
- const suggestedFileName = `file-${generateRandomString(
- 3,
- true
- )}${fileExtension}`
- const fileName = window.prompt('Enter file name' || '', suggestedFileName)
-
- if (!fileName) {
- // User pressed cancel on prompt.
- return
- }
-
- const blob = new Blob([value], { type: 'text/plain' })
- const url = URL.createObjectURL(blob)
- const link = document.createElement('a')
- link.download = fileName
- link.href = url
- link.style.display = 'none'
- document.body.appendChild(link)
- link.click()
- document.body.removeChild(link)
- URL.revokeObjectURL(url)
- }
-
- const onCopy = () => {
- if (isCopied) return
- copyToClipboard(value)
- }
-
- return (
-
-
-
{language}
-
-
- Download
-
-
- {isCopied ? Copy code
-
-
-
-
- {value}
-
-
-
-
-
-
{label_name}
-
-
- {percentage_score}%
-
-
-
-
{label_desc}
-
-
- {heading}
-
- {LABEL_BARS}
-
"
- msg = (
- # Mark this as a unicode string to prevent
- # "UnicodeEncodeError: 'ascii' codec can't encode character"
- # in Python 2 when the reason contains non-ascii characters.
- "The candidate selected for download or install is a "
- "yanked version: {candidate}\n"
- "Reason for being yanked: {reason}"
- ).format(candidate=best_candidate, reason=reason)
- logger.warning(msg)
-
- return link
-
- def _populate_link(self, req: InstallRequirement) -> None:
- """Ensure that if a link can be found for this, that it is found.
-
- Note that req.link may still be None - if the requirement is already
- installed and not needed to be upgraded based on the return value of
- _is_upgrade_allowed().
-
- If preparer.require_hashes is True, don't use the wheel cache, because
- cached wheels, always built locally, have different hashes than the
- files downloaded from the index server and thus throw false hash
- mismatches. Furthermore, cached wheels at present have undeterministic
- contents due to file modification times.
- """
- if req.link is None:
- req.link = self._find_requirement_link(req)
-
- if self.wheel_cache is None or self.preparer.require_hashes:
- return
- cache_entry = self.wheel_cache.get_cache_entry(
- link=req.link,
- package_name=req.name,
- supported_tags=get_supported(),
- )
- if cache_entry is not None:
- logger.debug("Using cached wheel link: %s", cache_entry.link)
- if req.link is req.original_link and cache_entry.persistent:
- req.original_link_is_in_wheel_cache = True
- if cache_entry.origin is not None:
- req.download_info = cache_entry.origin
- else:
- # Legacy cache entry that does not have origin.json.
- # download_info may miss the archive_info.hash field.
- req.download_info = direct_url_from_link(
- req.link, link_is_in_wheel_cache=cache_entry.persistent
- )
- req.link = cache_entry.link
-
- def _get_dist_for(self, req: InstallRequirement) -> BaseDistribution:
- """Takes a InstallRequirement and returns a single AbstractDist \
- representing a prepared variant of the same.
- """
- if req.editable:
- return self.preparer.prepare_editable_requirement(req)
-
- # satisfied_by is only evaluated by calling _check_skip_installed,
- # so it must be None here.
- assert req.satisfied_by is None
- skip_reason = self._check_skip_installed(req)
-
- if req.satisfied_by:
- return self.preparer.prepare_installed_requirement(req, skip_reason)
-
- # We eagerly populate the link, since that's our "legacy" behavior.
- self._populate_link(req)
- dist = self.preparer.prepare_linked_requirement(req)
-
- # NOTE
- # The following portion is for determining if a certain package is
- # going to be re-installed/upgraded or not and reporting to the user.
- # This should probably get cleaned up in a future refactor.
-
- # req.req is only avail after unpack for URL
- # pkgs repeat check_if_exists to uninstall-on-upgrade
- # (#14)
- if not self.ignore_installed:
- req.check_if_exists(self.use_user_site)
-
- if req.satisfied_by:
- should_modify = (
- self.upgrade_strategy != "to-satisfy-only"
- or self.force_reinstall
- or self.ignore_installed
- or req.link.scheme == "file"
- )
- if should_modify:
- self._set_req_to_reinstall(req)
- else:
- logger.info(
- "Requirement already satisfied (use --upgrade to upgrade): %s",
- req,
- )
- return dist
-
- def _resolve_one(
- self,
- requirement_set: RequirementSet,
- req_to_install: InstallRequirement,
- ) -> List[InstallRequirement]:
- """Prepare a single requirements file.
-
- :return: A list of additional InstallRequirements to also install.
- """
- # Tell user what we are doing for this requirement:
- # obtain (editable), skipping, processing (local url), collecting
- # (remote url or package name)
- if req_to_install.constraint or req_to_install.prepared:
- return []
-
- req_to_install.prepared = True
-
- # Parse and return dependencies
- dist = self._get_dist_for(req_to_install)
- # This will raise UnsupportedPythonVersion if the given Python
- # version isn't compatible with the distribution's Requires-Python.
- _check_dist_requires_python(
- dist,
- version_info=self._py_version_info,
- ignore_requires_python=self.ignore_requires_python,
- )
-
- more_reqs: List[InstallRequirement] = []
-
- def add_req(subreq: Requirement, extras_requested: Iterable[str]) -> None:
- # This idiosyncratically converts the Requirement to str and let
- # make_install_req then parse it again into Requirement. But this is
- # the legacy resolver so I'm just not going to bother refactoring.
- sub_install_req = self._make_install_req(str(subreq), req_to_install)
- parent_req_name = req_to_install.name
- to_scan_again, add_to_parent = self._add_requirement_to_set(
- requirement_set,
- sub_install_req,
- parent_req_name=parent_req_name,
- extras_requested=extras_requested,
- )
- if parent_req_name and add_to_parent:
- self._discovered_dependencies[parent_req_name].append(add_to_parent)
- more_reqs.extend(to_scan_again)
-
- with indent_log():
- # We add req_to_install before its dependencies, so that we
- # can refer to it when adding dependencies.
- if not requirement_set.has_requirement(req_to_install.name):
- # 'unnamed' requirements will get added here
- # 'unnamed' requirements can only come from being directly
- # provided by the user.
- assert req_to_install.user_supplied
- self._add_requirement_to_set(
- requirement_set, req_to_install, parent_req_name=None
- )
-
- if not self.ignore_dependencies:
- if req_to_install.extras:
- logger.debug(
- "Installing extra requirements: %r",
- ",".join(req_to_install.extras),
- )
- missing_requested = sorted(
- set(req_to_install.extras) - set(dist.iter_provided_extras())
- )
- for missing in missing_requested:
- logger.warning(
- "%s %s does not provide the extra '%s'",
- dist.raw_name,
- dist.version,
- missing,
- )
-
- available_requested = sorted(
- set(dist.iter_provided_extras()) & set(req_to_install.extras)
- )
- for subreq in dist.iter_dependencies(available_requested):
- add_req(subreq, extras_requested=available_requested)
-
- return more_reqs
-
- def get_installation_order(
- self, req_set: RequirementSet
- ) -> List[InstallRequirement]:
- """Create the installation order.
-
- The installation order is topological - requirements are installed
- before the requiring thing. We break cycles at an arbitrary point,
- and make no other guarantees.
- """
- # The current implementation, which we may change at any point
- # installs the user specified things in the order given, except when
- # dependencies must come earlier to achieve topological order.
- order = []
- ordered_reqs: Set[InstallRequirement] = set()
-
- def schedule(req: InstallRequirement) -> None:
- if req.satisfied_by or req in ordered_reqs:
- return
- if req.constraint:
- return
- ordered_reqs.add(req)
- for dep in self._discovered_dependencies[req.name]:
- schedule(dep)
- order.append(req)
-
- for install_req in req_set.requirements.values():
- schedule(install_req)
- return order
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/default_styles.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/default_styles.py
deleted file mode 100644
index 46e9ea52c54d067db5fba0ae0e9af34d910417a3..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pip/_vendor/rich/default_styles.py
+++ /dev/null
@@ -1,188 +0,0 @@
-from typing import Dict
-
-from .style import Style
-
-DEFAULT_STYLES: Dict[str, Style] = {
- "none": Style.null(),
- "reset": Style(
- color="default",
- bgcolor="default",
- dim=False,
- bold=False,
- italic=False,
- underline=False,
- blink=False,
- blink2=False,
- reverse=False,
- conceal=False,
- strike=False,
- ),
- "dim": Style(dim=True),
- "bright": Style(dim=False),
- "bold": Style(bold=True),
- "strong": Style(bold=True),
- "code": Style(reverse=True, bold=True),
- "italic": Style(italic=True),
- "emphasize": Style(italic=True),
- "underline": Style(underline=True),
- "blink": Style(blink=True),
- "blink2": Style(blink2=True),
- "reverse": Style(reverse=True),
- "strike": Style(strike=True),
- "black": Style(color="black"),
- "red": Style(color="red"),
- "green": Style(color="green"),
- "yellow": Style(color="yellow"),
- "magenta": Style(color="magenta"),
- "cyan": Style(color="cyan"),
- "white": Style(color="white"),
- "inspect.attr": Style(color="yellow", italic=True),
- "inspect.attr.dunder": Style(color="yellow", italic=True, dim=True),
- "inspect.callable": Style(bold=True, color="red"),
- "inspect.async_def": Style(italic=True, color="bright_cyan"),
- "inspect.def": Style(italic=True, color="bright_cyan"),
- "inspect.class": Style(italic=True, color="bright_cyan"),
- "inspect.error": Style(bold=True, color="red"),
- "inspect.equals": Style(),
- "inspect.help": Style(color="cyan"),
- "inspect.doc": Style(dim=True),
- "inspect.value.border": Style(color="green"),
- "live.ellipsis": Style(bold=True, color="red"),
- "layout.tree.row": Style(dim=False, color="red"),
- "layout.tree.column": Style(dim=False, color="blue"),
- "logging.keyword": Style(bold=True, color="yellow"),
- "logging.level.notset": Style(dim=True),
- "logging.level.debug": Style(color="green"),
- "logging.level.info": Style(color="blue"),
- "logging.level.warning": Style(color="red"),
- "logging.level.error": Style(color="red", bold=True),
- "logging.level.critical": Style(color="red", bold=True, reverse=True),
- "log.level": Style.null(),
- "log.time": Style(color="cyan", dim=True),
- "log.message": Style.null(),
- "log.path": Style(dim=True),
- "repr.ellipsis": Style(color="yellow"),
- "repr.indent": Style(color="green", dim=True),
- "repr.error": Style(color="red", bold=True),
- "repr.str": Style(color="green", italic=False, bold=False),
- "repr.brace": Style(bold=True),
- "repr.comma": Style(bold=True),
- "repr.ipv4": Style(bold=True, color="bright_green"),
- "repr.ipv6": Style(bold=True, color="bright_green"),
- "repr.eui48": Style(bold=True, color="bright_green"),
- "repr.eui64": Style(bold=True, color="bright_green"),
- "repr.tag_start": Style(bold=True),
- "repr.tag_name": Style(color="bright_magenta", bold=True),
- "repr.tag_contents": Style(color="default"),
- "repr.tag_end": Style(bold=True),
- "repr.attrib_name": Style(color="yellow", italic=False),
- "repr.attrib_equal": Style(bold=True),
- "repr.attrib_value": Style(color="magenta", italic=False),
- "repr.number": Style(color="cyan", bold=True, italic=False),
- "repr.number_complex": Style(color="cyan", bold=True, italic=False), # same
- "repr.bool_true": Style(color="bright_green", italic=True),
- "repr.bool_false": Style(color="bright_red", italic=True),
- "repr.none": Style(color="magenta", italic=True),
- "repr.url": Style(underline=True, color="bright_blue", italic=False, bold=False),
- "repr.uuid": Style(color="bright_yellow", bold=False),
- "repr.call": Style(color="magenta", bold=True),
- "repr.path": Style(color="magenta"),
- "repr.filename": Style(color="bright_magenta"),
- "rule.line": Style(color="bright_green"),
- "rule.text": Style.null(),
- "json.brace": Style(bold=True),
- "json.bool_true": Style(color="bright_green", italic=True),
- "json.bool_false": Style(color="bright_red", italic=True),
- "json.null": Style(color="magenta", italic=True),
- "json.number": Style(color="cyan", bold=True, italic=False),
- "json.str": Style(color="green", italic=False, bold=False),
- "json.key": Style(color="blue", bold=True),
- "prompt": Style.null(),
- "prompt.choices": Style(color="magenta", bold=True),
- "prompt.default": Style(color="cyan", bold=True),
- "prompt.invalid": Style(color="red"),
- "prompt.invalid.choice": Style(color="red"),
- "pretty": Style.null(),
- "scope.border": Style(color="blue"),
- "scope.key": Style(color="yellow", italic=True),
- "scope.key.special": Style(color="yellow", italic=True, dim=True),
- "scope.equals": Style(color="red"),
- "table.header": Style(bold=True),
- "table.footer": Style(bold=True),
- "table.cell": Style.null(),
- "table.title": Style(italic=True),
- "table.caption": Style(italic=True, dim=True),
- "traceback.error": Style(color="red", italic=True),
- "traceback.border.syntax_error": Style(color="bright_red"),
- "traceback.border": Style(color="red"),
- "traceback.text": Style.null(),
- "traceback.title": Style(color="red", bold=True),
- "traceback.exc_type": Style(color="bright_red", bold=True),
- "traceback.exc_value": Style.null(),
- "traceback.offset": Style(color="bright_red", bold=True),
- "bar.back": Style(color="grey23"),
- "bar.complete": Style(color="rgb(249,38,114)"),
- "bar.finished": Style(color="rgb(114,156,31)"),
- "bar.pulse": Style(color="rgb(249,38,114)"),
- "progress.description": Style.null(),
- "progress.filesize": Style(color="green"),
- "progress.filesize.total": Style(color="green"),
- "progress.download": Style(color="green"),
- "progress.elapsed": Style(color="yellow"),
- "progress.percentage": Style(color="magenta"),
- "progress.remaining": Style(color="cyan"),
- "progress.data.speed": Style(color="red"),
- "progress.spinner": Style(color="green"),
- "status.spinner": Style(color="green"),
- "tree": Style(),
- "tree.line": Style(),
- "markdown.paragraph": Style(),
- "markdown.text": Style(),
- "markdown.emph": Style(italic=True),
- "markdown.strong": Style(bold=True),
- "markdown.code": Style(bgcolor="black", color="bright_white"),
- "markdown.code_block": Style(dim=True, color="cyan", bgcolor="black"),
- "markdown.block_quote": Style(color="magenta"),
- "markdown.list": Style(color="cyan"),
- "markdown.item": Style(),
- "markdown.item.bullet": Style(color="yellow", bold=True),
- "markdown.item.number": Style(color="yellow", bold=True),
- "markdown.hr": Style(color="yellow"),
- "markdown.h1.border": Style(),
- "markdown.h1": Style(bold=True),
- "markdown.h2": Style(bold=True, underline=True),
- "markdown.h3": Style(bold=True),
- "markdown.h4": Style(bold=True, dim=True),
- "markdown.h5": Style(underline=True),
- "markdown.h6": Style(italic=True),
- "markdown.h7": Style(italic=True, dim=True),
- "markdown.link": Style(color="bright_blue"),
- "markdown.link_url": Style(color="blue"),
- "iso8601.date": Style(color="blue"),
- "iso8601.time": Style(color="magenta"),
- "iso8601.timezone": Style(color="yellow"),
-}
-
-
-if __name__ == "__main__": # pragma: no cover
- import argparse
- import io
-
- from pip._vendor.rich.console import Console
- from pip._vendor.rich.table import Table
- from pip._vendor.rich.text import Text
-
- parser = argparse.ArgumentParser()
- parser.add_argument("--html", action="store_true", help="Export as HTML table")
- args = parser.parse_args()
- html: bool = args.html
- console = Console(record=True, width=70, file=io.StringIO()) if html else Console()
-
- table = Table("Name", "Styling")
-
- for style_name, style in DEFAULT_STYLES.items():
- table.add_row(Text(style_name, style=style), str(style))
-
- console.print(table)
- if html:
- print(console.export_html(inline_styles=True))
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pkg_resources/_vendor/packaging/_structures.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pkg_resources/_vendor/packaging/_structures.py
deleted file mode 100644
index 90a6465f9682c886363eea5327dac64bf623a6ff..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/pkg_resources/_vendor/packaging/_structures.py
+++ /dev/null
@@ -1,61 +0,0 @@
-# This file is dual licensed under the terms of the Apache License, Version
-# 2.0, and the BSD License. See the LICENSE file in the root of this repository
-# for complete details.
-
-
-class InfinityType:
- def __repr__(self) -> str:
- return "Infinity"
-
- def __hash__(self) -> int:
- return hash(repr(self))
-
- def __lt__(self, other: object) -> bool:
- return False
-
- def __le__(self, other: object) -> bool:
- return False
-
- def __eq__(self, other: object) -> bool:
- return isinstance(other, self.__class__)
-
- def __gt__(self, other: object) -> bool:
- return True
-
- def __ge__(self, other: object) -> bool:
- return True
-
- def __neg__(self: object) -> "NegativeInfinityType":
- return NegativeInfinity
-
-
-Infinity = InfinityType()
-
-
-class NegativeInfinityType:
- def __repr__(self) -> str:
- return "-Infinity"
-
- def __hash__(self) -> int:
- return hash(repr(self))
-
- def __lt__(self, other: object) -> bool:
- return True
-
- def __le__(self, other: object) -> bool:
- return True
-
- def __eq__(self, other: object) -> bool:
- return isinstance(other, self.__class__)
-
- def __gt__(self, other: object) -> bool:
- return False
-
- def __ge__(self, other: object) -> bool:
- return False
-
- def __neg__(self: object) -> InfinityType:
- return Infinity
-
-
-NegativeInfinity = NegativeInfinityType()
diff --git a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/config/setupcfg.py b/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/config/setupcfg.py
deleted file mode 100644
index c2a974de6368c9f4f9b9943c94a457227370f143..0000000000000000000000000000000000000000
--- a/spaces/Raspberry-ai/main/.env/lib/python3.11/site-packages/setuptools/config/setupcfg.py
+++ /dev/null
@@ -1,762 +0,0 @@
-"""
-Load setuptools configuration from ``setup.cfg`` files.
-
-**API will be made private in the future**
-"""
-import os
-
-import contextlib
-import functools
-import warnings
-from collections import defaultdict
-from functools import partial
-from functools import wraps
-from typing import (TYPE_CHECKING, Callable, Any, Dict, Generic, Iterable, List,
- Optional, Tuple, TypeVar, Union)
-
-from distutils.errors import DistutilsOptionError, DistutilsFileError
-from setuptools.extern.packaging.requirements import Requirement, InvalidRequirement
-from setuptools.extern.packaging.version import Version, InvalidVersion
-from setuptools.extern.packaging.specifiers import SpecifierSet
-from setuptools._deprecation_warning import SetuptoolsDeprecationWarning
-
-from . import expand
-
-if TYPE_CHECKING:
- from setuptools.dist import Distribution # noqa
- from distutils.dist import DistributionMetadata # noqa
-
-_Path = Union[str, os.PathLike]
-SingleCommandOptions = Dict["str", Tuple["str", Any]]
-"""Dict that associate the name of the options of a particular command to a
-tuple. The first element of the tuple indicates the origin of the option value
-(e.g. the name of the configuration file where it was read from),
-while the second element of the tuple is the option value itself
-"""
-AllCommandOptions = Dict["str", SingleCommandOptions] # cmd name => its options
-Target = TypeVar("Target", bound=Union["Distribution", "DistributionMetadata"])
-
-
-def read_configuration(
- filepath: _Path,
- find_others=False,
- ignore_option_errors=False
-) -> dict:
- """Read given configuration file and returns options from it as a dict.
-
- :param str|unicode filepath: Path to configuration file
- to get options from.
-
- :param bool find_others: Whether to search for other configuration files
- which could be on in various places.
-
- :param bool ignore_option_errors: Whether to silently ignore
- options, values of which could not be resolved (e.g. due to exceptions
- in directives such as file:, attr:, etc.).
- If False exceptions are propagated as expected.
-
- :rtype: dict
- """
- from setuptools.dist import Distribution
-
- dist = Distribution()
- filenames = dist.find_config_files() if find_others else []
- handlers = _apply(dist, filepath, filenames, ignore_option_errors)
- return configuration_to_dict(handlers)
-
-
-def apply_configuration(dist: "Distribution", filepath: _Path) -> "Distribution":
- """Apply the configuration from a ``setup.cfg`` file into an existing
- distribution object.
- """
- _apply(dist, filepath)
- dist._finalize_requires()
- return dist
-
-
-def _apply(
- dist: "Distribution", filepath: _Path,
- other_files: Iterable[_Path] = (),
- ignore_option_errors: bool = False,
-) -> Tuple["ConfigHandler", ...]:
- """Read configuration from ``filepath`` and applies to the ``dist`` object."""
- from setuptools.dist import _Distribution
-
- filepath = os.path.abspath(filepath)
-
- if not os.path.isfile(filepath):
- raise DistutilsFileError('Configuration file %s does not exist.' % filepath)
-
- current_directory = os.getcwd()
- os.chdir(os.path.dirname(filepath))
- filenames = [*other_files, filepath]
-
- try:
- _Distribution.parse_config_files(dist, filenames=filenames)
- handlers = parse_configuration(
- dist, dist.command_options, ignore_option_errors=ignore_option_errors
- )
- dist._finalize_license_files()
- finally:
- os.chdir(current_directory)
-
- return handlers
-
-
-def _get_option(target_obj: Target, key: str):
- """
- Given a target object and option key, get that option from
- the target object, either through a get_{key} method or
- from an attribute directly.
- """
- getter_name = 'get_{key}'.format(**locals())
- by_attribute = functools.partial(getattr, target_obj, key)
- getter = getattr(target_obj, getter_name, by_attribute)
- return getter()
-
-
-def configuration_to_dict(handlers: Tuple["ConfigHandler", ...]) -> dict:
- """Returns configuration data gathered by given handlers as a dict.
-
- :param list[ConfigHandler] handlers: Handlers list,
- usually from parse_configuration()
-
- :rtype: dict
- """
- config_dict: dict = defaultdict(dict)
-
- for handler in handlers:
- for option in handler.set_options:
- value = _get_option(handler.target_obj, option)
- config_dict[handler.section_prefix][option] = value
-
- return config_dict
-
-
-def parse_configuration(
- distribution: "Distribution",
- command_options: AllCommandOptions,
- ignore_option_errors=False
-) -> Tuple["ConfigMetadataHandler", "ConfigOptionsHandler"]:
- """Performs additional parsing of configuration options
- for a distribution.
-
- Returns a list of used option handlers.
-
- :param Distribution distribution:
- :param dict command_options:
- :param bool ignore_option_errors: Whether to silently ignore
- options, values of which could not be resolved (e.g. due to exceptions
- in directives such as file:, attr:, etc.).
- If False exceptions are propagated as expected.
- :rtype: list
- """
- with expand.EnsurePackagesDiscovered(distribution) as ensure_discovered:
- options = ConfigOptionsHandler(
- distribution,
- command_options,
- ignore_option_errors,
- ensure_discovered,
- )
-
- options.parse()
- if not distribution.package_dir:
- distribution.package_dir = options.package_dir # Filled by `find_packages`
-
- meta = ConfigMetadataHandler(
- distribution.metadata,
- command_options,
- ignore_option_errors,
- ensure_discovered,
- distribution.package_dir,
- distribution.src_root,
- )
- meta.parse()
-
- return meta, options
-
-
-def _warn_accidental_env_marker_misconfig(label: str, orig_value: str, parsed: list):
- """Because users sometimes misinterpret this configuration:
-
- [options.extras_require]
- foo = bar;python_version<"4"
-
- It looks like one requirement with an environment marker
- but because there is no newline, it's parsed as two requirements
- with a semicolon as separator.
-
- Therefore, if:
- * input string does not contain a newline AND
- * parsed result contains two requirements AND
- * parsing of the two parts from the result (";")
- leads in a valid Requirement with a valid marker
- a UserWarning is shown to inform the user about the possible problem.
- """
- if "\n" in orig_value or len(parsed) != 2:
- return
-
- with contextlib.suppress(InvalidRequirement):
- original_requirements_str = ";".join(parsed)
- req = Requirement(original_requirements_str)
- if req.marker is not None:
- msg = (
- f"One of the parsed requirements in `{label}` "
- f"looks like a valid environment marker: '{parsed[1]}'\n"
- "Make sure that the config is correct and check "
- "https://setuptools.pypa.io/en/latest/userguide/declarative_config.html#opt-2" # noqa: E501
- )
- warnings.warn(msg, UserWarning)
-
-
-class ConfigHandler(Generic[Target]):
- """Handles metadata supplied in configuration files."""
-
- section_prefix: str
- """Prefix for config sections handled by this handler.
- Must be provided by class heirs.
-
- """
-
- aliases: Dict[str, str] = {}
- """Options aliases.
- For compatibility with various packages. E.g.: d2to1 and pbr.
- Note: `-` in keys is replaced with `_` by config parser.
-
- """
-
- def __init__(
- self,
- target_obj: Target,
- options: AllCommandOptions,
- ignore_option_errors,
- ensure_discovered: expand.EnsurePackagesDiscovered,
- ):
- sections: AllCommandOptions = {}
-
- section_prefix = self.section_prefix
- for section_name, section_options in options.items():
- if not section_name.startswith(section_prefix):
- continue
-
- section_name = section_name.replace(section_prefix, '').strip('.')
- sections[section_name] = section_options
-
- self.ignore_option_errors = ignore_option_errors
- self.target_obj = target_obj
- self.sections = sections
- self.set_options: List[str] = []
- self.ensure_discovered = ensure_discovered
-
- @property
- def parsers(self):
- """Metadata item name to parser function mapping."""
- raise NotImplementedError(
- '%s must provide .parsers property' % self.__class__.__name__
- )
-
- def __setitem__(self, option_name, value):
- unknown = tuple()
- target_obj = self.target_obj
-
- # Translate alias into real name.
- option_name = self.aliases.get(option_name, option_name)
-
- current_value = getattr(target_obj, option_name, unknown)
-
- if current_value is unknown:
- raise KeyError(option_name)
-
- if current_value:
- # Already inhabited. Skipping.
- return
-
- skip_option = False
- parser = self.parsers.get(option_name)
- if parser:
- try:
- value = parser(value)
-
- except Exception:
- skip_option = True
- if not self.ignore_option_errors:
- raise
-
- if skip_option:
- return
-
- setter = getattr(target_obj, 'set_%s' % option_name, None)
- if setter is None:
- setattr(target_obj, option_name, value)
- else:
- setter(value)
-
- self.set_options.append(option_name)
-
- @classmethod
- def _parse_list(cls, value, separator=','):
- """Represents value as a list.
-
- Value is split either by separator (defaults to comma) or by lines.
-
- :param value:
- :param separator: List items separator character.
- :rtype: list
- """
- if isinstance(value, list): # _get_parser_compound case
- return value
-
- if '\n' in value:
- value = value.splitlines()
- else:
- value = value.split(separator)
-
- return [chunk.strip() for chunk in value if chunk.strip()]
-
- @classmethod
- def _parse_dict(cls, value):
- """Represents value as a dict.
-
- :param value:
- :rtype: dict
- """
- separator = '='
- result = {}
- for line in cls._parse_list(value):
- key, sep, val = line.partition(separator)
- if sep != separator:
- raise DistutilsOptionError(
- 'Unable to parse option value to dict: %s' % value
- )
- result[key.strip()] = val.strip()
-
- return result
-
- @classmethod
- def _parse_bool(cls, value):
- """Represents value as boolean.
-
- :param value:
- :rtype: bool
- """
- value = value.lower()
- return value in ('1', 'true', 'yes')
-
- @classmethod
- def _exclude_files_parser(cls, key):
- """Returns a parser function to make sure field inputs
- are not files.
-
- Parses a value after getting the key so error messages are
- more informative.
-
- :param key:
- :rtype: callable
- """
-
- def parser(value):
- exclude_directive = 'file:'
- if value.startswith(exclude_directive):
- raise ValueError(
- 'Only strings are accepted for the {0} field, '
- 'files are not accepted'.format(key)
- )
- return value
-
- return parser
-
- @classmethod
- def _parse_file(cls, value, root_dir: _Path):
- """Represents value as a string, allowing including text
- from nearest files using `file:` directive.
-
- Directive is sandboxed and won't reach anything outside
- directory with setup.py.
-
- Examples:
- file: README.rst, CHANGELOG.md, src/file.txt
-
- :param str value:
- :rtype: str
- """
- include_directive = 'file:'
-
- if not isinstance(value, str):
- return value
-
- if not value.startswith(include_directive):
- return value
-
- spec = value[len(include_directive) :]
- filepaths = (path.strip() for path in spec.split(','))
- return expand.read_files(filepaths, root_dir)
-
- def _parse_attr(self, value, package_dir, root_dir: _Path):
- """Represents value as a module attribute.
-
- Examples:
- attr: package.attr
- attr: package.module.attr
-
- :param str value:
- :rtype: str
- """
- attr_directive = 'attr:'
- if not value.startswith(attr_directive):
- return value
-
- attr_desc = value.replace(attr_directive, '')
-
- # Make sure package_dir is populated correctly, so `attr:` directives can work
- package_dir.update(self.ensure_discovered.package_dir)
- return expand.read_attr(attr_desc, package_dir, root_dir)
-
- @classmethod
- def _get_parser_compound(cls, *parse_methods):
- """Returns parser function to represents value as a list.
-
- Parses a value applying given methods one after another.
-
- :param parse_methods:
- :rtype: callable
- """
-
- def parse(value):
- parsed = value
-
- for method in parse_methods:
- parsed = method(parsed)
-
- return parsed
-
- return parse
-
- @classmethod
- def _parse_section_to_dict_with_key(cls, section_options, values_parser):
- """Parses section options into a dictionary.
-
- Applies a given parser to each option in a section.
-
- :param dict section_options:
- :param callable values_parser: function with 2 args corresponding to key, value
- :rtype: dict
- """
- value = {}
- for key, (_, val) in section_options.items():
- value[key] = values_parser(key, val)
- return value
-
- @classmethod
- def _parse_section_to_dict(cls, section_options, values_parser=None):
- """Parses section options into a dictionary.
-
- Optionally applies a given parser to each value.
-
- :param dict section_options:
- :param callable values_parser: function with 1 arg corresponding to option value
- :rtype: dict
- """
- parser = (lambda _, v: values_parser(v)) if values_parser else (lambda _, v: v)
- return cls._parse_section_to_dict_with_key(section_options, parser)
-
- def parse_section(self, section_options):
- """Parses configuration file section.
-
- :param dict section_options:
- """
- for (name, (_, value)) in section_options.items():
- with contextlib.suppress(KeyError):
- # Keep silent for a new option may appear anytime.
- self[name] = value
-
- def parse(self):
- """Parses configuration file items from one
- or more related sections.
-
- """
- for section_name, section_options in self.sections.items():
-
- method_postfix = ''
- if section_name: # [section.option] variant
- method_postfix = '_%s' % section_name
-
- section_parser_method: Optional[Callable] = getattr(
- self,
- # Dots in section names are translated into dunderscores.
- ('parse_section%s' % method_postfix).replace('.', '__'),
- None,
- )
-
- if section_parser_method is None:
- raise DistutilsOptionError(
- 'Unsupported distribution option section: [%s.%s]'
- % (self.section_prefix, section_name)
- )
-
- section_parser_method(section_options)
-
- def _deprecated_config_handler(self, func, msg, warning_class):
- """this function will wrap around parameters that are deprecated
-
- :param msg: deprecation message
- :param warning_class: class of warning exception to be raised
- :param func: function to be wrapped around
- """
-
- @wraps(func)
- def config_handler(*args, **kwargs):
- warnings.warn(msg, warning_class)
- return func(*args, **kwargs)
-
- return config_handler
-
-
-class ConfigMetadataHandler(ConfigHandler["DistributionMetadata"]):
-
- section_prefix = 'metadata'
-
- aliases = {
- 'home_page': 'url',
- 'summary': 'description',
- 'classifier': 'classifiers',
- 'platform': 'platforms',
- }
-
- strict_mode = False
- """We need to keep it loose, to be partially compatible with
- `pbr` and `d2to1` packages which also uses `metadata` section.
-
- """
-
- def __init__(
- self,
- target_obj: "DistributionMetadata",
- options: AllCommandOptions,
- ignore_option_errors: bool,
- ensure_discovered: expand.EnsurePackagesDiscovered,
- package_dir: Optional[dict] = None,
- root_dir: _Path = os.curdir
- ):
- super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
- self.package_dir = package_dir
- self.root_dir = root_dir
-
- @property
- def parsers(self):
- """Metadata item name to parser function mapping."""
- parse_list = self._parse_list
- parse_file = partial(self._parse_file, root_dir=self.root_dir)
- parse_dict = self._parse_dict
- exclude_files_parser = self._exclude_files_parser
-
- return {
- 'platforms': parse_list,
- 'keywords': parse_list,
- 'provides': parse_list,
- 'requires': self._deprecated_config_handler(
- parse_list,
- "The requires parameter is deprecated, please use "
- "install_requires for runtime dependencies.",
- SetuptoolsDeprecationWarning,
- ),
- 'obsoletes': parse_list,
- 'classifiers': self._get_parser_compound(parse_file, parse_list),
- 'license': exclude_files_parser('license'),
- 'license_file': self._deprecated_config_handler(
- exclude_files_parser('license_file'),
- "The license_file parameter is deprecated, "
- "use license_files instead.",
- SetuptoolsDeprecationWarning,
- ),
- 'license_files': parse_list,
- 'description': parse_file,
- 'long_description': parse_file,
- 'version': self._parse_version,
- 'project_urls': parse_dict,
- }
-
- def _parse_version(self, value):
- """Parses `version` option value.
-
- :param value:
- :rtype: str
-
- """
- version = self._parse_file(value, self.root_dir)
-
- if version != value:
- version = version.strip()
- # Be strict about versions loaded from file because it's easy to
- # accidentally include newlines and other unintended content
- try:
- Version(version)
- except InvalidVersion:
- tmpl = (
- 'Version loaded from {value} does not '
- 'comply with PEP 440: {version}'
- )
- raise DistutilsOptionError(tmpl.format(**locals()))
-
- return version
-
- return expand.version(self._parse_attr(value, self.package_dir, self.root_dir))
-
-
-class ConfigOptionsHandler(ConfigHandler["Distribution"]):
-
- section_prefix = 'options'
-
- def __init__(
- self,
- target_obj: "Distribution",
- options: AllCommandOptions,
- ignore_option_errors: bool,
- ensure_discovered: expand.EnsurePackagesDiscovered,
- ):
- super().__init__(target_obj, options, ignore_option_errors, ensure_discovered)
- self.root_dir = target_obj.src_root
- self.package_dir: Dict[str, str] = {} # To be filled by `find_packages`
-
- @classmethod
- def _parse_list_semicolon(cls, value):
- return cls._parse_list(value, separator=';')
-
- def _parse_file_in_root(self, value):
- return self._parse_file(value, root_dir=self.root_dir)
-
- def _parse_requirements_list(self, label: str, value: str):
- # Parse a requirements list, either by reading in a `file:`, or a list.
- parsed = self._parse_list_semicolon(self._parse_file_in_root(value))
- _warn_accidental_env_marker_misconfig(label, value, parsed)
- # Filter it to only include lines that are not comments. `parse_list`
- # will have stripped each line and filtered out empties.
- return [line for line in parsed if not line.startswith("#")]
-
- @property
- def parsers(self):
- """Metadata item name to parser function mapping."""
- parse_list = self._parse_list
- parse_bool = self._parse_bool
- parse_dict = self._parse_dict
- parse_cmdclass = self._parse_cmdclass
-
- return {
- 'zip_safe': parse_bool,
- 'include_package_data': parse_bool,
- 'package_dir': parse_dict,
- 'scripts': parse_list,
- 'eager_resources': parse_list,
- 'dependency_links': parse_list,
- 'namespace_packages': self._deprecated_config_handler(
- parse_list,
- "The namespace_packages parameter is deprecated, "
- "consider using implicit namespaces instead (PEP 420).",
- SetuptoolsDeprecationWarning,
- ),
- 'install_requires': partial(
- self._parse_requirements_list, "install_requires"
- ),
- 'setup_requires': self._parse_list_semicolon,
- 'tests_require': self._parse_list_semicolon,
- 'packages': self._parse_packages,
- 'entry_points': self._parse_file_in_root,
- 'py_modules': parse_list,
- 'python_requires': SpecifierSet,
- 'cmdclass': parse_cmdclass,
- }
-
- def _parse_cmdclass(self, value):
- package_dir = self.ensure_discovered.package_dir
- return expand.cmdclass(self._parse_dict(value), package_dir, self.root_dir)
-
- def _parse_packages(self, value):
- """Parses `packages` option value.
-
- :param value:
- :rtype: list
- """
- find_directives = ['find:', 'find_namespace:']
- trimmed_value = value.strip()
-
- if trimmed_value not in find_directives:
- return self._parse_list(value)
-
- # Read function arguments from a dedicated section.
- find_kwargs = self.parse_section_packages__find(
- self.sections.get('packages.find', {})
- )
-
- find_kwargs.update(
- namespaces=(trimmed_value == find_directives[1]),
- root_dir=self.root_dir,
- fill_package_dir=self.package_dir,
- )
-
- return expand.find_packages(**find_kwargs)
-
- def parse_section_packages__find(self, section_options):
- """Parses `packages.find` configuration file section.
-
- To be used in conjunction with _parse_packages().
-
- :param dict section_options:
- """
- section_data = self._parse_section_to_dict(section_options, self._parse_list)
-
- valid_keys = ['where', 'include', 'exclude']
-
- find_kwargs = dict(
- [(k, v) for k, v in section_data.items() if k in valid_keys and v]
- )
-
- where = find_kwargs.get('where')
- if where is not None:
- find_kwargs['where'] = where[0] # cast list to single val
-
- return find_kwargs
-
- def parse_section_entry_points(self, section_options):
- """Parses `entry_points` configuration file section.
-
- :param dict section_options:
- """
- parsed = self._parse_section_to_dict(section_options, self._parse_list)
- self['entry_points'] = parsed
-
- def _parse_package_data(self, section_options):
- package_data = self._parse_section_to_dict(section_options, self._parse_list)
- return expand.canonic_package_data(package_data)
-
- def parse_section_package_data(self, section_options):
- """Parses `package_data` configuration file section.
-
- :param dict section_options:
- """
- self['package_data'] = self._parse_package_data(section_options)
-
- def parse_section_exclude_package_data(self, section_options):
- """Parses `exclude_package_data` configuration file section.
-
- :param dict section_options:
- """
- self['exclude_package_data'] = self._parse_package_data(section_options)
-
- def parse_section_extras_require(self, section_options):
- """Parses `extras_require` configuration file section.
-
- :param dict section_options:
- """
- parsed = self._parse_section_to_dict_with_key(
- section_options,
- lambda k, v: self._parse_requirements_list(f"extras_require[{k}]", v)
- )
-
- self['extras_require'] = parsed
-
- def parse_section_data_files(self, section_options):
- """Parses `data_files` configuration file section.
-
- :param dict section_options:
- """
- parsed = self._parse_section_to_dict(section_options, self._parse_list)
- self['data_files'] = expand.canonic_data_files(parsed, self.root_dir)
diff --git a/spaces/RealTimeLiveAIForHealth/WebcamObjectRecognition/xml_to_txt.py b/spaces/RealTimeLiveAIForHealth/WebcamObjectRecognition/xml_to_txt.py
deleted file mode 100644
index 6752fbfec4c60d1dcb90bf81446a6e66364dcd5f..0000000000000000000000000000000000000000
--- a/spaces/RealTimeLiveAIForHealth/WebcamObjectRecognition/xml_to_txt.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import xml.etree.ElementTree as ET
-import os
-from glob import glob
-
-XML_PATH = './dataset/xml'
-CLASSES_PATH = './class_names/classes.txt'
-TXT_PATH = './dataset/txt/anno.txt'
-
-
-'''loads the classes'''
-def get_classes(classes_path):
- with open(classes_path) as f:
- class_names = f.readlines()
- class_names = [c.strip() for c in class_names]
- return class_names
-
-
-classes = get_classes(CLASSES_PATH)
-assert len(classes) > 0, 'no class names detected!'
-print(f'num classes: {len(classes)}')
-
-# output file
-list_file = open(TXT_PATH, 'w')
-
-for path in glob(os.path.join(XML_PATH, '*.xml')):
- in_file = open(path)
-
- # Parse .xml file
- tree = ET.parse(in_file)
- root = tree.getroot()
- # Write object information to .txt file
- file_name = root.find('filename').text
- print(file_name)
- list_file.write(file_name)
- for obj in root.iter('object'):
- cls = obj.find('name').text
- cls_id = classes.index(cls)
- xmlbox = obj.find('bndbox')
- b = (int(xmlbox.find('xmin').text), int(xmlbox.find('ymin').text), int(xmlbox.find('xmax').text), int(xmlbox.find('ymax').text))
- list_file.write(" " + ",".join([str(a) for a in b]) + ',' + str(cls_id))
- list_file.write('\n')
-list_file.close()
diff --git a/spaces/Realcat/image-matching-webui/common/viz.py b/spaces/Realcat/image-matching-webui/common/viz.py
deleted file mode 100644
index bc194fd3e30f7f8a0827b393e24bdcf042522476..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/common/viz.py
+++ /dev/null
@@ -1,599 +0,0 @@
-import bisect
-import numpy as np
-import matplotlib.pyplot as plt
-import matplotlib, os, cv2
-import matplotlib.cm as cm
-from PIL import Image
-import torch.nn.functional as F
-import torch
-import seaborn as sns
-
-
-def _compute_conf_thresh(data):
- dataset_name = data["dataset_name"][0].lower()
- if dataset_name == "scannet":
- thr = 5e-4
- elif dataset_name == "megadepth":
- thr = 1e-4
- else:
- raise ValueError(f"Unknown dataset: {dataset_name}")
- return thr
-
-
-def plot_images(imgs, titles=None, cmaps="gray", dpi=100, size=5, pad=0.5):
- """Plot a set of images horizontally.
- Args:
- imgs: a list of NumPy or PyTorch images, RGB (H, W, 3) or mono (H, W).
- titles: a list of strings, as titles for each image.
- cmaps: colormaps for monochrome images.
- """
- n = len(imgs)
- if not isinstance(cmaps, (list, tuple)):
- cmaps = [cmaps] * n
- # figsize = (size*n, size*3/4) if size is not None else None
- figsize = (size * n, size * 6 / 5) if size is not None else None
- fig, ax = plt.subplots(1, n, figsize=figsize, dpi=dpi)
-
- if n == 1:
- ax = [ax]
- for i in range(n):
- ax[i].imshow(imgs[i], cmap=plt.get_cmap(cmaps[i]))
- ax[i].get_yaxis().set_ticks([])
- ax[i].get_xaxis().set_ticks([])
- ax[i].set_axis_off()
- for spine in ax[i].spines.values(): # remove frame
- spine.set_visible(False)
- if titles:
- ax[i].set_title(titles[i])
- fig.tight_layout(pad=pad)
- return fig
-
-
-def plot_color_line_matches(lines, correct_matches=None, lw=2, indices=(0, 1)):
- """Plot line matches for existing images with multiple colors.
- Args:
- lines: list of ndarrays of size (N, 2, 2).
- correct_matches: bool array of size (N,) indicating correct matches.
- lw: line width as float pixels.
- indices: indices of the images to draw the matches on.
- """
- n_lines = len(lines[0])
- colors = sns.color_palette("husl", n_colors=n_lines)
- np.random.shuffle(colors)
- alphas = np.ones(n_lines)
- # If correct_matches is not None, display wrong matches with a low alpha
- if correct_matches is not None:
- alphas[~np.array(correct_matches)] = 0.2
-
- fig = plt.gcf()
- ax = fig.axes
- assert len(ax) > max(indices)
- axes = [ax[i] for i in indices]
- fig.canvas.draw()
-
- # Plot the lines
- for a, l in zip(axes, lines):
- # Transform the points into the figure coordinate system
- transFigure = fig.transFigure.inverted()
- endpoint0 = transFigure.transform(a.transData.transform(l[:, 0]))
- endpoint1 = transFigure.transform(a.transData.transform(l[:, 1]))
- fig.lines += [
- matplotlib.lines.Line2D(
- (endpoint0[i, 0], endpoint1[i, 0]),
- (endpoint0[i, 1], endpoint1[i, 1]),
- zorder=1,
- transform=fig.transFigure,
- c=colors[i],
- alpha=alphas[i],
- linewidth=lw,
- )
- for i in range(n_lines)
- ]
-
- return fig
-
-
-def make_matching_figure(
- img0,
- img1,
- mkpts0,
- mkpts1,
- color,
- titles=None,
- kpts0=None,
- kpts1=None,
- text=[],
- dpi=75,
- path=None,
- pad=0,
-):
- # draw image pair
- # assert mkpts0.shape[0] == mkpts1.shape[0], f'mkpts0: {mkpts0.shape[0]} v.s. mkpts1: {mkpts1.shape[0]}'
- fig, axes = plt.subplots(1, 2, figsize=(10, 6), dpi=dpi)
- axes[0].imshow(img0) # , cmap='gray')
- axes[1].imshow(img1) # , cmap='gray')
- for i in range(2): # clear all frames
- axes[i].get_yaxis().set_ticks([])
- axes[i].get_xaxis().set_ticks([])
- for spine in axes[i].spines.values():
- spine.set_visible(False)
- if titles is not None:
- axes[i].set_title(titles[i])
-
- plt.tight_layout(pad=pad)
-
- if kpts0 is not None:
- assert kpts1 is not None
- axes[0].scatter(kpts0[:, 0], kpts0[:, 1], c="w", s=5)
- axes[1].scatter(kpts1[:, 0], kpts1[:, 1], c="w", s=5)
-
- # draw matches
- if mkpts0.shape[0] != 0 and mkpts1.shape[0] != 0:
- fig.canvas.draw()
- transFigure = fig.transFigure.inverted()
- fkpts0 = transFigure.transform(axes[0].transData.transform(mkpts0))
- fkpts1 = transFigure.transform(axes[1].transData.transform(mkpts1))
- fig.lines = [
- matplotlib.lines.Line2D(
- (fkpts0[i, 0], fkpts1[i, 0]),
- (fkpts0[i, 1], fkpts1[i, 1]),
- transform=fig.transFigure,
- c=color[i],
- linewidth=2,
- )
- for i in range(len(mkpts0))
- ]
-
- # freeze the axes to prevent the transform to change
- axes[0].autoscale(enable=False)
- axes[1].autoscale(enable=False)
-
- axes[0].scatter(mkpts0[:, 0], mkpts0[:, 1], c=color[..., :3], s=4)
- axes[1].scatter(mkpts1[:, 0], mkpts1[:, 1], c=color[..., :3], s=4)
-
- # put txts
- txt_color = "k" if img0[:100, :200].mean() > 200 else "w"
- fig.text(
- 0.01,
- 0.99,
- "\n".join(text),
- transform=fig.axes[0].transAxes,
- fontsize=15,
- va="top",
- ha="left",
- color=txt_color,
- )
-
- # save or return figure
- if path:
- plt.savefig(str(path), bbox_inches="tight", pad_inches=0)
- plt.close()
- else:
- return fig
-
-
-def _make_evaluation_figure(data, b_id, alpha="dynamic"):
- b_mask = data["m_bids"] == b_id
- conf_thr = _compute_conf_thresh(data)
-
- img0 = (
- (data["image0"][b_id][0].cpu().numpy() * 255).round().astype(np.int32)
- )
- img1 = (
- (data["image1"][b_id][0].cpu().numpy() * 255).round().astype(np.int32)
- )
- kpts0 = data["mkpts0_f"][b_mask].cpu().numpy()
- kpts1 = data["mkpts1_f"][b_mask].cpu().numpy()
-
- # for megadepth, we visualize matches on the resized image
- if "scale0" in data:
- kpts0 = kpts0 / data["scale0"][b_id].cpu().numpy()[[1, 0]]
- kpts1 = kpts1 / data["scale1"][b_id].cpu().numpy()[[1, 0]]
-
- epi_errs = data["epi_errs"][b_mask].cpu().numpy()
- correct_mask = epi_errs < conf_thr
- precision = np.mean(correct_mask) if len(correct_mask) > 0 else 0
- n_correct = np.sum(correct_mask)
- n_gt_matches = int(data["conf_matrix_gt"][b_id].sum().cpu())
- recall = 0 if n_gt_matches == 0 else n_correct / (n_gt_matches)
- # recall might be larger than 1, since the calculation of conf_matrix_gt
- # uses groundtruth depths and camera poses, but epipolar distance is used here.
-
- # matching info
- if alpha == "dynamic":
- alpha = dynamic_alpha(len(correct_mask))
- color = error_colormap(epi_errs, conf_thr, alpha=alpha)
-
- text = [
- f"#Matches {len(kpts0)}",
- f"Precision({conf_thr:.2e}) ({100 * precision:.1f}%):"
- f" {n_correct}/{len(kpts0)}",
- f"Recall({conf_thr:.2e}) ({100 * recall:.1f}%):"
- f" {n_correct}/{n_gt_matches}",
- ]
-
- # make the figure
- figure = make_matching_figure(img0, img1, kpts0, kpts1, color, text=text)
- return figure
-
-
-def _make_confidence_figure(data, b_id):
- # TODO: Implement confidence figure
- raise NotImplementedError()
-
-
-def make_matching_figures(data, config, mode="evaluation"):
- """Make matching figures for a batch.
-
- Args:
- data (Dict): a batch updated by PL_LoFTR.
- config (Dict): matcher config
- Returns:
- figures (Dict[str, List[plt.figure]]
- """
- assert mode in ["evaluation", "confidence"] # 'confidence'
- figures = {mode: []}
- for b_id in range(data["image0"].size(0)):
- if mode == "evaluation":
- fig = _make_evaluation_figure(
- data, b_id, alpha=config.TRAINER.PLOT_MATCHES_ALPHA
- )
- elif mode == "confidence":
- fig = _make_confidence_figure(data, b_id)
- else:
- raise ValueError(f"Unknown plot mode: {mode}")
- figures[mode].append(fig)
- return figures
-
-
-def dynamic_alpha(
- n_matches, milestones=[0, 300, 1000, 2000], alphas=[1.0, 0.8, 0.4, 0.2]
-):
- if n_matches == 0:
- return 1.0
- ranges = list(zip(alphas, alphas[1:] + [None]))
- loc = bisect.bisect_right(milestones, n_matches) - 1
- _range = ranges[loc]
- if _range[1] is None:
- return _range[0]
- return _range[1] + (milestones[loc + 1] - n_matches) / (
- milestones[loc + 1] - milestones[loc]
- ) * (_range[0] - _range[1])
-
-
-def error_colormap(err, thr, alpha=1.0):
- assert alpha <= 1.0 and alpha > 0, f"Invaid alpha value: {alpha}"
- x = 1 - np.clip(err / (thr * 2), 0, 1)
- return np.clip(
- np.stack(
- [2 - x * 2, x * 2, np.zeros_like(x), np.ones_like(x) * alpha], -1
- ),
- 0,
- 1,
- )
-
-
-np.random.seed(1995)
-color_map = np.arange(100)
-np.random.shuffle(color_map)
-
-
-def draw_topics(
- data,
- img0,
- img1,
- saved_folder="viz_topics",
- show_n_topics=8,
- saved_name=None,
-):
- topic0, topic1 = data["topic_matrix"]["img0"], data["topic_matrix"]["img1"]
- hw0_c, hw1_c = data["hw0_c"], data["hw1_c"]
- hw0_i, hw1_i = data["hw0_i"], data["hw1_i"]
- # print(hw0_i, hw1_i)
- scale0, scale1 = hw0_i[0] // hw0_c[0], hw1_i[0] // hw1_c[0]
- if "scale0" in data:
- scale0 *= data["scale0"][0]
- else:
- scale0 = (scale0, scale0)
- if "scale1" in data:
- scale1 *= data["scale1"][0]
- else:
- scale1 = (scale1, scale1)
-
- n_topics = topic0.shape[-1]
- # mask0_nonzero = topic0[0].sum(dim=-1, keepdim=True) > 0
- # mask1_nonzero = topic1[0].sum(dim=-1, keepdim=True) > 0
- theta0 = topic0[0].sum(dim=0)
- theta0 /= theta0.sum().float()
- theta1 = topic1[0].sum(dim=0)
- theta1 /= theta1.sum().float()
- # top_topic0 = torch.argsort(theta0, descending=True)[:show_n_topics]
- # top_topic1 = torch.argsort(theta1, descending=True)[:show_n_topics]
- top_topics = torch.argsort(theta0 * theta1, descending=True)[:show_n_topics]
- # print(sum_topic0, sum_topic1)
-
- topic0 = topic0[0].argmax(
- dim=-1, keepdim=True
- ) # .float() / (n_topics - 1) #* 255 + 1 #
- # topic0[~mask0_nonzero] = -1
- topic1 = topic1[0].argmax(
- dim=-1, keepdim=True
- ) # .float() / (n_topics - 1) #* 255 + 1
- # topic1[~mask1_nonzero] = -1
- label_img0, label_img1 = (
- torch.zeros_like(topic0) - 1,
- torch.zeros_like(topic1) - 1,
- )
- for i, k in enumerate(top_topics):
- label_img0[topic0 == k] = color_map[k]
- label_img1[topic1 == k] = color_map[k]
-
- # print(hw0_c, scale0)
- # print(hw1_c, scale1)
- # map_topic0 = F.fold(label_img0.unsqueeze(0), hw0_i, kernel_size=scale0, stride=scale0)
- map_topic0 = (
- label_img0.float().view(hw0_c).cpu().numpy()
- ) # map_topic0.squeeze(0).squeeze(0).cpu().numpy()
- map_topic0 = cv2.resize(
- map_topic0, (int(hw0_c[1] * scale0[0]), int(hw0_c[0] * scale0[1]))
- )
- # map_topic1 = F.fold(label_img1.unsqueeze(0), hw1_i, kernel_size=scale1, stride=scale1)
- map_topic1 = (
- label_img1.float().view(hw1_c).cpu().numpy()
- ) # map_topic1.squeeze(0).squeeze(0).cpu().numpy()
- map_topic1 = cv2.resize(
- map_topic1, (int(hw1_c[1] * scale1[0]), int(hw1_c[0] * scale1[1]))
- )
-
- # show image0
- if saved_name is None:
- return map_topic0, map_topic1
-
- if not os.path.exists(saved_folder):
- os.makedirs(saved_folder)
- path_saved_img0 = os.path.join(saved_folder, "{}_0.png".format(saved_name))
- plt.imshow(img0)
- masked_map_topic0 = np.ma.masked_where(map_topic0 < 0, map_topic0)
- plt.imshow(
- masked_map_topic0,
- cmap=plt.cm.jet,
- vmin=0,
- vmax=n_topics - 1,
- alpha=0.3,
- interpolation="bilinear",
- )
- # plt.show()
- plt.axis("off")
- plt.savefig(path_saved_img0, bbox_inches="tight", pad_inches=0, dpi=250)
- plt.close()
-
- path_saved_img1 = os.path.join(saved_folder, "{}_1.png".format(saved_name))
- plt.imshow(img1)
- masked_map_topic1 = np.ma.masked_where(map_topic1 < 0, map_topic1)
- plt.imshow(
- masked_map_topic1,
- cmap=plt.cm.jet,
- vmin=0,
- vmax=n_topics - 1,
- alpha=0.3,
- interpolation="bilinear",
- )
- plt.axis("off")
- plt.savefig(path_saved_img1, bbox_inches="tight", pad_inches=0, dpi=250)
- plt.close()
-
-
-def draw_topicfm_demo(
- data,
- img0,
- img1,
- mkpts0,
- mkpts1,
- mcolor,
- text,
- show_n_topics=8,
- topic_alpha=0.3,
- margin=5,
- path=None,
- opencv_display=False,
- opencv_title="",
-):
- topic_map0, topic_map1 = draw_topics(
- data, img0, img1, show_n_topics=show_n_topics
- )
-
- mask_tm0, mask_tm1 = np.expand_dims(
- topic_map0 >= 0, axis=-1
- ), np.expand_dims(topic_map1 >= 0, axis=-1)
-
- topic_cm0, topic_cm1 = cm.jet(topic_map0 / 99.0), cm.jet(topic_map1 / 99.0)
- topic_cm0 = cv2.cvtColor(
- topic_cm0[..., :3].astype(np.float32), cv2.COLOR_RGB2BGR
- )
- topic_cm1 = cv2.cvtColor(
- topic_cm1[..., :3].astype(np.float32), cv2.COLOR_RGB2BGR
- )
- overlay0 = (mask_tm0 * topic_cm0 + (1 - mask_tm0) * img0).astype(np.float32)
- overlay1 = (mask_tm1 * topic_cm1 + (1 - mask_tm1) * img1).astype(np.float32)
-
- cv2.addWeighted(overlay0, topic_alpha, img0, 1 - topic_alpha, 0, overlay0)
- cv2.addWeighted(overlay1, topic_alpha, img1, 1 - topic_alpha, 0, overlay1)
-
- overlay0, overlay1 = (overlay0 * 255).astype(np.uint8), (
- overlay1 * 255
- ).astype(np.uint8)
-
- h0, w0 = img0.shape[:2]
- h1, w1 = img1.shape[:2]
- h, w = h0 * 2 + margin * 2, w0 * 2 + margin
- out_fig = 255 * np.ones((h, w, 3), dtype=np.uint8)
- out_fig[:h0, :w0] = overlay0
- if h0 >= h1:
- start = (h0 - h1) // 2
- out_fig[
- start : (start + h1), (w0 + margin) : (w0 + margin + w1)
- ] = overlay1
- else:
- start = (h1 - h0) // 2
- out_fig[:h0, (w0 + margin) : (w0 + margin + w1)] = overlay1[
- start : (start + h0)
- ]
-
- step_h = h0 + margin * 2
- out_fig[step_h : step_h + h0, :w0] = (img0 * 255).astype(np.uint8)
- if h0 >= h1:
- start = step_h + (h0 - h1) // 2
- out_fig[start : start + h1, (w0 + margin) : (w0 + margin + w1)] = (
- img1 * 255
- ).astype(np.uint8)
- else:
- start = (h1 - h0) // 2
- out_fig[step_h : step_h + h0, (w0 + margin) : (w0 + margin + w1)] = (
- img1[start : start + h0] * 255
- ).astype(np.uint8)
-
- # draw matching lines, this is inspried from
- # https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/master/models/utils.py
- mkpts0, mkpts1 = np.round(mkpts0).astype(int), np.round(mkpts1).astype(int)
- mcolor = (np.array(mcolor[:, [2, 1, 0]]) * 255).astype(int)
-
- for (x0, y0), (x1, y1), c in zip(mkpts0, mkpts1, mcolor):
- c = c.tolist()
- cv2.line(
- out_fig,
- (x0, y0 + step_h),
- (x1 + margin + w0, y1 + step_h + (h0 - h1) // 2),
- color=c,
- thickness=1,
- lineType=cv2.LINE_AA,
- )
- # display line end-points as circles
- cv2.circle(out_fig, (x0, y0 + step_h), 2, c, -1, lineType=cv2.LINE_AA)
- cv2.circle(
- out_fig,
- (x1 + margin + w0, y1 + step_h + (h0 - h1) // 2),
- 2,
- c,
- -1,
- lineType=cv2.LINE_AA,
- )
-
- # Scale factor for consistent visualization across scales.
- sc = min(h / 960.0, 2.0)
-
- # Big text.
- Ht = int(30 * sc) # text height
- txt_color_fg = (255, 255, 255)
- txt_color_bg = (0, 0, 0)
- for i, t in enumerate(text):
- cv2.putText(
- out_fig,
- t,
- (int(8 * sc), Ht + step_h * i),
- cv2.FONT_HERSHEY_DUPLEX,
- 1.0 * sc,
- txt_color_bg,
- 2,
- cv2.LINE_AA,
- )
- cv2.putText(
- out_fig,
- t,
- (int(8 * sc), Ht + step_h * i),
- cv2.FONT_HERSHEY_DUPLEX,
- 1.0 * sc,
- txt_color_fg,
- 1,
- cv2.LINE_AA,
- )
-
- if path is not None:
- cv2.imwrite(str(path), out_fig)
-
- if opencv_display:
- cv2.imshow(opencv_title, out_fig)
- cv2.waitKey(1)
-
- return out_fig
-
-
-def fig2im(fig):
- fig.canvas.draw()
- w, h = fig.canvas.get_width_height()
- buf_ndarray = np.frombuffer(fig.canvas.tostring_rgb(), dtype="u1")
- im = buf_ndarray.reshape(h, w, 3)
- return im
-
-
-def draw_matches(
- mkpts0, mkpts1, img0, img1, conf, titles=None, dpi=150, path=None, pad=0.5
-):
- thr = 5e-4
- thr = 0.5
- color = error_colormap(conf, thr, alpha=0.1)
- text = [
- f"image name",
- f"#Matches: {len(mkpts0)}",
- ]
- if path:
- fig2im(
- make_matching_figure(
- img0,
- img1,
- mkpts0,
- mkpts1,
- color,
- titles=titles,
- text=text,
- path=path,
- dpi=dpi,
- pad=pad,
- )
- )
- else:
- return fig2im(
- make_matching_figure(
- img0,
- img1,
- mkpts0,
- mkpts1,
- color,
- titles=titles,
- text=text,
- pad=pad,
- dpi=dpi,
- )
- )
-
-
-def draw_image_pairs(img0, img1, text=[], dpi=75, path=None, pad=0.5):
- # draw image pair
- fig, axes = plt.subplots(1, 2, figsize=(10, 6), dpi=dpi)
- axes[0].imshow(img0) # , cmap='gray')
- axes[1].imshow(img1) # , cmap='gray')
- for i in range(2): # clear all frames
- axes[i].get_yaxis().set_ticks([])
- axes[i].get_xaxis().set_ticks([])
- for spine in axes[i].spines.values():
- spine.set_visible(False)
- plt.tight_layout(pad=pad)
-
- # put txts
- txt_color = "k" if img0[:100, :200].mean() > 200 else "w"
- fig.text(
- 0.01,
- 0.99,
- "\n".join(text),
- transform=fig.axes[0].transAxes,
- fontsize=15,
- va="top",
- ha="left",
- color=txt_color,
- )
-
- # save or return figure
- if path:
- plt.savefig(str(path), bbox_inches="tight", pad_inches=0)
- plt.close()
- else:
- return fig2im(fig)
diff --git a/spaces/Realcat/image-matching-webui/third_party/Roma/roma/models/transformer/layers/__init__.py b/spaces/Realcat/image-matching-webui/third_party/Roma/roma/models/transformer/layers/__init__.py
deleted file mode 100644
index 31f196aacac5be8a7c537a3dfa8f97084671b466..0000000000000000000000000000000000000000
--- a/spaces/Realcat/image-matching-webui/third_party/Roma/roma/models/transformer/layers/__init__.py
+++ /dev/null
@@ -1,12 +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 .dino_head import DINOHead
-from .mlp import Mlp
-from .patch_embed import PatchEmbed
-from .swiglu_ffn import SwiGLUFFN, SwiGLUFFNFused
-from .block import NestedTensorBlock
-from .attention import MemEffAttention
diff --git a/spaces/Ricecake123/RVC-demo/extract_locale.py b/spaces/Ricecake123/RVC-demo/extract_locale.py
deleted file mode 100644
index c42bda59d3b620590d77e1819b31eefd275d5d87..0000000000000000000000000000000000000000
--- a/spaces/Ricecake123/RVC-demo/extract_locale.py
+++ /dev/null
@@ -1,31 +0,0 @@
-import json
-import re
-
-# Define regular expression patterns
-pattern = r"""i18n\([\s\n\t]*(["'][^"']+["'])[\s\n\t]*\)"""
-
-# Initialize the dictionary to store key-value pairs
-data = {}
-
-
-def process(fn: str):
- global data
- with open(fn, "r", encoding="utf-8") as f:
- contents = f.read()
- matches = re.findall(pattern, contents)
- for key in matches:
- key = eval(key)
- print("extract:", key)
- data[key] = key
-
-
-print("processing infer-web.py")
-process("infer-web.py")
-
-print("processing gui.py")
-process("gui.py")
-
-# Save as a JSON file
-with open("./i18n/zh_CN.json", "w", encoding="utf-8") as f:
- json.dump(data, f, ensure_ascii=False, indent=4)
- f.write("\n")
diff --git a/spaces/RinInori/vicuna_finetuned_6_sentiments/README.md b/spaces/RinInori/vicuna_finetuned_6_sentiments/README.md
deleted file mode 100644
index 6a022737e4046ca148f99404787095aa34697cff..0000000000000000000000000000000000000000
--- a/spaces/RinInori/vicuna_finetuned_6_sentiments/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: vicuna_finetuned_6_sentiments
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: gradio
-sdk_version: 3.29.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
\ No newline at end of file
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/configs/_base_/datasets/drive.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/configs/_base_/datasets/drive.py
deleted file mode 100644
index 06e8ff606e0d2a4514ec8b7d2c6c436a32efcbf4..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/configs/_base_/datasets/drive.py
+++ /dev/null
@@ -1,59 +0,0 @@
-# dataset settings
-dataset_type = 'DRIVEDataset'
-data_root = 'data/DRIVE'
-img_norm_cfg = dict(
- mean=[123.675, 116.28, 103.53], std=[58.395, 57.12, 57.375], to_rgb=True)
-img_scale = (584, 565)
-crop_size = (64, 64)
-train_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(type='LoadAnnotations'),
- dict(type='Resize', img_scale=img_scale, ratio_range=(0.5, 2.0)),
- dict(type='RandomCrop', crop_size=crop_size, cat_max_ratio=0.75),
- dict(type='RandomFlip', prob=0.5),
- dict(type='PhotoMetricDistortion'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='Pad', size=crop_size, pad_val=0, seg_pad_val=255),
- dict(type='DefaultFormatBundle'),
- dict(type='Collect', keys=['img', 'gt_semantic_seg'])
-]
-test_pipeline = [
- dict(type='LoadImageFromFile'),
- dict(
- type='MultiScaleFlipAug',
- img_scale=img_scale,
- # img_ratios=[0.5, 0.75, 1.0, 1.25, 1.5, 1.75, 2.0],
- flip=False,
- transforms=[
- dict(type='Resize', keep_ratio=True),
- dict(type='RandomFlip'),
- dict(type='Normalize', **img_norm_cfg),
- dict(type='ImageToTensor', keys=['img']),
- dict(type='Collect', keys=['img'])
- ])
-]
-
-data = dict(
- samples_per_gpu=4,
- workers_per_gpu=4,
- train=dict(
- type='RepeatDataset',
- times=40000,
- dataset=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/training',
- ann_dir='annotations/training',
- pipeline=train_pipeline)),
- val=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/validation',
- ann_dir='annotations/validation',
- pipeline=test_pipeline),
- test=dict(
- type=dataset_type,
- data_root=data_root,
- img_dir='images/validation',
- ann_dir='annotations/validation',
- pipeline=test_pipeline))
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/ops/saconv.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/ops/saconv.py
deleted file mode 100644
index b4ee3978e097fca422805db4e31ae481006d7971..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmcv/ops/saconv.py
+++ /dev/null
@@ -1,145 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch
-import torch.nn as nn
-import torch.nn.functional as F
-
-from annotator.uniformer.mmcv.cnn import CONV_LAYERS, ConvAWS2d, constant_init
-from annotator.uniformer.mmcv.ops.deform_conv import deform_conv2d
-from annotator.uniformer.mmcv.utils import TORCH_VERSION, digit_version
-
-
-@CONV_LAYERS.register_module(name='SAC')
-class SAConv2d(ConvAWS2d):
- """SAC (Switchable Atrous Convolution)
-
- This is an implementation of SAC in DetectoRS
- (https://arxiv.org/pdf/2006.02334.pdf).
-
- Args:
- in_channels (int): Number of channels in the input image
- out_channels (int): Number of channels produced by the convolution
- kernel_size (int or tuple): Size of the convolving kernel
- stride (int or tuple, optional): Stride of the convolution. Default: 1
- padding (int or tuple, optional): Zero-padding added to both sides of
- the input. Default: 0
- padding_mode (string, optional): ``'zeros'``, ``'reflect'``,
- ``'replicate'`` or ``'circular'``. Default: ``'zeros'``
- dilation (int or tuple, optional): Spacing between kernel elements.
- Default: 1
- groups (int, optional): Number of blocked connections from input
- channels to output channels. Default: 1
- bias (bool, optional): If ``True``, adds a learnable bias to the
- output. Default: ``True``
- use_deform: If ``True``, replace convolution with deformable
- convolution. Default: ``False``.
- """
-
- def __init__(self,
- in_channels,
- out_channels,
- kernel_size,
- stride=1,
- padding=0,
- dilation=1,
- groups=1,
- bias=True,
- use_deform=False):
- super().__init__(
- in_channels,
- out_channels,
- kernel_size,
- stride=stride,
- padding=padding,
- dilation=dilation,
- groups=groups,
- bias=bias)
- self.use_deform = use_deform
- self.switch = nn.Conv2d(
- self.in_channels, 1, kernel_size=1, stride=stride, bias=True)
- self.weight_diff = nn.Parameter(torch.Tensor(self.weight.size()))
- self.pre_context = nn.Conv2d(
- self.in_channels, self.in_channels, kernel_size=1, bias=True)
- self.post_context = nn.Conv2d(
- self.out_channels, self.out_channels, kernel_size=1, bias=True)
- if self.use_deform:
- self.offset_s = nn.Conv2d(
- self.in_channels,
- 18,
- kernel_size=3,
- padding=1,
- stride=stride,
- bias=True)
- self.offset_l = nn.Conv2d(
- self.in_channels,
- 18,
- kernel_size=3,
- padding=1,
- stride=stride,
- bias=True)
- self.init_weights()
-
- def init_weights(self):
- constant_init(self.switch, 0, bias=1)
- self.weight_diff.data.zero_()
- constant_init(self.pre_context, 0)
- constant_init(self.post_context, 0)
- if self.use_deform:
- constant_init(self.offset_s, 0)
- constant_init(self.offset_l, 0)
-
- def forward(self, x):
- # pre-context
- avg_x = F.adaptive_avg_pool2d(x, output_size=1)
- avg_x = self.pre_context(avg_x)
- avg_x = avg_x.expand_as(x)
- x = x + avg_x
- # switch
- avg_x = F.pad(x, pad=(2, 2, 2, 2), mode='reflect')
- avg_x = F.avg_pool2d(avg_x, kernel_size=5, stride=1, padding=0)
- switch = self.switch(avg_x)
- # sac
- weight = self._get_weight(self.weight)
- zero_bias = torch.zeros(
- self.out_channels, device=weight.device, dtype=weight.dtype)
-
- if self.use_deform:
- offset = self.offset_s(avg_x)
- out_s = deform_conv2d(x, offset, weight, self.stride, self.padding,
- self.dilation, self.groups, 1)
- else:
- if (TORCH_VERSION == 'parrots'
- or digit_version(TORCH_VERSION) < digit_version('1.5.0')):
- out_s = super().conv2d_forward(x, weight)
- elif digit_version(TORCH_VERSION) >= digit_version('1.8.0'):
- # bias is a required argument of _conv_forward in torch 1.8.0
- out_s = super()._conv_forward(x, weight, zero_bias)
- else:
- out_s = super()._conv_forward(x, weight)
- ori_p = self.padding
- ori_d = self.dilation
- self.padding = tuple(3 * p for p in self.padding)
- self.dilation = tuple(3 * d for d in self.dilation)
- weight = weight + self.weight_diff
- if self.use_deform:
- offset = self.offset_l(avg_x)
- out_l = deform_conv2d(x, offset, weight, self.stride, self.padding,
- self.dilation, self.groups, 1)
- else:
- if (TORCH_VERSION == 'parrots'
- or digit_version(TORCH_VERSION) < digit_version('1.5.0')):
- out_l = super().conv2d_forward(x, weight)
- elif digit_version(TORCH_VERSION) >= digit_version('1.8.0'):
- # bias is a required argument of _conv_forward in torch 1.8.0
- out_l = super()._conv_forward(x, weight, zero_bias)
- else:
- out_l = super()._conv_forward(x, weight)
-
- out = switch * out_s + (1 - switch) * out_l
- self.padding = ori_p
- self.dilation = ori_d
- # post-context
- avg_x = F.adaptive_avg_pool2d(out, output_size=1)
- avg_x = self.post_context(avg_x)
- avg_x = avg_x.expand_as(out)
- out = out + avg_x
- return out
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/bbox/assigners/atss_assigner.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/bbox/assigners/atss_assigner.py
deleted file mode 100644
index d4fe9d0e3c8704bd780d493eff20a5505dbe9580..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet/core/bbox/assigners/atss_assigner.py
+++ /dev/null
@@ -1,178 +0,0 @@
-import torch
-
-from ..builder import BBOX_ASSIGNERS
-from ..iou_calculators import build_iou_calculator
-from .assign_result import AssignResult
-from .base_assigner import BaseAssigner
-
-
-@BBOX_ASSIGNERS.register_module()
-class ATSSAssigner(BaseAssigner):
- """Assign a corresponding gt bbox or background to each bbox.
-
- Each proposals will be assigned with `0` or a positive integer
- indicating the ground truth index.
-
- - 0: negative sample, no assigned gt
- - positive integer: positive sample, index (1-based) of assigned gt
-
- Args:
- topk (float): number of bbox selected in each level
- """
-
- def __init__(self,
- topk,
- iou_calculator=dict(type='BboxOverlaps2D'),
- ignore_iof_thr=-1):
- self.topk = topk
- self.iou_calculator = build_iou_calculator(iou_calculator)
- self.ignore_iof_thr = ignore_iof_thr
-
- # https://github.com/sfzhang15/ATSS/blob/master/atss_core/modeling/rpn/atss/loss.py
-
- def assign(self,
- bboxes,
- num_level_bboxes,
- gt_bboxes,
- gt_bboxes_ignore=None,
- gt_labels=None):
- """Assign gt to bboxes.
-
- The assignment is done in following steps
-
- 1. compute iou between all bbox (bbox of all pyramid levels) and gt
- 2. compute center distance between all bbox and gt
- 3. on each pyramid level, for each gt, select k bbox whose center
- are closest to the gt center, so we total select k*l bbox as
- candidates for each gt
- 4. get corresponding iou for the these candidates, and compute the
- mean and std, set mean + std as the iou threshold
- 5. select these candidates whose iou are greater than or equal to
- the threshold as positive
- 6. limit the positive sample's center in gt
-
-
- Args:
- bboxes (Tensor): Bounding boxes to be assigned, shape(n, 4).
- num_level_bboxes (List): num of bboxes in each level
- gt_bboxes (Tensor): Groundtruth boxes, shape (k, 4).
- gt_bboxes_ignore (Tensor, optional): Ground truth bboxes that are
- labelled as `ignored`, e.g., crowd boxes in COCO.
- gt_labels (Tensor, optional): Label of gt_bboxes, shape (k, ).
-
- Returns:
- :obj:`AssignResult`: The assign result.
- """
- INF = 100000000
- bboxes = bboxes[:, :4]
- num_gt, num_bboxes = gt_bboxes.size(0), bboxes.size(0)
-
- # compute iou between all bbox and gt
- overlaps = self.iou_calculator(bboxes, gt_bboxes)
-
- # assign 0 by default
- assigned_gt_inds = overlaps.new_full((num_bboxes, ),
- 0,
- dtype=torch.long)
-
- if num_gt == 0 or num_bboxes == 0:
- # No ground truth or boxes, return empty assignment
- max_overlaps = overlaps.new_zeros((num_bboxes, ))
- if num_gt == 0:
- # No truth, assign everything to background
- assigned_gt_inds[:] = 0
- if gt_labels is None:
- assigned_labels = None
- else:
- assigned_labels = overlaps.new_full((num_bboxes, ),
- -1,
- dtype=torch.long)
- return AssignResult(
- num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
-
- # compute center distance between all bbox and gt
- gt_cx = (gt_bboxes[:, 0] + gt_bboxes[:, 2]) / 2.0
- gt_cy = (gt_bboxes[:, 1] + gt_bboxes[:, 3]) / 2.0
- gt_points = torch.stack((gt_cx, gt_cy), dim=1)
-
- bboxes_cx = (bboxes[:, 0] + bboxes[:, 2]) / 2.0
- bboxes_cy = (bboxes[:, 1] + bboxes[:, 3]) / 2.0
- bboxes_points = torch.stack((bboxes_cx, bboxes_cy), dim=1)
-
- distances = (bboxes_points[:, None, :] -
- gt_points[None, :, :]).pow(2).sum(-1).sqrt()
-
- if (self.ignore_iof_thr > 0 and gt_bboxes_ignore is not None
- and gt_bboxes_ignore.numel() > 0 and bboxes.numel() > 0):
- ignore_overlaps = self.iou_calculator(
- bboxes, gt_bboxes_ignore, mode='iof')
- ignore_max_overlaps, _ = ignore_overlaps.max(dim=1)
- ignore_idxs = ignore_max_overlaps > self.ignore_iof_thr
- distances[ignore_idxs, :] = INF
- assigned_gt_inds[ignore_idxs] = -1
-
- # Selecting candidates based on the center distance
- candidate_idxs = []
- start_idx = 0
- for level, bboxes_per_level in enumerate(num_level_bboxes):
- # on each pyramid level, for each gt,
- # select k bbox whose center are closest to the gt center
- end_idx = start_idx + bboxes_per_level
- distances_per_level = distances[start_idx:end_idx, :]
- selectable_k = min(self.topk, bboxes_per_level)
- _, topk_idxs_per_level = distances_per_level.topk(
- selectable_k, dim=0, largest=False)
- candidate_idxs.append(topk_idxs_per_level + start_idx)
- start_idx = end_idx
- candidate_idxs = torch.cat(candidate_idxs, dim=0)
-
- # get corresponding iou for the these candidates, and compute the
- # mean and std, set mean + std as the iou threshold
- candidate_overlaps = overlaps[candidate_idxs, torch.arange(num_gt)]
- overlaps_mean_per_gt = candidate_overlaps.mean(0)
- overlaps_std_per_gt = candidate_overlaps.std(0)
- overlaps_thr_per_gt = overlaps_mean_per_gt + overlaps_std_per_gt
-
- is_pos = candidate_overlaps >= overlaps_thr_per_gt[None, :]
-
- # limit the positive sample's center in gt
- for gt_idx in range(num_gt):
- candidate_idxs[:, gt_idx] += gt_idx * num_bboxes
- ep_bboxes_cx = bboxes_cx.view(1, -1).expand(
- num_gt, num_bboxes).contiguous().view(-1)
- ep_bboxes_cy = bboxes_cy.view(1, -1).expand(
- num_gt, num_bboxes).contiguous().view(-1)
- candidate_idxs = candidate_idxs.view(-1)
-
- # calculate the left, top, right, bottom distance between positive
- # bbox center and gt side
- l_ = ep_bboxes_cx[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 0]
- t_ = ep_bboxes_cy[candidate_idxs].view(-1, num_gt) - gt_bboxes[:, 1]
- r_ = gt_bboxes[:, 2] - ep_bboxes_cx[candidate_idxs].view(-1, num_gt)
- b_ = gt_bboxes[:, 3] - ep_bboxes_cy[candidate_idxs].view(-1, num_gt)
- is_in_gts = torch.stack([l_, t_, r_, b_], dim=1).min(dim=1)[0] > 0.01
- is_pos = is_pos & is_in_gts
-
- # if an anchor box is assigned to multiple gts,
- # the one with the highest IoU will be selected.
- overlaps_inf = torch.full_like(overlaps,
- -INF).t().contiguous().view(-1)
- index = candidate_idxs.view(-1)[is_pos.view(-1)]
- overlaps_inf[index] = overlaps.t().contiguous().view(-1)[index]
- overlaps_inf = overlaps_inf.view(num_gt, -1).t()
-
- max_overlaps, argmax_overlaps = overlaps_inf.max(dim=1)
- assigned_gt_inds[
- max_overlaps != -INF] = argmax_overlaps[max_overlaps != -INF] + 1
-
- if gt_labels is not None:
- assigned_labels = assigned_gt_inds.new_full((num_bboxes, ), -1)
- pos_inds = torch.nonzero(
- assigned_gt_inds > 0, as_tuple=False).squeeze()
- if pos_inds.numel() > 0:
- assigned_labels[pos_inds] = gt_labels[
- assigned_gt_inds[pos_inds] - 1]
- else:
- assigned_labels = None
- return AssignResult(
- num_gt, assigned_gt_inds, max_overlaps, labels=assigned_labels)
diff --git a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/dense_heads/retina_head.py b/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/dense_heads/retina_head.py
deleted file mode 100644
index b12416fa8332f02b9a04bbfc7926f6d13875e61b..0000000000000000000000000000000000000000
--- a/spaces/Robert001/UniControl-Demo/annotator/uniformer/mmdet_null/models/dense_heads/retina_head.py
+++ /dev/null
@@ -1,114 +0,0 @@
-import torch.nn as nn
-from mmcv.cnn import ConvModule, bias_init_with_prob, normal_init
-
-from ..builder import HEADS
-from .anchor_head import AnchorHead
-
-
-@HEADS.register_module()
-class RetinaHead(AnchorHead):
- r"""An anchor-based head used in `RetinaNet
- `_.
-
- The head contains two subnetworks. The first classifies anchor boxes and
- the second regresses deltas for the anchors.
-
- Example:
- >>> import torch
- >>> self = RetinaHead(11, 7)
- >>> x = torch.rand(1, 7, 32, 32)
- >>> cls_score, bbox_pred = self.forward_single(x)
- >>> # Each anchor predicts a score for each class except background
- >>> cls_per_anchor = cls_score.shape[1] / self.num_anchors
- >>> box_per_anchor = bbox_pred.shape[1] / self.num_anchors
- >>> assert cls_per_anchor == (self.num_classes)
- >>> assert box_per_anchor == 4
- """
-
- def __init__(self,
- num_classes,
- in_channels,
- stacked_convs=4,
- conv_cfg=None,
- norm_cfg=None,
- anchor_generator=dict(
- type='AnchorGenerator',
- octave_base_scale=4,
- scales_per_octave=3,
- ratios=[0.5, 1.0, 2.0],
- strides=[8, 16, 32, 64, 128]),
- **kwargs):
- self.stacked_convs = stacked_convs
- self.conv_cfg = conv_cfg
- self.norm_cfg = norm_cfg
- super(RetinaHead, self).__init__(
- num_classes,
- in_channels,
- anchor_generator=anchor_generator,
- **kwargs)
-
- def _init_layers(self):
- """Initialize layers of the head."""
- self.relu = nn.ReLU(inplace=True)
- self.cls_convs = nn.ModuleList()
- self.reg_convs = nn.ModuleList()
- for i in range(self.stacked_convs):
- chn = self.in_channels if i == 0 else self.feat_channels
- self.cls_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg))
- self.reg_convs.append(
- ConvModule(
- chn,
- self.feat_channels,
- 3,
- stride=1,
- padding=1,
- conv_cfg=self.conv_cfg,
- norm_cfg=self.norm_cfg))
- self.retina_cls = nn.Conv2d(
- self.feat_channels,
- self.num_anchors * self.cls_out_channels,
- 3,
- padding=1)
- self.retina_reg = nn.Conv2d(
- self.feat_channels, self.num_anchors * 4, 3, padding=1)
-
- def init_weights(self):
- """Initialize weights of the head."""
- for m in self.cls_convs:
- normal_init(m.conv, std=0.01)
- for m in self.reg_convs:
- normal_init(m.conv, std=0.01)
- bias_cls = bias_init_with_prob(0.01)
- normal_init(self.retina_cls, std=0.01, bias=bias_cls)
- normal_init(self.retina_reg, std=0.01)
-
- def forward_single(self, x):
- """Forward feature of a single scale level.
-
- Args:
- x (Tensor): Features of a single scale level.
-
- Returns:
- tuple:
- cls_score (Tensor): Cls scores for a single scale level
- the channels number is num_anchors * num_classes.
- bbox_pred (Tensor): Box energies / deltas for a single scale
- level, the channels number is num_anchors * 4.
- """
- cls_feat = x
- reg_feat = x
- for cls_conv in self.cls_convs:
- cls_feat = cls_conv(cls_feat)
- for reg_conv in self.reg_convs:
- reg_feat = reg_conv(reg_feat)
- cls_score = self.retina_cls(cls_feat)
- bbox_pred = self.retina_reg(reg_feat)
- return cls_score, bbox_pred
diff --git a/spaces/SalahZa/Tunisian-ASR-v0/lm_tunisian.py b/spaces/SalahZa/Tunisian-ASR-v0/lm_tunisian.py
deleted file mode 100644
index ca1096f64b8a3d9eb7e2b670c5d1ec241d1a3ba3..0000000000000000000000000000000000000000
--- a/spaces/SalahZa/Tunisian-ASR-v0/lm_tunisian.py
+++ /dev/null
@@ -1,361 +0,0 @@
-#!/usr/bin/env/python3
-"""Recipe for training a wav2vec-based ctc ASR system with librispeech.
-The system employs wav2vec as its encoder. Decoding is performed with
-ctc greedy decoder.
-To run this recipe, do the following:
-> python train_with_wav2vec.py hparams/train_with_wav2vec.yaml
-The neural network is trained on CTC likelihood target and character units
-are used as basic recognition tokens. Training is performed on the full
-LibriSpeech dataset (960 h).
-
-Authors
- * Sung-Lin Yeh 2021
- * Titouan Parcollet 2021
- * Ju-Chieh Chou 2020
- * Mirco Ravanelli 2020
- * Abdel Heba 2020
- * Peter Plantinga 2020
- * Samuele Cornell 2020
-"""
-
-import os
-import sys
-import torch
-import logging
-import speechbrain as sb
-from speechbrain.utils.distributed import run_on_main
-from hyperpyyaml import load_hyperpyyaml
-from pathlib import Path
-import torchaudio.transforms as T
-
-from pyctcdecode import build_ctcdecoder
-logger = logging.getLogger(__name__)
-
-# Define training procedure
-class ASR(sb.Brain):
- def compute_forward(self, batch, stage):
- """Forward computations from the waveform batches to the output probabilities."""
- batch = batch.to(self.device)
- wavs, wav_lens = batch.sig
- tokens_bos, _ = batch.tokens_bos
- wavs, wav_lens = wavs.to(self.device), wav_lens.to(self.device)
-
- # Forward pass
- feats = self.modules.wav2vec2(wavs)
- x = self.modules.enc(feats)
- # Compute outputs
- p_tokens = None
- logits = self.modules.ctc_lin(x)
- p_ctc = self.hparams.log_softmax(logits)
- if stage != sb.Stage.TRAIN:
- p_tokens = sb.decoders.ctc_greedy_decode(
- p_ctc, wav_lens, blank_id=self.hparams.blank_index
- )
- return p_ctc, wav_lens, p_tokens
-
- def compute_objectives(self, predictions, batch, stage):
- """Computes the loss (CTC+NLL) given predictions and targets."""
-
- p_ctc, wav_lens, predicted_tokens = predictions
-
- ids = batch.id
- tokens_eos, tokens_eos_lens = batch.tokens_eos
- tokens, tokens_lens = batch.tokens
-
- if hasattr(self.modules, "env_corrupt") and stage == sb.Stage.TRAIN:
- tokens_eos = torch.cat([tokens_eos, tokens_eos], dim=0)
- tokens_eos_lens = torch.cat(
- [tokens_eos_lens, tokens_eos_lens], dim=0
- )
- tokens = torch.cat([tokens, tokens], dim=0)
- tokens_lens = torch.cat([tokens_lens, tokens_lens], dim=0)
-
- loss_ctc = self.hparams.ctc_cost(p_ctc, tokens, wav_lens, tokens_lens)
- loss = loss_ctc
- if stage != sb.Stage.TRAIN:
- # Decode token terms to words
- predicted_words =[]
- for logs in p_ctc:
- text = decoder.decode(logs.detach().cpu().numpy())
- predicted_words.append(text.split(" "))
-
-
- target_words = [wrd.split(" ") for wrd in batch.wrd]
- self.wer_metric.append(ids, predicted_words, target_words)
- self.cer_metric.append(ids, predicted_words, target_words)
-
- return loss
-
- def fit_batch(self, batch):
- """Train the parameters given a single batch in input"""
- predictions = self.compute_forward(batch, sb.Stage.TRAIN)
- loss = self.compute_objectives(predictions, batch, sb.Stage.TRAIN)
- loss.backward()
- if self.check_gradients(loss):
- self.wav2vec_optimizer.step()
- self.model_optimizer.step()
-
- self.wav2vec_optimizer.zero_grad()
- self.model_optimizer.zero_grad()
-
- return loss.detach()
-
- def evaluate_batch(self, batch, stage):
- """Computations needed for validation/test batches"""
- predictions = self.compute_forward(batch, stage=stage)
- with torch.no_grad():
- loss = self.compute_objectives(predictions, batch, stage=stage)
- return loss.detach()
-
- def on_stage_start(self, stage, epoch):
- """Gets called at the beginning of each epoch"""
- if stage != sb.Stage.TRAIN:
- self.cer_metric = self.hparams.cer_computer()
- self.wer_metric = self.hparams.error_rate_computer()
-
- def on_stage_end(self, stage, stage_loss, epoch):
- """Gets called at the end of an epoch."""
- # Compute/store important stats
- stage_stats = {"loss": stage_loss}
- if stage == sb.Stage.TRAIN:
- self.train_stats = stage_stats
- else:
- stage_stats["CER"] = self.cer_metric.summarize("error_rate")
- stage_stats["WER"] = self.wer_metric.summarize("error_rate")
-
- # Perform end-of-iteration things, like annealing, logging, etc.
- if stage == sb.Stage.VALID:
- old_lr_model, new_lr_model = self.hparams.lr_annealing_model(
- stage_stats["loss"]
- )
- old_lr_wav2vec, new_lr_wav2vec = self.hparams.lr_annealing_wav2vec(
- stage_stats["loss"]
- )
- sb.nnet.schedulers.update_learning_rate(
- self.model_optimizer, new_lr_model
- )
- sb.nnet.schedulers.update_learning_rate(
- self.wav2vec_optimizer, new_lr_wav2vec
- )
- self.hparams.train_logger.log_stats(
- stats_meta={
- "epoch": epoch,
- "lr_model": old_lr_model,
- "lr_wav2vec": old_lr_wav2vec,
- },
- train_stats=self.train_stats,
- valid_stats=stage_stats,
- )
- self.checkpointer.save_and_keep_only(
- meta={"WER": stage_stats["WER"]}, min_keys=["WER"],
- )
- elif stage == sb.Stage.TEST:
- self.hparams.train_logger.log_stats(
- stats_meta={"Epoch loaded": self.hparams.epoch_counter.current},
- test_stats=stage_stats,
- )
- with open(self.hparams.wer_file, "w") as w:
- self.wer_metric.write_stats(w)
-
- def init_optimizers(self):
- "Initializes the wav2vec2 optimizer and model optimizer"
- self.wav2vec_optimizer = self.hparams.wav2vec_opt_class(
- self.modules.wav2vec2.parameters()
- )
- self.model_optimizer = self.hparams.model_opt_class(
- self.hparams.model.parameters()
- )
-
- if self.checkpointer is not None:
- self.checkpointer.add_recoverable(
- "wav2vec_opt", self.wav2vec_optimizer
- )
- self.checkpointer.add_recoverable("modelopt", self.model_optimizer)
-
-
-def dataio_prepare(hparams):
- """This function prepares the datasets to be used in the brain class.
- It also defines the data processing pipeline through user-defined functions."""
- data_folder = hparams["data_folder"]
-
- train_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=hparams["train_csv"], replacements={"data_root": data_folder},
- )
-
- if hparams["sorting"] == "ascending":
- # we sort training data to speed up training and get better results.
- train_data = train_data.filtered_sorted(sort_key="duration")
- # when sorting do not shuffle in dataloader ! otherwise is pointless
- hparams["train_dataloader_opts"]["shuffle"] = False
-
- elif hparams["sorting"] == "descending":
- train_data = train_data.filtered_sorted(
- sort_key="duration", reverse=True
- )
- # when sorting do not shuffle in dataloader ! otherwise is pointless
- hparams["train_dataloader_opts"]["shuffle"] = False
-
- elif hparams["sorting"] == "random":
- pass
-
- else:
- raise NotImplementedError(
- "sorting must be random, ascending or descending"
- )
-
- valid_data = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=hparams["valid_csv"], replacements={"data_root": data_folder},
- )
- valid_data = valid_data.filtered_sorted(sort_key="duration")
-
- # test is separate
- test_datasets = {}
- for csv_file in hparams["test_csv"]:
- name = Path(csv_file).stem
- test_datasets[name] = sb.dataio.dataset.DynamicItemDataset.from_csv(
- csv_path=csv_file, replacements={"data_root": data_folder}
- )
- test_datasets[name] = test_datasets[name].filtered_sorted(
- sort_key="duration"
- )
-
- datasets = [train_data, valid_data] + [i for k, i in test_datasets.items()]
-
- # 2. Define audio pipeline:
- @sb.utils.data_pipeline.takes("wav", "sr")
- @sb.utils.data_pipeline.provides("sig")
- def audio_pipeline(wav, sr):
- sig = sb.dataio.dataio.read_audio(wav)
- sig = resamplers[sr](sig)
- return sig
-
- sb.dataio.dataset.add_dynamic_item(datasets, audio_pipeline)
- label_encoder = sb.dataio.encoder.CTCTextEncoder()
-
- # 3. Define text pipeline:
- @sb.utils.data_pipeline.takes("wrd")
- @sb.utils.data_pipeline.provides(
- "wrd", "char_list", "tokens_list", "tokens_bos", "tokens_eos", "tokens"
- )
- def text_pipeline(wrd):
- yield wrd
- char_list = list(wrd)
- yield char_list
- tokens_list = label_encoder.encode_sequence(char_list)
- yield tokens_list
- tokens_bos = torch.LongTensor([hparams["bos_index"]] + (tokens_list))
- yield tokens_bos
- tokens_eos = torch.LongTensor(tokens_list + [hparams["eos_index"]])
- yield tokens_eos
- tokens = torch.LongTensor(tokens_list)
- yield tokens
-
- sb.dataio.dataset.add_dynamic_item(datasets, text_pipeline)
-
- lab_enc_file = os.path.join(hparams["save_folder"], "label_encoder.txt")
- special_labels = {
- "bos_label": hparams["bos_index"],
- "eos_label": hparams["eos_index"],
- "blank_label": hparams["blank_index"],
- }
- label_encoder.load_or_create(
- path=lab_enc_file,
- from_didatasets=[train_data],
- output_key="char_list",
- special_labels=special_labels,
- sequence_input=True,
- )
-
- # 4. Set output:
- sb.dataio.dataset.set_output_keys(
- datasets,
- ["id", "sig", "wrd", "char_list", "tokens_bos", "tokens_eos", "tokens"],
- )
- return train_data, valid_data, test_datasets, label_encoder
-
-
-if __name__ == "__main__":
-
- # CLI:
- hparams_file, run_opts, overrides = sb.parse_arguments(sys.argv[1:])
-
- # If distributed_launch=True then
- # create ddp_group with the right communication protocol
- sb.utils.distributed.ddp_init_group(run_opts)
-
- with open(hparams_file) as fin:
- hparams = load_hyperpyyaml(fin, overrides)
-
- # Create experiment directory
- sb.create_experiment_directory(
- experiment_directory=hparams["output_folder"],
- hyperparams_to_save=hparams_file,
- overrides=overrides,
- )
- def read_labels_file(labels_file):
- with open(labels_file, "r") as lf:
- lines = lf.read().splitlines()
- division = "==="
- numbers = {}
- for line in lines :
- if division in line :
- break
- string, number = line.split("=>")
- number = int(number)
- string = string[1:-2]
- numbers[number] = string
- return [numbers[x] for x in range(len(numbers))]
- labels = read_labels_file(os.path.join(hparams["save_folder"], "label_encoder.txt"))
- print(labels)
- labels = [""] + labels[1:]
- print(len(labels))
- decoder = build_ctcdecoder(
- labels,
- kenlm_model_path="tunisian.arpa", # either .arpa or .bin file
- alpha=0.5, # tuned on a val set
- beta=1.0, # tuned on a val set
- )
-
- # Dataset prep (parsing Librispeech)
-
- resampler_8000 = T.Resample(8000, 16000, dtype=torch.float)
-
- resampler_44100 =T.Resample(44100, 16000, dtype=torch.float)
- resampler_48000 =T.Resample(48000, 16000, dtype=torch.float)
- resamplers = {"8000": resampler_8000, "44100":resampler_44100, "48000": resampler_48000}
-
- # here we create the datasets objects as well as tokenization and encoding
- train_data, valid_data, test_datasets, label_encoder = dataio_prepare(
- hparams
- )
-
- # Trainer initialization
- asr_brain = ASR(
- modules=hparams["modules"],
- hparams=hparams,
- run_opts=run_opts,
- checkpointer=hparams["checkpointer"],
- )
- asr_brain.device= "cpu"
- asr_brain.modules.to("cpu")
- # We dynamicaly add the tokenizer to our brain class.
- # NB: This tokenizer corresponds to the one used for the LM!!
- asr_brain.tokenizer = label_encoder
-
- # Training
- asr_brain.fit(
- asr_brain.hparams.epoch_counter,
- train_data,
- valid_data,
- train_loader_kwargs=hparams["train_dataloader_opts"],
- valid_loader_kwargs=hparams["valid_dataloader_opts"],
- )
-
- # Testing
- for k in test_datasets.keys(): # keys are test_clean, test_other etc
- asr_brain.hparams.wer_file = os.path.join(
- hparams["output_folder"], "wer_{}.txt".format(k)
- )
- asr_brain.evaluate(
- test_datasets[k], test_loader_kwargs=hparams["test_dataloader_opts"]
- )
diff --git a/spaces/SimianLuo/Latent_Consistency_Model/README.md b/spaces/SimianLuo/Latent_Consistency_Model/README.md
deleted file mode 100644
index 93217c74dd1f9d8e4c27abb6d908ce3f220fb36e..0000000000000000000000000000000000000000
--- a/spaces/SimianLuo/Latent_Consistency_Model/README.md
+++ /dev/null
@@ -1,16 +0,0 @@
----
-title: Latent Consistency Models
-emoji: ⚡️
-colorFrom: red
-colorTo: purple
-sdk: gradio
-sdk_version: 3.48.0
-app_file: app.py
-license: mit
-pinned: false
-suggested_hardware: a10g-small
-suggested_storage: small
-hf_oauth: true
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
\ No newline at end of file
diff --git a/spaces/Singularity666/VisionGPT-Automation2/main.py b/spaces/Singularity666/VisionGPT-Automation2/main.py
deleted file mode 100644
index a87344dd9933396c119c92032f82afeb2d6c0355..0000000000000000000000000000000000000000
--- a/spaces/Singularity666/VisionGPT-Automation2/main.py
+++ /dev/null
@@ -1,42 +0,0 @@
-import streamlit as st
-import requests
-from PIL import Image
-from io import BytesIO
-
-API_KEY = "1143a102dbe21628248d4bb992b391a49dc058c584181ea72e17c2ccd49be9ca69ccf4a2b97fc82c89ff1029578abbea"
-API_URL = "https://clipdrop-api.co/text-to-image/v1"
-
-def generate_image(prompt):
- headers = {"x-api-key": API_KEY}
- files = {"prompt": (None, prompt, "text/plain")}
-
- try:
- response = requests.post(API_URL, files=files, headers=headers)
- response.raise_for_status()
-
- # Get the generated image
- image = Image.open(BytesIO(response.content))
-
- return image
- except requests.exceptions.RequestException as e:
- st.error(f"Error occurred during image generation: {str(e)}")
- return None
-
-def main():
- st.title("Text-to-Image Generator")
-
- # Text prompt input
- prompt = st.text_input("Enter a text prompt")
-
- if prompt:
- # Generate image when the "Generate Image" button is clicked
- if st.button("Generate Image"):
- st.write("Generating image...")
- image = generate_image(prompt)
-
- if image:
- # Display the generated image
- st.image(image, caption="Generated Image", use_column_width=True)
-
-if __name__ == "__main__":
- main()
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/aiohttp/helpers.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/aiohttp/helpers.py
deleted file mode 100644
index 874ab1ac076bc311d8853f08bb5fe454b650099f..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/aiohttp/helpers.py
+++ /dev/null
@@ -1,878 +0,0 @@
-"""Various helper functions"""
-
-import asyncio
-import base64
-import binascii
-import datetime
-import functools
-import inspect
-import netrc
-import os
-import platform
-import re
-import sys
-import time
-import warnings
-import weakref
-from collections import namedtuple
-from contextlib import suppress
-from email.parser import HeaderParser
-from email.utils import parsedate
-from math import ceil
-from pathlib import Path
-from types import TracebackType
-from typing import (
- Any,
- Callable,
- ContextManager,
- Dict,
- Generator,
- Generic,
- Iterable,
- Iterator,
- List,
- Mapping,
- Optional,
- Pattern,
- Set,
- Tuple,
- Type,
- TypeVar,
- Union,
- cast,
-)
-from urllib.parse import quote
-from urllib.request import getproxies, proxy_bypass
-
-import async_timeout
-import attr
-from multidict import MultiDict, MultiDictProxy
-from yarl import URL
-
-from . import hdrs
-from .log import client_logger, internal_logger
-from .typedefs import PathLike, Protocol # noqa
-
-__all__ = ("BasicAuth", "ChainMapProxy", "ETag")
-
-IS_MACOS = platform.system() == "Darwin"
-IS_WINDOWS = platform.system() == "Windows"
-
-PY_36 = sys.version_info >= (3, 6)
-PY_37 = sys.version_info >= (3, 7)
-PY_38 = sys.version_info >= (3, 8)
-PY_310 = sys.version_info >= (3, 10)
-PY_311 = sys.version_info >= (3, 11)
-
-if sys.version_info < (3, 7):
- import idna_ssl
-
- idna_ssl.patch_match_hostname()
-
- def all_tasks(
- loop: Optional[asyncio.AbstractEventLoop] = None,
- ) -> Set["asyncio.Task[Any]"]:
- tasks = list(asyncio.Task.all_tasks(loop))
- return {t for t in tasks if not t.done()}
-
-else:
- all_tasks = asyncio.all_tasks
-
-
-_T = TypeVar("_T")
-_S = TypeVar("_S")
-
-
-sentinel: Any = object()
-NO_EXTENSIONS: bool = bool(os.environ.get("AIOHTTP_NO_EXTENSIONS"))
-
-# N.B. sys.flags.dev_mode is available on Python 3.7+, use getattr
-# for compatibility with older versions
-DEBUG: bool = getattr(sys.flags, "dev_mode", False) or (
- not sys.flags.ignore_environment and bool(os.environ.get("PYTHONASYNCIODEBUG"))
-)
-
-
-CHAR = {chr(i) for i in range(0, 128)}
-CTL = {chr(i) for i in range(0, 32)} | {
- chr(127),
-}
-SEPARATORS = {
- "(",
- ")",
- "<",
- ">",
- "@",
- ",",
- ";",
- ":",
- "\\",
- '"',
- "/",
- "[",
- "]",
- "?",
- "=",
- "{",
- "}",
- " ",
- chr(9),
-}
-TOKEN = CHAR ^ CTL ^ SEPARATORS
-
-
-class noop:
- def __await__(self) -> Generator[None, None, None]:
- yield
-
-
-class BasicAuth(namedtuple("BasicAuth", ["login", "password", "encoding"])):
- """Http basic authentication helper."""
-
- def __new__(
- cls, login: str, password: str = "", encoding: str = "latin1"
- ) -> "BasicAuth":
- if login is None:
- raise ValueError("None is not allowed as login value")
-
- if password is None:
- raise ValueError("None is not allowed as password value")
-
- if ":" in login:
- raise ValueError('A ":" is not allowed in login (RFC 1945#section-11.1)')
-
- return super().__new__(cls, login, password, encoding)
-
- @classmethod
- def decode(cls, auth_header: str, encoding: str = "latin1") -> "BasicAuth":
- """Create a BasicAuth object from an Authorization HTTP header."""
- try:
- auth_type, encoded_credentials = auth_header.split(" ", 1)
- except ValueError:
- raise ValueError("Could not parse authorization header.")
-
- if auth_type.lower() != "basic":
- raise ValueError("Unknown authorization method %s" % auth_type)
-
- try:
- decoded = base64.b64decode(
- encoded_credentials.encode("ascii"), validate=True
- ).decode(encoding)
- except binascii.Error:
- raise ValueError("Invalid base64 encoding.")
-
- try:
- # RFC 2617 HTTP Authentication
- # https://www.ietf.org/rfc/rfc2617.txt
- # the colon must be present, but the username and password may be
- # otherwise blank.
- username, password = decoded.split(":", 1)
- except ValueError:
- raise ValueError("Invalid credentials.")
-
- return cls(username, password, encoding=encoding)
-
- @classmethod
- def from_url(cls, url: URL, *, encoding: str = "latin1") -> Optional["BasicAuth"]:
- """Create BasicAuth from url."""
- if not isinstance(url, URL):
- raise TypeError("url should be yarl.URL instance")
- if url.user is None:
- return None
- return cls(url.user, url.password or "", encoding=encoding)
-
- def encode(self) -> str:
- """Encode credentials."""
- creds = (f"{self.login}:{self.password}").encode(self.encoding)
- return "Basic %s" % base64.b64encode(creds).decode(self.encoding)
-
-
-def strip_auth_from_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
- auth = BasicAuth.from_url(url)
- if auth is None:
- return url, None
- else:
- return url.with_user(None), auth
-
-
-def netrc_from_env() -> Optional[netrc.netrc]:
- """Load netrc from file.
-
- Attempt to load it from the path specified by the env-var
- NETRC or in the default location in the user's home directory.
-
- Returns None if it couldn't be found or fails to parse.
- """
- netrc_env = os.environ.get("NETRC")
-
- if netrc_env is not None:
- netrc_path = Path(netrc_env)
- else:
- try:
- home_dir = Path.home()
- except RuntimeError as e: # pragma: no cover
- # if pathlib can't resolve home, it may raise a RuntimeError
- client_logger.debug(
- "Could not resolve home directory when "
- "trying to look for .netrc file: %s",
- e,
- )
- return None
-
- netrc_path = home_dir / ("_netrc" if IS_WINDOWS else ".netrc")
-
- try:
- return netrc.netrc(str(netrc_path))
- except netrc.NetrcParseError as e:
- client_logger.warning("Could not parse .netrc file: %s", e)
- except OSError as e:
- # we couldn't read the file (doesn't exist, permissions, etc.)
- if netrc_env or netrc_path.is_file():
- # only warn if the environment wanted us to load it,
- # or it appears like the default file does actually exist
- client_logger.warning("Could not read .netrc file: %s", e)
-
- return None
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class ProxyInfo:
- proxy: URL
- proxy_auth: Optional[BasicAuth]
-
-
-def proxies_from_env() -> Dict[str, ProxyInfo]:
- proxy_urls = {
- k: URL(v)
- for k, v in getproxies().items()
- if k in ("http", "https", "ws", "wss")
- }
- netrc_obj = netrc_from_env()
- stripped = {k: strip_auth_from_url(v) for k, v in proxy_urls.items()}
- ret = {}
- for proto, val in stripped.items():
- proxy, auth = val
- if proxy.scheme in ("https", "wss"):
- client_logger.warning(
- "%s proxies %s are not supported, ignoring", proxy.scheme.upper(), proxy
- )
- continue
- if netrc_obj and auth is None:
- auth_from_netrc = None
- if proxy.host is not None:
- auth_from_netrc = netrc_obj.authenticators(proxy.host)
- if auth_from_netrc is not None:
- # auth_from_netrc is a (`user`, `account`, `password`) tuple,
- # `user` and `account` both can be username,
- # if `user` is None, use `account`
- *logins, password = auth_from_netrc
- login = logins[0] if logins[0] else logins[-1]
- auth = BasicAuth(cast(str, login), cast(str, password))
- ret[proto] = ProxyInfo(proxy, auth)
- return ret
-
-
-def current_task(
- loop: Optional[asyncio.AbstractEventLoop] = None,
-) -> "Optional[asyncio.Task[Any]]":
- if sys.version_info >= (3, 7):
- return asyncio.current_task(loop=loop)
- else:
- return asyncio.Task.current_task(loop=loop)
-
-
-def get_running_loop(
- loop: Optional[asyncio.AbstractEventLoop] = None,
-) -> asyncio.AbstractEventLoop:
- if loop is None:
- loop = asyncio.get_event_loop()
- if not loop.is_running():
- warnings.warn(
- "The object should be created within an async function",
- DeprecationWarning,
- stacklevel=3,
- )
- if loop.get_debug():
- internal_logger.warning(
- "The object should be created within an async function", stack_info=True
- )
- return loop
-
-
-def isasyncgenfunction(obj: Any) -> bool:
- func = getattr(inspect, "isasyncgenfunction", None)
- if func is not None:
- return func(obj) # type: ignore[no-any-return]
- else:
- return False
-
-
-def get_env_proxy_for_url(url: URL) -> Tuple[URL, Optional[BasicAuth]]:
- """Get a permitted proxy for the given URL from the env."""
- if url.host is not None and proxy_bypass(url.host):
- raise LookupError(f"Proxying is disallowed for `{url.host!r}`")
-
- proxies_in_env = proxies_from_env()
- try:
- proxy_info = proxies_in_env[url.scheme]
- except KeyError:
- raise LookupError(f"No proxies found for `{url!s}` in the env")
- else:
- return proxy_info.proxy, proxy_info.proxy_auth
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class MimeType:
- type: str
- subtype: str
- suffix: str
- parameters: "MultiDictProxy[str]"
-
-
-@functools.lru_cache(maxsize=56)
-def parse_mimetype(mimetype: str) -> MimeType:
- """Parses a MIME type into its components.
-
- mimetype is a MIME type string.
-
- Returns a MimeType object.
-
- Example:
-
- >>> parse_mimetype('text/html; charset=utf-8')
- MimeType(type='text', subtype='html', suffix='',
- parameters={'charset': 'utf-8'})
-
- """
- if not mimetype:
- return MimeType(
- type="", subtype="", suffix="", parameters=MultiDictProxy(MultiDict())
- )
-
- parts = mimetype.split(";")
- params: MultiDict[str] = MultiDict()
- for item in parts[1:]:
- if not item:
- continue
- key, value = cast(
- Tuple[str, str], item.split("=", 1) if "=" in item else (item, "")
- )
- params.add(key.lower().strip(), value.strip(' "'))
-
- fulltype = parts[0].strip().lower()
- if fulltype == "*":
- fulltype = "*/*"
-
- mtype, stype = (
- cast(Tuple[str, str], fulltype.split("/", 1))
- if "/" in fulltype
- else (fulltype, "")
- )
- stype, suffix = (
- cast(Tuple[str, str], stype.split("+", 1)) if "+" in stype else (stype, "")
- )
-
- return MimeType(
- type=mtype, subtype=stype, suffix=suffix, parameters=MultiDictProxy(params)
- )
-
-
-def guess_filename(obj: Any, default: Optional[str] = None) -> Optional[str]:
- name = getattr(obj, "name", None)
- if name and isinstance(name, str) and name[0] != "<" and name[-1] != ">":
- return Path(name).name
- return default
-
-
-not_qtext_re = re.compile(r"[^\041\043-\133\135-\176]")
-QCONTENT = {chr(i) for i in range(0x20, 0x7F)} | {"\t"}
-
-
-def quoted_string(content: str) -> str:
- """Return 7-bit content as quoted-string.
-
- Format content into a quoted-string as defined in RFC5322 for
- Internet Message Format. Notice that this is not the 8-bit HTTP
- format, but the 7-bit email format. Content must be in usascii or
- a ValueError is raised.
- """
- if not (QCONTENT > set(content)):
- raise ValueError(f"bad content for quoted-string {content!r}")
- return not_qtext_re.sub(lambda x: "\\" + x.group(0), content)
-
-
-def content_disposition_header(
- disptype: str, quote_fields: bool = True, _charset: str = "utf-8", **params: str
-) -> str:
- """Sets ``Content-Disposition`` header for MIME.
-
- This is the MIME payload Content-Disposition header from RFC 2183
- and RFC 7579 section 4.2, not the HTTP Content-Disposition from
- RFC 6266.
-
- disptype is a disposition type: inline, attachment, form-data.
- Should be valid extension token (see RFC 2183)
-
- quote_fields performs value quoting to 7-bit MIME headers
- according to RFC 7578. Set to quote_fields to False if recipient
- can take 8-bit file names and field values.
-
- _charset specifies the charset to use when quote_fields is True.
-
- params is a dict with disposition params.
- """
- if not disptype or not (TOKEN > set(disptype)):
- raise ValueError("bad content disposition type {!r}" "".format(disptype))
-
- value = disptype
- if params:
- lparams = []
- for key, val in params.items():
- if not key or not (TOKEN > set(key)):
- raise ValueError(
- "bad content disposition parameter" " {!r}={!r}".format(key, val)
- )
- if quote_fields:
- if key.lower() == "filename":
- qval = quote(val, "", encoding=_charset)
- lparams.append((key, '"%s"' % qval))
- else:
- try:
- qval = quoted_string(val)
- except ValueError:
- qval = "".join(
- (_charset, "''", quote(val, "", encoding=_charset))
- )
- lparams.append((key + "*", qval))
- else:
- lparams.append((key, '"%s"' % qval))
- else:
- qval = val.replace("\\", "\\\\").replace('"', '\\"')
- lparams.append((key, '"%s"' % qval))
- sparams = "; ".join("=".join(pair) for pair in lparams)
- value = "; ".join((value, sparams))
- return value
-
-
-class _TSelf(Protocol, Generic[_T]):
- _cache: Dict[str, _T]
-
-
-class reify(Generic[_T]):
- """Use as a class method decorator.
-
- It operates almost exactly like
- the Python `@property` decorator, but it puts the result of the
- method it decorates into the instance dict after the first call,
- effectively replacing the function it decorates with an instance
- variable. It is, in Python parlance, a data descriptor.
- """
-
- def __init__(self, wrapped: Callable[..., _T]) -> None:
- self.wrapped = wrapped
- self.__doc__ = wrapped.__doc__
- self.name = wrapped.__name__
-
- def __get__(self, inst: _TSelf[_T], owner: Optional[Type[Any]] = None) -> _T:
- try:
- try:
- return inst._cache[self.name]
- except KeyError:
- val = self.wrapped(inst)
- inst._cache[self.name] = val
- return val
- except AttributeError:
- if inst is None:
- return self
- raise
-
- def __set__(self, inst: _TSelf[_T], value: _T) -> None:
- raise AttributeError("reified property is read-only")
-
-
-reify_py = reify
-
-try:
- from ._helpers import reify as reify_c
-
- if not NO_EXTENSIONS:
- reify = reify_c # type: ignore[misc,assignment]
-except ImportError:
- pass
-
-_ipv4_pattern = (
- r"^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}"
- r"(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$"
-)
-_ipv6_pattern = (
- r"^(?:(?:(?:[A-F0-9]{1,4}:){6}|(?=(?:[A-F0-9]{0,4}:){0,6}"
- r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}$)(([0-9A-F]{1,4}:){0,5}|:)"
- r"((:[0-9A-F]{1,4}){1,5}:|:)|::(?:[A-F0-9]{1,4}:){5})"
- r"(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])\.){3}"
- r"(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9]?[0-9])|(?:[A-F0-9]{1,4}:){7}"
- r"[A-F0-9]{1,4}|(?=(?:[A-F0-9]{0,4}:){0,7}[A-F0-9]{0,4}$)"
- r"(([0-9A-F]{1,4}:){1,7}|:)((:[0-9A-F]{1,4}){1,7}|:)|(?:[A-F0-9]{1,4}:){7}"
- r":|:(:[A-F0-9]{1,4}){7})$"
-)
-_ipv4_regex = re.compile(_ipv4_pattern)
-_ipv6_regex = re.compile(_ipv6_pattern, flags=re.IGNORECASE)
-_ipv4_regexb = re.compile(_ipv4_pattern.encode("ascii"))
-_ipv6_regexb = re.compile(_ipv6_pattern.encode("ascii"), flags=re.IGNORECASE)
-
-
-def _is_ip_address(
- regex: Pattern[str], regexb: Pattern[bytes], host: Optional[Union[str, bytes]]
-) -> bool:
- if host is None:
- return False
- if isinstance(host, str):
- return bool(regex.match(host))
- elif isinstance(host, (bytes, bytearray, memoryview)):
- return bool(regexb.match(host))
- else:
- raise TypeError(f"{host} [{type(host)}] is not a str or bytes")
-
-
-is_ipv4_address = functools.partial(_is_ip_address, _ipv4_regex, _ipv4_regexb)
-is_ipv6_address = functools.partial(_is_ip_address, _ipv6_regex, _ipv6_regexb)
-
-
-def is_ip_address(host: Optional[Union[str, bytes, bytearray, memoryview]]) -> bool:
- return is_ipv4_address(host) or is_ipv6_address(host)
-
-
-def next_whole_second() -> datetime.datetime:
- """Return current time rounded up to the next whole second."""
- return datetime.datetime.now(datetime.timezone.utc).replace(
- microsecond=0
- ) + datetime.timedelta(seconds=0)
-
-
-_cached_current_datetime: Optional[int] = None
-_cached_formatted_datetime = ""
-
-
-def rfc822_formatted_time() -> str:
- global _cached_current_datetime
- global _cached_formatted_datetime
-
- now = int(time.time())
- if now != _cached_current_datetime:
- # Weekday and month names for HTTP date/time formatting;
- # always English!
- # Tuples are constants stored in codeobject!
- _weekdayname = ("Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun")
- _monthname = (
- "", # Dummy so we can use 1-based month numbers
- "Jan",
- "Feb",
- "Mar",
- "Apr",
- "May",
- "Jun",
- "Jul",
- "Aug",
- "Sep",
- "Oct",
- "Nov",
- "Dec",
- )
-
- year, month, day, hh, mm, ss, wd, *tail = time.gmtime(now)
- _cached_formatted_datetime = "%s, %02d %3s %4d %02d:%02d:%02d GMT" % (
- _weekdayname[wd],
- day,
- _monthname[month],
- year,
- hh,
- mm,
- ss,
- )
- _cached_current_datetime = now
- return _cached_formatted_datetime
-
-
-def _weakref_handle(info: "Tuple[weakref.ref[object], str]") -> None:
- ref, name = info
- ob = ref()
- if ob is not None:
- with suppress(Exception):
- getattr(ob, name)()
-
-
-def weakref_handle(
- ob: object, name: str, timeout: float, loop: asyncio.AbstractEventLoop
-) -> Optional[asyncio.TimerHandle]:
- if timeout is not None and timeout > 0:
- when = loop.time() + timeout
- if timeout >= 5:
- when = ceil(when)
-
- return loop.call_at(when, _weakref_handle, (weakref.ref(ob), name))
- return None
-
-
-def call_later(
- cb: Callable[[], Any], timeout: float, loop: asyncio.AbstractEventLoop
-) -> Optional[asyncio.TimerHandle]:
- if timeout is not None and timeout > 0:
- when = loop.time() + timeout
- if timeout > 5:
- when = ceil(when)
- return loop.call_at(when, cb)
- return None
-
-
-class TimeoutHandle:
- """Timeout handle"""
-
- def __init__(
- self, loop: asyncio.AbstractEventLoop, timeout: Optional[float]
- ) -> None:
- self._timeout = timeout
- self._loop = loop
- self._callbacks: List[
- Tuple[Callable[..., None], Tuple[Any, ...], Dict[str, Any]]
- ] = []
-
- def register(
- self, callback: Callable[..., None], *args: Any, **kwargs: Any
- ) -> None:
- self._callbacks.append((callback, args, kwargs))
-
- def close(self) -> None:
- self._callbacks.clear()
-
- def start(self) -> Optional[asyncio.Handle]:
- timeout = self._timeout
- if timeout is not None and timeout > 0:
- when = self._loop.time() + timeout
- if timeout >= 5:
- when = ceil(when)
- return self._loop.call_at(when, self.__call__)
- else:
- return None
-
- def timer(self) -> "BaseTimerContext":
- if self._timeout is not None and self._timeout > 0:
- timer = TimerContext(self._loop)
- self.register(timer.timeout)
- return timer
- else:
- return TimerNoop()
-
- def __call__(self) -> None:
- for cb, args, kwargs in self._callbacks:
- with suppress(Exception):
- cb(*args, **kwargs)
-
- self._callbacks.clear()
-
-
-class BaseTimerContext(ContextManager["BaseTimerContext"]):
- pass
-
-
-class TimerNoop(BaseTimerContext):
- def __enter__(self) -> BaseTimerContext:
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> None:
- return
-
-
-class TimerContext(BaseTimerContext):
- """Low resolution timeout context manager"""
-
- def __init__(self, loop: asyncio.AbstractEventLoop) -> None:
- self._loop = loop
- self._tasks: List[asyncio.Task[Any]] = []
- self._cancelled = False
-
- def __enter__(self) -> BaseTimerContext:
- task = current_task(loop=self._loop)
-
- if task is None:
- raise RuntimeError(
- "Timeout context manager should be used " "inside a task"
- )
-
- if self._cancelled:
- raise asyncio.TimeoutError from None
-
- self._tasks.append(task)
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> Optional[bool]:
- if self._tasks:
- self._tasks.pop()
-
- if exc_type is asyncio.CancelledError and self._cancelled:
- raise asyncio.TimeoutError from None
- return None
-
- def timeout(self) -> None:
- if not self._cancelled:
- for task in set(self._tasks):
- task.cancel()
-
- self._cancelled = True
-
-
-def ceil_timeout(delay: Optional[float]) -> async_timeout.Timeout:
- if delay is None or delay <= 0:
- return async_timeout.timeout(None)
-
- loop = get_running_loop()
- now = loop.time()
- when = now + delay
- if delay > 5:
- when = ceil(when)
- return async_timeout.timeout_at(when)
-
-
-class HeadersMixin:
-
- ATTRS = frozenset(["_content_type", "_content_dict", "_stored_content_type"])
-
- _content_type: Optional[str] = None
- _content_dict: Optional[Dict[str, str]] = None
- _stored_content_type = sentinel
-
- def _parse_content_type(self, raw: str) -> None:
- self._stored_content_type = raw
- if raw is None:
- # default value according to RFC 2616
- self._content_type = "application/octet-stream"
- self._content_dict = {}
- else:
- msg = HeaderParser().parsestr("Content-Type: " + raw)
- self._content_type = msg.get_content_type()
- params = msg.get_params()
- self._content_dict = dict(params[1:]) # First element is content type again
-
- @property
- def content_type(self) -> str:
- """The value of content part for Content-Type HTTP header."""
- raw = self._headers.get(hdrs.CONTENT_TYPE) # type: ignore[attr-defined]
- if self._stored_content_type != raw:
- self._parse_content_type(raw)
- return self._content_type # type: ignore[return-value]
-
- @property
- def charset(self) -> Optional[str]:
- """The value of charset part for Content-Type HTTP header."""
- raw = self._headers.get(hdrs.CONTENT_TYPE) # type: ignore[attr-defined]
- if self._stored_content_type != raw:
- self._parse_content_type(raw)
- return self._content_dict.get("charset") # type: ignore[union-attr]
-
- @property
- def content_length(self) -> Optional[int]:
- """The value of Content-Length HTTP header."""
- content_length = self._headers.get( # type: ignore[attr-defined]
- hdrs.CONTENT_LENGTH
- )
-
- if content_length is not None:
- return int(content_length)
- else:
- return None
-
-
-def set_result(fut: "asyncio.Future[_T]", result: _T) -> None:
- if not fut.done():
- fut.set_result(result)
-
-
-def set_exception(fut: "asyncio.Future[_T]", exc: BaseException) -> None:
- if not fut.done():
- fut.set_exception(exc)
-
-
-class ChainMapProxy(Mapping[str, Any]):
- __slots__ = ("_maps",)
-
- def __init__(self, maps: Iterable[Mapping[str, Any]]) -> None:
- self._maps = tuple(maps)
-
- def __init_subclass__(cls) -> None:
- raise TypeError(
- "Inheritance class {} from ChainMapProxy "
- "is forbidden".format(cls.__name__)
- )
-
- def __getitem__(self, key: str) -> Any:
- for mapping in self._maps:
- try:
- return mapping[key]
- except KeyError:
- pass
- raise KeyError(key)
-
- def get(self, key: str, default: Any = None) -> Any:
- return self[key] if key in self else default
-
- def __len__(self) -> int:
- # reuses stored hash values if possible
- return len(set().union(*self._maps)) # type: ignore[arg-type]
-
- def __iter__(self) -> Iterator[str]:
- d: Dict[str, Any] = {}
- for mapping in reversed(self._maps):
- # reuses stored hash values if possible
- d.update(mapping)
- return iter(d)
-
- def __contains__(self, key: object) -> bool:
- return any(key in m for m in self._maps)
-
- def __bool__(self) -> bool:
- return any(self._maps)
-
- def __repr__(self) -> str:
- content = ", ".join(map(repr, self._maps))
- return f"ChainMapProxy({content})"
-
-
-# https://tools.ietf.org/html/rfc7232#section-2.3
-_ETAGC = r"[!#-}\x80-\xff]+"
-_ETAGC_RE = re.compile(_ETAGC)
-_QUOTED_ETAG = rf'(W/)?"({_ETAGC})"'
-QUOTED_ETAG_RE = re.compile(_QUOTED_ETAG)
-LIST_QUOTED_ETAG_RE = re.compile(rf"({_QUOTED_ETAG})(?:\s*,\s*|$)|(.)")
-
-ETAG_ANY = "*"
-
-
-@attr.s(auto_attribs=True, frozen=True, slots=True)
-class ETag:
- value: str
- is_weak: bool = False
-
-
-def validate_etag_value(value: str) -> None:
- if value != ETAG_ANY and not _ETAGC_RE.fullmatch(value):
- raise ValueError(
- f"Value {value!r} is not a valid etag. Maybe it contains '\"'?"
- )
-
-
-def parse_http_date(date_str: Optional[str]) -> Optional[datetime.datetime]:
- """Process a date string, return a datetime object"""
- if date_str is not None:
- timetuple = parsedate(date_str)
- if timetuple is not None:
- with suppress(ValueError):
- return datetime.datetime(*timetuple[:6], tzinfo=datetime.timezone.utc)
- return None
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/server/fastapi/types.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/server/fastapi/types.py
deleted file mode 100644
index fc12949dcd06f0a8b8187669f5759107fd5afb79..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/chromadb/server/fastapi/types.py
+++ /dev/null
@@ -1,67 +0,0 @@
-from pydantic import BaseModel
-from typing import Any, Dict, List, Optional
-from chromadb.api.types import (
- CollectionMetadata,
- Include,
-)
-
-
-class AddEmbedding(BaseModel): # type: ignore
- # Pydantic doesn't handle Union types cleanly like Embeddings which has
- # Union[int, float] so we use Any here to ensure data is parsed
- # to its original type.
- embeddings: Optional[List[Any]] = None
- metadatas: Optional[List[Dict[Any, Any]]] = None
- documents: Optional[List[str]] = None
- ids: List[str]
- increment_index: bool = True
-
-
-class UpdateEmbedding(BaseModel): # type: ignore
- embeddings: Optional[List[Any]] = None
- metadatas: Optional[List[Dict[Any, Any]]] = None
- documents: Optional[List[str]] = None
- ids: List[str]
- increment_index: bool = True
-
-
-class QueryEmbedding(BaseModel): # type: ignore
- # TODO: Pydantic doesn't bode well with recursive types so we use generic Dicts
- # for Where and WhereDocument. This is not ideal, but it works for now since
- # there is a lot of downstream validation.
- where: Optional[Dict[Any, Any]] = {}
- where_document: Optional[Dict[Any, Any]] = {}
- query_embeddings: List[Any]
- n_results: int = 10
- include: Include = ["metadatas", "documents", "distances"]
-
-
-class GetEmbedding(BaseModel): # type: ignore
- ids: Optional[List[str]] = None
- where: Optional[Dict[Any, Any]] = None
- where_document: Optional[Dict[Any, Any]] = None
- sort: Optional[str] = None
- limit: Optional[int] = None
- offset: Optional[int] = None
- include: Include = ["metadatas", "documents"]
-
-
-class RawSql(BaseModel): # type: ignore
- raw_sql: str
-
-
-class DeleteEmbedding(BaseModel): # type: ignore
- ids: Optional[List[str]] = None
- where: Optional[Dict[Any, Any]] = None
- where_document: Optional[Dict[Any, Any]] = None
-
-
-class CreateCollection(BaseModel): # type: ignore
- name: str
- metadata: Optional[CollectionMetadata] = None
- get_or_create: bool = False
-
-
-class UpdateCollection(BaseModel): # type: ignore
- new_name: Optional[str] = None
- new_metadata: Optional[CollectionMetadata] = None
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/dataclasses_json/mm.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/dataclasses_json/mm.py
deleted file mode 100644
index 2125de6e5db136802a767279883242358d70dd31..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/dataclasses_json/mm.py
+++ /dev/null
@@ -1,373 +0,0 @@
-# flake8: noqa
-
-import typing
-import warnings
-import sys
-from copy import deepcopy
-
-from dataclasses import MISSING, is_dataclass, fields as dc_fields
-from datetime import datetime
-from decimal import Decimal
-from uuid import UUID
-from enum import Enum
-
-from typing_inspect import is_union_type # type: ignore
-
-from marshmallow import fields, Schema, post_load
-from marshmallow_enum import EnumField # type: ignore
-from marshmallow.exceptions import ValidationError
-
-from dataclasses_json.core import (_is_supported_generic, _decode_dataclass,
- _ExtendedEncoder, _user_overrides_or_exts)
-from dataclasses_json.utils import (_is_collection, _is_optional,
- _issubclass_safe, _timestamp_to_dt_aware,
- _is_new_type, _get_type_origin,
- _handle_undefined_parameters_safe,
- CatchAllVar)
-
-
-class _TimestampField(fields.Field):
- def _serialize(self, value, attr, obj, **kwargs):
- if value is not None:
- return value.timestamp()
- else:
- if not self.required:
- return None
- else:
- raise ValidationError(self.default_error_messages["required"])
-
- def _deserialize(self, value, attr, data, **kwargs):
- if value is not None:
- return _timestamp_to_dt_aware(value)
- else:
- if not self.required:
- return None
- else:
- raise ValidationError(self.default_error_messages["required"])
-
-
-class _IsoField(fields.Field):
- def _serialize(self, value, attr, obj, **kwargs):
- if value is not None:
- return value.isoformat()
- else:
- if not self.required:
- return None
- else:
- raise ValidationError(self.default_error_messages["required"])
-
- def _deserialize(self, value, attr, data, **kwargs):
- if value is not None:
- return datetime.fromisoformat(value)
- else:
- if not self.required:
- return None
- else:
- raise ValidationError(self.default_error_messages["required"])
-
-
-class _UnionField(fields.Field):
- def __init__(self, desc, cls, field, *args, **kwargs):
- self.desc = desc
- self.cls = cls
- self.field = field
- super().__init__(*args, **kwargs)
-
- def _serialize(self, value, attr, obj, **kwargs):
- if self.allow_none and value is None:
- return None
- for type_, schema_ in self.desc.items():
- if _issubclass_safe(type(value), type_):
- if is_dataclass(value):
- res = schema_._serialize(value, attr, obj, **kwargs)
- res['__type'] = str(type_.__name__)
- return res
- break
- elif isinstance(value, _get_type_origin(type_)):
- return schema_._serialize(value, attr, obj, **kwargs)
- else:
- warnings.warn(
- f'The type "{type(value).__name__}" (value: "{value}") '
- f'is not in the list of possible types of typing.Union '
- f'(dataclass: {self.cls.__name__}, field: {self.field.name}). '
- f'Value cannot be serialized properly.')
- return super()._serialize(value, attr, obj, **kwargs)
-
- def _deserialize(self, value, attr, data, **kwargs):
- tmp_value = deepcopy(value)
- if isinstance(tmp_value, dict) and '__type' in tmp_value:
- dc_name = tmp_value['__type']
- for type_, schema_ in self.desc.items():
- if is_dataclass(type_) and type_.__name__ == dc_name:
- del tmp_value['__type']
- return schema_._deserialize(tmp_value, attr, data, **kwargs)
- for type_, schema_ in self.desc.items():
- if isinstance(tmp_value, _get_type_origin(type_)):
- return schema_._deserialize(tmp_value, attr, data, **kwargs)
- else:
- warnings.warn(
- f'The type "{type(tmp_value).__name__}" (value: "{tmp_value}") '
- f'is not in the list of possible types of typing.Union '
- f'(dataclass: {self.cls.__name__}, field: {self.field.name}). '
- f'Value cannot be deserialized properly.')
- return super()._deserialize(tmp_value, attr, data, **kwargs)
-
-
-TYPES = {
- typing.Mapping: fields.Mapping,
- typing.MutableMapping: fields.Mapping,
- typing.List: fields.List,
- typing.Dict: fields.Dict,
- typing.Tuple: fields.Tuple,
- typing.Callable: fields.Function,
- typing.Any: fields.Raw,
- dict: fields.Dict,
- list: fields.List,
- tuple: fields.Tuple,
- str: fields.Str,
- int: fields.Int,
- float: fields.Float,
- bool: fields.Bool,
- datetime: _TimestampField,
- UUID: fields.UUID,
- Decimal: fields.Decimal,
- CatchAllVar: fields.Dict,
-}
-
-A = typing.TypeVar('A')
-JsonData = typing.Union[str, bytes, bytearray]
-TEncoded = typing.Dict[str, typing.Any]
-TOneOrMulti = typing.Union[typing.List[A], A]
-TOneOrMultiEncoded = typing.Union[typing.List[TEncoded], TEncoded]
-
-if sys.version_info >= (3, 7):
- class SchemaF(Schema, typing.Generic[A]):
- """Lift Schema into a type constructor"""
-
- def __init__(self, *args, **kwargs):
- """
- Raises exception because this class should not be inherited.
- This class is helper only.
- """
-
- super().__init__(*args, **kwargs)
- raise NotImplementedError()
-
- @typing.overload
- def dump(self, obj: typing.List[A], many: bool = None) -> typing.List[
- TEncoded]: # type: ignore
- # mm has the wrong return type annotation (dict) so we can ignore the mypy error
- pass
-
- @typing.overload
- def dump(self, obj: A, many: bool = None) -> TEncoded:
- pass
-
- def dump(self, obj: TOneOrMulti,
- many: bool = None) -> TOneOrMultiEncoded:
- pass
-
- @typing.overload
- def dumps(self, obj: typing.List[A], many: bool = None, *args,
- **kwargs) -> str:
- pass
-
- @typing.overload
- def dumps(self, obj: A, many: bool = None, *args, **kwargs) -> str:
- pass
-
- def dumps(self, obj: TOneOrMulti, many: bool = None, *args,
- **kwargs) -> str:
- pass
-
- @typing.overload # type: ignore
- def load(self, data: typing.List[TEncoded],
- many: bool = True, partial: bool = None,
- unknown: str = None) -> \
- typing.List[A]:
- # ignore the mypy error of the decorator because mm does not define lists as an allowed input type
- pass
-
- @typing.overload
- def load(self, data: TEncoded,
- many: None = None, partial: bool = None,
- unknown: str = None) -> A:
- pass
-
- def load(self, data: TOneOrMultiEncoded,
- many: bool = None, partial: bool = None,
- unknown: str = None) -> TOneOrMulti:
- pass
-
- @typing.overload # type: ignore
- def loads(self, json_data: JsonData, # type: ignore
- many: bool = True, partial: bool = None, unknown: str = None,
- **kwargs) -> typing.List[A]:
- # ignore the mypy error of the decorator because mm does not define bytes as correct input data
- # mm has the wrong return type annotation (dict) so we can ignore the mypy error
- # for the return type overlap
- pass
-
- @typing.overload
- def loads(self, json_data: JsonData,
- many: None = None, partial: bool = None, unknown: str = None,
- **kwargs) -> A:
- pass
-
- def loads(self, json_data: JsonData,
- many: bool = None, partial: bool = None, unknown: str = None,
- **kwargs) -> TOneOrMulti:
- pass
-
-
- SchemaType = SchemaF[A]
-else:
- SchemaType = Schema
-
-
-def build_type(type_, options, mixin, field, cls):
- def inner(type_, options):
- while True:
- if not _is_new_type(type_):
- break
-
- type_ = type_.__supertype__
-
- if is_dataclass(type_):
- if _issubclass_safe(type_, mixin):
- options['field_many'] = bool(
- _is_supported_generic(field.type) and _is_collection(
- field.type))
- return fields.Nested(type_.schema(), **options)
- else:
- warnings.warn(f"Nested dataclass field {field.name} of type "
- f"{field.type} detected in "
- f"{cls.__name__} that is not an instance of "
- f"dataclass_json. Did you mean to recursively "
- f"serialize this field? If so, make sure to "
- f"augment {type_} with either the "
- f"`dataclass_json` decorator or mixin.")
- return fields.Field(**options)
-
- origin = getattr(type_, '__origin__', type_)
- args = [inner(a, {}) for a in getattr(type_, '__args__', []) if
- a is not type(None)]
-
- if _is_optional(type_):
- options["allow_none"] = True
-
- if origin in TYPES:
- return TYPES[origin](*args, **options)
-
- if _issubclass_safe(origin, Enum):
- return EnumField(enum=origin, by_value=True, *args, **options)
-
- if is_union_type(type_):
- union_types = [a for a in getattr(type_, '__args__', []) if
- a is not type(None)]
- union_desc = dict(zip(union_types, args))
- return _UnionField(union_desc, cls, field, **options)
-
- warnings.warn(
- f"Unknown type {type_} at {cls.__name__}.{field.name}: {field.type} "
- f"It's advised to pass the correct marshmallow type to `mm_field`.")
- return fields.Field(**options)
-
- return inner(type_, options)
-
-
-def schema(cls, mixin, infer_missing):
- schema = {}
- overrides = _user_overrides_or_exts(cls)
- # TODO check the undefined parameters and add the proper schema action
- # https://marshmallow.readthedocs.io/en/stable/quickstart.html
- for field in dc_fields(cls):
- metadata = (field.metadata or {}).get('dataclasses_json', {})
- metadata = overrides[field.name]
- if metadata.mm_field is not None:
- schema[field.name] = metadata.mm_field
- else:
- type_ = field.type
- options = {}
- missing_key = 'missing' if infer_missing else 'default'
- if field.default is not MISSING:
- options[missing_key] = field.default
- elif field.default_factory is not MISSING:
- options[missing_key] = field.default_factory
-
- if options.get(missing_key, ...) is None:
- options['allow_none'] = True
-
- if _is_optional(type_):
- options.setdefault(missing_key, None)
- options['allow_none'] = True
- if len(type_.__args__) == 2:
- # Union[str, int, None] is optional too, but it has more than 1 typed field.
- type_ = type_.__args__[0]
-
- if metadata.letter_case is not None:
- options['data_key'] = metadata.letter_case(field.name)
-
- t = build_type(type_, options, mixin, field, cls)
- # if type(t) is not fields.Field: # If we use `isinstance` we would return nothing.
- if field.type != typing.Optional[CatchAllVar]:
- schema[field.name] = t
-
- return schema
-
-
-def build_schema(cls: typing.Type[A],
- mixin,
- infer_missing,
- partial) -> typing.Type[SchemaType]:
- Meta = type('Meta',
- (),
- {'fields': tuple(field.name for field in dc_fields(cls)
- if
- field.name != 'dataclass_json_config' and field.type !=
- typing.Optional[CatchAllVar]),
- # TODO #180
- # 'render_module': global_config.json_module
- })
-
- @post_load
- def make_instance(self, kvs, **kwargs):
- return _decode_dataclass(cls, kvs, partial)
-
- def dumps(self, *args, **kwargs):
- if 'cls' not in kwargs:
- kwargs['cls'] = _ExtendedEncoder
-
- return Schema.dumps(self, *args, **kwargs)
-
- def dump(self, obj, *, many=None):
- many = self.many if many is None else bool(many)
- dumped = Schema.dump(self, obj, many=many)
- # TODO This is hacky, but the other option I can think of is to generate a different schema
- # depending on dump and load, which is even more hacky
-
- # The only problem is the catch all field, we can't statically create a schema for it
- # so we just update the dumped dict
- if many:
- for i, _obj in enumerate(obj):
- dumped[i].update(
- _handle_undefined_parameters_safe(cls=_obj, kvs={},
- usage="dump"))
- else:
- dumped.update(_handle_undefined_parameters_safe(cls=obj, kvs={},
- usage="dump"))
- return dumped
-
- schema_ = schema(cls, mixin, infer_missing)
- DataClassSchema: typing.Type[SchemaType] = type(
- f'{cls.__name__.capitalize()}Schema',
- (Schema,),
- {'Meta': Meta,
- f'make_{cls.__name__.lower()}': make_instance,
- 'dumps': dumps,
- 'dump': dump,
- **schema_})
-
- return DataClassSchema
-
-
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydev_ipython/inputhookwx.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydev_ipython/inputhookwx.py
deleted file mode 100644
index c2e4b91d0c81d518e9a9f7c2c8e071b53b670489..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydev_ipython/inputhookwx.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# encoding: utf-8
-"""
-Enable wxPython to be used interacive by setting PyOS_InputHook.
-
-Authors: Robin Dunn, Brian Granger, Ondrej Certik
-"""
-
-#-----------------------------------------------------------------------------
-# Copyright (C) 2008-2011 The IPython Development Team
-#
-# Distributed under the terms of the BSD License. The full license is in
-# the file COPYING, distributed as part of this software.
-#-----------------------------------------------------------------------------
-
-#-----------------------------------------------------------------------------
-# Imports
-#-----------------------------------------------------------------------------
-
-import sys
-import signal
-from _pydev_bundle._pydev_saved_modules import time
-from timeit import default_timer as clock
-import wx
-
-from pydev_ipython.inputhook import stdin_ready
-
-
-#-----------------------------------------------------------------------------
-# Code
-#-----------------------------------------------------------------------------
-
-def inputhook_wx1():
- """Run the wx event loop by processing pending events only.
-
- This approach seems to work, but its performance is not great as it
- relies on having PyOS_InputHook called regularly.
- """
- try:
- app = wx.GetApp() # @UndefinedVariable
- if app is not None:
- assert wx.Thread_IsMain() # @UndefinedVariable
-
- # Make a temporary event loop and process system events until
- # there are no more waiting, then allow idle events (which
- # will also deal with pending or posted wx events.)
- evtloop = wx.EventLoop() # @UndefinedVariable
- ea = wx.EventLoopActivator(evtloop) # @UndefinedVariable
- while evtloop.Pending():
- evtloop.Dispatch()
- app.ProcessIdle()
- del ea
- except KeyboardInterrupt:
- pass
- return 0
-
-class EventLoopTimer(wx.Timer): # @UndefinedVariable
-
- def __init__(self, func):
- self.func = func
- wx.Timer.__init__(self) # @UndefinedVariable
-
- def Notify(self):
- self.func()
-
-class EventLoopRunner(object):
-
- def Run(self, time):
- self.evtloop = wx.EventLoop() # @UndefinedVariable
- self.timer = EventLoopTimer(self.check_stdin)
- self.timer.Start(time)
- self.evtloop.Run()
-
- def check_stdin(self):
- if stdin_ready():
- self.timer.Stop()
- self.evtloop.Exit()
-
-def inputhook_wx2():
- """Run the wx event loop, polling for stdin.
-
- This version runs the wx eventloop for an undetermined amount of time,
- during which it periodically checks to see if anything is ready on
- stdin. If anything is ready on stdin, the event loop exits.
-
- The argument to elr.Run controls how often the event loop looks at stdin.
- This determines the responsiveness at the keyboard. A setting of 1000
- enables a user to type at most 1 char per second. I have found that a
- setting of 10 gives good keyboard response. We can shorten it further,
- but eventually performance would suffer from calling select/kbhit too
- often.
- """
- try:
- app = wx.GetApp() # @UndefinedVariable
- if app is not None:
- assert wx.Thread_IsMain() # @UndefinedVariable
- elr = EventLoopRunner()
- # As this time is made shorter, keyboard response improves, but idle
- # CPU load goes up. 10 ms seems like a good compromise.
- elr.Run(time=10) # CHANGE time here to control polling interval
- except KeyboardInterrupt:
- pass
- return 0
-
-def inputhook_wx3():
- """Run the wx event loop by processing pending events only.
-
- This is like inputhook_wx1, but it keeps processing pending events
- until stdin is ready. After processing all pending events, a call to
- time.sleep is inserted. This is needed, otherwise, CPU usage is at 100%.
- This sleep time should be tuned though for best performance.
- """
- # We need to protect against a user pressing Control-C when IPython is
- # idle and this is running. We trap KeyboardInterrupt and pass.
- try:
- app = wx.GetApp() # @UndefinedVariable
- if app is not None:
- if hasattr(wx, 'IsMainThread'):
- assert wx.IsMainThread() # @UndefinedVariable
- else:
- assert wx.Thread_IsMain() # @UndefinedVariable
-
- # The import of wx on Linux sets the handler for signal.SIGINT
- # to 0. This is a bug in wx or gtk. We fix by just setting it
- # back to the Python default.
- if not callable(signal.getsignal(signal.SIGINT)):
- signal.signal(signal.SIGINT, signal.default_int_handler)
-
- evtloop = wx.EventLoop() # @UndefinedVariable
- ea = wx.EventLoopActivator(evtloop) # @UndefinedVariable
- t = clock()
- while not stdin_ready():
- while evtloop.Pending():
- t = clock()
- evtloop.Dispatch()
- app.ProcessIdle()
- # We need to sleep at this point to keep the idle CPU load
- # low. However, if sleep to long, GUI response is poor. As
- # a compromise, we watch how often GUI events are being processed
- # and switch between a short and long sleep time. Here are some
- # stats useful in helping to tune this.
- # time CPU load
- # 0.001 13%
- # 0.005 3%
- # 0.01 1.5%
- # 0.05 0.5%
- used_time = clock() - t
- if used_time > 10.0:
- # print 'Sleep for 1 s' # dbg
- time.sleep(1.0)
- elif used_time > 0.1:
- # Few GUI events coming in, so we can sleep longer
- # print 'Sleep for 0.05 s' # dbg
- time.sleep(0.05)
- else:
- # Many GUI events coming in, so sleep only very little
- time.sleep(0.001)
- del ea
- except KeyboardInterrupt:
- pass
- return 0
-
-if sys.platform == 'darwin':
- # On OSX, evtloop.Pending() always returns True, regardless of there being
- # any events pending. As such we can't use implementations 1 or 3 of the
- # inputhook as those depend on a pending/dispatch loop.
- inputhook_wx = inputhook_wx2
-else:
- # This is our default implementation
- inputhook_wx = inputhook_wx3
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_settrace.hpp b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_settrace.hpp
deleted file mode 100644
index ba6c25fb3f4bc85bc734abf4482136c4671726e6..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/common/py_settrace.hpp
+++ /dev/null
@@ -1,193 +0,0 @@
-#ifndef _PY_SETTRACE_HPP_
-#define _PY_SETTRACE_HPP_
-
-#include "ref_utils.hpp"
-#include "py_utils.hpp"
-#include "python.h"
-#include "py_custom_pyeval_settrace.hpp"
-#include
-
-
-#ifdef _WIN32
-
-typedef HMODULE MODULE_TYPE;
-#else // LINUX -----------------------------------------------------------------
-
-typedef void* MODULE_TYPE;
-typedef ssize_t SSIZE_T;
-typedef unsigned int DWORD;
-
-#endif
-
-DWORD GetPythonThreadId(PythonVersion version, PyThreadState* curThread) {
- DWORD threadId = 0;
- if (PyThreadState_25_27::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_25_27*)curThread)->thread_id;
- } else if (PyThreadState_30_33::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_30_33*)curThread)->thread_id;
- } else if (PyThreadState_34_36::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_34_36*)curThread)->thread_id;
- } else if (PyThreadState_37_38::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_37_38*)curThread)->thread_id;
- } else if (PyThreadState_39::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_39*)curThread)->thread_id;
- } else if (PyThreadState_310::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_310*)curThread)->thread_id;
- } else if (PyThreadState_311::IsFor(version)) {
- threadId = (DWORD)((PyThreadState_311*)curThread)->thread_id;
- }
- return threadId;
-}
-
-
-/**
- * This function may be called to set a tracing function to existing python threads.
- */
-int InternalSetSysTraceFunc(
- MODULE_TYPE module,
- bool isDebug,
- bool showDebugInfo,
- PyObjectHolder* traceFunc,
- PyObjectHolder* setTraceFunc,
- unsigned int threadId,
- PyObjectHolder* pyNone)
-{
-
- if(showDebugInfo){
- PRINT("InternalSetSysTraceFunc started.");
- }
-
- DEFINE_PROC(isInit, Py_IsInitialized*, "Py_IsInitialized", 100);
- if (!isInit()) {
- PRINT("Py_IsInitialized returned false.");
- return 110;
- }
-
- auto version = GetPythonVersion(module);
-
- // found initialized Python runtime, gather and check the APIs we need.
-
- DEFINE_PROC(interpHead, PyInterpreterState_Head*, "PyInterpreterState_Head", 120);
- DEFINE_PROC(gilEnsure, PyGILState_Ensure*, "PyGILState_Ensure", 130);
- DEFINE_PROC(gilRelease, PyGILState_Release*, "PyGILState_Release", 140);
- DEFINE_PROC(threadHead, PyInterpreterState_ThreadHead*, "PyInterpreterState_ThreadHead", 150);
- DEFINE_PROC(threadNext, PyThreadState_Next*, "PyThreadState_Next", 160);
- DEFINE_PROC(threadSwap, PyThreadState_Swap*, "PyThreadState_Swap", 170);
- DEFINE_PROC(call, PyObject_CallFunctionObjArgs*, "PyObject_CallFunctionObjArgs", 180);
-
- PyInt_FromLong* intFromLong;
-
- if (version >= PythonVersion_30) {
- DEFINE_PROC(intFromLongPy3, PyInt_FromLong*, "PyLong_FromLong", 190);
- intFromLong = intFromLongPy3;
- } else {
- DEFINE_PROC(intFromLongPy2, PyInt_FromLong*, "PyInt_FromLong", 200);
- intFromLong = intFromLongPy2;
- }
-
- DEFINE_PROC(pyGetAttr, PyObject_GetAttrString*, "PyObject_GetAttrString", 250);
- DEFINE_PROC(pyHasAttr, PyObject_HasAttrString*, "PyObject_HasAttrString", 260);
- DEFINE_PROC_NO_CHECK(PyCFrame_Type, PyTypeObject*, "PyCFrame_Type", 300); // optional
-
- DEFINE_PROC_NO_CHECK(curPythonThread, PyThreadState**, "_PyThreadState_Current", 310); // optional
- DEFINE_PROC_NO_CHECK(getPythonThread, _PyThreadState_UncheckedGet*, "_PyThreadState_UncheckedGet", 320); // optional
-
- if (curPythonThread == nullptr && getPythonThread == nullptr) {
- // we're missing some APIs, we cannot attach.
- PRINT("Error, missing Python threading API!!");
- return 330;
- }
-
- auto head = interpHead();
- if (head == nullptr) {
- // this interpreter is loaded but not initialized.
- PRINT("Interpreter not initialized!");
- return 340;
- }
-
- GilHolder gilLock(gilEnsure, gilRelease); // acquire and hold the GIL until done...
-
- int retVal = 0;
- // find what index is holding onto the thread state...
- auto curPyThread = getPythonThread ? getPythonThread() : *curPythonThread;
-
- if(curPyThread == nullptr){
- PRINT("Getting the current python thread returned nullptr.");
- return 345;
- }
-
-
- // We do what PyEval_SetTrace does, but for any target thread.
- PyUnicode_InternFromString* pyUnicode_InternFromString;
- if (version >= PythonVersion_30) {
- DEFINE_PROC(unicodeFromString, PyUnicode_InternFromString*, "PyUnicode_InternFromString", 520);
- pyUnicode_InternFromString = unicodeFromString;
- } else {
- DEFINE_PROC(stringFromString, PyUnicode_InternFromString*, "PyString_InternFromString", 525);
- pyUnicode_InternFromString = stringFromString;
- }
-
- DEFINE_PROC_NO_CHECK(pyObject_FastCallDict, _PyObject_FastCallDict*, "_PyObject_FastCallDict", 530);
- DEFINE_PROC(pyTuple_New, PyTuple_New*, "PyTuple_New", 531);
- DEFINE_PROC(pyEval_CallObjectWithKeywords, PyEval_CallObjectWithKeywords*, "PyEval_CallObjectWithKeywords", 532);
-
- if(pyObject_FastCallDict == nullptr) {
- DEFINE_PROC_NO_CHECK(pyObject_FastCallDict, _PyObject_FastCallDict*, "PyObject_VectorcallDict", 533);
- }
-
- if(pyObject_FastCallDict == nullptr) {
- // we have to use PyObject_FastCallDictCustom for older versions of CPython (pre 3.7).
- pyObject_FastCallDict = reinterpret_cast<_PyObject_FastCallDict*>(&PyObject_FastCallDictCustom);
- }
-
-
- DEFINE_PROC(pyTraceBack_Here, PyTraceBack_Here*, "PyTraceBack_Here", 540);
- DEFINE_PROC(pyEval_SetTrace, PyEval_SetTrace*, "PyEval_SetTrace", 550);
-
- // These are defined mostly for printing info while debugging, so, if they're not there, don't bother reporting.
- DEFINE_PROC_NO_CHECK(pyObject_Repr, PyObject_Repr*, "PyObject_Repr", 551);
- DEFINE_PROC_NO_CHECK(pyUnicode_AsUTF8, PyUnicode_AsUTF8*, "PyUnicode_AsUTF8", 552);
-
-
- bool found = false;
- for (PyThreadState* curThread = threadHead(head); curThread != nullptr; curThread = threadNext(curThread)) {
- if (GetPythonThreadId(version, curThread) != threadId) {
- continue;
- }
- found = true;
-
- if(showDebugInfo){
- printf("setting trace for thread: %d\n", threadId);
- }
-
- if(!InternalIsTraceInitialized())
- {
- InternalInitializeCustomPyEvalSetTrace *internalInitializeCustomPyEvalSetTrace = new InternalInitializeCustomPyEvalSetTrace();
-
- IncRef(pyNone->ToPython());
- internalInitializeCustomPyEvalSetTrace->pyNone = pyNone->ToPython();
-
- internalInitializeCustomPyEvalSetTrace->pyUnicode_InternFromString = pyUnicode_InternFromString;
- internalInitializeCustomPyEvalSetTrace->pyObject_FastCallDict = pyObject_FastCallDict;
- internalInitializeCustomPyEvalSetTrace->isDebug = isDebug;
- internalInitializeCustomPyEvalSetTrace->pyTraceBack_Here = pyTraceBack_Here;
- internalInitializeCustomPyEvalSetTrace->pyEval_SetTrace = pyEval_SetTrace;
- internalInitializeCustomPyEvalSetTrace->pyTuple_New = pyTuple_New;
- internalInitializeCustomPyEvalSetTrace->pyEval_CallObjectWithKeywords = pyEval_CallObjectWithKeywords;
- internalInitializeCustomPyEvalSetTrace->pyObject_Repr = pyObject_Repr;
- internalInitializeCustomPyEvalSetTrace->pyUnicode_AsUTF8 = pyUnicode_AsUTF8;
-
- InternalTraceInit(internalInitializeCustomPyEvalSetTrace);
- }
- InternalPySetTrace(curThread, traceFunc, isDebug, version);
- break;
- }
- if(!found) {
- retVal = 501;
- }
-
- return retVal;
-
-}
-
-#endif // _PY_SETTRACE_HPP_
diff --git a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/shlwapi.py b/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/shlwapi.py
deleted file mode 100644
index 5f6eb3eab7d0e3fda68426569fb923ed68d5b57a..0000000000000000000000000000000000000000
--- a/spaces/SungBeom/chatwine-korean/.venv/Lib/site-packages/debugpy/_vendored/pydevd/pydevd_attach_to_process/winappdbg/win32/shlwapi.py
+++ /dev/null
@@ -1,756 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-
-# Copyright (c) 2009-2014, Mario Vilas
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are met:
-#
-# * Redistributions of source code must retain the above copyright notice,
-# this list of conditions and the following disclaimer.
-# * Redistributions in binary form must reproduce the above copyright
-# notice,this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-# * Neither the name of the copyright holder nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-# POSSIBILITY OF SUCH DAMAGE.
-
-"""
-Wrapper for shlwapi.dll in ctypes.
-"""
-
-__revision__ = "$Id$"
-
-from winappdbg.win32.defines import *
-from winappdbg.win32.kernel32 import *
-
-#==============================================================================
-# This is used later on to calculate the list of exported symbols.
-_all = None
-_all = set(vars().keys())
-#==============================================================================
-
-OS_WINDOWS = 0
-OS_NT = 1
-OS_WIN95ORGREATER = 2
-OS_NT4ORGREATER = 3
-OS_WIN98ORGREATER = 5
-OS_WIN98_GOLD = 6
-OS_WIN2000ORGREATER = 7
-OS_WIN2000PRO = 8
-OS_WIN2000SERVER = 9
-OS_WIN2000ADVSERVER = 10
-OS_WIN2000DATACENTER = 11
-OS_WIN2000TERMINAL = 12
-OS_EMBEDDED = 13
-OS_TERMINALCLIENT = 14
-OS_TERMINALREMOTEADMIN = 15
-OS_WIN95_GOLD = 16
-OS_MEORGREATER = 17
-OS_XPORGREATER = 18
-OS_HOME = 19
-OS_PROFESSIONAL = 20
-OS_DATACENTER = 21
-OS_ADVSERVER = 22
-OS_SERVER = 23
-OS_TERMINALSERVER = 24
-OS_PERSONALTERMINALSERVER = 25
-OS_FASTUSERSWITCHING = 26
-OS_WELCOMELOGONUI = 27
-OS_DOMAINMEMBER = 28
-OS_ANYSERVER = 29
-OS_WOW6432 = 30
-OS_WEBSERVER = 31
-OS_SMALLBUSINESSSERVER = 32
-OS_TABLETPC = 33
-OS_SERVERADMINUI = 34
-OS_MEDIACENTER = 35
-OS_APPLIANCE = 36
-
-#--- shlwapi.dll --------------------------------------------------------------
-
-# BOOL IsOS(
-# DWORD dwOS
-# );
-def IsOS(dwOS):
- try:
- _IsOS = windll.shlwapi.IsOS
- _IsOS.argtypes = [DWORD]
- _IsOS.restype = bool
- except AttributeError:
- # According to MSDN, on Windows versions prior to Vista
- # this function is exported only by ordinal number 437.
- # http://msdn.microsoft.com/en-us/library/bb773795%28VS.85%29.aspx
- _GetProcAddress = windll.kernel32.GetProcAddress
- _GetProcAddress.argtypes = [HINSTANCE, DWORD]
- _GetProcAddress.restype = LPVOID
- _IsOS = windll.kernel32.GetProcAddress(windll.shlwapi._handle, 437)
- _IsOS = WINFUNCTYPE(bool, DWORD)(_IsOS)
- return _IsOS(dwOS)
-
-# LPTSTR PathAddBackslash(
-# LPTSTR lpszPath
-# );
-def PathAddBackslashA(lpszPath):
- _PathAddBackslashA = windll.shlwapi.PathAddBackslashA
- _PathAddBackslashA.argtypes = [LPSTR]
- _PathAddBackslashA.restype = LPSTR
-
- lpszPath = ctypes.create_string_buffer(lpszPath, MAX_PATH)
- retval = _PathAddBackslashA(lpszPath)
- if retval == NULL:
- raise ctypes.WinError()
- return lpszPath.value
-
-def PathAddBackslashW(lpszPath):
- _PathAddBackslashW = windll.shlwapi.PathAddBackslashW
- _PathAddBackslashW.argtypes = [LPWSTR]
- _PathAddBackslashW.restype = LPWSTR
-
- lpszPath = ctypes.create_unicode_buffer(lpszPath, MAX_PATH)
- retval = _PathAddBackslashW(lpszPath)
- if retval == NULL:
- raise ctypes.WinError()
- return lpszPath.value
-
-PathAddBackslash = GuessStringType(PathAddBackslashA, PathAddBackslashW)
-
-# BOOL PathAddExtension(
-# LPTSTR pszPath,
-# LPCTSTR pszExtension
-# );
-def PathAddExtensionA(lpszPath, pszExtension = None):
- _PathAddExtensionA = windll.shlwapi.PathAddExtensionA
- _PathAddExtensionA.argtypes = [LPSTR, LPSTR]
- _PathAddExtensionA.restype = bool
- _PathAddExtensionA.errcheck = RaiseIfZero
-
- if not pszExtension:
- pszExtension = None
- lpszPath = ctypes.create_string_buffer(lpszPath, MAX_PATH)
- _PathAddExtensionA(lpszPath, pszExtension)
- return lpszPath.value
-
-def PathAddExtensionW(lpszPath, pszExtension = None):
- _PathAddExtensionW = windll.shlwapi.PathAddExtensionW
- _PathAddExtensionW.argtypes = [LPWSTR, LPWSTR]
- _PathAddExtensionW.restype = bool
- _PathAddExtensionW.errcheck = RaiseIfZero
-
- if not pszExtension:
- pszExtension = None
- lpszPath = ctypes.create_unicode_buffer(lpszPath, MAX_PATH)
- _PathAddExtensionW(lpszPath, pszExtension)
- return lpszPath.value
-
-PathAddExtension = GuessStringType(PathAddExtensionA, PathAddExtensionW)
-
-# BOOL PathAppend(
-# LPTSTR pszPath,
-# LPCTSTR pszMore
-# );
-def PathAppendA(lpszPath, pszMore = None):
- _PathAppendA = windll.shlwapi.PathAppendA
- _PathAppendA.argtypes = [LPSTR, LPSTR]
- _PathAppendA.restype = bool
- _PathAppendA.errcheck = RaiseIfZero
-
- if not pszMore:
- pszMore = None
- lpszPath = ctypes.create_string_buffer(lpszPath, MAX_PATH)
- _PathAppendA(lpszPath, pszMore)
- return lpszPath.value
-
-def PathAppendW(lpszPath, pszMore = None):
- _PathAppendW = windll.shlwapi.PathAppendW
- _PathAppendW.argtypes = [LPWSTR, LPWSTR]
- _PathAppendW.restype = bool
- _PathAppendW.errcheck = RaiseIfZero
-
- if not pszMore:
- pszMore = None
- lpszPath = ctypes.create_unicode_buffer(lpszPath, MAX_PATH)
- _PathAppendW(lpszPath, pszMore)
- return lpszPath.value
-
-PathAppend = GuessStringType(PathAppendA, PathAppendW)
-
-# LPTSTR PathCombine(
-# LPTSTR lpszDest,
-# LPCTSTR lpszDir,
-# LPCTSTR lpszFile
-# );
-def PathCombineA(lpszDir, lpszFile):
- _PathCombineA = windll.shlwapi.PathCombineA
- _PathCombineA.argtypes = [LPSTR, LPSTR, LPSTR]
- _PathCombineA.restype = LPSTR
-
- lpszDest = ctypes.create_string_buffer("", max(MAX_PATH, len(lpszDir) + len(lpszFile) + 1))
- retval = _PathCombineA(lpszDest, lpszDir, lpszFile)
- if retval == NULL:
- return None
- return lpszDest.value
-
-def PathCombineW(lpszDir, lpszFile):
- _PathCombineW = windll.shlwapi.PathCombineW
- _PathCombineW.argtypes = [LPWSTR, LPWSTR, LPWSTR]
- _PathCombineW.restype = LPWSTR
-
- lpszDest = ctypes.create_unicode_buffer(u"", max(MAX_PATH, len(lpszDir) + len(lpszFile) + 1))
- retval = _PathCombineW(lpszDest, lpszDir, lpszFile)
- if retval == NULL:
- return None
- return lpszDest.value
-
-PathCombine = GuessStringType(PathCombineA, PathCombineW)
-
-# BOOL PathCanonicalize(
-# LPTSTR lpszDst,
-# LPCTSTR lpszSrc
-# );
-def PathCanonicalizeA(lpszSrc):
- _PathCanonicalizeA = windll.shlwapi.PathCanonicalizeA
- _PathCanonicalizeA.argtypes = [LPSTR, LPSTR]
- _PathCanonicalizeA.restype = bool
- _PathCanonicalizeA.errcheck = RaiseIfZero
-
- lpszDst = ctypes.create_string_buffer("", MAX_PATH)
- _PathCanonicalizeA(lpszDst, lpszSrc)
- return lpszDst.value
-
-def PathCanonicalizeW(lpszSrc):
- _PathCanonicalizeW = windll.shlwapi.PathCanonicalizeW
- _PathCanonicalizeW.argtypes = [LPWSTR, LPWSTR]
- _PathCanonicalizeW.restype = bool
- _PathCanonicalizeW.errcheck = RaiseIfZero
-
- lpszDst = ctypes.create_unicode_buffer(u"", MAX_PATH)
- _PathCanonicalizeW(lpszDst, lpszSrc)
- return lpszDst.value
-
-PathCanonicalize = GuessStringType(PathCanonicalizeA, PathCanonicalizeW)
-
-# BOOL PathRelativePathTo(
-# _Out_ LPTSTR pszPath,
-# _In_ LPCTSTR pszFrom,
-# _In_ DWORD dwAttrFrom,
-# _In_ LPCTSTR pszTo,
-# _In_ DWORD dwAttrTo
-# );
-def PathRelativePathToA(pszFrom = None, dwAttrFrom = FILE_ATTRIBUTE_DIRECTORY, pszTo = None, dwAttrTo = FILE_ATTRIBUTE_DIRECTORY):
- _PathRelativePathToA = windll.shlwapi.PathRelativePathToA
- _PathRelativePathToA.argtypes = [LPSTR, LPSTR, DWORD, LPSTR, DWORD]
- _PathRelativePathToA.restype = bool
- _PathRelativePathToA.errcheck = RaiseIfZero
-
- # Make the paths absolute or the function fails.
- if pszFrom:
- pszFrom = GetFullPathNameA(pszFrom)[0]
- else:
- pszFrom = GetCurrentDirectoryA()
- if pszTo:
- pszTo = GetFullPathNameA(pszTo)[0]
- else:
- pszTo = GetCurrentDirectoryA()
-
- # Argh, this function doesn't receive an output buffer size!
- # We'll try to guess the maximum possible buffer size.
- dwPath = max((len(pszFrom) + len(pszTo)) * 2 + 1, MAX_PATH + 1)
- pszPath = ctypes.create_string_buffer('', dwPath)
-
- # Also, it doesn't set the last error value.
- # Whoever coded it must have been drunk or tripping on acid. Or both.
- # The only failure conditions I've seen were invalid paths, paths not
- # on the same drive, or the path is not absolute.
- SetLastError(ERROR_INVALID_PARAMETER)
-
- _PathRelativePathToA(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo)
- return pszPath.value
-
-def PathRelativePathToW(pszFrom = None, dwAttrFrom = FILE_ATTRIBUTE_DIRECTORY, pszTo = None, dwAttrTo = FILE_ATTRIBUTE_DIRECTORY):
- _PathRelativePathToW = windll.shlwapi.PathRelativePathToW
- _PathRelativePathToW.argtypes = [LPWSTR, LPWSTR, DWORD, LPWSTR, DWORD]
- _PathRelativePathToW.restype = bool
- _PathRelativePathToW.errcheck = RaiseIfZero
-
- # Refer to PathRelativePathToA to know why this code is so ugly.
- if pszFrom:
- pszFrom = GetFullPathNameW(pszFrom)[0]
- else:
- pszFrom = GetCurrentDirectoryW()
- if pszTo:
- pszTo = GetFullPathNameW(pszTo)[0]
- else:
- pszTo = GetCurrentDirectoryW()
- dwPath = max((len(pszFrom) + len(pszTo)) * 2 + 1, MAX_PATH + 1)
- pszPath = ctypes.create_unicode_buffer(u'', dwPath)
- SetLastError(ERROR_INVALID_PARAMETER)
- _PathRelativePathToW(pszPath, pszFrom, dwAttrFrom, pszTo, dwAttrTo)
- return pszPath.value
-
-PathRelativePathTo = GuessStringType(PathRelativePathToA, PathRelativePathToW)
-
-# BOOL PathFileExists(
-# LPCTSTR pszPath
-# );
-def PathFileExistsA(pszPath):
- _PathFileExistsA = windll.shlwapi.PathFileExistsA
- _PathFileExistsA.argtypes = [LPSTR]
- _PathFileExistsA.restype = bool
- return _PathFileExistsA(pszPath)
-
-def PathFileExistsW(pszPath):
- _PathFileExistsW = windll.shlwapi.PathFileExistsW
- _PathFileExistsW.argtypes = [LPWSTR]
- _PathFileExistsW.restype = bool
- return _PathFileExistsW(pszPath)
-
-PathFileExists = GuessStringType(PathFileExistsA, PathFileExistsW)
-
-# LPTSTR PathFindExtension(
-# LPCTSTR pszPath
-# );
-def PathFindExtensionA(pszPath):
- _PathFindExtensionA = windll.shlwapi.PathFindExtensionA
- _PathFindExtensionA.argtypes = [LPSTR]
- _PathFindExtensionA.restype = LPSTR
- pszPath = ctypes.create_string_buffer(pszPath)
- return _PathFindExtensionA(pszPath)
-
-def PathFindExtensionW(pszPath):
- _PathFindExtensionW = windll.shlwapi.PathFindExtensionW
- _PathFindExtensionW.argtypes = [LPWSTR]
- _PathFindExtensionW.restype = LPWSTR
- pszPath = ctypes.create_unicode_buffer(pszPath)
- return _PathFindExtensionW(pszPath)
-
-PathFindExtension = GuessStringType(PathFindExtensionA, PathFindExtensionW)
-
-# LPTSTR PathFindFileName(
-# LPCTSTR pszPath
-# );
-def PathFindFileNameA(pszPath):
- _PathFindFileNameA = windll.shlwapi.PathFindFileNameA
- _PathFindFileNameA.argtypes = [LPSTR]
- _PathFindFileNameA.restype = LPSTR
- pszPath = ctypes.create_string_buffer(pszPath)
- return _PathFindFileNameA(pszPath)
-
-def PathFindFileNameW(pszPath):
- _PathFindFileNameW = windll.shlwapi.PathFindFileNameW
- _PathFindFileNameW.argtypes = [LPWSTR]
- _PathFindFileNameW.restype = LPWSTR
- pszPath = ctypes.create_unicode_buffer(pszPath)
- return _PathFindFileNameW(pszPath)
-
-PathFindFileName = GuessStringType(PathFindFileNameA, PathFindFileNameW)
-
-# LPTSTR PathFindNextComponent(
-# LPCTSTR pszPath
-# );
-def PathFindNextComponentA(pszPath):
- _PathFindNextComponentA = windll.shlwapi.PathFindNextComponentA
- _PathFindNextComponentA.argtypes = [LPSTR]
- _PathFindNextComponentA.restype = LPSTR
- pszPath = ctypes.create_string_buffer(pszPath)
- return _PathFindNextComponentA(pszPath)
-
-def PathFindNextComponentW(pszPath):
- _PathFindNextComponentW = windll.shlwapi.PathFindNextComponentW
- _PathFindNextComponentW.argtypes = [LPWSTR]
- _PathFindNextComponentW.restype = LPWSTR
- pszPath = ctypes.create_unicode_buffer(pszPath)
- return _PathFindNextComponentW(pszPath)
-
-PathFindNextComponent = GuessStringType(PathFindNextComponentA, PathFindNextComponentW)
-
-# BOOL PathFindOnPath(
-# LPTSTR pszFile,
-# LPCTSTR *ppszOtherDirs
-# );
-def PathFindOnPathA(pszFile, ppszOtherDirs = None):
- _PathFindOnPathA = windll.shlwapi.PathFindOnPathA
- _PathFindOnPathA.argtypes = [LPSTR, LPSTR]
- _PathFindOnPathA.restype = bool
-
- pszFile = ctypes.create_string_buffer(pszFile, MAX_PATH)
- if not ppszOtherDirs:
- ppszOtherDirs = None
- else:
- szArray = ""
- for pszOtherDirs in ppszOtherDirs:
- if pszOtherDirs:
- szArray = "%s%s\0" % (szArray, pszOtherDirs)
- szArray = szArray + "\0"
- pszOtherDirs = ctypes.create_string_buffer(szArray)
- ppszOtherDirs = ctypes.pointer(pszOtherDirs)
- if _PathFindOnPathA(pszFile, ppszOtherDirs):
- return pszFile.value
- return None
-
-def PathFindOnPathW(pszFile, ppszOtherDirs = None):
- _PathFindOnPathW = windll.shlwapi.PathFindOnPathA
- _PathFindOnPathW.argtypes = [LPWSTR, LPWSTR]
- _PathFindOnPathW.restype = bool
-
- pszFile = ctypes.create_unicode_buffer(pszFile, MAX_PATH)
- if not ppszOtherDirs:
- ppszOtherDirs = None
- else:
- szArray = u""
- for pszOtherDirs in ppszOtherDirs:
- if pszOtherDirs:
- szArray = u"%s%s\0" % (szArray, pszOtherDirs)
- szArray = szArray + u"\0"
- pszOtherDirs = ctypes.create_unicode_buffer(szArray)
- ppszOtherDirs = ctypes.pointer(pszOtherDirs)
- if _PathFindOnPathW(pszFile, ppszOtherDirs):
- return pszFile.value
- return None
-
-PathFindOnPath = GuessStringType(PathFindOnPathA, PathFindOnPathW)
-
-# LPTSTR PathGetArgs(
-# LPCTSTR pszPath
-# );
-def PathGetArgsA(pszPath):
- _PathGetArgsA = windll.shlwapi.PathGetArgsA
- _PathGetArgsA.argtypes = [LPSTR]
- _PathGetArgsA.restype = LPSTR
- pszPath = ctypes.create_string_buffer(pszPath)
- return _PathGetArgsA(pszPath)
-
-def PathGetArgsW(pszPath):
- _PathGetArgsW = windll.shlwapi.PathGetArgsW
- _PathGetArgsW.argtypes = [LPWSTR]
- _PathGetArgsW.restype = LPWSTR
- pszPath = ctypes.create_unicode_buffer(pszPath)
- return _PathGetArgsW(pszPath)
-
-PathGetArgs = GuessStringType(PathGetArgsA, PathGetArgsW)
-
-# BOOL PathIsContentType(
-# LPCTSTR pszPath,
-# LPCTSTR pszContentType
-# );
-def PathIsContentTypeA(pszPath, pszContentType):
- _PathIsContentTypeA = windll.shlwapi.PathIsContentTypeA
- _PathIsContentTypeA.argtypes = [LPSTR, LPSTR]
- _PathIsContentTypeA.restype = bool
- return _PathIsContentTypeA(pszPath, pszContentType)
-
-def PathIsContentTypeW(pszPath, pszContentType):
- _PathIsContentTypeW = windll.shlwapi.PathIsContentTypeW
- _PathIsContentTypeW.argtypes = [LPWSTR, LPWSTR]
- _PathIsContentTypeW.restype = bool
- return _PathIsContentTypeW(pszPath, pszContentType)
-
-PathIsContentType = GuessStringType(PathIsContentTypeA, PathIsContentTypeW)
-
-# BOOL PathIsDirectory(
-# LPCTSTR pszPath
-# );
-def PathIsDirectoryA(pszPath):
- _PathIsDirectoryA = windll.shlwapi.PathIsDirectoryA
- _PathIsDirectoryA.argtypes = [LPSTR]
- _PathIsDirectoryA.restype = bool
- return _PathIsDirectoryA(pszPath)
-
-def PathIsDirectoryW(pszPath):
- _PathIsDirectoryW = windll.shlwapi.PathIsDirectoryW
- _PathIsDirectoryW.argtypes = [LPWSTR]
- _PathIsDirectoryW.restype = bool
- return _PathIsDirectoryW(pszPath)
-
-PathIsDirectory = GuessStringType(PathIsDirectoryA, PathIsDirectoryW)
-
-# BOOL PathIsDirectoryEmpty(
-# LPCTSTR pszPath
-# );
-def PathIsDirectoryEmptyA(pszPath):
- _PathIsDirectoryEmptyA = windll.shlwapi.PathIsDirectoryEmptyA
- _PathIsDirectoryEmptyA.argtypes = [LPSTR]
- _PathIsDirectoryEmptyA.restype = bool
- return _PathIsDirectoryEmptyA(pszPath)
-
-def PathIsDirectoryEmptyW(pszPath):
- _PathIsDirectoryEmptyW = windll.shlwapi.PathIsDirectoryEmptyW
- _PathIsDirectoryEmptyW.argtypes = [LPWSTR]
- _PathIsDirectoryEmptyW.restype = bool
- return _PathIsDirectoryEmptyW(pszPath)
-
-PathIsDirectoryEmpty = GuessStringType(PathIsDirectoryEmptyA, PathIsDirectoryEmptyW)
-
-# BOOL PathIsNetworkPath(
-# LPCTSTR pszPath
-# );
-def PathIsNetworkPathA(pszPath):
- _PathIsNetworkPathA = windll.shlwapi.PathIsNetworkPathA
- _PathIsNetworkPathA.argtypes = [LPSTR]
- _PathIsNetworkPathA.restype = bool
- return _PathIsNetworkPathA(pszPath)
-
-def PathIsNetworkPathW(pszPath):
- _PathIsNetworkPathW = windll.shlwapi.PathIsNetworkPathW
- _PathIsNetworkPathW.argtypes = [LPWSTR]
- _PathIsNetworkPathW.restype = bool
- return _PathIsNetworkPathW(pszPath)
-
-PathIsNetworkPath = GuessStringType(PathIsNetworkPathA, PathIsNetworkPathW)
-
-# BOOL PathIsRelative(
-# LPCTSTR lpszPath
-# );
-def PathIsRelativeA(pszPath):
- _PathIsRelativeA = windll.shlwapi.PathIsRelativeA
- _PathIsRelativeA.argtypes = [LPSTR]
- _PathIsRelativeA.restype = bool
- return _PathIsRelativeA(pszPath)
-
-def PathIsRelativeW(pszPath):
- _PathIsRelativeW = windll.shlwapi.PathIsRelativeW
- _PathIsRelativeW.argtypes = [LPWSTR]
- _PathIsRelativeW.restype = bool
- return _PathIsRelativeW(pszPath)
-
-PathIsRelative = GuessStringType(PathIsRelativeA, PathIsRelativeW)
-
-# BOOL PathIsRoot(
-# LPCTSTR pPath
-# );
-def PathIsRootA(pszPath):
- _PathIsRootA = windll.shlwapi.PathIsRootA
- _PathIsRootA.argtypes = [LPSTR]
- _PathIsRootA.restype = bool
- return _PathIsRootA(pszPath)
-
-def PathIsRootW(pszPath):
- _PathIsRootW = windll.shlwapi.PathIsRootW
- _PathIsRootW.argtypes = [LPWSTR]
- _PathIsRootW.restype = bool
- return _PathIsRootW(pszPath)
-
-PathIsRoot = GuessStringType(PathIsRootA, PathIsRootW)
-
-# BOOL PathIsSameRoot(
-# LPCTSTR pszPath1,
-# LPCTSTR pszPath2
-# );
-def PathIsSameRootA(pszPath1, pszPath2):
- _PathIsSameRootA = windll.shlwapi.PathIsSameRootA
- _PathIsSameRootA.argtypes = [LPSTR, LPSTR]
- _PathIsSameRootA.restype = bool
- return _PathIsSameRootA(pszPath1, pszPath2)
-
-def PathIsSameRootW(pszPath1, pszPath2):
- _PathIsSameRootW = windll.shlwapi.PathIsSameRootW
- _PathIsSameRootW.argtypes = [LPWSTR, LPWSTR]
- _PathIsSameRootW.restype = bool
- return _PathIsSameRootW(pszPath1, pszPath2)
-
-PathIsSameRoot = GuessStringType(PathIsSameRootA, PathIsSameRootW)
-
-# BOOL PathIsUNC(
-# LPCTSTR pszPath
-# );
-def PathIsUNCA(pszPath):
- _PathIsUNCA = windll.shlwapi.PathIsUNCA
- _PathIsUNCA.argtypes = [LPSTR]
- _PathIsUNCA.restype = bool
- return _PathIsUNCA(pszPath)
-
-def PathIsUNCW(pszPath):
- _PathIsUNCW = windll.shlwapi.PathIsUNCW
- _PathIsUNCW.argtypes = [LPWSTR]
- _PathIsUNCW.restype = bool
- return _PathIsUNCW(pszPath)
-
-PathIsUNC = GuessStringType(PathIsUNCA, PathIsUNCW)
-
-# XXX WARNING
-# PathMakePretty turns filenames into all lowercase.
-# I'm not sure how well that might work on Wine.
-
-# BOOL PathMakePretty(
-# LPCTSTR pszPath
-# );
-def PathMakePrettyA(pszPath):
- _PathMakePrettyA = windll.shlwapi.PathMakePrettyA
- _PathMakePrettyA.argtypes = [LPSTR]
- _PathMakePrettyA.restype = bool
- _PathMakePrettyA.errcheck = RaiseIfZero
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- _PathMakePrettyA(pszPath)
- return pszPath.value
-
-def PathMakePrettyW(pszPath):
- _PathMakePrettyW = windll.shlwapi.PathMakePrettyW
- _PathMakePrettyW.argtypes = [LPWSTR]
- _PathMakePrettyW.restype = bool
- _PathMakePrettyW.errcheck = RaiseIfZero
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- _PathMakePrettyW(pszPath)
- return pszPath.value
-
-PathMakePretty = GuessStringType(PathMakePrettyA, PathMakePrettyW)
-
-# void PathRemoveArgs(
-# LPTSTR pszPath
-# );
-def PathRemoveArgsA(pszPath):
- _PathRemoveArgsA = windll.shlwapi.PathRemoveArgsA
- _PathRemoveArgsA.argtypes = [LPSTR]
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- _PathRemoveArgsA(pszPath)
- return pszPath.value
-
-def PathRemoveArgsW(pszPath):
- _PathRemoveArgsW = windll.shlwapi.PathRemoveArgsW
- _PathRemoveArgsW.argtypes = [LPWSTR]
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- _PathRemoveArgsW(pszPath)
- return pszPath.value
-
-PathRemoveArgs = GuessStringType(PathRemoveArgsA, PathRemoveArgsW)
-
-# void PathRemoveBackslash(
-# LPTSTR pszPath
-# );
-def PathRemoveBackslashA(pszPath):
- _PathRemoveBackslashA = windll.shlwapi.PathRemoveBackslashA
- _PathRemoveBackslashA.argtypes = [LPSTR]
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- _PathRemoveBackslashA(pszPath)
- return pszPath.value
-
-def PathRemoveBackslashW(pszPath):
- _PathRemoveBackslashW = windll.shlwapi.PathRemoveBackslashW
- _PathRemoveBackslashW.argtypes = [LPWSTR]
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- _PathRemoveBackslashW(pszPath)
- return pszPath.value
-
-PathRemoveBackslash = GuessStringType(PathRemoveBackslashA, PathRemoveBackslashW)
-
-# void PathRemoveExtension(
-# LPTSTR pszPath
-# );
-def PathRemoveExtensionA(pszPath):
- _PathRemoveExtensionA = windll.shlwapi.PathRemoveExtensionA
- _PathRemoveExtensionA.argtypes = [LPSTR]
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- _PathRemoveExtensionA(pszPath)
- return pszPath.value
-
-def PathRemoveExtensionW(pszPath):
- _PathRemoveExtensionW = windll.shlwapi.PathRemoveExtensionW
- _PathRemoveExtensionW.argtypes = [LPWSTR]
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- _PathRemoveExtensionW(pszPath)
- return pszPath.value
-
-PathRemoveExtension = GuessStringType(PathRemoveExtensionA, PathRemoveExtensionW)
-
-# void PathRemoveFileSpec(
-# LPTSTR pszPath
-# );
-def PathRemoveFileSpecA(pszPath):
- _PathRemoveFileSpecA = windll.shlwapi.PathRemoveFileSpecA
- _PathRemoveFileSpecA.argtypes = [LPSTR]
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- _PathRemoveFileSpecA(pszPath)
- return pszPath.value
-
-def PathRemoveFileSpecW(pszPath):
- _PathRemoveFileSpecW = windll.shlwapi.PathRemoveFileSpecW
- _PathRemoveFileSpecW.argtypes = [LPWSTR]
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- _PathRemoveFileSpecW(pszPath)
- return pszPath.value
-
-PathRemoveFileSpec = GuessStringType(PathRemoveFileSpecA, PathRemoveFileSpecW)
-
-# BOOL PathRenameExtension(
-# LPTSTR pszPath,
-# LPCTSTR pszExt
-# );
-def PathRenameExtensionA(pszPath, pszExt):
- _PathRenameExtensionA = windll.shlwapi.PathRenameExtensionA
- _PathRenameExtensionA.argtypes = [LPSTR, LPSTR]
- _PathRenameExtensionA.restype = bool
-
- pszPath = ctypes.create_string_buffer(pszPath, MAX_PATH)
- if _PathRenameExtensionA(pszPath, pszExt):
- return pszPath.value
- return None
-
-def PathRenameExtensionW(pszPath, pszExt):
- _PathRenameExtensionW = windll.shlwapi.PathRenameExtensionW
- _PathRenameExtensionW.argtypes = [LPWSTR, LPWSTR]
- _PathRenameExtensionW.restype = bool
-
- pszPath = ctypes.create_unicode_buffer(pszPath, MAX_PATH)
- if _PathRenameExtensionW(pszPath, pszExt):
- return pszPath.value
- return None
-
-PathRenameExtension = GuessStringType(PathRenameExtensionA, PathRenameExtensionW)
-
-# BOOL PathUnExpandEnvStrings(
-# LPCTSTR pszPath,
-# LPTSTR pszBuf,
-# UINT cchBuf
-# );
-def PathUnExpandEnvStringsA(pszPath):
- _PathUnExpandEnvStringsA = windll.shlwapi.PathUnExpandEnvStringsA
- _PathUnExpandEnvStringsA.argtypes = [LPSTR, LPSTR]
- _PathUnExpandEnvStringsA.restype = bool
- _PathUnExpandEnvStringsA.errcheck = RaiseIfZero
-
- cchBuf = MAX_PATH
- pszBuf = ctypes.create_string_buffer("", cchBuf)
- _PathUnExpandEnvStringsA(pszPath, pszBuf, cchBuf)
- return pszBuf.value
-
-def PathUnExpandEnvStringsW(pszPath):
- _PathUnExpandEnvStringsW = windll.shlwapi.PathUnExpandEnvStringsW
- _PathUnExpandEnvStringsW.argtypes = [LPWSTR, LPWSTR]
- _PathUnExpandEnvStringsW.restype = bool
- _PathUnExpandEnvStringsW.errcheck = RaiseIfZero
-
- cchBuf = MAX_PATH
- pszBuf = ctypes.create_unicode_buffer(u"", cchBuf)
- _PathUnExpandEnvStringsW(pszPath, pszBuf, cchBuf)
- return pszBuf.value
-
-PathUnExpandEnvStrings = GuessStringType(PathUnExpandEnvStringsA, PathUnExpandEnvStringsW)
-
-#==============================================================================
-# This calculates the list of exported symbols.
-_all = set(vars().keys()).difference(_all)
-__all__ = [_x for _x in _all if not _x.startswith('_')]
-__all__.sort()
-#==============================================================================
diff --git a/spaces/Surn/UnlimitedMusicGen/MODEL_CARD.md b/spaces/Surn/UnlimitedMusicGen/MODEL_CARD.md
deleted file mode 100644
index 6c2c9f883969eb905e74ad3376966d156cc5ca00..0000000000000000000000000000000000000000
--- a/spaces/Surn/UnlimitedMusicGen/MODEL_CARD.md
+++ /dev/null
@@ -1,81 +0,0 @@
-# MusicGen Model Card
-
-## Model details
-
-**Organization developing the model:** The FAIR team of Meta AI.
-
-**Model date:** MusicGen was trained between April 2023 and May 2023.
-
-**Model version:** This is the version 1 of the model.
-
-**Model type:** MusicGen consists of an EnCodec model for audio tokenization, an auto-regressive language model based on the transformer architecture for music modeling. The model comes in different sizes: 300M, 1.5B and 3.3B parameters ; and two variants: a model trained for text-to-music generation task and a model trained for melody-guided music generation.
-
-**Paper or resources for more information:** More information can be found in the paper [Simple and Controllable Music Generation][arxiv].
-
-**Citation details** See [our paper][arxiv]
-
-**License** Code is released under MIT, model weights are released under CC-BY-NC 4.0.
-
-**Where to send questions or comments about the model:** Questions and comments about MusicGen can be sent via the [Github repository](https://github.com/facebookresearch/audiocraft) of the project, or by opening an issue.
-
-## Intended use
-**Primary intended use:** The primary use of MusicGen is research on AI-based music generation, including:
-
-- Research efforts, such as probing and better understanding the limitations of generative models to further improve the state of science
-- Generation of music guided by text or melody to understand current abilities of generative AI models by machine learning amateurs
-
-**Primary intended users:** The primary intended users of the model are researchers in audio, machine learning and artificial intelligence, as well as amateur seeking to better understand those models.
-
-**Out-of-scope use cases** The model should not be used on downstream applications without further risk evaluation and mitigation. The model should not be used to intentionally create or disseminate music pieces that create hostile or alienating environments for people. This includes generating music that people would foreseeably find disturbing, distressing, or offensive; or content that propagates historical or current stereotypes.
-
-## Metrics
-
-**Models performance measures:** We used the following objective measure to evaluate the model on a standard music benchmark:
-
-- Frechet Audio Distance computed on features extracted from a pre-trained audio classifier (VGGish)
-- Kullback-Leibler Divergence on label distributions extracted from a pre-trained audio classifier (PaSST)
-- CLAP Score between audio embedding and text embedding extracted from a pre-trained CLAP model
-
-Additionally, we run qualitative studies with human participants, evaluating the performance of the model with the following axes:
-
-- Overall quality of the music samples;
-- Text relevance to the provided text input;
-- Adherence to the melody for melody-guided music generation.
-
-More details on performance measures and human studies can be found in the paper.
-
-**Decision thresholds:** Not applicable.
-
-## Evaluation datasets
-
-The model was evaluated on the [MusicCaps benchmark](https://www.kaggle.com/datasets/googleai/musiccaps) and on an in-domain held-out evaluation set, with no artist overlap with the training set.
-
-## Training datasets
-
-The model was trained on licensed data using the following sources: the [Meta Music Initiative Sound Collection](https://www.fb.com/sound), [Shutterstock music collection](https://www.shutterstock.com/music) and the [Pond5 music collection](https://www.pond5.com/). See the paper for more details about the training set and corresponding preprocessing.
-
-## Quantitative analysis
-
-More information can be found in the paper [Simple and Controllable Music Generation][arxiv], in the Experimental Setup section.
-
-## Limitations and biases
-
-**Data:** The data sources used to train the model are created by music professionals and covered by legal agreements with the right holders. The model is trained on 20K hours of data, we believe that scaling the model on larger datasets can further improve the performance of the model.
-
-**Mitigations:** Vocals have been removed from the data source using corresponding tags, and then using using a state-of-the-art music source separation method, namely using the open source [Hybrid Transformer for Music Source Separation](https://github.com/facebookresearch/demucs) (HT-Demucs).
-
-**Limitations:**
-
-- The model is not able to generate realistic vocals.
-- The model has been trained with English descriptions and will not perform as well in other languages.
-- The model does not perform equally well for all music styles and cultures.
-- The model sometimes generates end of songs, collapsing to silence.
-- It is sometimes difficult to assess what types of text descriptions provide the best generations. Prompt engineering may be required to obtain satisfying results.
-
-**Biases:** The source of data is potentially lacking diversity and all music cultures are not equally represented in the dataset. The model may not perform equally well on the wide variety of music genres that exists. The generated samples from the model will reflect the biases from the training data. Further work on this model should include methods for balanced and just representations of cultures, for example, by scaling the training data to be both diverse and inclusive.
-
-**Risks and harms:** Biases and limitations of the model may lead to generation of samples that may be considered as biased, inappropriate or offensive. We believe that providing the code to reproduce the research and train new models will allow to broaden the application to new and more representative data.
-
-**Use cases:** Users must be aware of the biases, limitations and risks of the model. MusicGen is a model developed for artificial intelligence research on controllable music generation. As such, it should not be used for downstream applications without further investigation and mitigation of risks.
-
-[arxiv]: https://arxiv.org/abs/2306.05284
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/lvis_v0_5_categories.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/lvis_v0_5_categories.py
deleted file mode 100644
index d3dab6198da614937b08682f4c9edf52bdf1d236..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/detectron2/data/datasets/lvis_v0_5_categories.py
+++ /dev/null
@@ -1,13 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-# Autogen with
-# with open("lvis_v0.5_val.json", "r") as f:
-# a = json.load(f)
-# c = a["categories"]
-# for x in c:
-# del x["image_count"]
-# del x["instance_count"]
-# LVIS_CATEGORIES = repr(c) + " # noqa"
-
-# fmt: off
-LVIS_CATEGORIES = [{'frequency': 'r', 'id': 1, 'synset': 'acorn.n.01', 'synonyms': ['acorn'], 'def': 'nut from an oak tree', 'name': 'acorn'}, {'frequency': 'c', 'id': 2, 'synset': 'aerosol.n.02', 'synonyms': ['aerosol_can', 'spray_can'], 'def': 'a dispenser that holds a substance under pressure', 'name': 'aerosol_can'}, {'frequency': 'f', 'id': 3, 'synset': 'air_conditioner.n.01', 'synonyms': ['air_conditioner'], 'def': 'a machine that keeps air cool and dry', 'name': 'air_conditioner'}, {'frequency': 'f', 'id': 4, 'synset': 'airplane.n.01', 'synonyms': ['airplane', 'aeroplane'], 'def': 'an aircraft that has a fixed wing and is powered by propellers or jets', 'name': 'airplane'}, {'frequency': 'c', 'id': 5, 'synset': 'alarm_clock.n.01', 'synonyms': ['alarm_clock'], 'def': 'a clock that wakes a sleeper at some preset time', 'name': 'alarm_clock'}, {'frequency': 'c', 'id': 6, 'synset': 'alcohol.n.01', 'synonyms': ['alcohol', 'alcoholic_beverage'], 'def': 'a liquor or brew containing alcohol as the active agent', 'name': 'alcohol'}, {'frequency': 'r', 'id': 7, 'synset': 'alligator.n.02', 'synonyms': ['alligator', 'gator'], 'def': 'amphibious reptiles related to crocodiles but with shorter broader snouts', 'name': 'alligator'}, {'frequency': 'c', 'id': 8, 'synset': 'almond.n.02', 'synonyms': ['almond'], 'def': 'oval-shaped edible seed of the almond tree', 'name': 'almond'}, {'frequency': 'c', 'id': 9, 'synset': 'ambulance.n.01', 'synonyms': ['ambulance'], 'def': 'a vehicle that takes people to and from hospitals', 'name': 'ambulance'}, {'frequency': 'r', 'id': 10, 'synset': 'amplifier.n.01', 'synonyms': ['amplifier'], 'def': 'electronic equipment that increases strength of signals', 'name': 'amplifier'}, {'frequency': 'c', 'id': 11, 'synset': 'anklet.n.03', 'synonyms': ['anklet', 'ankle_bracelet'], 'def': 'an ornament worn around the ankle', 'name': 'anklet'}, {'frequency': 'f', 'id': 12, 'synset': 'antenna.n.01', 'synonyms': ['antenna', 'aerial', 'transmitting_aerial'], 'def': 'an electrical device that sends or receives radio or television signals', 'name': 'antenna'}, {'frequency': 'f', 'id': 13, 'synset': 'apple.n.01', 'synonyms': ['apple'], 'def': 'fruit with red or yellow or green skin and sweet to tart crisp whitish flesh', 'name': 'apple'}, {'frequency': 'r', 'id': 14, 'synset': 'apple_juice.n.01', 'synonyms': ['apple_juice'], 'def': 'the juice of apples', 'name': 'apple_juice'}, {'frequency': 'r', 'id': 15, 'synset': 'applesauce.n.01', 'synonyms': ['applesauce'], 'def': 'puree of stewed apples usually sweetened and spiced', 'name': 'applesauce'}, {'frequency': 'r', 'id': 16, 'synset': 'apricot.n.02', 'synonyms': ['apricot'], 'def': 'downy yellow to rosy-colored fruit resembling a small peach', 'name': 'apricot'}, {'frequency': 'f', 'id': 17, 'synset': 'apron.n.01', 'synonyms': ['apron'], 'def': 'a garment of cloth that is tied about the waist and worn to protect clothing', 'name': 'apron'}, {'frequency': 'c', 'id': 18, 'synset': 'aquarium.n.01', 'synonyms': ['aquarium', 'fish_tank'], 'def': 'a tank/pool/bowl filled with water for keeping live fish and underwater animals', 'name': 'aquarium'}, {'frequency': 'c', 'id': 19, 'synset': 'armband.n.02', 'synonyms': ['armband'], 'def': 'a band worn around the upper arm', 'name': 'armband'}, {'frequency': 'f', 'id': 20, 'synset': 'armchair.n.01', 'synonyms': ['armchair'], 'def': 'chair with a support on each side for arms', 'name': 'armchair'}, {'frequency': 'r', 'id': 21, 'synset': 'armoire.n.01', 'synonyms': ['armoire'], 'def': 'a large wardrobe or cabinet', 'name': 'armoire'}, {'frequency': 'r', 'id': 22, 'synset': 'armor.n.01', 'synonyms': ['armor', 'armour'], 'def': 'protective covering made of metal and used in combat', 'name': 'armor'}, {'frequency': 'c', 'id': 23, 'synset': 'artichoke.n.02', 'synonyms': ['artichoke'], 'def': 'a thistlelike flower head with edible fleshy leaves and heart', 'name': 'artichoke'}, {'frequency': 'f', 'id': 24, 'synset': 'ashcan.n.01', 'synonyms': ['trash_can', 'garbage_can', 'wastebin', 'dustbin', 'trash_barrel', 'trash_bin'], 'def': 'a bin that holds rubbish until it is collected', 'name': 'trash_can'}, {'frequency': 'c', 'id': 25, 'synset': 'ashtray.n.01', 'synonyms': ['ashtray'], 'def': "a receptacle for the ash from smokers' cigars or cigarettes", 'name': 'ashtray'}, {'frequency': 'c', 'id': 26, 'synset': 'asparagus.n.02', 'synonyms': ['asparagus'], 'def': 'edible young shoots of the asparagus plant', 'name': 'asparagus'}, {'frequency': 'c', 'id': 27, 'synset': 'atomizer.n.01', 'synonyms': ['atomizer', 'atomiser', 'spray', 'sprayer', 'nebulizer', 'nebuliser'], 'def': 'a dispenser that turns a liquid (such as perfume) into a fine mist', 'name': 'atomizer'}, {'frequency': 'c', 'id': 28, 'synset': 'avocado.n.01', 'synonyms': ['avocado'], 'def': 'a pear-shaped fruit with green or blackish skin and rich yellowish pulp enclosing a single large seed', 'name': 'avocado'}, {'frequency': 'c', 'id': 29, 'synset': 'award.n.02', 'synonyms': ['award', 'accolade'], 'def': 'a tangible symbol signifying approval or distinction', 'name': 'award'}, {'frequency': 'f', 'id': 30, 'synset': 'awning.n.01', 'synonyms': ['awning'], 'def': 'a canopy made of canvas to shelter people or things from rain or sun', 'name': 'awning'}, {'frequency': 'r', 'id': 31, 'synset': 'ax.n.01', 'synonyms': ['ax', 'axe'], 'def': 'an edge tool with a heavy bladed head mounted across a handle', 'name': 'ax'}, {'frequency': 'f', 'id': 32, 'synset': 'baby_buggy.n.01', 'synonyms': ['baby_buggy', 'baby_carriage', 'perambulator', 'pram', 'stroller'], 'def': 'a small vehicle with four wheels in which a baby or child is pushed around', 'name': 'baby_buggy'}, {'frequency': 'c', 'id': 33, 'synset': 'backboard.n.01', 'synonyms': ['basketball_backboard'], 'def': 'a raised vertical board with basket attached; used to play basketball', 'name': 'basketball_backboard'}, {'frequency': 'f', 'id': 34, 'synset': 'backpack.n.01', 'synonyms': ['backpack', 'knapsack', 'packsack', 'rucksack', 'haversack'], 'def': 'a bag carried by a strap on your back or shoulder', 'name': 'backpack'}, {'frequency': 'f', 'id': 35, 'synset': 'bag.n.04', 'synonyms': ['handbag', 'purse', 'pocketbook'], 'def': 'a container used for carrying money and small personal items or accessories', 'name': 'handbag'}, {'frequency': 'f', 'id': 36, 'synset': 'bag.n.06', 'synonyms': ['suitcase', 'baggage', 'luggage'], 'def': 'cases used to carry belongings when traveling', 'name': 'suitcase'}, {'frequency': 'c', 'id': 37, 'synset': 'bagel.n.01', 'synonyms': ['bagel', 'beigel'], 'def': 'glazed yeast-raised doughnut-shaped roll with hard crust', 'name': 'bagel'}, {'frequency': 'r', 'id': 38, 'synset': 'bagpipe.n.01', 'synonyms': ['bagpipe'], 'def': 'a tubular wind instrument; the player blows air into a bag and squeezes it out', 'name': 'bagpipe'}, {'frequency': 'r', 'id': 39, 'synset': 'baguet.n.01', 'synonyms': ['baguet', 'baguette'], 'def': 'narrow French stick loaf', 'name': 'baguet'}, {'frequency': 'r', 'id': 40, 'synset': 'bait.n.02', 'synonyms': ['bait', 'lure'], 'def': 'something used to lure fish or other animals into danger so they can be trapped or killed', 'name': 'bait'}, {'frequency': 'f', 'id': 41, 'synset': 'ball.n.06', 'synonyms': ['ball'], 'def': 'a spherical object used as a plaything', 'name': 'ball'}, {'frequency': 'r', 'id': 42, 'synset': 'ballet_skirt.n.01', 'synonyms': ['ballet_skirt', 'tutu'], 'def': 'very short skirt worn by ballerinas', 'name': 'ballet_skirt'}, {'frequency': 'f', 'id': 43, 'synset': 'balloon.n.01', 'synonyms': ['balloon'], 'def': 'large tough nonrigid bag filled with gas or heated air', 'name': 'balloon'}, {'frequency': 'c', 'id': 44, 'synset': 'bamboo.n.02', 'synonyms': ['bamboo'], 'def': 'woody tropical grass having hollow woody stems', 'name': 'bamboo'}, {'frequency': 'f', 'id': 45, 'synset': 'banana.n.02', 'synonyms': ['banana'], 'def': 'elongated crescent-shaped yellow fruit with soft sweet flesh', 'name': 'banana'}, {'frequency': 'r', 'id': 46, 'synset': 'band_aid.n.01', 'synonyms': ['Band_Aid'], 'def': 'trade name for an adhesive bandage to cover small cuts or blisters', 'name': 'Band_Aid'}, {'frequency': 'c', 'id': 47, 'synset': 'bandage.n.01', 'synonyms': ['bandage'], 'def': 'a piece of soft material that covers and protects an injured part of the body', 'name': 'bandage'}, {'frequency': 'c', 'id': 48, 'synset': 'bandanna.n.01', 'synonyms': ['bandanna', 'bandana'], 'def': 'large and brightly colored handkerchief; often used as a neckerchief', 'name': 'bandanna'}, {'frequency': 'r', 'id': 49, 'synset': 'banjo.n.01', 'synonyms': ['banjo'], 'def': 'a stringed instrument of the guitar family with a long neck and circular body', 'name': 'banjo'}, {'frequency': 'f', 'id': 50, 'synset': 'banner.n.01', 'synonyms': ['banner', 'streamer'], 'def': 'long strip of cloth or paper used for decoration or advertising', 'name': 'banner'}, {'frequency': 'r', 'id': 51, 'synset': 'barbell.n.01', 'synonyms': ['barbell'], 'def': 'a bar to which heavy discs are attached at each end; used in weightlifting', 'name': 'barbell'}, {'frequency': 'r', 'id': 52, 'synset': 'barge.n.01', 'synonyms': ['barge'], 'def': 'a flatbottom boat for carrying heavy loads (especially on canals)', 'name': 'barge'}, {'frequency': 'f', 'id': 53, 'synset': 'barrel.n.02', 'synonyms': ['barrel', 'cask'], 'def': 'a cylindrical container that holds liquids', 'name': 'barrel'}, {'frequency': 'c', 'id': 54, 'synset': 'barrette.n.01', 'synonyms': ['barrette'], 'def': "a pin for holding women's hair in place", 'name': 'barrette'}, {'frequency': 'c', 'id': 55, 'synset': 'barrow.n.03', 'synonyms': ['barrow', 'garden_cart', 'lawn_cart', 'wheelbarrow'], 'def': 'a cart for carrying small loads; has handles and one or more wheels', 'name': 'barrow'}, {'frequency': 'f', 'id': 56, 'synset': 'base.n.03', 'synonyms': ['baseball_base'], 'def': 'a place that the runner must touch before scoring', 'name': 'baseball_base'}, {'frequency': 'f', 'id': 57, 'synset': 'baseball.n.02', 'synonyms': ['baseball'], 'def': 'a ball used in playing baseball', 'name': 'baseball'}, {'frequency': 'f', 'id': 58, 'synset': 'baseball_bat.n.01', 'synonyms': ['baseball_bat'], 'def': 'an implement used in baseball by the batter', 'name': 'baseball_bat'}, {'frequency': 'f', 'id': 59, 'synset': 'baseball_cap.n.01', 'synonyms': ['baseball_cap', 'jockey_cap', 'golf_cap'], 'def': 'a cap with a bill', 'name': 'baseball_cap'}, {'frequency': 'f', 'id': 60, 'synset': 'baseball_glove.n.01', 'synonyms': ['baseball_glove', 'baseball_mitt'], 'def': 'the handwear used by fielders in playing baseball', 'name': 'baseball_glove'}, {'frequency': 'f', 'id': 61, 'synset': 'basket.n.01', 'synonyms': ['basket', 'handbasket'], 'def': 'a container that is usually woven and has handles', 'name': 'basket'}, {'frequency': 'c', 'id': 62, 'synset': 'basket.n.03', 'synonyms': ['basketball_hoop'], 'def': 'metal hoop supporting a net through which players try to throw the basketball', 'name': 'basketball_hoop'}, {'frequency': 'c', 'id': 63, 'synset': 'basketball.n.02', 'synonyms': ['basketball'], 'def': 'an inflated ball used in playing basketball', 'name': 'basketball'}, {'frequency': 'r', 'id': 64, 'synset': 'bass_horn.n.01', 'synonyms': ['bass_horn', 'sousaphone', 'tuba'], 'def': 'the lowest brass wind instrument', 'name': 'bass_horn'}, {'frequency': 'r', 'id': 65, 'synset': 'bat.n.01', 'synonyms': ['bat_(animal)'], 'def': 'nocturnal mouselike mammal with forelimbs modified to form membranous wings', 'name': 'bat_(animal)'}, {'frequency': 'f', 'id': 66, 'synset': 'bath_mat.n.01', 'synonyms': ['bath_mat'], 'def': 'a heavy towel or mat to stand on while drying yourself after a bath', 'name': 'bath_mat'}, {'frequency': 'f', 'id': 67, 'synset': 'bath_towel.n.01', 'synonyms': ['bath_towel'], 'def': 'a large towel; to dry yourself after a bath', 'name': 'bath_towel'}, {'frequency': 'c', 'id': 68, 'synset': 'bathrobe.n.01', 'synonyms': ['bathrobe'], 'def': 'a loose-fitting robe of towelling; worn after a bath or swim', 'name': 'bathrobe'}, {'frequency': 'f', 'id': 69, 'synset': 'bathtub.n.01', 'synonyms': ['bathtub', 'bathing_tub'], 'def': 'a large open container that you fill with water and use to wash the body', 'name': 'bathtub'}, {'frequency': 'r', 'id': 70, 'synset': 'batter.n.02', 'synonyms': ['batter_(food)'], 'def': 'a liquid or semiliquid mixture, as of flour, eggs, and milk, used in cooking', 'name': 'batter_(food)'}, {'frequency': 'c', 'id': 71, 'synset': 'battery.n.02', 'synonyms': ['battery'], 'def': 'a portable device that produces electricity', 'name': 'battery'}, {'frequency': 'r', 'id': 72, 'synset': 'beach_ball.n.01', 'synonyms': ['beachball'], 'def': 'large and light ball; for play at the seaside', 'name': 'beachball'}, {'frequency': 'c', 'id': 73, 'synset': 'bead.n.01', 'synonyms': ['bead'], 'def': 'a small ball with a hole through the middle used for ornamentation, jewellery, etc.', 'name': 'bead'}, {'frequency': 'r', 'id': 74, 'synset': 'beaker.n.01', 'synonyms': ['beaker'], 'def': 'a flatbottomed jar made of glass or plastic; used for chemistry', 'name': 'beaker'}, {'frequency': 'c', 'id': 75, 'synset': 'bean_curd.n.01', 'synonyms': ['bean_curd', 'tofu'], 'def': 'cheeselike food made of curdled soybean milk', 'name': 'bean_curd'}, {'frequency': 'c', 'id': 76, 'synset': 'beanbag.n.01', 'synonyms': ['beanbag'], 'def': 'a bag filled with dried beans or similar items; used in games or to sit on', 'name': 'beanbag'}, {'frequency': 'f', 'id': 77, 'synset': 'beanie.n.01', 'synonyms': ['beanie', 'beany'], 'def': 'a small skullcap; formerly worn by schoolboys and college freshmen', 'name': 'beanie'}, {'frequency': 'f', 'id': 78, 'synset': 'bear.n.01', 'synonyms': ['bear'], 'def': 'large carnivorous or omnivorous mammals with shaggy coats and claws', 'name': 'bear'}, {'frequency': 'f', 'id': 79, 'synset': 'bed.n.01', 'synonyms': ['bed'], 'def': 'a piece of furniture that provides a place to sleep', 'name': 'bed'}, {'frequency': 'c', 'id': 80, 'synset': 'bedspread.n.01', 'synonyms': ['bedspread', 'bedcover', 'bed_covering', 'counterpane', 'spread'], 'def': 'decorative cover for a bed', 'name': 'bedspread'}, {'frequency': 'f', 'id': 81, 'synset': 'beef.n.01', 'synonyms': ['cow'], 'def': 'cattle that are reared for their meat', 'name': 'cow'}, {'frequency': 'c', 'id': 82, 'synset': 'beef.n.02', 'synonyms': ['beef_(food)', 'boeuf_(food)'], 'def': 'meat from an adult domestic bovine', 'name': 'beef_(food)'}, {'frequency': 'r', 'id': 83, 'synset': 'beeper.n.01', 'synonyms': ['beeper', 'pager'], 'def': 'an device that beeps when the person carrying it is being paged', 'name': 'beeper'}, {'frequency': 'f', 'id': 84, 'synset': 'beer_bottle.n.01', 'synonyms': ['beer_bottle'], 'def': 'a bottle that holds beer', 'name': 'beer_bottle'}, {'frequency': 'c', 'id': 85, 'synset': 'beer_can.n.01', 'synonyms': ['beer_can'], 'def': 'a can that holds beer', 'name': 'beer_can'}, {'frequency': 'r', 'id': 86, 'synset': 'beetle.n.01', 'synonyms': ['beetle'], 'def': 'insect with hard wing covers', 'name': 'beetle'}, {'frequency': 'f', 'id': 87, 'synset': 'bell.n.01', 'synonyms': ['bell'], 'def': 'a hollow device made of metal that makes a ringing sound when struck', 'name': 'bell'}, {'frequency': 'f', 'id': 88, 'synset': 'bell_pepper.n.02', 'synonyms': ['bell_pepper', 'capsicum'], 'def': 'large bell-shaped sweet pepper in green or red or yellow or orange or black varieties', 'name': 'bell_pepper'}, {'frequency': 'f', 'id': 89, 'synset': 'belt.n.02', 'synonyms': ['belt'], 'def': 'a band to tie or buckle around the body (usually at the waist)', 'name': 'belt'}, {'frequency': 'f', 'id': 90, 'synset': 'belt_buckle.n.01', 'synonyms': ['belt_buckle'], 'def': 'the buckle used to fasten a belt', 'name': 'belt_buckle'}, {'frequency': 'f', 'id': 91, 'synset': 'bench.n.01', 'synonyms': ['bench'], 'def': 'a long seat for more than one person', 'name': 'bench'}, {'frequency': 'c', 'id': 92, 'synset': 'beret.n.01', 'synonyms': ['beret'], 'def': 'a cap with no brim or bill; made of soft cloth', 'name': 'beret'}, {'frequency': 'c', 'id': 93, 'synset': 'bib.n.02', 'synonyms': ['bib'], 'def': 'a napkin tied under the chin of a child while eating', 'name': 'bib'}, {'frequency': 'r', 'id': 94, 'synset': 'bible.n.01', 'synonyms': ['Bible'], 'def': 'the sacred writings of the Christian religions', 'name': 'Bible'}, {'frequency': 'f', 'id': 95, 'synset': 'bicycle.n.01', 'synonyms': ['bicycle', 'bike_(bicycle)'], 'def': 'a wheeled vehicle that has two wheels and is moved by foot pedals', 'name': 'bicycle'}, {'frequency': 'f', 'id': 96, 'synset': 'bill.n.09', 'synonyms': ['visor', 'vizor'], 'def': 'a brim that projects to the front to shade the eyes', 'name': 'visor'}, {'frequency': 'c', 'id': 97, 'synset': 'binder.n.03', 'synonyms': ['binder', 'ring-binder'], 'def': 'holds loose papers or magazines', 'name': 'binder'}, {'frequency': 'c', 'id': 98, 'synset': 'binoculars.n.01', 'synonyms': ['binoculars', 'field_glasses', 'opera_glasses'], 'def': 'an optical instrument designed for simultaneous use by both eyes', 'name': 'binoculars'}, {'frequency': 'f', 'id': 99, 'synset': 'bird.n.01', 'synonyms': ['bird'], 'def': 'animal characterized by feathers and wings', 'name': 'bird'}, {'frequency': 'r', 'id': 100, 'synset': 'bird_feeder.n.01', 'synonyms': ['birdfeeder'], 'def': 'an outdoor device that supplies food for wild birds', 'name': 'birdfeeder'}, {'frequency': 'r', 'id': 101, 'synset': 'birdbath.n.01', 'synonyms': ['birdbath'], 'def': 'an ornamental basin (usually in a garden) for birds to bathe in', 'name': 'birdbath'}, {'frequency': 'c', 'id': 102, 'synset': 'birdcage.n.01', 'synonyms': ['birdcage'], 'def': 'a cage in which a bird can be kept', 'name': 'birdcage'}, {'frequency': 'c', 'id': 103, 'synset': 'birdhouse.n.01', 'synonyms': ['birdhouse'], 'def': 'a shelter for birds', 'name': 'birdhouse'}, {'frequency': 'f', 'id': 104, 'synset': 'birthday_cake.n.01', 'synonyms': ['birthday_cake'], 'def': 'decorated cake served at a birthday party', 'name': 'birthday_cake'}, {'frequency': 'r', 'id': 105, 'synset': 'birthday_card.n.01', 'synonyms': ['birthday_card'], 'def': 'a card expressing a birthday greeting', 'name': 'birthday_card'}, {'frequency': 'r', 'id': 106, 'synset': 'biscuit.n.01', 'synonyms': ['biscuit_(bread)'], 'def': 'small round bread leavened with baking-powder or soda', 'name': 'biscuit_(bread)'}, {'frequency': 'r', 'id': 107, 'synset': 'black_flag.n.01', 'synonyms': ['pirate_flag'], 'def': 'a flag usually bearing a white skull and crossbones on a black background', 'name': 'pirate_flag'}, {'frequency': 'c', 'id': 108, 'synset': 'black_sheep.n.02', 'synonyms': ['black_sheep'], 'def': 'sheep with a black coat', 'name': 'black_sheep'}, {'frequency': 'c', 'id': 109, 'synset': 'blackboard.n.01', 'synonyms': ['blackboard', 'chalkboard'], 'def': 'sheet of slate; for writing with chalk', 'name': 'blackboard'}, {'frequency': 'f', 'id': 110, 'synset': 'blanket.n.01', 'synonyms': ['blanket'], 'def': 'bedding that keeps a person warm in bed', 'name': 'blanket'}, {'frequency': 'c', 'id': 111, 'synset': 'blazer.n.01', 'synonyms': ['blazer', 'sport_jacket', 'sport_coat', 'sports_jacket', 'sports_coat'], 'def': 'lightweight jacket; often striped in the colors of a club or school', 'name': 'blazer'}, {'frequency': 'f', 'id': 112, 'synset': 'blender.n.01', 'synonyms': ['blender', 'liquidizer', 'liquidiser'], 'def': 'an electrically powered mixer that mix or chop or liquefy foods', 'name': 'blender'}, {'frequency': 'r', 'id': 113, 'synset': 'blimp.n.02', 'synonyms': ['blimp'], 'def': 'a small nonrigid airship used for observation or as a barrage balloon', 'name': 'blimp'}, {'frequency': 'c', 'id': 114, 'synset': 'blinker.n.01', 'synonyms': ['blinker', 'flasher'], 'def': 'a light that flashes on and off; used as a signal or to send messages', 'name': 'blinker'}, {'frequency': 'c', 'id': 115, 'synset': 'blueberry.n.02', 'synonyms': ['blueberry'], 'def': 'sweet edible dark-blue berries of blueberry plants', 'name': 'blueberry'}, {'frequency': 'r', 'id': 116, 'synset': 'boar.n.02', 'synonyms': ['boar'], 'def': 'an uncastrated male hog', 'name': 'boar'}, {'frequency': 'r', 'id': 117, 'synset': 'board.n.09', 'synonyms': ['gameboard'], 'def': 'a flat portable surface (usually rectangular) designed for board games', 'name': 'gameboard'}, {'frequency': 'f', 'id': 118, 'synset': 'boat.n.01', 'synonyms': ['boat', 'ship_(boat)'], 'def': 'a vessel for travel on water', 'name': 'boat'}, {'frequency': 'c', 'id': 119, 'synset': 'bobbin.n.01', 'synonyms': ['bobbin', 'spool', 'reel'], 'def': 'a thing around which thread/tape/film or other flexible materials can be wound', 'name': 'bobbin'}, {'frequency': 'r', 'id': 120, 'synset': 'bobby_pin.n.01', 'synonyms': ['bobby_pin', 'hairgrip'], 'def': 'a flat wire hairpin used to hold bobbed hair in place', 'name': 'bobby_pin'}, {'frequency': 'c', 'id': 121, 'synset': 'boiled_egg.n.01', 'synonyms': ['boiled_egg', 'coddled_egg'], 'def': 'egg cooked briefly in the shell in gently boiling water', 'name': 'boiled_egg'}, {'frequency': 'r', 'id': 122, 'synset': 'bolo_tie.n.01', 'synonyms': ['bolo_tie', 'bolo', 'bola_tie', 'bola'], 'def': 'a cord fastened around the neck with an ornamental clasp and worn as a necktie', 'name': 'bolo_tie'}, {'frequency': 'c', 'id': 123, 'synset': 'bolt.n.03', 'synonyms': ['deadbolt'], 'def': 'the part of a lock that is engaged or withdrawn with a key', 'name': 'deadbolt'}, {'frequency': 'f', 'id': 124, 'synset': 'bolt.n.06', 'synonyms': ['bolt'], 'def': 'a screw that screws into a nut to form a fastener', 'name': 'bolt'}, {'frequency': 'r', 'id': 125, 'synset': 'bonnet.n.01', 'synonyms': ['bonnet'], 'def': 'a hat tied under the chin', 'name': 'bonnet'}, {'frequency': 'f', 'id': 126, 'synset': 'book.n.01', 'synonyms': ['book'], 'def': 'a written work or composition that has been published', 'name': 'book'}, {'frequency': 'r', 'id': 127, 'synset': 'book_bag.n.01', 'synonyms': ['book_bag'], 'def': 'a bag in which students carry their books', 'name': 'book_bag'}, {'frequency': 'c', 'id': 128, 'synset': 'bookcase.n.01', 'synonyms': ['bookcase'], 'def': 'a piece of furniture with shelves for storing books', 'name': 'bookcase'}, {'frequency': 'c', 'id': 129, 'synset': 'booklet.n.01', 'synonyms': ['booklet', 'brochure', 'leaflet', 'pamphlet'], 'def': 'a small book usually having a paper cover', 'name': 'booklet'}, {'frequency': 'r', 'id': 130, 'synset': 'bookmark.n.01', 'synonyms': ['bookmark', 'bookmarker'], 'def': 'a marker (a piece of paper or ribbon) placed between the pages of a book', 'name': 'bookmark'}, {'frequency': 'r', 'id': 131, 'synset': 'boom.n.04', 'synonyms': ['boom_microphone', 'microphone_boom'], 'def': 'a pole carrying an overhead microphone projected over a film or tv set', 'name': 'boom_microphone'}, {'frequency': 'f', 'id': 132, 'synset': 'boot.n.01', 'synonyms': ['boot'], 'def': 'footwear that covers the whole foot and lower leg', 'name': 'boot'}, {'frequency': 'f', 'id': 133, 'synset': 'bottle.n.01', 'synonyms': ['bottle'], 'def': 'a glass or plastic vessel used for storing drinks or other liquids', 'name': 'bottle'}, {'frequency': 'c', 'id': 134, 'synset': 'bottle_opener.n.01', 'synonyms': ['bottle_opener'], 'def': 'an opener for removing caps or corks from bottles', 'name': 'bottle_opener'}, {'frequency': 'c', 'id': 135, 'synset': 'bouquet.n.01', 'synonyms': ['bouquet'], 'def': 'an arrangement of flowers that is usually given as a present', 'name': 'bouquet'}, {'frequency': 'r', 'id': 136, 'synset': 'bow.n.04', 'synonyms': ['bow_(weapon)'], 'def': 'a weapon for shooting arrows', 'name': 'bow_(weapon)'}, {'frequency': 'f', 'id': 137, 'synset': 'bow.n.08', 'synonyms': ['bow_(decorative_ribbons)'], 'def': 'a decorative interlacing of ribbons', 'name': 'bow_(decorative_ribbons)'}, {'frequency': 'f', 'id': 138, 'synset': 'bow_tie.n.01', 'synonyms': ['bow-tie', 'bowtie'], 'def': "a man's tie that ties in a bow", 'name': 'bow-tie'}, {'frequency': 'f', 'id': 139, 'synset': 'bowl.n.03', 'synonyms': ['bowl'], 'def': 'a dish that is round and open at the top for serving foods', 'name': 'bowl'}, {'frequency': 'r', 'id': 140, 'synset': 'bowl.n.08', 'synonyms': ['pipe_bowl'], 'def': 'a small round container that is open at the top for holding tobacco', 'name': 'pipe_bowl'}, {'frequency': 'c', 'id': 141, 'synset': 'bowler_hat.n.01', 'synonyms': ['bowler_hat', 'bowler', 'derby_hat', 'derby', 'plug_hat'], 'def': 'a felt hat that is round and hard with a narrow brim', 'name': 'bowler_hat'}, {'frequency': 'r', 'id': 142, 'synset': 'bowling_ball.n.01', 'synonyms': ['bowling_ball'], 'def': 'a large ball with finger holes used in the sport of bowling', 'name': 'bowling_ball'}, {'frequency': 'r', 'id': 143, 'synset': 'bowling_pin.n.01', 'synonyms': ['bowling_pin'], 'def': 'a club-shaped wooden object used in bowling', 'name': 'bowling_pin'}, {'frequency': 'r', 'id': 144, 'synset': 'boxing_glove.n.01', 'synonyms': ['boxing_glove'], 'def': 'large glove coverings the fists of a fighter worn for the sport of boxing', 'name': 'boxing_glove'}, {'frequency': 'c', 'id': 145, 'synset': 'brace.n.06', 'synonyms': ['suspenders'], 'def': 'elastic straps that hold trousers up (usually used in the plural)', 'name': 'suspenders'}, {'frequency': 'f', 'id': 146, 'synset': 'bracelet.n.02', 'synonyms': ['bracelet', 'bangle'], 'def': 'jewelry worn around the wrist for decoration', 'name': 'bracelet'}, {'frequency': 'r', 'id': 147, 'synset': 'brass.n.07', 'synonyms': ['brass_plaque'], 'def': 'a memorial made of brass', 'name': 'brass_plaque'}, {'frequency': 'c', 'id': 148, 'synset': 'brassiere.n.01', 'synonyms': ['brassiere', 'bra', 'bandeau'], 'def': 'an undergarment worn by women to support their breasts', 'name': 'brassiere'}, {'frequency': 'c', 'id': 149, 'synset': 'bread-bin.n.01', 'synonyms': ['bread-bin', 'breadbox'], 'def': 'a container used to keep bread or cake in', 'name': 'bread-bin'}, {'frequency': 'r', 'id': 150, 'synset': 'breechcloth.n.01', 'synonyms': ['breechcloth', 'breechclout', 'loincloth'], 'def': 'a garment that provides covering for the loins', 'name': 'breechcloth'}, {'frequency': 'c', 'id': 151, 'synset': 'bridal_gown.n.01', 'synonyms': ['bridal_gown', 'wedding_gown', 'wedding_dress'], 'def': 'a gown worn by the bride at a wedding', 'name': 'bridal_gown'}, {'frequency': 'c', 'id': 152, 'synset': 'briefcase.n.01', 'synonyms': ['briefcase'], 'def': 'a case with a handle; for carrying papers or files or books', 'name': 'briefcase'}, {'frequency': 'c', 'id': 153, 'synset': 'bristle_brush.n.01', 'synonyms': ['bristle_brush'], 'def': 'a brush that is made with the short stiff hairs of an animal or plant', 'name': 'bristle_brush'}, {'frequency': 'f', 'id': 154, 'synset': 'broccoli.n.01', 'synonyms': ['broccoli'], 'def': 'plant with dense clusters of tight green flower buds', 'name': 'broccoli'}, {'frequency': 'r', 'id': 155, 'synset': 'brooch.n.01', 'synonyms': ['broach'], 'def': 'a decorative pin worn by women', 'name': 'broach'}, {'frequency': 'c', 'id': 156, 'synset': 'broom.n.01', 'synonyms': ['broom'], 'def': 'bundle of straws or twigs attached to a long handle; used for cleaning', 'name': 'broom'}, {'frequency': 'c', 'id': 157, 'synset': 'brownie.n.03', 'synonyms': ['brownie'], 'def': 'square or bar of very rich chocolate cake usually with nuts', 'name': 'brownie'}, {'frequency': 'c', 'id': 158, 'synset': 'brussels_sprouts.n.01', 'synonyms': ['brussels_sprouts'], 'def': 'the small edible cabbage-like buds growing along a stalk', 'name': 'brussels_sprouts'}, {'frequency': 'r', 'id': 159, 'synset': 'bubble_gum.n.01', 'synonyms': ['bubble_gum'], 'def': 'a kind of chewing gum that can be blown into bubbles', 'name': 'bubble_gum'}, {'frequency': 'f', 'id': 160, 'synset': 'bucket.n.01', 'synonyms': ['bucket', 'pail'], 'def': 'a roughly cylindrical vessel that is open at the top', 'name': 'bucket'}, {'frequency': 'r', 'id': 161, 'synset': 'buggy.n.01', 'synonyms': ['horse_buggy'], 'def': 'a small lightweight carriage; drawn by a single horse', 'name': 'horse_buggy'}, {'frequency': 'c', 'id': 162, 'synset': 'bull.n.11', 'synonyms': ['bull'], 'def': 'mature male cow', 'name': 'bull'}, {'frequency': 'r', 'id': 163, 'synset': 'bulldog.n.01', 'synonyms': ['bulldog'], 'def': 'a thickset short-haired dog with a large head and strong undershot lower jaw', 'name': 'bulldog'}, {'frequency': 'r', 'id': 164, 'synset': 'bulldozer.n.01', 'synonyms': ['bulldozer', 'dozer'], 'def': 'large powerful tractor; a large blade in front flattens areas of ground', 'name': 'bulldozer'}, {'frequency': 'c', 'id': 165, 'synset': 'bullet_train.n.01', 'synonyms': ['bullet_train'], 'def': 'a high-speed passenger train', 'name': 'bullet_train'}, {'frequency': 'c', 'id': 166, 'synset': 'bulletin_board.n.02', 'synonyms': ['bulletin_board', 'notice_board'], 'def': 'a board that hangs on a wall; displays announcements', 'name': 'bulletin_board'}, {'frequency': 'r', 'id': 167, 'synset': 'bulletproof_vest.n.01', 'synonyms': ['bulletproof_vest'], 'def': 'a vest capable of resisting the impact of a bullet', 'name': 'bulletproof_vest'}, {'frequency': 'c', 'id': 168, 'synset': 'bullhorn.n.01', 'synonyms': ['bullhorn', 'megaphone'], 'def': 'a portable loudspeaker with built-in microphone and amplifier', 'name': 'bullhorn'}, {'frequency': 'r', 'id': 169, 'synset': 'bully_beef.n.01', 'synonyms': ['corned_beef', 'corn_beef'], 'def': 'beef cured or pickled in brine', 'name': 'corned_beef'}, {'frequency': 'f', 'id': 170, 'synset': 'bun.n.01', 'synonyms': ['bun', 'roll'], 'def': 'small rounded bread either plain or sweet', 'name': 'bun'}, {'frequency': 'c', 'id': 171, 'synset': 'bunk_bed.n.01', 'synonyms': ['bunk_bed'], 'def': 'beds built one above the other', 'name': 'bunk_bed'}, {'frequency': 'f', 'id': 172, 'synset': 'buoy.n.01', 'synonyms': ['buoy'], 'def': 'a float attached by rope to the seabed to mark channels in a harbor or underwater hazards', 'name': 'buoy'}, {'frequency': 'r', 'id': 173, 'synset': 'burrito.n.01', 'synonyms': ['burrito'], 'def': 'a flour tortilla folded around a filling', 'name': 'burrito'}, {'frequency': 'f', 'id': 174, 'synset': 'bus.n.01', 'synonyms': ['bus_(vehicle)', 'autobus', 'charabanc', 'double-decker', 'motorbus', 'motorcoach'], 'def': 'a vehicle carrying many passengers; used for public transport', 'name': 'bus_(vehicle)'}, {'frequency': 'c', 'id': 175, 'synset': 'business_card.n.01', 'synonyms': ['business_card'], 'def': "a card on which are printed the person's name and business affiliation", 'name': 'business_card'}, {'frequency': 'c', 'id': 176, 'synset': 'butcher_knife.n.01', 'synonyms': ['butcher_knife'], 'def': 'a large sharp knife for cutting or trimming meat', 'name': 'butcher_knife'}, {'frequency': 'c', 'id': 177, 'synset': 'butter.n.01', 'synonyms': ['butter'], 'def': 'an edible emulsion of fat globules made by churning milk or cream; for cooking and table use', 'name': 'butter'}, {'frequency': 'c', 'id': 178, 'synset': 'butterfly.n.01', 'synonyms': ['butterfly'], 'def': 'insect typically having a slender body with knobbed antennae and broad colorful wings', 'name': 'butterfly'}, {'frequency': 'f', 'id': 179, 'synset': 'button.n.01', 'synonyms': ['button'], 'def': 'a round fastener sewn to shirts and coats etc to fit through buttonholes', 'name': 'button'}, {'frequency': 'f', 'id': 180, 'synset': 'cab.n.03', 'synonyms': ['cab_(taxi)', 'taxi', 'taxicab'], 'def': 'a car that takes passengers where they want to go in exchange for money', 'name': 'cab_(taxi)'}, {'frequency': 'r', 'id': 181, 'synset': 'cabana.n.01', 'synonyms': ['cabana'], 'def': 'a small tent used as a dressing room beside the sea or a swimming pool', 'name': 'cabana'}, {'frequency': 'r', 'id': 182, 'synset': 'cabin_car.n.01', 'synonyms': ['cabin_car', 'caboose'], 'def': 'a car on a freight train for use of the train crew; usually the last car on the train', 'name': 'cabin_car'}, {'frequency': 'f', 'id': 183, 'synset': 'cabinet.n.01', 'synonyms': ['cabinet'], 'def': 'a piece of furniture resembling a cupboard with doors and shelves and drawers', 'name': 'cabinet'}, {'frequency': 'r', 'id': 184, 'synset': 'cabinet.n.03', 'synonyms': ['locker', 'storage_locker'], 'def': 'a storage compartment for clothes and valuables; usually it has a lock', 'name': 'locker'}, {'frequency': 'f', 'id': 185, 'synset': 'cake.n.03', 'synonyms': ['cake'], 'def': 'baked goods made from or based on a mixture of flour, sugar, eggs, and fat', 'name': 'cake'}, {'frequency': 'c', 'id': 186, 'synset': 'calculator.n.02', 'synonyms': ['calculator'], 'def': 'a small machine that is used for mathematical calculations', 'name': 'calculator'}, {'frequency': 'f', 'id': 187, 'synset': 'calendar.n.02', 'synonyms': ['calendar'], 'def': 'a list or register of events (appointments/social events/court cases, etc)', 'name': 'calendar'}, {'frequency': 'c', 'id': 188, 'synset': 'calf.n.01', 'synonyms': ['calf'], 'def': 'young of domestic cattle', 'name': 'calf'}, {'frequency': 'c', 'id': 189, 'synset': 'camcorder.n.01', 'synonyms': ['camcorder'], 'def': 'a portable television camera and videocassette recorder', 'name': 'camcorder'}, {'frequency': 'c', 'id': 190, 'synset': 'camel.n.01', 'synonyms': ['camel'], 'def': 'cud-chewing mammal used as a draft or saddle animal in desert regions', 'name': 'camel'}, {'frequency': 'f', 'id': 191, 'synset': 'camera.n.01', 'synonyms': ['camera'], 'def': 'equipment for taking photographs', 'name': 'camera'}, {'frequency': 'c', 'id': 192, 'synset': 'camera_lens.n.01', 'synonyms': ['camera_lens'], 'def': 'a lens that focuses the image in a camera', 'name': 'camera_lens'}, {'frequency': 'c', 'id': 193, 'synset': 'camper.n.02', 'synonyms': ['camper_(vehicle)', 'camping_bus', 'motor_home'], 'def': 'a recreational vehicle equipped for camping out while traveling', 'name': 'camper_(vehicle)'}, {'frequency': 'f', 'id': 194, 'synset': 'can.n.01', 'synonyms': ['can', 'tin_can'], 'def': 'airtight sealed metal container for food or drink or paint etc.', 'name': 'can'}, {'frequency': 'c', 'id': 195, 'synset': 'can_opener.n.01', 'synonyms': ['can_opener', 'tin_opener'], 'def': 'a device for cutting cans open', 'name': 'can_opener'}, {'frequency': 'r', 'id': 196, 'synset': 'candelabrum.n.01', 'synonyms': ['candelabrum', 'candelabra'], 'def': 'branched candlestick; ornamental; has several lights', 'name': 'candelabrum'}, {'frequency': 'f', 'id': 197, 'synset': 'candle.n.01', 'synonyms': ['candle', 'candlestick'], 'def': 'stick of wax with a wick in the middle', 'name': 'candle'}, {'frequency': 'f', 'id': 198, 'synset': 'candlestick.n.01', 'synonyms': ['candle_holder'], 'def': 'a holder with sockets for candles', 'name': 'candle_holder'}, {'frequency': 'r', 'id': 199, 'synset': 'candy_bar.n.01', 'synonyms': ['candy_bar'], 'def': 'a candy shaped as a bar', 'name': 'candy_bar'}, {'frequency': 'c', 'id': 200, 'synset': 'candy_cane.n.01', 'synonyms': ['candy_cane'], 'def': 'a hard candy in the shape of a rod (usually with stripes)', 'name': 'candy_cane'}, {'frequency': 'c', 'id': 201, 'synset': 'cane.n.01', 'synonyms': ['walking_cane'], 'def': 'a stick that people can lean on to help them walk', 'name': 'walking_cane'}, {'frequency': 'c', 'id': 202, 'synset': 'canister.n.02', 'synonyms': ['canister', 'cannister'], 'def': 'metal container for storing dry foods such as tea or flour', 'name': 'canister'}, {'frequency': 'r', 'id': 203, 'synset': 'cannon.n.02', 'synonyms': ['cannon'], 'def': 'heavy gun fired from a tank', 'name': 'cannon'}, {'frequency': 'c', 'id': 204, 'synset': 'canoe.n.01', 'synonyms': ['canoe'], 'def': 'small and light boat; pointed at both ends; propelled with a paddle', 'name': 'canoe'}, {'frequency': 'r', 'id': 205, 'synset': 'cantaloup.n.02', 'synonyms': ['cantaloup', 'cantaloupe'], 'def': 'the fruit of a cantaloup vine; small to medium-sized melon with yellowish flesh', 'name': 'cantaloup'}, {'frequency': 'r', 'id': 206, 'synset': 'canteen.n.01', 'synonyms': ['canteen'], 'def': 'a flask for carrying water; used by soldiers or travelers', 'name': 'canteen'}, {'frequency': 'c', 'id': 207, 'synset': 'cap.n.01', 'synonyms': ['cap_(headwear)'], 'def': 'a tight-fitting headwear', 'name': 'cap_(headwear)'}, {'frequency': 'f', 'id': 208, 'synset': 'cap.n.02', 'synonyms': ['bottle_cap', 'cap_(container_lid)'], 'def': 'a top (as for a bottle)', 'name': 'bottle_cap'}, {'frequency': 'r', 'id': 209, 'synset': 'cape.n.02', 'synonyms': ['cape'], 'def': 'a sleeveless garment like a cloak but shorter', 'name': 'cape'}, {'frequency': 'c', 'id': 210, 'synset': 'cappuccino.n.01', 'synonyms': ['cappuccino', 'coffee_cappuccino'], 'def': 'equal parts of espresso and steamed milk', 'name': 'cappuccino'}, {'frequency': 'f', 'id': 211, 'synset': 'car.n.01', 'synonyms': ['car_(automobile)', 'auto_(automobile)', 'automobile'], 'def': 'a motor vehicle with four wheels', 'name': 'car_(automobile)'}, {'frequency': 'f', 'id': 212, 'synset': 'car.n.02', 'synonyms': ['railcar_(part_of_a_train)', 'railway_car_(part_of_a_train)', 'railroad_car_(part_of_a_train)'], 'def': 'a wheeled vehicle adapted to the rails of railroad', 'name': 'railcar_(part_of_a_train)'}, {'frequency': 'r', 'id': 213, 'synset': 'car.n.04', 'synonyms': ['elevator_car'], 'def': 'where passengers ride up and down', 'name': 'elevator_car'}, {'frequency': 'r', 'id': 214, 'synset': 'car_battery.n.01', 'synonyms': ['car_battery', 'automobile_battery'], 'def': 'a battery in a motor vehicle', 'name': 'car_battery'}, {'frequency': 'c', 'id': 215, 'synset': 'card.n.02', 'synonyms': ['identity_card'], 'def': 'a card certifying the identity of the bearer', 'name': 'identity_card'}, {'frequency': 'c', 'id': 216, 'synset': 'card.n.03', 'synonyms': ['card'], 'def': 'a rectangular piece of paper used to send messages (e.g. greetings or pictures)', 'name': 'card'}, {'frequency': 'r', 'id': 217, 'synset': 'cardigan.n.01', 'synonyms': ['cardigan'], 'def': 'knitted jacket that is fastened up the front with buttons or a zipper', 'name': 'cardigan'}, {'frequency': 'r', 'id': 218, 'synset': 'cargo_ship.n.01', 'synonyms': ['cargo_ship', 'cargo_vessel'], 'def': 'a ship designed to carry cargo', 'name': 'cargo_ship'}, {'frequency': 'r', 'id': 219, 'synset': 'carnation.n.01', 'synonyms': ['carnation'], 'def': 'plant with pink to purple-red spice-scented usually double flowers', 'name': 'carnation'}, {'frequency': 'c', 'id': 220, 'synset': 'carriage.n.02', 'synonyms': ['horse_carriage'], 'def': 'a vehicle with wheels drawn by one or more horses', 'name': 'horse_carriage'}, {'frequency': 'f', 'id': 221, 'synset': 'carrot.n.01', 'synonyms': ['carrot'], 'def': 'deep orange edible root of the cultivated carrot plant', 'name': 'carrot'}, {'frequency': 'c', 'id': 222, 'synset': 'carryall.n.01', 'synonyms': ['tote_bag'], 'def': 'a capacious bag or basket', 'name': 'tote_bag'}, {'frequency': 'c', 'id': 223, 'synset': 'cart.n.01', 'synonyms': ['cart'], 'def': 'a heavy open wagon usually having two wheels and drawn by an animal', 'name': 'cart'}, {'frequency': 'c', 'id': 224, 'synset': 'carton.n.02', 'synonyms': ['carton'], 'def': 'a box made of cardboard; opens by flaps on top', 'name': 'carton'}, {'frequency': 'c', 'id': 225, 'synset': 'cash_register.n.01', 'synonyms': ['cash_register', 'register_(for_cash_transactions)'], 'def': 'a cashbox with an adding machine to register transactions', 'name': 'cash_register'}, {'frequency': 'r', 'id': 226, 'synset': 'casserole.n.01', 'synonyms': ['casserole'], 'def': 'food cooked and served in a casserole', 'name': 'casserole'}, {'frequency': 'r', 'id': 227, 'synset': 'cassette.n.01', 'synonyms': ['cassette'], 'def': 'a container that holds a magnetic tape used for recording or playing sound or video', 'name': 'cassette'}, {'frequency': 'c', 'id': 228, 'synset': 'cast.n.05', 'synonyms': ['cast', 'plaster_cast', 'plaster_bandage'], 'def': 'bandage consisting of a firm covering that immobilizes broken bones while they heal', 'name': 'cast'}, {'frequency': 'f', 'id': 229, 'synset': 'cat.n.01', 'synonyms': ['cat'], 'def': 'a domestic house cat', 'name': 'cat'}, {'frequency': 'c', 'id': 230, 'synset': 'cauliflower.n.02', 'synonyms': ['cauliflower'], 'def': 'edible compact head of white undeveloped flowers', 'name': 'cauliflower'}, {'frequency': 'r', 'id': 231, 'synset': 'caviar.n.01', 'synonyms': ['caviar', 'caviare'], 'def': "salted roe of sturgeon or other large fish; usually served as an hors d'oeuvre", 'name': 'caviar'}, {'frequency': 'c', 'id': 232, 'synset': 'cayenne.n.02', 'synonyms': ['cayenne_(spice)', 'cayenne_pepper_(spice)', 'red_pepper_(spice)'], 'def': 'ground pods and seeds of pungent red peppers of the genus Capsicum', 'name': 'cayenne_(spice)'}, {'frequency': 'c', 'id': 233, 'synset': 'cd_player.n.01', 'synonyms': ['CD_player'], 'def': 'electronic equipment for playing compact discs (CDs)', 'name': 'CD_player'}, {'frequency': 'c', 'id': 234, 'synset': 'celery.n.01', 'synonyms': ['celery'], 'def': 'widely cultivated herb with aromatic leaf stalks that are eaten raw or cooked', 'name': 'celery'}, {'frequency': 'f', 'id': 235, 'synset': 'cellular_telephone.n.01', 'synonyms': ['cellular_telephone', 'cellular_phone', 'cellphone', 'mobile_phone', 'smart_phone'], 'def': 'a hand-held mobile telephone', 'name': 'cellular_telephone'}, {'frequency': 'r', 'id': 236, 'synset': 'chain_mail.n.01', 'synonyms': ['chain_mail', 'ring_mail', 'chain_armor', 'chain_armour', 'ring_armor', 'ring_armour'], 'def': '(Middle Ages) flexible armor made of interlinked metal rings', 'name': 'chain_mail'}, {'frequency': 'f', 'id': 237, 'synset': 'chair.n.01', 'synonyms': ['chair'], 'def': 'a seat for one person, with a support for the back', 'name': 'chair'}, {'frequency': 'r', 'id': 238, 'synset': 'chaise_longue.n.01', 'synonyms': ['chaise_longue', 'chaise', 'daybed'], 'def': 'a long chair; for reclining', 'name': 'chaise_longue'}, {'frequency': 'r', 'id': 239, 'synset': 'champagne.n.01', 'synonyms': ['champagne'], 'def': 'a white sparkling wine produced in Champagne or resembling that produced there', 'name': 'champagne'}, {'frequency': 'f', 'id': 240, 'synset': 'chandelier.n.01', 'synonyms': ['chandelier'], 'def': 'branched lighting fixture; often ornate; hangs from the ceiling', 'name': 'chandelier'}, {'frequency': 'r', 'id': 241, 'synset': 'chap.n.04', 'synonyms': ['chap'], 'def': 'leather leggings without a seat; worn over trousers by cowboys to protect their legs', 'name': 'chap'}, {'frequency': 'r', 'id': 242, 'synset': 'checkbook.n.01', 'synonyms': ['checkbook', 'chequebook'], 'def': 'a book issued to holders of checking accounts', 'name': 'checkbook'}, {'frequency': 'r', 'id': 243, 'synset': 'checkerboard.n.01', 'synonyms': ['checkerboard'], 'def': 'a board having 64 squares of two alternating colors', 'name': 'checkerboard'}, {'frequency': 'c', 'id': 244, 'synset': 'cherry.n.03', 'synonyms': ['cherry'], 'def': 'a red fruit with a single hard stone', 'name': 'cherry'}, {'frequency': 'r', 'id': 245, 'synset': 'chessboard.n.01', 'synonyms': ['chessboard'], 'def': 'a checkerboard used to play chess', 'name': 'chessboard'}, {'frequency': 'r', 'id': 246, 'synset': 'chest_of_drawers.n.01', 'synonyms': ['chest_of_drawers_(furniture)', 'bureau_(furniture)', 'chest_(furniture)'], 'def': 'furniture with drawers for keeping clothes', 'name': 'chest_of_drawers_(furniture)'}, {'frequency': 'c', 'id': 247, 'synset': 'chicken.n.02', 'synonyms': ['chicken_(animal)'], 'def': 'a domestic fowl bred for flesh or eggs', 'name': 'chicken_(animal)'}, {'frequency': 'c', 'id': 248, 'synset': 'chicken_wire.n.01', 'synonyms': ['chicken_wire'], 'def': 'a galvanized wire network with a hexagonal mesh; used to build fences', 'name': 'chicken_wire'}, {'frequency': 'r', 'id': 249, 'synset': 'chickpea.n.01', 'synonyms': ['chickpea', 'garbanzo'], 'def': 'the seed of the chickpea plant; usually dried', 'name': 'chickpea'}, {'frequency': 'r', 'id': 250, 'synset': 'chihuahua.n.03', 'synonyms': ['Chihuahua'], 'def': 'an old breed of tiny short-haired dog with protruding eyes from Mexico', 'name': 'Chihuahua'}, {'frequency': 'r', 'id': 251, 'synset': 'chili.n.02', 'synonyms': ['chili_(vegetable)', 'chili_pepper_(vegetable)', 'chilli_(vegetable)', 'chilly_(vegetable)', 'chile_(vegetable)'], 'def': 'very hot and finely tapering pepper of special pungency', 'name': 'chili_(vegetable)'}, {'frequency': 'r', 'id': 252, 'synset': 'chime.n.01', 'synonyms': ['chime', 'gong'], 'def': 'an instrument consisting of a set of bells that are struck with a hammer', 'name': 'chime'}, {'frequency': 'r', 'id': 253, 'synset': 'chinaware.n.01', 'synonyms': ['chinaware'], 'def': 'dishware made of high quality porcelain', 'name': 'chinaware'}, {'frequency': 'c', 'id': 254, 'synset': 'chip.n.04', 'synonyms': ['crisp_(potato_chip)', 'potato_chip'], 'def': 'a thin crisp slice of potato fried in deep fat', 'name': 'crisp_(potato_chip)'}, {'frequency': 'r', 'id': 255, 'synset': 'chip.n.06', 'synonyms': ['poker_chip'], 'def': 'a small disk-shaped counter used to represent money when gambling', 'name': 'poker_chip'}, {'frequency': 'c', 'id': 256, 'synset': 'chocolate_bar.n.01', 'synonyms': ['chocolate_bar'], 'def': 'a bar of chocolate candy', 'name': 'chocolate_bar'}, {'frequency': 'c', 'id': 257, 'synset': 'chocolate_cake.n.01', 'synonyms': ['chocolate_cake'], 'def': 'cake containing chocolate', 'name': 'chocolate_cake'}, {'frequency': 'r', 'id': 258, 'synset': 'chocolate_milk.n.01', 'synonyms': ['chocolate_milk'], 'def': 'milk flavored with chocolate syrup', 'name': 'chocolate_milk'}, {'frequency': 'r', 'id': 259, 'synset': 'chocolate_mousse.n.01', 'synonyms': ['chocolate_mousse'], 'def': 'dessert mousse made with chocolate', 'name': 'chocolate_mousse'}, {'frequency': 'f', 'id': 260, 'synset': 'choker.n.03', 'synonyms': ['choker', 'collar', 'neckband'], 'def': 'necklace that fits tightly around the neck', 'name': 'choker'}, {'frequency': 'f', 'id': 261, 'synset': 'chopping_board.n.01', 'synonyms': ['chopping_board', 'cutting_board', 'chopping_block'], 'def': 'a wooden board where meats or vegetables can be cut', 'name': 'chopping_board'}, {'frequency': 'c', 'id': 262, 'synset': 'chopstick.n.01', 'synonyms': ['chopstick'], 'def': 'one of a pair of slender sticks used as oriental tableware to eat food with', 'name': 'chopstick'}, {'frequency': 'f', 'id': 263, 'synset': 'christmas_tree.n.05', 'synonyms': ['Christmas_tree'], 'def': 'an ornamented evergreen used as a Christmas decoration', 'name': 'Christmas_tree'}, {'frequency': 'c', 'id': 264, 'synset': 'chute.n.02', 'synonyms': ['slide'], 'def': 'sloping channel through which things can descend', 'name': 'slide'}, {'frequency': 'r', 'id': 265, 'synset': 'cider.n.01', 'synonyms': ['cider', 'cyder'], 'def': 'a beverage made from juice pressed from apples', 'name': 'cider'}, {'frequency': 'r', 'id': 266, 'synset': 'cigar_box.n.01', 'synonyms': ['cigar_box'], 'def': 'a box for holding cigars', 'name': 'cigar_box'}, {'frequency': 'c', 'id': 267, 'synset': 'cigarette.n.01', 'synonyms': ['cigarette'], 'def': 'finely ground tobacco wrapped in paper; for smoking', 'name': 'cigarette'}, {'frequency': 'c', 'id': 268, 'synset': 'cigarette_case.n.01', 'synonyms': ['cigarette_case', 'cigarette_pack'], 'def': 'a small flat case for holding cigarettes', 'name': 'cigarette_case'}, {'frequency': 'f', 'id': 269, 'synset': 'cistern.n.02', 'synonyms': ['cistern', 'water_tank'], 'def': 'a tank that holds the water used to flush a toilet', 'name': 'cistern'}, {'frequency': 'r', 'id': 270, 'synset': 'clarinet.n.01', 'synonyms': ['clarinet'], 'def': 'a single-reed instrument with a straight tube', 'name': 'clarinet'}, {'frequency': 'r', 'id': 271, 'synset': 'clasp.n.01', 'synonyms': ['clasp'], 'def': 'a fastener (as a buckle or hook) that is used to hold two things together', 'name': 'clasp'}, {'frequency': 'c', 'id': 272, 'synset': 'cleansing_agent.n.01', 'synonyms': ['cleansing_agent', 'cleanser', 'cleaner'], 'def': 'a preparation used in cleaning something', 'name': 'cleansing_agent'}, {'frequency': 'r', 'id': 273, 'synset': 'clementine.n.01', 'synonyms': ['clementine'], 'def': 'a variety of mandarin orange', 'name': 'clementine'}, {'frequency': 'c', 'id': 274, 'synset': 'clip.n.03', 'synonyms': ['clip'], 'def': 'any of various small fasteners used to hold loose articles together', 'name': 'clip'}, {'frequency': 'c', 'id': 275, 'synset': 'clipboard.n.01', 'synonyms': ['clipboard'], 'def': 'a small writing board with a clip at the top for holding papers', 'name': 'clipboard'}, {'frequency': 'f', 'id': 276, 'synset': 'clock.n.01', 'synonyms': ['clock', 'timepiece', 'timekeeper'], 'def': 'a timepiece that shows the time of day', 'name': 'clock'}, {'frequency': 'f', 'id': 277, 'synset': 'clock_tower.n.01', 'synonyms': ['clock_tower'], 'def': 'a tower with a large clock visible high up on an outside face', 'name': 'clock_tower'}, {'frequency': 'c', 'id': 278, 'synset': 'clothes_hamper.n.01', 'synonyms': ['clothes_hamper', 'laundry_basket', 'clothes_basket'], 'def': 'a hamper that holds dirty clothes to be washed or wet clothes to be dried', 'name': 'clothes_hamper'}, {'frequency': 'c', 'id': 279, 'synset': 'clothespin.n.01', 'synonyms': ['clothespin', 'clothes_peg'], 'def': 'wood or plastic fastener; for holding clothes on a clothesline', 'name': 'clothespin'}, {'frequency': 'r', 'id': 280, 'synset': 'clutch_bag.n.01', 'synonyms': ['clutch_bag'], 'def': "a woman's strapless purse that is carried in the hand", 'name': 'clutch_bag'}, {'frequency': 'f', 'id': 281, 'synset': 'coaster.n.03', 'synonyms': ['coaster'], 'def': 'a covering (plate or mat) that protects the surface of a table', 'name': 'coaster'}, {'frequency': 'f', 'id': 282, 'synset': 'coat.n.01', 'synonyms': ['coat'], 'def': 'an outer garment that has sleeves and covers the body from shoulder down', 'name': 'coat'}, {'frequency': 'c', 'id': 283, 'synset': 'coat_hanger.n.01', 'synonyms': ['coat_hanger', 'clothes_hanger', 'dress_hanger'], 'def': "a hanger that is shaped like a person's shoulders", 'name': 'coat_hanger'}, {'frequency': 'r', 'id': 284, 'synset': 'coatrack.n.01', 'synonyms': ['coatrack', 'hatrack'], 'def': 'a rack with hooks for temporarily holding coats and hats', 'name': 'coatrack'}, {'frequency': 'c', 'id': 285, 'synset': 'cock.n.04', 'synonyms': ['cock', 'rooster'], 'def': 'adult male chicken', 'name': 'cock'}, {'frequency': 'c', 'id': 286, 'synset': 'coconut.n.02', 'synonyms': ['coconut', 'cocoanut'], 'def': 'large hard-shelled brown oval nut with a fibrous husk', 'name': 'coconut'}, {'frequency': 'r', 'id': 287, 'synset': 'coffee_filter.n.01', 'synonyms': ['coffee_filter'], 'def': 'filter (usually of paper) that passes the coffee and retains the coffee grounds', 'name': 'coffee_filter'}, {'frequency': 'f', 'id': 288, 'synset': 'coffee_maker.n.01', 'synonyms': ['coffee_maker', 'coffee_machine'], 'def': 'a kitchen appliance for brewing coffee automatically', 'name': 'coffee_maker'}, {'frequency': 'f', 'id': 289, 'synset': 'coffee_table.n.01', 'synonyms': ['coffee_table', 'cocktail_table'], 'def': 'low table where magazines can be placed and coffee or cocktails are served', 'name': 'coffee_table'}, {'frequency': 'c', 'id': 290, 'synset': 'coffeepot.n.01', 'synonyms': ['coffeepot'], 'def': 'tall pot in which coffee is brewed', 'name': 'coffeepot'}, {'frequency': 'r', 'id': 291, 'synset': 'coil.n.05', 'synonyms': ['coil'], 'def': 'tubing that is wound in a spiral', 'name': 'coil'}, {'frequency': 'c', 'id': 292, 'synset': 'coin.n.01', 'synonyms': ['coin'], 'def': 'a flat metal piece (usually a disc) used as money', 'name': 'coin'}, {'frequency': 'r', 'id': 293, 'synset': 'colander.n.01', 'synonyms': ['colander', 'cullender'], 'def': 'bowl-shaped strainer; used to wash or drain foods', 'name': 'colander'}, {'frequency': 'c', 'id': 294, 'synset': 'coleslaw.n.01', 'synonyms': ['coleslaw', 'slaw'], 'def': 'basically shredded cabbage', 'name': 'coleslaw'}, {'frequency': 'r', 'id': 295, 'synset': 'coloring_material.n.01', 'synonyms': ['coloring_material', 'colouring_material'], 'def': 'any material used for its color', 'name': 'coloring_material'}, {'frequency': 'r', 'id': 296, 'synset': 'combination_lock.n.01', 'synonyms': ['combination_lock'], 'def': 'lock that can be opened only by turning dials in a special sequence', 'name': 'combination_lock'}, {'frequency': 'c', 'id': 297, 'synset': 'comforter.n.04', 'synonyms': ['pacifier', 'teething_ring'], 'def': 'device used for an infant to suck or bite on', 'name': 'pacifier'}, {'frequency': 'r', 'id': 298, 'synset': 'comic_book.n.01', 'synonyms': ['comic_book'], 'def': 'a magazine devoted to comic strips', 'name': 'comic_book'}, {'frequency': 'f', 'id': 299, 'synset': 'computer_keyboard.n.01', 'synonyms': ['computer_keyboard', 'keyboard_(computer)'], 'def': 'a keyboard that is a data input device for computers', 'name': 'computer_keyboard'}, {'frequency': 'r', 'id': 300, 'synset': 'concrete_mixer.n.01', 'synonyms': ['concrete_mixer', 'cement_mixer'], 'def': 'a machine with a large revolving drum in which cement/concrete is mixed', 'name': 'concrete_mixer'}, {'frequency': 'f', 'id': 301, 'synset': 'cone.n.01', 'synonyms': ['cone', 'traffic_cone'], 'def': 'a cone-shaped object used to direct traffic', 'name': 'cone'}, {'frequency': 'f', 'id': 302, 'synset': 'control.n.09', 'synonyms': ['control', 'controller'], 'def': 'a mechanism that controls the operation of a machine', 'name': 'control'}, {'frequency': 'r', 'id': 303, 'synset': 'convertible.n.01', 'synonyms': ['convertible_(automobile)'], 'def': 'a car that has top that can be folded or removed', 'name': 'convertible_(automobile)'}, {'frequency': 'r', 'id': 304, 'synset': 'convertible.n.03', 'synonyms': ['sofa_bed'], 'def': 'a sofa that can be converted into a bed', 'name': 'sofa_bed'}, {'frequency': 'c', 'id': 305, 'synset': 'cookie.n.01', 'synonyms': ['cookie', 'cooky', 'biscuit_(cookie)'], 'def': "any of various small flat sweet cakes (`biscuit' is the British term)", 'name': 'cookie'}, {'frequency': 'r', 'id': 306, 'synset': 'cookie_jar.n.01', 'synonyms': ['cookie_jar', 'cooky_jar'], 'def': 'a jar in which cookies are kept (and sometimes money is hidden)', 'name': 'cookie_jar'}, {'frequency': 'r', 'id': 307, 'synset': 'cooking_utensil.n.01', 'synonyms': ['cooking_utensil'], 'def': 'a kitchen utensil made of material that does not melt easily; used for cooking', 'name': 'cooking_utensil'}, {'frequency': 'f', 'id': 308, 'synset': 'cooler.n.01', 'synonyms': ['cooler_(for_food)', 'ice_chest'], 'def': 'an insulated box for storing food often with ice', 'name': 'cooler_(for_food)'}, {'frequency': 'c', 'id': 309, 'synset': 'cork.n.04', 'synonyms': ['cork_(bottle_plug)', 'bottle_cork'], 'def': 'the plug in the mouth of a bottle (especially a wine bottle)', 'name': 'cork_(bottle_plug)'}, {'frequency': 'r', 'id': 310, 'synset': 'corkboard.n.01', 'synonyms': ['corkboard'], 'def': 'a sheet consisting of cork granules', 'name': 'corkboard'}, {'frequency': 'r', 'id': 311, 'synset': 'corkscrew.n.01', 'synonyms': ['corkscrew', 'bottle_screw'], 'def': 'a bottle opener that pulls corks', 'name': 'corkscrew'}, {'frequency': 'c', 'id': 312, 'synset': 'corn.n.03', 'synonyms': ['edible_corn', 'corn', 'maize'], 'def': 'ears of corn that can be prepared and served for human food', 'name': 'edible_corn'}, {'frequency': 'r', 'id': 313, 'synset': 'cornbread.n.01', 'synonyms': ['cornbread'], 'def': 'bread made primarily of cornmeal', 'name': 'cornbread'}, {'frequency': 'c', 'id': 314, 'synset': 'cornet.n.01', 'synonyms': ['cornet', 'horn', 'trumpet'], 'def': 'a brass musical instrument with a narrow tube and a flared bell and many valves', 'name': 'cornet'}, {'frequency': 'c', 'id': 315, 'synset': 'cornice.n.01', 'synonyms': ['cornice', 'valance', 'valance_board', 'pelmet'], 'def': 'a decorative framework to conceal curtain fixtures at the top of a window casing', 'name': 'cornice'}, {'frequency': 'r', 'id': 316, 'synset': 'cornmeal.n.01', 'synonyms': ['cornmeal'], 'def': 'coarsely ground corn', 'name': 'cornmeal'}, {'frequency': 'r', 'id': 317, 'synset': 'corset.n.01', 'synonyms': ['corset', 'girdle'], 'def': "a woman's close-fitting foundation garment", 'name': 'corset'}, {'frequency': 'r', 'id': 318, 'synset': 'cos.n.02', 'synonyms': ['romaine_lettuce'], 'def': 'lettuce with long dark-green leaves in a loosely packed elongated head', 'name': 'romaine_lettuce'}, {'frequency': 'c', 'id': 319, 'synset': 'costume.n.04', 'synonyms': ['costume'], 'def': 'the attire characteristic of a country or a time or a social class', 'name': 'costume'}, {'frequency': 'r', 'id': 320, 'synset': 'cougar.n.01', 'synonyms': ['cougar', 'puma', 'catamount', 'mountain_lion', 'panther'], 'def': 'large American feline resembling a lion', 'name': 'cougar'}, {'frequency': 'r', 'id': 321, 'synset': 'coverall.n.01', 'synonyms': ['coverall'], 'def': 'a loose-fitting protective garment that is worn over other clothing', 'name': 'coverall'}, {'frequency': 'r', 'id': 322, 'synset': 'cowbell.n.01', 'synonyms': ['cowbell'], 'def': 'a bell hung around the neck of cow so that the cow can be easily located', 'name': 'cowbell'}, {'frequency': 'f', 'id': 323, 'synset': 'cowboy_hat.n.01', 'synonyms': ['cowboy_hat', 'ten-gallon_hat'], 'def': 'a hat with a wide brim and a soft crown; worn by American ranch hands', 'name': 'cowboy_hat'}, {'frequency': 'r', 'id': 324, 'synset': 'crab.n.01', 'synonyms': ['crab_(animal)'], 'def': 'decapod having eyes on short stalks and a broad flattened shell and pincers', 'name': 'crab_(animal)'}, {'frequency': 'c', 'id': 325, 'synset': 'cracker.n.01', 'synonyms': ['cracker'], 'def': 'a thin crisp wafer', 'name': 'cracker'}, {'frequency': 'r', 'id': 326, 'synset': 'crape.n.01', 'synonyms': ['crape', 'crepe', 'French_pancake'], 'def': 'small very thin pancake', 'name': 'crape'}, {'frequency': 'f', 'id': 327, 'synset': 'crate.n.01', 'synonyms': ['crate'], 'def': 'a rugged box (usually made of wood); used for shipping', 'name': 'crate'}, {'frequency': 'r', 'id': 328, 'synset': 'crayon.n.01', 'synonyms': ['crayon', 'wax_crayon'], 'def': 'writing or drawing implement made of a colored stick of composition wax', 'name': 'crayon'}, {'frequency': 'r', 'id': 329, 'synset': 'cream_pitcher.n.01', 'synonyms': ['cream_pitcher'], 'def': 'a small pitcher for serving cream', 'name': 'cream_pitcher'}, {'frequency': 'r', 'id': 330, 'synset': 'credit_card.n.01', 'synonyms': ['credit_card', 'charge_card', 'debit_card'], 'def': 'a card, usually plastic, used to pay for goods and services', 'name': 'credit_card'}, {'frequency': 'c', 'id': 331, 'synset': 'crescent_roll.n.01', 'synonyms': ['crescent_roll', 'croissant'], 'def': 'very rich flaky crescent-shaped roll', 'name': 'crescent_roll'}, {'frequency': 'c', 'id': 332, 'synset': 'crib.n.01', 'synonyms': ['crib', 'cot'], 'def': 'baby bed with high sides made of slats', 'name': 'crib'}, {'frequency': 'c', 'id': 333, 'synset': 'crock.n.03', 'synonyms': ['crock_pot', 'earthenware_jar'], 'def': 'an earthen jar (made of baked clay)', 'name': 'crock_pot'}, {'frequency': 'f', 'id': 334, 'synset': 'crossbar.n.01', 'synonyms': ['crossbar'], 'def': 'a horizontal bar that goes across something', 'name': 'crossbar'}, {'frequency': 'r', 'id': 335, 'synset': 'crouton.n.01', 'synonyms': ['crouton'], 'def': 'a small piece of toasted or fried bread; served in soup or salads', 'name': 'crouton'}, {'frequency': 'r', 'id': 336, 'synset': 'crow.n.01', 'synonyms': ['crow'], 'def': 'black birds having a raucous call', 'name': 'crow'}, {'frequency': 'c', 'id': 337, 'synset': 'crown.n.04', 'synonyms': ['crown'], 'def': 'an ornamental jeweled headdress signifying sovereignty', 'name': 'crown'}, {'frequency': 'c', 'id': 338, 'synset': 'crucifix.n.01', 'synonyms': ['crucifix'], 'def': 'representation of the cross on which Jesus died', 'name': 'crucifix'}, {'frequency': 'c', 'id': 339, 'synset': 'cruise_ship.n.01', 'synonyms': ['cruise_ship', 'cruise_liner'], 'def': 'a passenger ship used commercially for pleasure cruises', 'name': 'cruise_ship'}, {'frequency': 'c', 'id': 340, 'synset': 'cruiser.n.01', 'synonyms': ['police_cruiser', 'patrol_car', 'police_car', 'squad_car'], 'def': 'a car in which policemen cruise the streets', 'name': 'police_cruiser'}, {'frequency': 'c', 'id': 341, 'synset': 'crumb.n.03', 'synonyms': ['crumb'], 'def': 'small piece of e.g. bread or cake', 'name': 'crumb'}, {'frequency': 'r', 'id': 342, 'synset': 'crutch.n.01', 'synonyms': ['crutch'], 'def': 'a wooden or metal staff that fits under the armpit and reaches to the ground', 'name': 'crutch'}, {'frequency': 'c', 'id': 343, 'synset': 'cub.n.03', 'synonyms': ['cub_(animal)'], 'def': 'the young of certain carnivorous mammals such as the bear or wolf or lion', 'name': 'cub_(animal)'}, {'frequency': 'r', 'id': 344, 'synset': 'cube.n.05', 'synonyms': ['cube', 'square_block'], 'def': 'a block in the (approximate) shape of a cube', 'name': 'cube'}, {'frequency': 'f', 'id': 345, 'synset': 'cucumber.n.02', 'synonyms': ['cucumber', 'cuke'], 'def': 'cylindrical green fruit with thin green rind and white flesh eaten as a vegetable', 'name': 'cucumber'}, {'frequency': 'c', 'id': 346, 'synset': 'cufflink.n.01', 'synonyms': ['cufflink'], 'def': 'jewelry consisting of linked buttons used to fasten the cuffs of a shirt', 'name': 'cufflink'}, {'frequency': 'f', 'id': 347, 'synset': 'cup.n.01', 'synonyms': ['cup'], 'def': 'a small open container usually used for drinking; usually has a handle', 'name': 'cup'}, {'frequency': 'c', 'id': 348, 'synset': 'cup.n.08', 'synonyms': ['trophy_cup'], 'def': 'a metal vessel with handles that is awarded as a trophy to a competition winner', 'name': 'trophy_cup'}, {'frequency': 'c', 'id': 349, 'synset': 'cupcake.n.01', 'synonyms': ['cupcake'], 'def': 'small cake baked in a muffin tin', 'name': 'cupcake'}, {'frequency': 'r', 'id': 350, 'synset': 'curler.n.01', 'synonyms': ['hair_curler', 'hair_roller', 'hair_crimper'], 'def': 'a cylindrical tube around which the hair is wound to curl it', 'name': 'hair_curler'}, {'frequency': 'r', 'id': 351, 'synset': 'curling_iron.n.01', 'synonyms': ['curling_iron'], 'def': 'a cylindrical home appliance that heats hair that has been curled around it', 'name': 'curling_iron'}, {'frequency': 'f', 'id': 352, 'synset': 'curtain.n.01', 'synonyms': ['curtain', 'drapery'], 'def': 'hanging cloth used as a blind (especially for a window)', 'name': 'curtain'}, {'frequency': 'f', 'id': 353, 'synset': 'cushion.n.03', 'synonyms': ['cushion'], 'def': 'a soft bag filled with air or padding such as feathers or foam rubber', 'name': 'cushion'}, {'frequency': 'r', 'id': 354, 'synset': 'custard.n.01', 'synonyms': ['custard'], 'def': 'sweetened mixture of milk and eggs baked or boiled or frozen', 'name': 'custard'}, {'frequency': 'c', 'id': 355, 'synset': 'cutter.n.06', 'synonyms': ['cutting_tool'], 'def': 'a cutting implement; a tool for cutting', 'name': 'cutting_tool'}, {'frequency': 'r', 'id': 356, 'synset': 'cylinder.n.04', 'synonyms': ['cylinder'], 'def': 'a cylindrical container', 'name': 'cylinder'}, {'frequency': 'r', 'id': 357, 'synset': 'cymbal.n.01', 'synonyms': ['cymbal'], 'def': 'a percussion instrument consisting of a concave brass disk', 'name': 'cymbal'}, {'frequency': 'r', 'id': 358, 'synset': 'dachshund.n.01', 'synonyms': ['dachshund', 'dachsie', 'badger_dog'], 'def': 'small long-bodied short-legged breed of dog having a short sleek coat and long drooping ears', 'name': 'dachshund'}, {'frequency': 'r', 'id': 359, 'synset': 'dagger.n.01', 'synonyms': ['dagger'], 'def': 'a short knife with a pointed blade used for piercing or stabbing', 'name': 'dagger'}, {'frequency': 'r', 'id': 360, 'synset': 'dartboard.n.01', 'synonyms': ['dartboard'], 'def': 'a circular board of wood or cork used as the target in the game of darts', 'name': 'dartboard'}, {'frequency': 'r', 'id': 361, 'synset': 'date.n.08', 'synonyms': ['date_(fruit)'], 'def': 'sweet edible fruit of the date palm with a single long woody seed', 'name': 'date_(fruit)'}, {'frequency': 'f', 'id': 362, 'synset': 'deck_chair.n.01', 'synonyms': ['deck_chair', 'beach_chair'], 'def': 'a folding chair for use outdoors; a wooden frame supports a length of canvas', 'name': 'deck_chair'}, {'frequency': 'c', 'id': 363, 'synset': 'deer.n.01', 'synonyms': ['deer', 'cervid'], 'def': "distinguished from Bovidae by the male's having solid deciduous antlers", 'name': 'deer'}, {'frequency': 'c', 'id': 364, 'synset': 'dental_floss.n.01', 'synonyms': ['dental_floss', 'floss'], 'def': 'a soft thread for cleaning the spaces between the teeth', 'name': 'dental_floss'}, {'frequency': 'f', 'id': 365, 'synset': 'desk.n.01', 'synonyms': ['desk'], 'def': 'a piece of furniture with a writing surface and usually drawers or other compartments', 'name': 'desk'}, {'frequency': 'r', 'id': 366, 'synset': 'detergent.n.01', 'synonyms': ['detergent'], 'def': 'a surface-active chemical widely used in industry and laundering', 'name': 'detergent'}, {'frequency': 'c', 'id': 367, 'synset': 'diaper.n.01', 'synonyms': ['diaper'], 'def': 'garment consisting of a folded cloth drawn up between the legs and fastened at the waist', 'name': 'diaper'}, {'frequency': 'r', 'id': 368, 'synset': 'diary.n.01', 'synonyms': ['diary', 'journal'], 'def': 'a daily written record of (usually personal) experiences and observations', 'name': 'diary'}, {'frequency': 'r', 'id': 369, 'synset': 'die.n.01', 'synonyms': ['die', 'dice'], 'def': 'a small cube with 1 to 6 spots on the six faces; used in gambling', 'name': 'die'}, {'frequency': 'r', 'id': 370, 'synset': 'dinghy.n.01', 'synonyms': ['dinghy', 'dory', 'rowboat'], 'def': 'a small boat of shallow draft with seats and oars with which it is propelled', 'name': 'dinghy'}, {'frequency': 'f', 'id': 371, 'synset': 'dining_table.n.01', 'synonyms': ['dining_table'], 'def': 'a table at which meals are served', 'name': 'dining_table'}, {'frequency': 'r', 'id': 372, 'synset': 'dinner_jacket.n.01', 'synonyms': ['tux', 'tuxedo'], 'def': 'semiformal evening dress for men', 'name': 'tux'}, {'frequency': 'c', 'id': 373, 'synset': 'dish.n.01', 'synonyms': ['dish'], 'def': 'a piece of dishware normally used as a container for holding or serving food', 'name': 'dish'}, {'frequency': 'c', 'id': 374, 'synset': 'dish.n.05', 'synonyms': ['dish_antenna'], 'def': 'directional antenna consisting of a parabolic reflector', 'name': 'dish_antenna'}, {'frequency': 'c', 'id': 375, 'synset': 'dishrag.n.01', 'synonyms': ['dishrag', 'dishcloth'], 'def': 'a cloth for washing dishes', 'name': 'dishrag'}, {'frequency': 'c', 'id': 376, 'synset': 'dishtowel.n.01', 'synonyms': ['dishtowel', 'tea_towel'], 'def': 'a towel for drying dishes', 'name': 'dishtowel'}, {'frequency': 'f', 'id': 377, 'synset': 'dishwasher.n.01', 'synonyms': ['dishwasher', 'dishwashing_machine'], 'def': 'a machine for washing dishes', 'name': 'dishwasher'}, {'frequency': 'r', 'id': 378, 'synset': 'dishwasher_detergent.n.01', 'synonyms': ['dishwasher_detergent', 'dishwashing_detergent', 'dishwashing_liquid'], 'def': 'a low-sudsing detergent designed for use in dishwashers', 'name': 'dishwasher_detergent'}, {'frequency': 'r', 'id': 379, 'synset': 'diskette.n.01', 'synonyms': ['diskette', 'floppy', 'floppy_disk'], 'def': 'a small plastic magnetic disk enclosed in a stiff envelope used to store data', 'name': 'diskette'}, {'frequency': 'c', 'id': 380, 'synset': 'dispenser.n.01', 'synonyms': ['dispenser'], 'def': 'a container so designed that the contents can be used in prescribed amounts', 'name': 'dispenser'}, {'frequency': 'c', 'id': 381, 'synset': 'dixie_cup.n.01', 'synonyms': ['Dixie_cup', 'paper_cup'], 'def': 'a disposable cup made of paper; for holding drinks', 'name': 'Dixie_cup'}, {'frequency': 'f', 'id': 382, 'synset': 'dog.n.01', 'synonyms': ['dog'], 'def': 'a common domesticated dog', 'name': 'dog'}, {'frequency': 'f', 'id': 383, 'synset': 'dog_collar.n.01', 'synonyms': ['dog_collar'], 'def': 'a collar for a dog', 'name': 'dog_collar'}, {'frequency': 'c', 'id': 384, 'synset': 'doll.n.01', 'synonyms': ['doll'], 'def': 'a toy replica of a HUMAN (NOT AN ANIMAL)', 'name': 'doll'}, {'frequency': 'r', 'id': 385, 'synset': 'dollar.n.02', 'synonyms': ['dollar', 'dollar_bill', 'one_dollar_bill'], 'def': 'a piece of paper money worth one dollar', 'name': 'dollar'}, {'frequency': 'r', 'id': 386, 'synset': 'dolphin.n.02', 'synonyms': ['dolphin'], 'def': 'any of various small toothed whales with a beaklike snout; larger than porpoises', 'name': 'dolphin'}, {'frequency': 'c', 'id': 387, 'synset': 'domestic_ass.n.01', 'synonyms': ['domestic_ass', 'donkey'], 'def': 'domestic beast of burden descended from the African wild ass; patient but stubborn', 'name': 'domestic_ass'}, {'frequency': 'r', 'id': 388, 'synset': 'domino.n.03', 'synonyms': ['eye_mask'], 'def': 'a mask covering the upper part of the face but with holes for the eyes', 'name': 'eye_mask'}, {'frequency': 'r', 'id': 389, 'synset': 'doorbell.n.01', 'synonyms': ['doorbell', 'buzzer'], 'def': 'a button at an outer door that gives a ringing or buzzing signal when pushed', 'name': 'doorbell'}, {'frequency': 'f', 'id': 390, 'synset': 'doorknob.n.01', 'synonyms': ['doorknob', 'doorhandle'], 'def': "a knob used to open a door (often called `doorhandle' in Great Britain)", 'name': 'doorknob'}, {'frequency': 'c', 'id': 391, 'synset': 'doormat.n.02', 'synonyms': ['doormat', 'welcome_mat'], 'def': 'a mat placed outside an exterior door for wiping the shoes before entering', 'name': 'doormat'}, {'frequency': 'f', 'id': 392, 'synset': 'doughnut.n.02', 'synonyms': ['doughnut', 'donut'], 'def': 'a small ring-shaped friedcake', 'name': 'doughnut'}, {'frequency': 'r', 'id': 393, 'synset': 'dove.n.01', 'synonyms': ['dove'], 'def': 'any of numerous small pigeons', 'name': 'dove'}, {'frequency': 'r', 'id': 394, 'synset': 'dragonfly.n.01', 'synonyms': ['dragonfly'], 'def': 'slender-bodied non-stinging insect having iridescent wings that are outspread at rest', 'name': 'dragonfly'}, {'frequency': 'f', 'id': 395, 'synset': 'drawer.n.01', 'synonyms': ['drawer'], 'def': 'a boxlike container in a piece of furniture; made so as to slide in and out', 'name': 'drawer'}, {'frequency': 'c', 'id': 396, 'synset': 'drawers.n.01', 'synonyms': ['underdrawers', 'boxers', 'boxershorts'], 'def': 'underpants worn by men', 'name': 'underdrawers'}, {'frequency': 'f', 'id': 397, 'synset': 'dress.n.01', 'synonyms': ['dress', 'frock'], 'def': 'a one-piece garment for a woman; has skirt and bodice', 'name': 'dress'}, {'frequency': 'c', 'id': 398, 'synset': 'dress_hat.n.01', 'synonyms': ['dress_hat', 'high_hat', 'opera_hat', 'silk_hat', 'top_hat'], 'def': "a man's hat with a tall crown; usually covered with silk or with beaver fur", 'name': 'dress_hat'}, {'frequency': 'c', 'id': 399, 'synset': 'dress_suit.n.01', 'synonyms': ['dress_suit'], 'def': 'formalwear consisting of full evening dress for men', 'name': 'dress_suit'}, {'frequency': 'c', 'id': 400, 'synset': 'dresser.n.05', 'synonyms': ['dresser'], 'def': 'a cabinet with shelves', 'name': 'dresser'}, {'frequency': 'c', 'id': 401, 'synset': 'drill.n.01', 'synonyms': ['drill'], 'def': 'a tool with a sharp rotating point for making holes in hard materials', 'name': 'drill'}, {'frequency': 'r', 'id': 402, 'synset': 'drinking_fountain.n.01', 'synonyms': ['drinking_fountain'], 'def': 'a public fountain to provide a jet of drinking water', 'name': 'drinking_fountain'}, {'frequency': 'r', 'id': 403, 'synset': 'drone.n.04', 'synonyms': ['drone'], 'def': 'an aircraft without a pilot that is operated by remote control', 'name': 'drone'}, {'frequency': 'r', 'id': 404, 'synset': 'dropper.n.01', 'synonyms': ['dropper', 'eye_dropper'], 'def': 'pipet consisting of a small tube with a vacuum bulb at one end for drawing liquid in and releasing it a drop at a time', 'name': 'dropper'}, {'frequency': 'c', 'id': 405, 'synset': 'drum.n.01', 'synonyms': ['drum_(musical_instrument)'], 'def': 'a musical percussion instrument; usually consists of a hollow cylinder with a membrane stretched across each end', 'name': 'drum_(musical_instrument)'}, {'frequency': 'r', 'id': 406, 'synset': 'drumstick.n.02', 'synonyms': ['drumstick'], 'def': 'a stick used for playing a drum', 'name': 'drumstick'}, {'frequency': 'f', 'id': 407, 'synset': 'duck.n.01', 'synonyms': ['duck'], 'def': 'small web-footed broad-billed swimming bird', 'name': 'duck'}, {'frequency': 'r', 'id': 408, 'synset': 'duckling.n.02', 'synonyms': ['duckling'], 'def': 'young duck', 'name': 'duckling'}, {'frequency': 'c', 'id': 409, 'synset': 'duct_tape.n.01', 'synonyms': ['duct_tape'], 'def': 'a wide silvery adhesive tape', 'name': 'duct_tape'}, {'frequency': 'f', 'id': 410, 'synset': 'duffel_bag.n.01', 'synonyms': ['duffel_bag', 'duffle_bag', 'duffel', 'duffle'], 'def': 'a large cylindrical bag of heavy cloth', 'name': 'duffel_bag'}, {'frequency': 'r', 'id': 411, 'synset': 'dumbbell.n.01', 'synonyms': ['dumbbell'], 'def': 'an exercising weight with two ball-like ends connected by a short handle', 'name': 'dumbbell'}, {'frequency': 'c', 'id': 412, 'synset': 'dumpster.n.01', 'synonyms': ['dumpster'], 'def': 'a container designed to receive and transport and dump waste', 'name': 'dumpster'}, {'frequency': 'r', 'id': 413, 'synset': 'dustpan.n.02', 'synonyms': ['dustpan'], 'def': 'a short-handled receptacle into which dust can be swept', 'name': 'dustpan'}, {'frequency': 'r', 'id': 414, 'synset': 'dutch_oven.n.02', 'synonyms': ['Dutch_oven'], 'def': 'iron or earthenware cooking pot; used for stews', 'name': 'Dutch_oven'}, {'frequency': 'c', 'id': 415, 'synset': 'eagle.n.01', 'synonyms': ['eagle'], 'def': 'large birds of prey noted for their broad wings and strong soaring flight', 'name': 'eagle'}, {'frequency': 'f', 'id': 416, 'synset': 'earphone.n.01', 'synonyms': ['earphone', 'earpiece', 'headphone'], 'def': 'device for listening to audio that is held over or inserted into the ear', 'name': 'earphone'}, {'frequency': 'r', 'id': 417, 'synset': 'earplug.n.01', 'synonyms': ['earplug'], 'def': 'a soft plug that is inserted into the ear canal to block sound', 'name': 'earplug'}, {'frequency': 'f', 'id': 418, 'synset': 'earring.n.01', 'synonyms': ['earring'], 'def': 'jewelry to ornament the ear', 'name': 'earring'}, {'frequency': 'c', 'id': 419, 'synset': 'easel.n.01', 'synonyms': ['easel'], 'def': "an upright tripod for displaying something (usually an artist's canvas)", 'name': 'easel'}, {'frequency': 'r', 'id': 420, 'synset': 'eclair.n.01', 'synonyms': ['eclair'], 'def': 'oblong cream puff', 'name': 'eclair'}, {'frequency': 'r', 'id': 421, 'synset': 'eel.n.01', 'synonyms': ['eel'], 'def': 'an elongate fish with fatty flesh', 'name': 'eel'}, {'frequency': 'f', 'id': 422, 'synset': 'egg.n.02', 'synonyms': ['egg', 'eggs'], 'def': 'oval reproductive body of a fowl (especially a hen) used as food', 'name': 'egg'}, {'frequency': 'r', 'id': 423, 'synset': 'egg_roll.n.01', 'synonyms': ['egg_roll', 'spring_roll'], 'def': 'minced vegetables and meat wrapped in a pancake and fried', 'name': 'egg_roll'}, {'frequency': 'c', 'id': 424, 'synset': 'egg_yolk.n.01', 'synonyms': ['egg_yolk', 'yolk_(egg)'], 'def': 'the yellow spherical part of an egg', 'name': 'egg_yolk'}, {'frequency': 'c', 'id': 425, 'synset': 'eggbeater.n.02', 'synonyms': ['eggbeater', 'eggwhisk'], 'def': 'a mixer for beating eggs or whipping cream', 'name': 'eggbeater'}, {'frequency': 'c', 'id': 426, 'synset': 'eggplant.n.01', 'synonyms': ['eggplant', 'aubergine'], 'def': 'egg-shaped vegetable having a shiny skin typically dark purple', 'name': 'eggplant'}, {'frequency': 'r', 'id': 427, 'synset': 'electric_chair.n.01', 'synonyms': ['electric_chair'], 'def': 'a chair-shaped instrument of execution by electrocution', 'name': 'electric_chair'}, {'frequency': 'f', 'id': 428, 'synset': 'electric_refrigerator.n.01', 'synonyms': ['refrigerator'], 'def': 'a refrigerator in which the coolant is pumped around by an electric motor', 'name': 'refrigerator'}, {'frequency': 'f', 'id': 429, 'synset': 'elephant.n.01', 'synonyms': ['elephant'], 'def': 'a common elephant', 'name': 'elephant'}, {'frequency': 'r', 'id': 430, 'synset': 'elk.n.01', 'synonyms': ['elk', 'moose'], 'def': 'large northern deer with enormous flattened antlers in the male', 'name': 'elk'}, {'frequency': 'c', 'id': 431, 'synset': 'envelope.n.01', 'synonyms': ['envelope'], 'def': 'a flat (usually rectangular) container for a letter, thin package, etc.', 'name': 'envelope'}, {'frequency': 'c', 'id': 432, 'synset': 'eraser.n.01', 'synonyms': ['eraser'], 'def': 'an implement used to erase something', 'name': 'eraser'}, {'frequency': 'r', 'id': 433, 'synset': 'escargot.n.01', 'synonyms': ['escargot'], 'def': 'edible snail usually served in the shell with a sauce of melted butter and garlic', 'name': 'escargot'}, {'frequency': 'r', 'id': 434, 'synset': 'eyepatch.n.01', 'synonyms': ['eyepatch'], 'def': 'a protective cloth covering for an injured eye', 'name': 'eyepatch'}, {'frequency': 'r', 'id': 435, 'synset': 'falcon.n.01', 'synonyms': ['falcon'], 'def': 'birds of prey having long pointed powerful wings adapted for swift flight', 'name': 'falcon'}, {'frequency': 'f', 'id': 436, 'synset': 'fan.n.01', 'synonyms': ['fan'], 'def': 'a device for creating a current of air by movement of a surface or surfaces', 'name': 'fan'}, {'frequency': 'f', 'id': 437, 'synset': 'faucet.n.01', 'synonyms': ['faucet', 'spigot', 'tap'], 'def': 'a regulator for controlling the flow of a liquid from a reservoir', 'name': 'faucet'}, {'frequency': 'r', 'id': 438, 'synset': 'fedora.n.01', 'synonyms': ['fedora'], 'def': 'a hat made of felt with a creased crown', 'name': 'fedora'}, {'frequency': 'r', 'id': 439, 'synset': 'ferret.n.02', 'synonyms': ['ferret'], 'def': 'domesticated albino variety of the European polecat bred for hunting rats and rabbits', 'name': 'ferret'}, {'frequency': 'c', 'id': 440, 'synset': 'ferris_wheel.n.01', 'synonyms': ['Ferris_wheel'], 'def': 'a large wheel with suspended seats that remain upright as the wheel rotates', 'name': 'Ferris_wheel'}, {'frequency': 'r', 'id': 441, 'synset': 'ferry.n.01', 'synonyms': ['ferry', 'ferryboat'], 'def': 'a boat that transports people or vehicles across a body of water and operates on a regular schedule', 'name': 'ferry'}, {'frequency': 'r', 'id': 442, 'synset': 'fig.n.04', 'synonyms': ['fig_(fruit)'], 'def': 'fleshy sweet pear-shaped yellowish or purple fruit eaten fresh or preserved or dried', 'name': 'fig_(fruit)'}, {'frequency': 'c', 'id': 443, 'synset': 'fighter.n.02', 'synonyms': ['fighter_jet', 'fighter_aircraft', 'attack_aircraft'], 'def': 'a high-speed military or naval airplane designed to destroy enemy targets', 'name': 'fighter_jet'}, {'frequency': 'f', 'id': 444, 'synset': 'figurine.n.01', 'synonyms': ['figurine'], 'def': 'a small carved or molded figure', 'name': 'figurine'}, {'frequency': 'c', 'id': 445, 'synset': 'file.n.03', 'synonyms': ['file_cabinet', 'filing_cabinet'], 'def': 'office furniture consisting of a container for keeping papers in order', 'name': 'file_cabinet'}, {'frequency': 'r', 'id': 446, 'synset': 'file.n.04', 'synonyms': ['file_(tool)'], 'def': 'a steel hand tool with small sharp teeth on some or all of its surfaces; used for smoothing wood or metal', 'name': 'file_(tool)'}, {'frequency': 'f', 'id': 447, 'synset': 'fire_alarm.n.02', 'synonyms': ['fire_alarm', 'smoke_alarm'], 'def': 'an alarm that is tripped off by fire or smoke', 'name': 'fire_alarm'}, {'frequency': 'c', 'id': 448, 'synset': 'fire_engine.n.01', 'synonyms': ['fire_engine', 'fire_truck'], 'def': 'large trucks that carry firefighters and equipment to the site of a fire', 'name': 'fire_engine'}, {'frequency': 'c', 'id': 449, 'synset': 'fire_extinguisher.n.01', 'synonyms': ['fire_extinguisher', 'extinguisher'], 'def': 'a manually operated device for extinguishing small fires', 'name': 'fire_extinguisher'}, {'frequency': 'c', 'id': 450, 'synset': 'fire_hose.n.01', 'synonyms': ['fire_hose'], 'def': 'a large hose that carries water from a fire hydrant to the site of the fire', 'name': 'fire_hose'}, {'frequency': 'f', 'id': 451, 'synset': 'fireplace.n.01', 'synonyms': ['fireplace'], 'def': 'an open recess in a wall at the base of a chimney where a fire can be built', 'name': 'fireplace'}, {'frequency': 'f', 'id': 452, 'synset': 'fireplug.n.01', 'synonyms': ['fireplug', 'fire_hydrant', 'hydrant'], 'def': 'an upright hydrant for drawing water to use in fighting a fire', 'name': 'fireplug'}, {'frequency': 'c', 'id': 453, 'synset': 'fish.n.01', 'synonyms': ['fish'], 'def': 'any of various mostly cold-blooded aquatic vertebrates usually having scales and breathing through gills', 'name': 'fish'}, {'frequency': 'r', 'id': 454, 'synset': 'fish.n.02', 'synonyms': ['fish_(food)'], 'def': 'the flesh of fish used as food', 'name': 'fish_(food)'}, {'frequency': 'r', 'id': 455, 'synset': 'fishbowl.n.02', 'synonyms': ['fishbowl', 'goldfish_bowl'], 'def': 'a transparent bowl in which small fish are kept', 'name': 'fishbowl'}, {'frequency': 'r', 'id': 456, 'synset': 'fishing_boat.n.01', 'synonyms': ['fishing_boat', 'fishing_vessel'], 'def': 'a vessel for fishing', 'name': 'fishing_boat'}, {'frequency': 'c', 'id': 457, 'synset': 'fishing_rod.n.01', 'synonyms': ['fishing_rod', 'fishing_pole'], 'def': 'a rod that is used in fishing to extend the fishing line', 'name': 'fishing_rod'}, {'frequency': 'f', 'id': 458, 'synset': 'flag.n.01', 'synonyms': ['flag'], 'def': 'emblem usually consisting of a rectangular piece of cloth of distinctive design (do not include pole)', 'name': 'flag'}, {'frequency': 'f', 'id': 459, 'synset': 'flagpole.n.02', 'synonyms': ['flagpole', 'flagstaff'], 'def': 'a tall staff or pole on which a flag is raised', 'name': 'flagpole'}, {'frequency': 'c', 'id': 460, 'synset': 'flamingo.n.01', 'synonyms': ['flamingo'], 'def': 'large pink web-footed bird with down-bent bill', 'name': 'flamingo'}, {'frequency': 'c', 'id': 461, 'synset': 'flannel.n.01', 'synonyms': ['flannel'], 'def': 'a soft light woolen fabric; used for clothing', 'name': 'flannel'}, {'frequency': 'r', 'id': 462, 'synset': 'flash.n.10', 'synonyms': ['flash', 'flashbulb'], 'def': 'a lamp for providing momentary light to take a photograph', 'name': 'flash'}, {'frequency': 'c', 'id': 463, 'synset': 'flashlight.n.01', 'synonyms': ['flashlight', 'torch'], 'def': 'a small portable battery-powered electric lamp', 'name': 'flashlight'}, {'frequency': 'r', 'id': 464, 'synset': 'fleece.n.03', 'synonyms': ['fleece'], 'def': 'a soft bulky fabric with deep pile; used chiefly for clothing', 'name': 'fleece'}, {'frequency': 'f', 'id': 465, 'synset': 'flip-flop.n.02', 'synonyms': ['flip-flop_(sandal)'], 'def': 'a backless sandal held to the foot by a thong between two toes', 'name': 'flip-flop_(sandal)'}, {'frequency': 'c', 'id': 466, 'synset': 'flipper.n.01', 'synonyms': ['flipper_(footwear)', 'fin_(footwear)'], 'def': 'a shoe to aid a person in swimming', 'name': 'flipper_(footwear)'}, {'frequency': 'f', 'id': 467, 'synset': 'flower_arrangement.n.01', 'synonyms': ['flower_arrangement', 'floral_arrangement'], 'def': 'a decorative arrangement of flowers', 'name': 'flower_arrangement'}, {'frequency': 'c', 'id': 468, 'synset': 'flute.n.02', 'synonyms': ['flute_glass', 'champagne_flute'], 'def': 'a tall narrow wineglass', 'name': 'flute_glass'}, {'frequency': 'r', 'id': 469, 'synset': 'foal.n.01', 'synonyms': ['foal'], 'def': 'a young horse', 'name': 'foal'}, {'frequency': 'c', 'id': 470, 'synset': 'folding_chair.n.01', 'synonyms': ['folding_chair'], 'def': 'a chair that can be folded flat for storage', 'name': 'folding_chair'}, {'frequency': 'c', 'id': 471, 'synset': 'food_processor.n.01', 'synonyms': ['food_processor'], 'def': 'a kitchen appliance for shredding, blending, chopping, or slicing food', 'name': 'food_processor'}, {'frequency': 'c', 'id': 472, 'synset': 'football.n.02', 'synonyms': ['football_(American)'], 'def': 'the inflated oblong ball used in playing American football', 'name': 'football_(American)'}, {'frequency': 'r', 'id': 473, 'synset': 'football_helmet.n.01', 'synonyms': ['football_helmet'], 'def': 'a padded helmet with a face mask to protect the head of football players', 'name': 'football_helmet'}, {'frequency': 'c', 'id': 474, 'synset': 'footstool.n.01', 'synonyms': ['footstool', 'footrest'], 'def': 'a low seat or a stool to rest the feet of a seated person', 'name': 'footstool'}, {'frequency': 'f', 'id': 475, 'synset': 'fork.n.01', 'synonyms': ['fork'], 'def': 'cutlery used for serving and eating food', 'name': 'fork'}, {'frequency': 'r', 'id': 476, 'synset': 'forklift.n.01', 'synonyms': ['forklift'], 'def': 'an industrial vehicle with a power operated fork in front that can be inserted under loads to lift and move them', 'name': 'forklift'}, {'frequency': 'r', 'id': 477, 'synset': 'freight_car.n.01', 'synonyms': ['freight_car'], 'def': 'a railway car that carries freight', 'name': 'freight_car'}, {'frequency': 'r', 'id': 478, 'synset': 'french_toast.n.01', 'synonyms': ['French_toast'], 'def': 'bread slice dipped in egg and milk and fried', 'name': 'French_toast'}, {'frequency': 'c', 'id': 479, 'synset': 'freshener.n.01', 'synonyms': ['freshener', 'air_freshener'], 'def': 'anything that freshens', 'name': 'freshener'}, {'frequency': 'f', 'id': 480, 'synset': 'frisbee.n.01', 'synonyms': ['frisbee'], 'def': 'a light, plastic disk propelled with a flip of the wrist for recreation or competition', 'name': 'frisbee'}, {'frequency': 'c', 'id': 481, 'synset': 'frog.n.01', 'synonyms': ['frog', 'toad', 'toad_frog'], 'def': 'a tailless stout-bodied amphibians with long hind limbs for leaping', 'name': 'frog'}, {'frequency': 'c', 'id': 482, 'synset': 'fruit_juice.n.01', 'synonyms': ['fruit_juice'], 'def': 'drink produced by squeezing or crushing fruit', 'name': 'fruit_juice'}, {'frequency': 'r', 'id': 483, 'synset': 'fruit_salad.n.01', 'synonyms': ['fruit_salad'], 'def': 'salad composed of fruits', 'name': 'fruit_salad'}, {'frequency': 'c', 'id': 484, 'synset': 'frying_pan.n.01', 'synonyms': ['frying_pan', 'frypan', 'skillet'], 'def': 'a pan used for frying foods', 'name': 'frying_pan'}, {'frequency': 'r', 'id': 485, 'synset': 'fudge.n.01', 'synonyms': ['fudge'], 'def': 'soft creamy candy', 'name': 'fudge'}, {'frequency': 'r', 'id': 486, 'synset': 'funnel.n.02', 'synonyms': ['funnel'], 'def': 'a cone-shaped utensil used to channel a substance into a container with a small mouth', 'name': 'funnel'}, {'frequency': 'c', 'id': 487, 'synset': 'futon.n.01', 'synonyms': ['futon'], 'def': 'a pad that is used for sleeping on the floor or on a raised frame', 'name': 'futon'}, {'frequency': 'r', 'id': 488, 'synset': 'gag.n.02', 'synonyms': ['gag', 'muzzle'], 'def': "restraint put into a person's mouth to prevent speaking or shouting", 'name': 'gag'}, {'frequency': 'r', 'id': 489, 'synset': 'garbage.n.03', 'synonyms': ['garbage'], 'def': 'a receptacle where waste can be discarded', 'name': 'garbage'}, {'frequency': 'c', 'id': 490, 'synset': 'garbage_truck.n.01', 'synonyms': ['garbage_truck'], 'def': 'a truck for collecting domestic refuse', 'name': 'garbage_truck'}, {'frequency': 'c', 'id': 491, 'synset': 'garden_hose.n.01', 'synonyms': ['garden_hose'], 'def': 'a hose used for watering a lawn or garden', 'name': 'garden_hose'}, {'frequency': 'c', 'id': 492, 'synset': 'gargle.n.01', 'synonyms': ['gargle', 'mouthwash'], 'def': 'a medicated solution used for gargling and rinsing the mouth', 'name': 'gargle'}, {'frequency': 'r', 'id': 493, 'synset': 'gargoyle.n.02', 'synonyms': ['gargoyle'], 'def': 'an ornament consisting of a grotesquely carved figure of a person or animal', 'name': 'gargoyle'}, {'frequency': 'c', 'id': 494, 'synset': 'garlic.n.02', 'synonyms': ['garlic', 'ail'], 'def': 'aromatic bulb used as seasoning', 'name': 'garlic'}, {'frequency': 'r', 'id': 495, 'synset': 'gasmask.n.01', 'synonyms': ['gasmask', 'respirator', 'gas_helmet'], 'def': 'a protective face mask with a filter', 'name': 'gasmask'}, {'frequency': 'r', 'id': 496, 'synset': 'gazelle.n.01', 'synonyms': ['gazelle'], 'def': 'small swift graceful antelope of Africa and Asia having lustrous eyes', 'name': 'gazelle'}, {'frequency': 'c', 'id': 497, 'synset': 'gelatin.n.02', 'synonyms': ['gelatin', 'jelly'], 'def': 'an edible jelly made with gelatin and used as a dessert or salad base or a coating for foods', 'name': 'gelatin'}, {'frequency': 'r', 'id': 498, 'synset': 'gem.n.02', 'synonyms': ['gemstone'], 'def': 'a crystalline rock that can be cut and polished for jewelry', 'name': 'gemstone'}, {'frequency': 'c', 'id': 499, 'synset': 'giant_panda.n.01', 'synonyms': ['giant_panda', 'panda', 'panda_bear'], 'def': 'large black-and-white herbivorous mammal of bamboo forests of China and Tibet', 'name': 'giant_panda'}, {'frequency': 'c', 'id': 500, 'synset': 'gift_wrap.n.01', 'synonyms': ['gift_wrap'], 'def': 'attractive wrapping paper suitable for wrapping gifts', 'name': 'gift_wrap'}, {'frequency': 'c', 'id': 501, 'synset': 'ginger.n.03', 'synonyms': ['ginger', 'gingerroot'], 'def': 'the root of the common ginger plant; used fresh as a seasoning', 'name': 'ginger'}, {'frequency': 'f', 'id': 502, 'synset': 'giraffe.n.01', 'synonyms': ['giraffe'], 'def': 'tall animal having a spotted coat and small horns and very long neck and legs', 'name': 'giraffe'}, {'frequency': 'c', 'id': 503, 'synset': 'girdle.n.02', 'synonyms': ['cincture', 'sash', 'waistband', 'waistcloth'], 'def': 'a band of material around the waist that strengthens a skirt or trousers', 'name': 'cincture'}, {'frequency': 'f', 'id': 504, 'synset': 'glass.n.02', 'synonyms': ['glass_(drink_container)', 'drinking_glass'], 'def': 'a container for holding liquids while drinking', 'name': 'glass_(drink_container)'}, {'frequency': 'c', 'id': 505, 'synset': 'globe.n.03', 'synonyms': ['globe'], 'def': 'a sphere on which a map (especially of the earth) is represented', 'name': 'globe'}, {'frequency': 'f', 'id': 506, 'synset': 'glove.n.02', 'synonyms': ['glove'], 'def': 'handwear covering the hand', 'name': 'glove'}, {'frequency': 'c', 'id': 507, 'synset': 'goat.n.01', 'synonyms': ['goat'], 'def': 'a common goat', 'name': 'goat'}, {'frequency': 'f', 'id': 508, 'synset': 'goggles.n.01', 'synonyms': ['goggles'], 'def': 'tight-fitting spectacles worn to protect the eyes', 'name': 'goggles'}, {'frequency': 'r', 'id': 509, 'synset': 'goldfish.n.01', 'synonyms': ['goldfish'], 'def': 'small golden or orange-red freshwater fishes used as pond or aquarium pets', 'name': 'goldfish'}, {'frequency': 'r', 'id': 510, 'synset': 'golf_club.n.02', 'synonyms': ['golf_club', 'golf-club'], 'def': 'golf equipment used by a golfer to hit a golf ball', 'name': 'golf_club'}, {'frequency': 'c', 'id': 511, 'synset': 'golfcart.n.01', 'synonyms': ['golfcart'], 'def': 'a small motor vehicle in which golfers can ride between shots', 'name': 'golfcart'}, {'frequency': 'r', 'id': 512, 'synset': 'gondola.n.02', 'synonyms': ['gondola_(boat)'], 'def': 'long narrow flat-bottomed boat propelled by sculling; traditionally used on canals of Venice', 'name': 'gondola_(boat)'}, {'frequency': 'c', 'id': 513, 'synset': 'goose.n.01', 'synonyms': ['goose'], 'def': 'loud, web-footed long-necked aquatic birds usually larger than ducks', 'name': 'goose'}, {'frequency': 'r', 'id': 514, 'synset': 'gorilla.n.01', 'synonyms': ['gorilla'], 'def': 'largest ape', 'name': 'gorilla'}, {'frequency': 'r', 'id': 515, 'synset': 'gourd.n.02', 'synonyms': ['gourd'], 'def': 'any of numerous inedible fruits with hard rinds', 'name': 'gourd'}, {'frequency': 'r', 'id': 516, 'synset': 'gown.n.04', 'synonyms': ['surgical_gown', 'scrubs_(surgical_clothing)'], 'def': 'protective garment worn by surgeons during operations', 'name': 'surgical_gown'}, {'frequency': 'f', 'id': 517, 'synset': 'grape.n.01', 'synonyms': ['grape'], 'def': 'any of various juicy fruit with green or purple skins; grow in clusters', 'name': 'grape'}, {'frequency': 'r', 'id': 518, 'synset': 'grasshopper.n.01', 'synonyms': ['grasshopper'], 'def': 'plant-eating insect with hind legs adapted for leaping', 'name': 'grasshopper'}, {'frequency': 'c', 'id': 519, 'synset': 'grater.n.01', 'synonyms': ['grater'], 'def': 'utensil with sharp perforations for shredding foods (as vegetables or cheese)', 'name': 'grater'}, {'frequency': 'c', 'id': 520, 'synset': 'gravestone.n.01', 'synonyms': ['gravestone', 'headstone', 'tombstone'], 'def': 'a stone that is used to mark a grave', 'name': 'gravestone'}, {'frequency': 'r', 'id': 521, 'synset': 'gravy_boat.n.01', 'synonyms': ['gravy_boat', 'gravy_holder'], 'def': 'a dish (often boat-shaped) for serving gravy or sauce', 'name': 'gravy_boat'}, {'frequency': 'c', 'id': 522, 'synset': 'green_bean.n.02', 'synonyms': ['green_bean'], 'def': 'a common bean plant cultivated for its slender green edible pods', 'name': 'green_bean'}, {'frequency': 'c', 'id': 523, 'synset': 'green_onion.n.01', 'synonyms': ['green_onion', 'spring_onion', 'scallion'], 'def': 'a young onion before the bulb has enlarged', 'name': 'green_onion'}, {'frequency': 'r', 'id': 524, 'synset': 'griddle.n.01', 'synonyms': ['griddle'], 'def': 'cooking utensil consisting of a flat heated surface on which food is cooked', 'name': 'griddle'}, {'frequency': 'r', 'id': 525, 'synset': 'grillroom.n.01', 'synonyms': ['grillroom', 'grill_(restaurant)'], 'def': 'a restaurant where food is cooked on a grill', 'name': 'grillroom'}, {'frequency': 'r', 'id': 526, 'synset': 'grinder.n.04', 'synonyms': ['grinder_(tool)'], 'def': 'a machine tool that polishes metal', 'name': 'grinder_(tool)'}, {'frequency': 'r', 'id': 527, 'synset': 'grits.n.01', 'synonyms': ['grits', 'hominy_grits'], 'def': 'coarsely ground corn boiled as a breakfast dish', 'name': 'grits'}, {'frequency': 'c', 'id': 528, 'synset': 'grizzly.n.01', 'synonyms': ['grizzly', 'grizzly_bear'], 'def': 'powerful brownish-yellow bear of the uplands of western North America', 'name': 'grizzly'}, {'frequency': 'c', 'id': 529, 'synset': 'grocery_bag.n.01', 'synonyms': ['grocery_bag'], 'def': "a sack for holding customer's groceries", 'name': 'grocery_bag'}, {'frequency': 'r', 'id': 530, 'synset': 'guacamole.n.01', 'synonyms': ['guacamole'], 'def': 'a dip made of mashed avocado mixed with chopped onions and other seasonings', 'name': 'guacamole'}, {'frequency': 'f', 'id': 531, 'synset': 'guitar.n.01', 'synonyms': ['guitar'], 'def': 'a stringed instrument usually having six strings; played by strumming or plucking', 'name': 'guitar'}, {'frequency': 'c', 'id': 532, 'synset': 'gull.n.02', 'synonyms': ['gull', 'seagull'], 'def': 'mostly white aquatic bird having long pointed wings and short legs', 'name': 'gull'}, {'frequency': 'c', 'id': 533, 'synset': 'gun.n.01', 'synonyms': ['gun'], 'def': 'a weapon that discharges a bullet at high velocity from a metal tube', 'name': 'gun'}, {'frequency': 'r', 'id': 534, 'synset': 'hair_spray.n.01', 'synonyms': ['hair_spray'], 'def': 'substance sprayed on the hair to hold it in place', 'name': 'hair_spray'}, {'frequency': 'c', 'id': 535, 'synset': 'hairbrush.n.01', 'synonyms': ['hairbrush'], 'def': "a brush used to groom a person's hair", 'name': 'hairbrush'}, {'frequency': 'c', 'id': 536, 'synset': 'hairnet.n.01', 'synonyms': ['hairnet'], 'def': 'a small net that someone wears over their hair to keep it in place', 'name': 'hairnet'}, {'frequency': 'c', 'id': 537, 'synset': 'hairpin.n.01', 'synonyms': ['hairpin'], 'def': "a double pronged pin used to hold women's hair in place", 'name': 'hairpin'}, {'frequency': 'f', 'id': 538, 'synset': 'ham.n.01', 'synonyms': ['ham', 'jambon', 'gammon'], 'def': 'meat cut from the thigh of a hog (usually smoked)', 'name': 'ham'}, {'frequency': 'c', 'id': 539, 'synset': 'hamburger.n.01', 'synonyms': ['hamburger', 'beefburger', 'burger'], 'def': 'a sandwich consisting of a patty of minced beef served on a bun', 'name': 'hamburger'}, {'frequency': 'c', 'id': 540, 'synset': 'hammer.n.02', 'synonyms': ['hammer'], 'def': 'a hand tool with a heavy head and a handle; used to deliver an impulsive force by striking', 'name': 'hammer'}, {'frequency': 'r', 'id': 541, 'synset': 'hammock.n.02', 'synonyms': ['hammock'], 'def': 'a hanging bed of canvas or rope netting (usually suspended between two trees)', 'name': 'hammock'}, {'frequency': 'r', 'id': 542, 'synset': 'hamper.n.02', 'synonyms': ['hamper'], 'def': 'a basket usually with a cover', 'name': 'hamper'}, {'frequency': 'r', 'id': 543, 'synset': 'hamster.n.01', 'synonyms': ['hamster'], 'def': 'short-tailed burrowing rodent with large cheek pouches', 'name': 'hamster'}, {'frequency': 'c', 'id': 544, 'synset': 'hand_blower.n.01', 'synonyms': ['hair_dryer'], 'def': 'a hand-held electric blower that can blow warm air onto the hair', 'name': 'hair_dryer'}, {'frequency': 'r', 'id': 545, 'synset': 'hand_glass.n.01', 'synonyms': ['hand_glass', 'hand_mirror'], 'def': 'a mirror intended to be held in the hand', 'name': 'hand_glass'}, {'frequency': 'f', 'id': 546, 'synset': 'hand_towel.n.01', 'synonyms': ['hand_towel', 'face_towel'], 'def': 'a small towel used to dry the hands or face', 'name': 'hand_towel'}, {'frequency': 'c', 'id': 547, 'synset': 'handcart.n.01', 'synonyms': ['handcart', 'pushcart', 'hand_truck'], 'def': 'wheeled vehicle that can be pushed by a person', 'name': 'handcart'}, {'frequency': 'r', 'id': 548, 'synset': 'handcuff.n.01', 'synonyms': ['handcuff'], 'def': 'shackle that consists of a metal loop that can be locked around the wrist', 'name': 'handcuff'}, {'frequency': 'c', 'id': 549, 'synset': 'handkerchief.n.01', 'synonyms': ['handkerchief'], 'def': 'a square piece of cloth used for wiping the eyes or nose or as a costume accessory', 'name': 'handkerchief'}, {'frequency': 'f', 'id': 550, 'synset': 'handle.n.01', 'synonyms': ['handle', 'grip', 'handgrip'], 'def': 'the appendage to an object that is designed to be held in order to use or move it', 'name': 'handle'}, {'frequency': 'r', 'id': 551, 'synset': 'handsaw.n.01', 'synonyms': ['handsaw', "carpenter's_saw"], 'def': 'a saw used with one hand for cutting wood', 'name': 'handsaw'}, {'frequency': 'r', 'id': 552, 'synset': 'hardback.n.01', 'synonyms': ['hardback_book', 'hardcover_book'], 'def': 'a book with cardboard or cloth or leather covers', 'name': 'hardback_book'}, {'frequency': 'r', 'id': 553, 'synset': 'harmonium.n.01', 'synonyms': ['harmonium', 'organ_(musical_instrument)', 'reed_organ_(musical_instrument)'], 'def': 'a free-reed instrument in which air is forced through the reeds by bellows', 'name': 'harmonium'}, {'frequency': 'f', 'id': 554, 'synset': 'hat.n.01', 'synonyms': ['hat'], 'def': 'headwear that protects the head from bad weather, sun, or worn for fashion', 'name': 'hat'}, {'frequency': 'r', 'id': 555, 'synset': 'hatbox.n.01', 'synonyms': ['hatbox'], 'def': 'a round piece of luggage for carrying hats', 'name': 'hatbox'}, {'frequency': 'r', 'id': 556, 'synset': 'hatch.n.03', 'synonyms': ['hatch'], 'def': 'a movable barrier covering a hatchway', 'name': 'hatch'}, {'frequency': 'c', 'id': 557, 'synset': 'head_covering.n.01', 'synonyms': ['veil'], 'def': 'a garment that covers the head and face', 'name': 'veil'}, {'frequency': 'f', 'id': 558, 'synset': 'headband.n.01', 'synonyms': ['headband'], 'def': 'a band worn around or over the head', 'name': 'headband'}, {'frequency': 'f', 'id': 559, 'synset': 'headboard.n.01', 'synonyms': ['headboard'], 'def': 'a vertical board or panel forming the head of a bedstead', 'name': 'headboard'}, {'frequency': 'f', 'id': 560, 'synset': 'headlight.n.01', 'synonyms': ['headlight', 'headlamp'], 'def': 'a powerful light with reflector; attached to the front of an automobile or locomotive', 'name': 'headlight'}, {'frequency': 'c', 'id': 561, 'synset': 'headscarf.n.01', 'synonyms': ['headscarf'], 'def': 'a kerchief worn over the head and tied under the chin', 'name': 'headscarf'}, {'frequency': 'r', 'id': 562, 'synset': 'headset.n.01', 'synonyms': ['headset'], 'def': 'receiver consisting of a pair of headphones', 'name': 'headset'}, {'frequency': 'c', 'id': 563, 'synset': 'headstall.n.01', 'synonyms': ['headstall_(for_horses)', 'headpiece_(for_horses)'], 'def': "the band that is the part of a bridle that fits around a horse's head", 'name': 'headstall_(for_horses)'}, {'frequency': 'r', 'id': 564, 'synset': 'hearing_aid.n.02', 'synonyms': ['hearing_aid'], 'def': 'an acoustic device used to direct sound to the ear of a hearing-impaired person', 'name': 'hearing_aid'}, {'frequency': 'c', 'id': 565, 'synset': 'heart.n.02', 'synonyms': ['heart'], 'def': 'a muscular organ; its contractions move the blood through the body', 'name': 'heart'}, {'frequency': 'c', 'id': 566, 'synset': 'heater.n.01', 'synonyms': ['heater', 'warmer'], 'def': 'device that heats water or supplies warmth to a room', 'name': 'heater'}, {'frequency': 'c', 'id': 567, 'synset': 'helicopter.n.01', 'synonyms': ['helicopter'], 'def': 'an aircraft without wings that obtains its lift from the rotation of overhead blades', 'name': 'helicopter'}, {'frequency': 'f', 'id': 568, 'synset': 'helmet.n.02', 'synonyms': ['helmet'], 'def': 'a protective headgear made of hard material to resist blows', 'name': 'helmet'}, {'frequency': 'r', 'id': 569, 'synset': 'heron.n.02', 'synonyms': ['heron'], 'def': 'grey or white wading bird with long neck and long legs and (usually) long bill', 'name': 'heron'}, {'frequency': 'c', 'id': 570, 'synset': 'highchair.n.01', 'synonyms': ['highchair', 'feeding_chair'], 'def': 'a chair for feeding a very young child', 'name': 'highchair'}, {'frequency': 'f', 'id': 571, 'synset': 'hinge.n.01', 'synonyms': ['hinge'], 'def': 'a joint that holds two parts together so that one can swing relative to the other', 'name': 'hinge'}, {'frequency': 'r', 'id': 572, 'synset': 'hippopotamus.n.01', 'synonyms': ['hippopotamus'], 'def': 'massive thick-skinned animal living in or around rivers of tropical Africa', 'name': 'hippopotamus'}, {'frequency': 'r', 'id': 573, 'synset': 'hockey_stick.n.01', 'synonyms': ['hockey_stick'], 'def': 'sports implement consisting of a stick used by hockey players to move the puck', 'name': 'hockey_stick'}, {'frequency': 'c', 'id': 574, 'synset': 'hog.n.03', 'synonyms': ['hog', 'pig'], 'def': 'domestic swine', 'name': 'hog'}, {'frequency': 'f', 'id': 575, 'synset': 'home_plate.n.01', 'synonyms': ['home_plate_(baseball)', 'home_base_(baseball)'], 'def': '(baseball) a rubber slab where the batter stands; it must be touched by a base runner in order to score', 'name': 'home_plate_(baseball)'}, {'frequency': 'c', 'id': 576, 'synset': 'honey.n.01', 'synonyms': ['honey'], 'def': 'a sweet yellow liquid produced by bees', 'name': 'honey'}, {'frequency': 'f', 'id': 577, 'synset': 'hood.n.06', 'synonyms': ['fume_hood', 'exhaust_hood'], 'def': 'metal covering leading to a vent that exhausts smoke or fumes', 'name': 'fume_hood'}, {'frequency': 'f', 'id': 578, 'synset': 'hook.n.05', 'synonyms': ['hook'], 'def': 'a curved or bent implement for suspending or pulling something', 'name': 'hook'}, {'frequency': 'f', 'id': 579, 'synset': 'horse.n.01', 'synonyms': ['horse'], 'def': 'a common horse', 'name': 'horse'}, {'frequency': 'f', 'id': 580, 'synset': 'hose.n.03', 'synonyms': ['hose', 'hosepipe'], 'def': 'a flexible pipe for conveying a liquid or gas', 'name': 'hose'}, {'frequency': 'r', 'id': 581, 'synset': 'hot-air_balloon.n.01', 'synonyms': ['hot-air_balloon'], 'def': 'balloon for travel through the air in a basket suspended below a large bag of heated air', 'name': 'hot-air_balloon'}, {'frequency': 'r', 'id': 582, 'synset': 'hot_plate.n.01', 'synonyms': ['hotplate'], 'def': 'a portable electric appliance for heating or cooking or keeping food warm', 'name': 'hotplate'}, {'frequency': 'c', 'id': 583, 'synset': 'hot_sauce.n.01', 'synonyms': ['hot_sauce'], 'def': 'a pungent peppery sauce', 'name': 'hot_sauce'}, {'frequency': 'r', 'id': 584, 'synset': 'hourglass.n.01', 'synonyms': ['hourglass'], 'def': 'a sandglass timer that runs for sixty minutes', 'name': 'hourglass'}, {'frequency': 'r', 'id': 585, 'synset': 'houseboat.n.01', 'synonyms': ['houseboat'], 'def': 'a barge that is designed and equipped for use as a dwelling', 'name': 'houseboat'}, {'frequency': 'r', 'id': 586, 'synset': 'hummingbird.n.01', 'synonyms': ['hummingbird'], 'def': 'tiny American bird having brilliant iridescent plumage and long slender bills', 'name': 'hummingbird'}, {'frequency': 'r', 'id': 587, 'synset': 'hummus.n.01', 'synonyms': ['hummus', 'humus', 'hommos', 'hoummos', 'humous'], 'def': 'a thick spread made from mashed chickpeas', 'name': 'hummus'}, {'frequency': 'c', 'id': 588, 'synset': 'ice_bear.n.01', 'synonyms': ['polar_bear'], 'def': 'white bear of Arctic regions', 'name': 'polar_bear'}, {'frequency': 'c', 'id': 589, 'synset': 'ice_cream.n.01', 'synonyms': ['icecream'], 'def': 'frozen dessert containing cream and sugar and flavoring', 'name': 'icecream'}, {'frequency': 'r', 'id': 590, 'synset': 'ice_lolly.n.01', 'synonyms': ['popsicle'], 'def': 'ice cream or water ice on a small wooden stick', 'name': 'popsicle'}, {'frequency': 'c', 'id': 591, 'synset': 'ice_maker.n.01', 'synonyms': ['ice_maker'], 'def': 'an appliance included in some electric refrigerators for making ice cubes', 'name': 'ice_maker'}, {'frequency': 'r', 'id': 592, 'synset': 'ice_pack.n.01', 'synonyms': ['ice_pack', 'ice_bag'], 'def': 'a waterproof bag filled with ice: applied to the body (especially the head) to cool or reduce swelling', 'name': 'ice_pack'}, {'frequency': 'r', 'id': 593, 'synset': 'ice_skate.n.01', 'synonyms': ['ice_skate'], 'def': 'skate consisting of a boot with a steel blade fitted to the sole', 'name': 'ice_skate'}, {'frequency': 'r', 'id': 594, 'synset': 'ice_tea.n.01', 'synonyms': ['ice_tea', 'iced_tea'], 'def': 'strong tea served over ice', 'name': 'ice_tea'}, {'frequency': 'c', 'id': 595, 'synset': 'igniter.n.01', 'synonyms': ['igniter', 'ignitor', 'lighter'], 'def': 'a substance or device used to start a fire', 'name': 'igniter'}, {'frequency': 'r', 'id': 596, 'synset': 'incense.n.01', 'synonyms': ['incense'], 'def': 'a substance that produces a fragrant odor when burned', 'name': 'incense'}, {'frequency': 'r', 'id': 597, 'synset': 'inhaler.n.01', 'synonyms': ['inhaler', 'inhalator'], 'def': 'a dispenser that produces a chemical vapor to be inhaled through mouth or nose', 'name': 'inhaler'}, {'frequency': 'c', 'id': 598, 'synset': 'ipod.n.01', 'synonyms': ['iPod'], 'def': 'a pocket-sized device used to play music files', 'name': 'iPod'}, {'frequency': 'c', 'id': 599, 'synset': 'iron.n.04', 'synonyms': ['iron_(for_clothing)', 'smoothing_iron_(for_clothing)'], 'def': 'home appliance consisting of a flat metal base that is heated and used to smooth cloth', 'name': 'iron_(for_clothing)'}, {'frequency': 'r', 'id': 600, 'synset': 'ironing_board.n.01', 'synonyms': ['ironing_board'], 'def': 'narrow padded board on collapsible supports; used for ironing clothes', 'name': 'ironing_board'}, {'frequency': 'f', 'id': 601, 'synset': 'jacket.n.01', 'synonyms': ['jacket'], 'def': 'a waist-length coat', 'name': 'jacket'}, {'frequency': 'r', 'id': 602, 'synset': 'jam.n.01', 'synonyms': ['jam'], 'def': 'preserve of crushed fruit', 'name': 'jam'}, {'frequency': 'f', 'id': 603, 'synset': 'jean.n.01', 'synonyms': ['jean', 'blue_jean', 'denim'], 'def': '(usually plural) close-fitting trousers of heavy denim for manual work or casual wear', 'name': 'jean'}, {'frequency': 'c', 'id': 604, 'synset': 'jeep.n.01', 'synonyms': ['jeep', 'landrover'], 'def': 'a car suitable for traveling over rough terrain', 'name': 'jeep'}, {'frequency': 'r', 'id': 605, 'synset': 'jelly_bean.n.01', 'synonyms': ['jelly_bean', 'jelly_egg'], 'def': 'sugar-glazed jellied candy', 'name': 'jelly_bean'}, {'frequency': 'f', 'id': 606, 'synset': 'jersey.n.03', 'synonyms': ['jersey', 'T-shirt', 'tee_shirt'], 'def': 'a close-fitting pullover shirt', 'name': 'jersey'}, {'frequency': 'c', 'id': 607, 'synset': 'jet.n.01', 'synonyms': ['jet_plane', 'jet-propelled_plane'], 'def': 'an airplane powered by one or more jet engines', 'name': 'jet_plane'}, {'frequency': 'c', 'id': 608, 'synset': 'jewelry.n.01', 'synonyms': ['jewelry', 'jewellery'], 'def': 'an adornment (as a bracelet or ring or necklace) made of precious metals and set with gems (or imitation gems)', 'name': 'jewelry'}, {'frequency': 'r', 'id': 609, 'synset': 'joystick.n.02', 'synonyms': ['joystick'], 'def': 'a control device for computers consisting of a vertical handle that can move freely in two directions', 'name': 'joystick'}, {'frequency': 'r', 'id': 610, 'synset': 'jump_suit.n.01', 'synonyms': ['jumpsuit'], 'def': "one-piece garment fashioned after a parachutist's uniform", 'name': 'jumpsuit'}, {'frequency': 'c', 'id': 611, 'synset': 'kayak.n.01', 'synonyms': ['kayak'], 'def': 'a small canoe consisting of a light frame made watertight with animal skins', 'name': 'kayak'}, {'frequency': 'r', 'id': 612, 'synset': 'keg.n.02', 'synonyms': ['keg'], 'def': 'small cask or barrel', 'name': 'keg'}, {'frequency': 'r', 'id': 613, 'synset': 'kennel.n.01', 'synonyms': ['kennel', 'doghouse'], 'def': 'outbuilding that serves as a shelter for a dog', 'name': 'kennel'}, {'frequency': 'c', 'id': 614, 'synset': 'kettle.n.01', 'synonyms': ['kettle', 'boiler'], 'def': 'a metal pot for stewing or boiling; usually has a lid', 'name': 'kettle'}, {'frequency': 'f', 'id': 615, 'synset': 'key.n.01', 'synonyms': ['key'], 'def': 'metal instrument used to unlock a lock', 'name': 'key'}, {'frequency': 'r', 'id': 616, 'synset': 'keycard.n.01', 'synonyms': ['keycard'], 'def': 'a plastic card used to gain access typically to a door', 'name': 'keycard'}, {'frequency': 'r', 'id': 617, 'synset': 'kilt.n.01', 'synonyms': ['kilt'], 'def': 'a knee-length pleated tartan skirt worn by men as part of the traditional dress in the Highlands of northern Scotland', 'name': 'kilt'}, {'frequency': 'c', 'id': 618, 'synset': 'kimono.n.01', 'synonyms': ['kimono'], 'def': 'a loose robe; imitated from robes originally worn by Japanese', 'name': 'kimono'}, {'frequency': 'f', 'id': 619, 'synset': 'kitchen_sink.n.01', 'synonyms': ['kitchen_sink'], 'def': 'a sink in a kitchen', 'name': 'kitchen_sink'}, {'frequency': 'c', 'id': 620, 'synset': 'kitchen_table.n.01', 'synonyms': ['kitchen_table'], 'def': 'a table in the kitchen', 'name': 'kitchen_table'}, {'frequency': 'f', 'id': 621, 'synset': 'kite.n.03', 'synonyms': ['kite'], 'def': 'plaything consisting of a light frame covered with tissue paper; flown in wind at end of a string', 'name': 'kite'}, {'frequency': 'c', 'id': 622, 'synset': 'kitten.n.01', 'synonyms': ['kitten', 'kitty'], 'def': 'young domestic cat', 'name': 'kitten'}, {'frequency': 'c', 'id': 623, 'synset': 'kiwi.n.03', 'synonyms': ['kiwi_fruit'], 'def': 'fuzzy brown egg-shaped fruit with slightly tart green flesh', 'name': 'kiwi_fruit'}, {'frequency': 'f', 'id': 624, 'synset': 'knee_pad.n.01', 'synonyms': ['knee_pad'], 'def': 'protective garment consisting of a pad worn by football or baseball or hockey players', 'name': 'knee_pad'}, {'frequency': 'f', 'id': 625, 'synset': 'knife.n.01', 'synonyms': ['knife'], 'def': 'tool with a blade and point used as a cutting instrument', 'name': 'knife'}, {'frequency': 'r', 'id': 626, 'synset': 'knight.n.02', 'synonyms': ['knight_(chess_piece)', 'horse_(chess_piece)'], 'def': 'a chess game piece shaped to resemble the head of a horse', 'name': 'knight_(chess_piece)'}, {'frequency': 'r', 'id': 627, 'synset': 'knitting_needle.n.01', 'synonyms': ['knitting_needle'], 'def': 'needle consisting of a slender rod with pointed ends; usually used in pairs', 'name': 'knitting_needle'}, {'frequency': 'f', 'id': 628, 'synset': 'knob.n.02', 'synonyms': ['knob'], 'def': 'a round handle often found on a door', 'name': 'knob'}, {'frequency': 'r', 'id': 629, 'synset': 'knocker.n.05', 'synonyms': ['knocker_(on_a_door)', 'doorknocker'], 'def': 'a device (usually metal and ornamental) attached by a hinge to a door', 'name': 'knocker_(on_a_door)'}, {'frequency': 'r', 'id': 630, 'synset': 'koala.n.01', 'synonyms': ['koala', 'koala_bear'], 'def': 'sluggish tailless Australian marsupial with grey furry ears and coat', 'name': 'koala'}, {'frequency': 'r', 'id': 631, 'synset': 'lab_coat.n.01', 'synonyms': ['lab_coat', 'laboratory_coat'], 'def': 'a light coat worn to protect clothing from substances used while working in a laboratory', 'name': 'lab_coat'}, {'frequency': 'f', 'id': 632, 'synset': 'ladder.n.01', 'synonyms': ['ladder'], 'def': 'steps consisting of two parallel members connected by rungs', 'name': 'ladder'}, {'frequency': 'c', 'id': 633, 'synset': 'ladle.n.01', 'synonyms': ['ladle'], 'def': 'a spoon-shaped vessel with a long handle frequently used to transfer liquids', 'name': 'ladle'}, {'frequency': 'r', 'id': 634, 'synset': 'ladybug.n.01', 'synonyms': ['ladybug', 'ladybeetle', 'ladybird_beetle'], 'def': 'small round bright-colored and spotted beetle, typically red and black', 'name': 'ladybug'}, {'frequency': 'c', 'id': 635, 'synset': 'lamb.n.01', 'synonyms': ['lamb_(animal)'], 'def': 'young sheep', 'name': 'lamb_(animal)'}, {'frequency': 'r', 'id': 636, 'synset': 'lamb_chop.n.01', 'synonyms': ['lamb-chop', 'lambchop'], 'def': 'chop cut from a lamb', 'name': 'lamb-chop'}, {'frequency': 'f', 'id': 637, 'synset': 'lamp.n.02', 'synonyms': ['lamp'], 'def': 'a piece of furniture holding one or more electric light bulbs', 'name': 'lamp'}, {'frequency': 'f', 'id': 638, 'synset': 'lamppost.n.01', 'synonyms': ['lamppost'], 'def': 'a metal post supporting an outdoor lamp (such as a streetlight)', 'name': 'lamppost'}, {'frequency': 'f', 'id': 639, 'synset': 'lampshade.n.01', 'synonyms': ['lampshade'], 'def': 'a protective ornamental shade used to screen a light bulb from direct view', 'name': 'lampshade'}, {'frequency': 'c', 'id': 640, 'synset': 'lantern.n.01', 'synonyms': ['lantern'], 'def': 'light in a transparent protective case', 'name': 'lantern'}, {'frequency': 'f', 'id': 641, 'synset': 'lanyard.n.02', 'synonyms': ['lanyard', 'laniard'], 'def': 'a cord worn around the neck to hold a knife or whistle, etc.', 'name': 'lanyard'}, {'frequency': 'f', 'id': 642, 'synset': 'laptop.n.01', 'synonyms': ['laptop_computer', 'notebook_computer'], 'def': 'a portable computer small enough to use in your lap', 'name': 'laptop_computer'}, {'frequency': 'r', 'id': 643, 'synset': 'lasagna.n.01', 'synonyms': ['lasagna', 'lasagne'], 'def': 'baked dish of layers of lasagna pasta with sauce and cheese and meat or vegetables', 'name': 'lasagna'}, {'frequency': 'c', 'id': 644, 'synset': 'latch.n.02', 'synonyms': ['latch'], 'def': 'a bar that can be lowered or slid into a groove to fasten a door or gate', 'name': 'latch'}, {'frequency': 'r', 'id': 645, 'synset': 'lawn_mower.n.01', 'synonyms': ['lawn_mower'], 'def': 'garden tool for mowing grass on lawns', 'name': 'lawn_mower'}, {'frequency': 'r', 'id': 646, 'synset': 'leather.n.01', 'synonyms': ['leather'], 'def': 'an animal skin made smooth and flexible by removing the hair and then tanning', 'name': 'leather'}, {'frequency': 'c', 'id': 647, 'synset': 'legging.n.01', 'synonyms': ['legging_(clothing)', 'leging_(clothing)', 'leg_covering'], 'def': 'a garment covering the leg (usually extending from the knee to the ankle)', 'name': 'legging_(clothing)'}, {'frequency': 'c', 'id': 648, 'synset': 'lego.n.01', 'synonyms': ['Lego', 'Lego_set'], 'def': "a child's plastic construction set for making models from blocks", 'name': 'Lego'}, {'frequency': 'f', 'id': 649, 'synset': 'lemon.n.01', 'synonyms': ['lemon'], 'def': 'yellow oval fruit with juicy acidic flesh', 'name': 'lemon'}, {'frequency': 'r', 'id': 650, 'synset': 'lemonade.n.01', 'synonyms': ['lemonade'], 'def': 'sweetened beverage of diluted lemon juice', 'name': 'lemonade'}, {'frequency': 'f', 'id': 651, 'synset': 'lettuce.n.02', 'synonyms': ['lettuce'], 'def': 'leafy plant commonly eaten in salad or on sandwiches', 'name': 'lettuce'}, {'frequency': 'f', 'id': 652, 'synset': 'license_plate.n.01', 'synonyms': ['license_plate', 'numberplate'], 'def': "a plate mounted on the front and back of car and bearing the car's registration number", 'name': 'license_plate'}, {'frequency': 'f', 'id': 653, 'synset': 'life_buoy.n.01', 'synonyms': ['life_buoy', 'lifesaver', 'life_belt', 'life_ring'], 'def': 'a ring-shaped life preserver used to prevent drowning (NOT a life-jacket or vest)', 'name': 'life_buoy'}, {'frequency': 'f', 'id': 654, 'synset': 'life_jacket.n.01', 'synonyms': ['life_jacket', 'life_vest'], 'def': 'life preserver consisting of a sleeveless jacket of buoyant or inflatable design', 'name': 'life_jacket'}, {'frequency': 'f', 'id': 655, 'synset': 'light_bulb.n.01', 'synonyms': ['lightbulb'], 'def': 'glass bulb or tube shaped electric device that emits light (DO NOT MARK LAMPS AS A WHOLE)', 'name': 'lightbulb'}, {'frequency': 'r', 'id': 656, 'synset': 'lightning_rod.n.02', 'synonyms': ['lightning_rod', 'lightning_conductor'], 'def': 'a metallic conductor that is attached to a high point and leads to the ground', 'name': 'lightning_rod'}, {'frequency': 'c', 'id': 657, 'synset': 'lime.n.06', 'synonyms': ['lime'], 'def': 'the green acidic fruit of any of various lime trees', 'name': 'lime'}, {'frequency': 'r', 'id': 658, 'synset': 'limousine.n.01', 'synonyms': ['limousine'], 'def': 'long luxurious car; usually driven by a chauffeur', 'name': 'limousine'}, {'frequency': 'r', 'id': 659, 'synset': 'linen.n.02', 'synonyms': ['linen_paper'], 'def': 'a high-quality paper made of linen fibers or with a linen finish', 'name': 'linen_paper'}, {'frequency': 'c', 'id': 660, 'synset': 'lion.n.01', 'synonyms': ['lion'], 'def': 'large gregarious predatory cat of Africa and India', 'name': 'lion'}, {'frequency': 'c', 'id': 661, 'synset': 'lip_balm.n.01', 'synonyms': ['lip_balm'], 'def': 'a balm applied to the lips', 'name': 'lip_balm'}, {'frequency': 'c', 'id': 662, 'synset': 'lipstick.n.01', 'synonyms': ['lipstick', 'lip_rouge'], 'def': 'makeup that is used to color the lips', 'name': 'lipstick'}, {'frequency': 'r', 'id': 663, 'synset': 'liquor.n.01', 'synonyms': ['liquor', 'spirits', 'hard_liquor', 'liqueur', 'cordial'], 'def': 'an alcoholic beverage that is distilled rather than fermented', 'name': 'liquor'}, {'frequency': 'r', 'id': 664, 'synset': 'lizard.n.01', 'synonyms': ['lizard'], 'def': 'a reptile with usually two pairs of legs and a tapering tail', 'name': 'lizard'}, {'frequency': 'r', 'id': 665, 'synset': 'loafer.n.02', 'synonyms': ['Loafer_(type_of_shoe)'], 'def': 'a low leather step-in shoe', 'name': 'Loafer_(type_of_shoe)'}, {'frequency': 'f', 'id': 666, 'synset': 'log.n.01', 'synonyms': ['log'], 'def': 'a segment of the trunk of a tree when stripped of branches', 'name': 'log'}, {'frequency': 'c', 'id': 667, 'synset': 'lollipop.n.02', 'synonyms': ['lollipop'], 'def': 'hard candy on a stick', 'name': 'lollipop'}, {'frequency': 'c', 'id': 668, 'synset': 'lotion.n.01', 'synonyms': ['lotion'], 'def': 'any of various cosmetic preparations that are applied to the skin', 'name': 'lotion'}, {'frequency': 'f', 'id': 669, 'synset': 'loudspeaker.n.01', 'synonyms': ['speaker_(stero_equipment)'], 'def': 'electronic device that produces sound often as part of a stereo system', 'name': 'speaker_(stero_equipment)'}, {'frequency': 'c', 'id': 670, 'synset': 'love_seat.n.01', 'synonyms': ['loveseat'], 'def': 'small sofa that seats two people', 'name': 'loveseat'}, {'frequency': 'r', 'id': 671, 'synset': 'machine_gun.n.01', 'synonyms': ['machine_gun'], 'def': 'a rapidly firing automatic gun', 'name': 'machine_gun'}, {'frequency': 'f', 'id': 672, 'synset': 'magazine.n.02', 'synonyms': ['magazine'], 'def': 'a paperback periodic publication', 'name': 'magazine'}, {'frequency': 'f', 'id': 673, 'synset': 'magnet.n.01', 'synonyms': ['magnet'], 'def': 'a device that attracts iron and produces a magnetic field', 'name': 'magnet'}, {'frequency': 'r', 'id': 674, 'synset': 'mail_slot.n.01', 'synonyms': ['mail_slot'], 'def': 'a slot (usually in a door) through which mail can be delivered', 'name': 'mail_slot'}, {'frequency': 'c', 'id': 675, 'synset': 'mailbox.n.01', 'synonyms': ['mailbox_(at_home)', 'letter_box_(at_home)'], 'def': 'a private box for delivery of mail', 'name': 'mailbox_(at_home)'}, {'frequency': 'r', 'id': 676, 'synset': 'mallet.n.01', 'synonyms': ['mallet'], 'def': 'a sports implement with a long handle and a hammer-like head used to hit a ball', 'name': 'mallet'}, {'frequency': 'r', 'id': 677, 'synset': 'mammoth.n.01', 'synonyms': ['mammoth'], 'def': 'any of numerous extinct elephants widely distributed in the Pleistocene', 'name': 'mammoth'}, {'frequency': 'c', 'id': 678, 'synset': 'mandarin.n.05', 'synonyms': ['mandarin_orange'], 'def': 'a somewhat flat reddish-orange loose skinned citrus of China', 'name': 'mandarin_orange'}, {'frequency': 'c', 'id': 679, 'synset': 'manger.n.01', 'synonyms': ['manger', 'trough'], 'def': 'a container (usually in a barn or stable) from which cattle or horses feed', 'name': 'manger'}, {'frequency': 'f', 'id': 680, 'synset': 'manhole.n.01', 'synonyms': ['manhole'], 'def': 'a hole (usually with a flush cover) through which a person can gain access to an underground structure', 'name': 'manhole'}, {'frequency': 'c', 'id': 681, 'synset': 'map.n.01', 'synonyms': ['map'], 'def': "a diagrammatic representation of the earth's surface (or part of it)", 'name': 'map'}, {'frequency': 'c', 'id': 682, 'synset': 'marker.n.03', 'synonyms': ['marker'], 'def': 'a writing implement for making a mark', 'name': 'marker'}, {'frequency': 'r', 'id': 683, 'synset': 'martini.n.01', 'synonyms': ['martini'], 'def': 'a cocktail made of gin (or vodka) with dry vermouth', 'name': 'martini'}, {'frequency': 'r', 'id': 684, 'synset': 'mascot.n.01', 'synonyms': ['mascot'], 'def': 'a person or animal that is adopted by a team or other group as a symbolic figure', 'name': 'mascot'}, {'frequency': 'c', 'id': 685, 'synset': 'mashed_potato.n.01', 'synonyms': ['mashed_potato'], 'def': 'potato that has been peeled and boiled and then mashed', 'name': 'mashed_potato'}, {'frequency': 'r', 'id': 686, 'synset': 'masher.n.02', 'synonyms': ['masher'], 'def': 'a kitchen utensil used for mashing (e.g. potatoes)', 'name': 'masher'}, {'frequency': 'f', 'id': 687, 'synset': 'mask.n.04', 'synonyms': ['mask', 'facemask'], 'def': 'a protective covering worn over the face', 'name': 'mask'}, {'frequency': 'f', 'id': 688, 'synset': 'mast.n.01', 'synonyms': ['mast'], 'def': 'a vertical spar for supporting sails', 'name': 'mast'}, {'frequency': 'c', 'id': 689, 'synset': 'mat.n.03', 'synonyms': ['mat_(gym_equipment)', 'gym_mat'], 'def': 'sports equipment consisting of a piece of thick padding on the floor for gymnastics', 'name': 'mat_(gym_equipment)'}, {'frequency': 'r', 'id': 690, 'synset': 'matchbox.n.01', 'synonyms': ['matchbox'], 'def': 'a box for holding matches', 'name': 'matchbox'}, {'frequency': 'f', 'id': 691, 'synset': 'mattress.n.01', 'synonyms': ['mattress'], 'def': 'a thick pad filled with resilient material used as a bed or part of a bed', 'name': 'mattress'}, {'frequency': 'c', 'id': 692, 'synset': 'measuring_cup.n.01', 'synonyms': ['measuring_cup'], 'def': 'graduated cup used to measure liquid or granular ingredients', 'name': 'measuring_cup'}, {'frequency': 'c', 'id': 693, 'synset': 'measuring_stick.n.01', 'synonyms': ['measuring_stick', 'ruler_(measuring_stick)', 'measuring_rod'], 'def': 'measuring instrument having a sequence of marks at regular intervals', 'name': 'measuring_stick'}, {'frequency': 'c', 'id': 694, 'synset': 'meatball.n.01', 'synonyms': ['meatball'], 'def': 'ground meat formed into a ball and fried or simmered in broth', 'name': 'meatball'}, {'frequency': 'c', 'id': 695, 'synset': 'medicine.n.02', 'synonyms': ['medicine'], 'def': 'something that treats or prevents or alleviates the symptoms of disease', 'name': 'medicine'}, {'frequency': 'r', 'id': 696, 'synset': 'melon.n.01', 'synonyms': ['melon'], 'def': 'fruit of the gourd family having a hard rind and sweet juicy flesh', 'name': 'melon'}, {'frequency': 'f', 'id': 697, 'synset': 'microphone.n.01', 'synonyms': ['microphone'], 'def': 'device for converting sound waves into electrical energy', 'name': 'microphone'}, {'frequency': 'r', 'id': 698, 'synset': 'microscope.n.01', 'synonyms': ['microscope'], 'def': 'magnifier of the image of small objects', 'name': 'microscope'}, {'frequency': 'f', 'id': 699, 'synset': 'microwave.n.02', 'synonyms': ['microwave_oven'], 'def': 'kitchen appliance that cooks food by passing an electromagnetic wave through it', 'name': 'microwave_oven'}, {'frequency': 'r', 'id': 700, 'synset': 'milestone.n.01', 'synonyms': ['milestone', 'milepost'], 'def': 'stone post at side of a road to show distances', 'name': 'milestone'}, {'frequency': 'c', 'id': 701, 'synset': 'milk.n.01', 'synonyms': ['milk'], 'def': 'a white nutritious liquid secreted by mammals and used as food by human beings', 'name': 'milk'}, {'frequency': 'f', 'id': 702, 'synset': 'minivan.n.01', 'synonyms': ['minivan'], 'def': 'a small box-shaped passenger van', 'name': 'minivan'}, {'frequency': 'r', 'id': 703, 'synset': 'mint.n.05', 'synonyms': ['mint_candy'], 'def': 'a candy that is flavored with a mint oil', 'name': 'mint_candy'}, {'frequency': 'f', 'id': 704, 'synset': 'mirror.n.01', 'synonyms': ['mirror'], 'def': 'polished surface that forms images by reflecting light', 'name': 'mirror'}, {'frequency': 'c', 'id': 705, 'synset': 'mitten.n.01', 'synonyms': ['mitten'], 'def': 'glove that encases the thumb separately and the other four fingers together', 'name': 'mitten'}, {'frequency': 'c', 'id': 706, 'synset': 'mixer.n.04', 'synonyms': ['mixer_(kitchen_tool)', 'stand_mixer'], 'def': 'a kitchen utensil that is used for mixing foods', 'name': 'mixer_(kitchen_tool)'}, {'frequency': 'c', 'id': 707, 'synset': 'money.n.03', 'synonyms': ['money'], 'def': 'the official currency issued by a government or national bank', 'name': 'money'}, {'frequency': 'f', 'id': 708, 'synset': 'monitor.n.04', 'synonyms': ['monitor_(computer_equipment) computer_monitor'], 'def': 'a computer monitor', 'name': 'monitor_(computer_equipment) computer_monitor'}, {'frequency': 'c', 'id': 709, 'synset': 'monkey.n.01', 'synonyms': ['monkey'], 'def': 'any of various long-tailed primates', 'name': 'monkey'}, {'frequency': 'f', 'id': 710, 'synset': 'motor.n.01', 'synonyms': ['motor'], 'def': 'machine that converts other forms of energy into mechanical energy and so imparts motion', 'name': 'motor'}, {'frequency': 'f', 'id': 711, 'synset': 'motor_scooter.n.01', 'synonyms': ['motor_scooter', 'scooter'], 'def': 'a wheeled vehicle with small wheels and a low-powered engine', 'name': 'motor_scooter'}, {'frequency': 'r', 'id': 712, 'synset': 'motor_vehicle.n.01', 'synonyms': ['motor_vehicle', 'automotive_vehicle'], 'def': 'a self-propelled wheeled vehicle that does not run on rails', 'name': 'motor_vehicle'}, {'frequency': 'r', 'id': 713, 'synset': 'motorboat.n.01', 'synonyms': ['motorboat', 'powerboat'], 'def': 'a boat propelled by an internal-combustion engine', 'name': 'motorboat'}, {'frequency': 'f', 'id': 714, 'synset': 'motorcycle.n.01', 'synonyms': ['motorcycle'], 'def': 'a motor vehicle with two wheels and a strong frame', 'name': 'motorcycle'}, {'frequency': 'f', 'id': 715, 'synset': 'mound.n.01', 'synonyms': ['mound_(baseball)', "pitcher's_mound"], 'def': '(baseball) the slight elevation on which the pitcher stands', 'name': 'mound_(baseball)'}, {'frequency': 'r', 'id': 716, 'synset': 'mouse.n.01', 'synonyms': ['mouse_(animal_rodent)'], 'def': 'a small rodent with pointed snouts and small ears on elongated bodies with slender usually hairless tails', 'name': 'mouse_(animal_rodent)'}, {'frequency': 'f', 'id': 717, 'synset': 'mouse.n.04', 'synonyms': ['mouse_(computer_equipment)', 'computer_mouse'], 'def': 'a computer input device that controls an on-screen pointer', 'name': 'mouse_(computer_equipment)'}, {'frequency': 'f', 'id': 718, 'synset': 'mousepad.n.01', 'synonyms': ['mousepad'], 'def': 'a small portable pad that provides an operating surface for a computer mouse', 'name': 'mousepad'}, {'frequency': 'c', 'id': 719, 'synset': 'muffin.n.01', 'synonyms': ['muffin'], 'def': 'a sweet quick bread baked in a cup-shaped pan', 'name': 'muffin'}, {'frequency': 'f', 'id': 720, 'synset': 'mug.n.04', 'synonyms': ['mug'], 'def': 'with handle and usually cylindrical', 'name': 'mug'}, {'frequency': 'f', 'id': 721, 'synset': 'mushroom.n.02', 'synonyms': ['mushroom'], 'def': 'a common mushroom', 'name': 'mushroom'}, {'frequency': 'r', 'id': 722, 'synset': 'music_stool.n.01', 'synonyms': ['music_stool', 'piano_stool'], 'def': 'a stool for piano players; usually adjustable in height', 'name': 'music_stool'}, {'frequency': 'r', 'id': 723, 'synset': 'musical_instrument.n.01', 'synonyms': ['musical_instrument', 'instrument_(musical)'], 'def': 'any of various devices or contrivances that can be used to produce musical tones or sounds', 'name': 'musical_instrument'}, {'frequency': 'r', 'id': 724, 'synset': 'nailfile.n.01', 'synonyms': ['nailfile'], 'def': 'a small flat file for shaping the nails', 'name': 'nailfile'}, {'frequency': 'r', 'id': 725, 'synset': 'nameplate.n.01', 'synonyms': ['nameplate'], 'def': 'a plate bearing a name', 'name': 'nameplate'}, {'frequency': 'f', 'id': 726, 'synset': 'napkin.n.01', 'synonyms': ['napkin', 'table_napkin', 'serviette'], 'def': 'a small piece of table linen or paper that is used to wipe the mouth and to cover the lap in order to protect clothing', 'name': 'napkin'}, {'frequency': 'r', 'id': 727, 'synset': 'neckerchief.n.01', 'synonyms': ['neckerchief'], 'def': 'a kerchief worn around the neck', 'name': 'neckerchief'}, {'frequency': 'f', 'id': 728, 'synset': 'necklace.n.01', 'synonyms': ['necklace'], 'def': 'jewelry consisting of a cord or chain (often bearing gems) worn about the neck as an ornament', 'name': 'necklace'}, {'frequency': 'f', 'id': 729, 'synset': 'necktie.n.01', 'synonyms': ['necktie', 'tie_(necktie)'], 'def': 'neckwear consisting of a long narrow piece of material worn under a collar and tied in knot at the front', 'name': 'necktie'}, {'frequency': 'r', 'id': 730, 'synset': 'needle.n.03', 'synonyms': ['needle'], 'def': 'a sharp pointed implement (usually metal)', 'name': 'needle'}, {'frequency': 'c', 'id': 731, 'synset': 'nest.n.01', 'synonyms': ['nest'], 'def': 'a structure in which animals lay eggs or give birth to their young', 'name': 'nest'}, {'frequency': 'r', 'id': 732, 'synset': 'newsstand.n.01', 'synonyms': ['newsstand'], 'def': 'a stall where newspapers and other periodicals are sold', 'name': 'newsstand'}, {'frequency': 'c', 'id': 733, 'synset': 'nightwear.n.01', 'synonyms': ['nightshirt', 'nightwear', 'sleepwear', 'nightclothes'], 'def': 'garments designed to be worn in bed', 'name': 'nightshirt'}, {'frequency': 'r', 'id': 734, 'synset': 'nosebag.n.01', 'synonyms': ['nosebag_(for_animals)', 'feedbag'], 'def': 'a canvas bag that is used to feed an animal (such as a horse); covers the muzzle and fastens at the top of the head', 'name': 'nosebag_(for_animals)'}, {'frequency': 'r', 'id': 735, 'synset': 'noseband.n.01', 'synonyms': ['noseband_(for_animals)', 'nosepiece_(for_animals)'], 'def': "a strap that is the part of a bridle that goes over the animal's nose", 'name': 'noseband_(for_animals)'}, {'frequency': 'f', 'id': 736, 'synset': 'notebook.n.01', 'synonyms': ['notebook'], 'def': 'a book with blank pages for recording notes or memoranda', 'name': 'notebook'}, {'frequency': 'c', 'id': 737, 'synset': 'notepad.n.01', 'synonyms': ['notepad'], 'def': 'a pad of paper for keeping notes', 'name': 'notepad'}, {'frequency': 'c', 'id': 738, 'synset': 'nut.n.03', 'synonyms': ['nut'], 'def': 'a small metal block (usually square or hexagonal) with internal screw thread to be fitted onto a bolt', 'name': 'nut'}, {'frequency': 'r', 'id': 739, 'synset': 'nutcracker.n.01', 'synonyms': ['nutcracker'], 'def': 'a hand tool used to crack nuts open', 'name': 'nutcracker'}, {'frequency': 'c', 'id': 740, 'synset': 'oar.n.01', 'synonyms': ['oar'], 'def': 'an implement used to propel or steer a boat', 'name': 'oar'}, {'frequency': 'r', 'id': 741, 'synset': 'octopus.n.01', 'synonyms': ['octopus_(food)'], 'def': 'tentacles of octopus prepared as food', 'name': 'octopus_(food)'}, {'frequency': 'r', 'id': 742, 'synset': 'octopus.n.02', 'synonyms': ['octopus_(animal)'], 'def': 'bottom-living cephalopod having a soft oval body with eight long tentacles', 'name': 'octopus_(animal)'}, {'frequency': 'c', 'id': 743, 'synset': 'oil_lamp.n.01', 'synonyms': ['oil_lamp', 'kerosene_lamp', 'kerosine_lamp'], 'def': 'a lamp that burns oil (as kerosine) for light', 'name': 'oil_lamp'}, {'frequency': 'c', 'id': 744, 'synset': 'olive_oil.n.01', 'synonyms': ['olive_oil'], 'def': 'oil from olives', 'name': 'olive_oil'}, {'frequency': 'r', 'id': 745, 'synset': 'omelet.n.01', 'synonyms': ['omelet', 'omelette'], 'def': 'beaten eggs cooked until just set; may be folded around e.g. ham or cheese or jelly', 'name': 'omelet'}, {'frequency': 'f', 'id': 746, 'synset': 'onion.n.01', 'synonyms': ['onion'], 'def': 'the bulb of an onion plant', 'name': 'onion'}, {'frequency': 'f', 'id': 747, 'synset': 'orange.n.01', 'synonyms': ['orange_(fruit)'], 'def': 'orange (FRUIT of an orange tree)', 'name': 'orange_(fruit)'}, {'frequency': 'c', 'id': 748, 'synset': 'orange_juice.n.01', 'synonyms': ['orange_juice'], 'def': 'bottled or freshly squeezed juice of oranges', 'name': 'orange_juice'}, {'frequency': 'r', 'id': 749, 'synset': 'oregano.n.01', 'synonyms': ['oregano', 'marjoram'], 'def': 'aromatic Eurasian perennial herb used in cooking and baking', 'name': 'oregano'}, {'frequency': 'c', 'id': 750, 'synset': 'ostrich.n.02', 'synonyms': ['ostrich'], 'def': 'fast-running African flightless bird with two-toed feet; largest living bird', 'name': 'ostrich'}, {'frequency': 'c', 'id': 751, 'synset': 'ottoman.n.03', 'synonyms': ['ottoman', 'pouf', 'pouffe', 'hassock'], 'def': 'thick cushion used as a seat', 'name': 'ottoman'}, {'frequency': 'c', 'id': 752, 'synset': 'overall.n.01', 'synonyms': ['overalls_(clothing)'], 'def': 'work clothing consisting of denim trousers usually with a bib and shoulder straps', 'name': 'overalls_(clothing)'}, {'frequency': 'c', 'id': 753, 'synset': 'owl.n.01', 'synonyms': ['owl'], 'def': 'nocturnal bird of prey with hawk-like beak and claws and large head with front-facing eyes', 'name': 'owl'}, {'frequency': 'c', 'id': 754, 'synset': 'packet.n.03', 'synonyms': ['packet'], 'def': 'a small package or bundle', 'name': 'packet'}, {'frequency': 'r', 'id': 755, 'synset': 'pad.n.03', 'synonyms': ['inkpad', 'inking_pad', 'stamp_pad'], 'def': 'absorbent material saturated with ink used to transfer ink evenly to a rubber stamp', 'name': 'inkpad'}, {'frequency': 'c', 'id': 756, 'synset': 'pad.n.04', 'synonyms': ['pad'], 'def': 'a flat mass of soft material used for protection, stuffing, or comfort', 'name': 'pad'}, {'frequency': 'c', 'id': 757, 'synset': 'paddle.n.04', 'synonyms': ['paddle', 'boat_paddle'], 'def': 'a short light oar used without an oarlock to propel a canoe or small boat', 'name': 'paddle'}, {'frequency': 'c', 'id': 758, 'synset': 'padlock.n.01', 'synonyms': ['padlock'], 'def': 'a detachable, portable lock', 'name': 'padlock'}, {'frequency': 'r', 'id': 759, 'synset': 'paintbox.n.01', 'synonyms': ['paintbox'], 'def': "a box containing a collection of cubes or tubes of artists' paint", 'name': 'paintbox'}, {'frequency': 'c', 'id': 760, 'synset': 'paintbrush.n.01', 'synonyms': ['paintbrush'], 'def': 'a brush used as an applicator to apply paint', 'name': 'paintbrush'}, {'frequency': 'f', 'id': 761, 'synset': 'painting.n.01', 'synonyms': ['painting'], 'def': 'graphic art consisting of an artistic composition made by applying paints to a surface', 'name': 'painting'}, {'frequency': 'c', 'id': 762, 'synset': 'pajama.n.02', 'synonyms': ['pajamas', 'pyjamas'], 'def': 'loose-fitting nightclothes worn for sleeping or lounging', 'name': 'pajamas'}, {'frequency': 'c', 'id': 763, 'synset': 'palette.n.02', 'synonyms': ['palette', 'pallet'], 'def': 'board that provides a flat surface on which artists mix paints and the range of colors used', 'name': 'palette'}, {'frequency': 'f', 'id': 764, 'synset': 'pan.n.01', 'synonyms': ['pan_(for_cooking)', 'cooking_pan'], 'def': 'cooking utensil consisting of a wide metal vessel', 'name': 'pan_(for_cooking)'}, {'frequency': 'r', 'id': 765, 'synset': 'pan.n.03', 'synonyms': ['pan_(metal_container)'], 'def': 'shallow container made of metal', 'name': 'pan_(metal_container)'}, {'frequency': 'c', 'id': 766, 'synset': 'pancake.n.01', 'synonyms': ['pancake'], 'def': 'a flat cake of thin batter fried on both sides on a griddle', 'name': 'pancake'}, {'frequency': 'r', 'id': 767, 'synset': 'pantyhose.n.01', 'synonyms': ['pantyhose'], 'def': "a woman's tights consisting of underpants and stockings", 'name': 'pantyhose'}, {'frequency': 'r', 'id': 768, 'synset': 'papaya.n.02', 'synonyms': ['papaya'], 'def': 'large oval melon-like tropical fruit with yellowish flesh', 'name': 'papaya'}, {'frequency': 'r', 'id': 769, 'synset': 'paper_clip.n.01', 'synonyms': ['paperclip'], 'def': 'a wire or plastic clip for holding sheets of paper together', 'name': 'paperclip'}, {'frequency': 'f', 'id': 770, 'synset': 'paper_plate.n.01', 'synonyms': ['paper_plate'], 'def': 'a disposable plate made of cardboard', 'name': 'paper_plate'}, {'frequency': 'f', 'id': 771, 'synset': 'paper_towel.n.01', 'synonyms': ['paper_towel'], 'def': 'a disposable towel made of absorbent paper', 'name': 'paper_towel'}, {'frequency': 'r', 'id': 772, 'synset': 'paperback_book.n.01', 'synonyms': ['paperback_book', 'paper-back_book', 'softback_book', 'soft-cover_book'], 'def': 'a book with paper covers', 'name': 'paperback_book'}, {'frequency': 'r', 'id': 773, 'synset': 'paperweight.n.01', 'synonyms': ['paperweight'], 'def': 'a weight used to hold down a stack of papers', 'name': 'paperweight'}, {'frequency': 'c', 'id': 774, 'synset': 'parachute.n.01', 'synonyms': ['parachute'], 'def': 'rescue equipment consisting of a device that fills with air and retards your fall', 'name': 'parachute'}, {'frequency': 'r', 'id': 775, 'synset': 'parakeet.n.01', 'synonyms': ['parakeet', 'parrakeet', 'parroket', 'paraquet', 'paroquet', 'parroquet'], 'def': 'any of numerous small slender long-tailed parrots', 'name': 'parakeet'}, {'frequency': 'c', 'id': 776, 'synset': 'parasail.n.01', 'synonyms': ['parasail_(sports)'], 'def': 'parachute that will lift a person up into the air when it is towed by a motorboat or a car', 'name': 'parasail_(sports)'}, {'frequency': 'r', 'id': 777, 'synset': 'parchment.n.01', 'synonyms': ['parchment'], 'def': 'a superior paper resembling sheepskin', 'name': 'parchment'}, {'frequency': 'r', 'id': 778, 'synset': 'parka.n.01', 'synonyms': ['parka', 'anorak'], 'def': "a kind of heavy jacket (`windcheater' is a British term)", 'name': 'parka'}, {'frequency': 'f', 'id': 779, 'synset': 'parking_meter.n.01', 'synonyms': ['parking_meter'], 'def': 'a coin-operated timer located next to a parking space', 'name': 'parking_meter'}, {'frequency': 'c', 'id': 780, 'synset': 'parrot.n.01', 'synonyms': ['parrot'], 'def': 'usually brightly colored tropical birds with short hooked beaks and the ability to mimic sounds', 'name': 'parrot'}, {'frequency': 'c', 'id': 781, 'synset': 'passenger_car.n.01', 'synonyms': ['passenger_car_(part_of_a_train)', 'coach_(part_of_a_train)'], 'def': 'a railcar where passengers ride', 'name': 'passenger_car_(part_of_a_train)'}, {'frequency': 'r', 'id': 782, 'synset': 'passenger_ship.n.01', 'synonyms': ['passenger_ship'], 'def': 'a ship built to carry passengers', 'name': 'passenger_ship'}, {'frequency': 'r', 'id': 783, 'synset': 'passport.n.02', 'synonyms': ['passport'], 'def': 'a document issued by a country to a citizen allowing that person to travel abroad and re-enter the home country', 'name': 'passport'}, {'frequency': 'f', 'id': 784, 'synset': 'pastry.n.02', 'synonyms': ['pastry'], 'def': 'any of various baked foods made of dough or batter', 'name': 'pastry'}, {'frequency': 'r', 'id': 785, 'synset': 'patty.n.01', 'synonyms': ['patty_(food)'], 'def': 'small flat mass of chopped food', 'name': 'patty_(food)'}, {'frequency': 'c', 'id': 786, 'synset': 'pea.n.01', 'synonyms': ['pea_(food)'], 'def': 'seed of a pea plant used for food', 'name': 'pea_(food)'}, {'frequency': 'c', 'id': 787, 'synset': 'peach.n.03', 'synonyms': ['peach'], 'def': 'downy juicy fruit with sweet yellowish or whitish flesh', 'name': 'peach'}, {'frequency': 'c', 'id': 788, 'synset': 'peanut_butter.n.01', 'synonyms': ['peanut_butter'], 'def': 'a spread made from ground peanuts', 'name': 'peanut_butter'}, {'frequency': 'c', 'id': 789, 'synset': 'pear.n.01', 'synonyms': ['pear'], 'def': 'sweet juicy gritty-textured fruit available in many varieties', 'name': 'pear'}, {'frequency': 'r', 'id': 790, 'synset': 'peeler.n.03', 'synonyms': ['peeler_(tool_for_fruit_and_vegetables)'], 'def': 'a device for peeling vegetables or fruits', 'name': 'peeler_(tool_for_fruit_and_vegetables)'}, {'frequency': 'r', 'id': 791, 'synset': 'pegboard.n.01', 'synonyms': ['pegboard'], 'def': 'a board perforated with regularly spaced holes into which pegs can be fitted', 'name': 'pegboard'}, {'frequency': 'c', 'id': 792, 'synset': 'pelican.n.01', 'synonyms': ['pelican'], 'def': 'large long-winged warm-water seabird having a large bill with a distensible pouch for fish', 'name': 'pelican'}, {'frequency': 'f', 'id': 793, 'synset': 'pen.n.01', 'synonyms': ['pen'], 'def': 'a writing implement with a point from which ink flows', 'name': 'pen'}, {'frequency': 'c', 'id': 794, 'synset': 'pencil.n.01', 'synonyms': ['pencil'], 'def': 'a thin cylindrical pointed writing implement made of wood and graphite', 'name': 'pencil'}, {'frequency': 'r', 'id': 795, 'synset': 'pencil_box.n.01', 'synonyms': ['pencil_box', 'pencil_case'], 'def': 'a box for holding pencils', 'name': 'pencil_box'}, {'frequency': 'r', 'id': 796, 'synset': 'pencil_sharpener.n.01', 'synonyms': ['pencil_sharpener'], 'def': 'a rotary implement for sharpening the point on pencils', 'name': 'pencil_sharpener'}, {'frequency': 'r', 'id': 797, 'synset': 'pendulum.n.01', 'synonyms': ['pendulum'], 'def': 'an apparatus consisting of an object mounted so that it swings freely under the influence of gravity', 'name': 'pendulum'}, {'frequency': 'c', 'id': 798, 'synset': 'penguin.n.01', 'synonyms': ['penguin'], 'def': 'short-legged flightless birds of cold southern regions having webbed feet and wings modified as flippers', 'name': 'penguin'}, {'frequency': 'r', 'id': 799, 'synset': 'pennant.n.02', 'synonyms': ['pennant'], 'def': 'a flag longer than it is wide (and often tapering)', 'name': 'pennant'}, {'frequency': 'r', 'id': 800, 'synset': 'penny.n.02', 'synonyms': ['penny_(coin)'], 'def': 'a coin worth one-hundredth of the value of the basic unit', 'name': 'penny_(coin)'}, {'frequency': 'c', 'id': 801, 'synset': 'pepper.n.03', 'synonyms': ['pepper', 'peppercorn'], 'def': 'pungent seasoning from the berry of the common pepper plant; whole or ground', 'name': 'pepper'}, {'frequency': 'c', 'id': 802, 'synset': 'pepper_mill.n.01', 'synonyms': ['pepper_mill', 'pepper_grinder'], 'def': 'a mill for grinding pepper', 'name': 'pepper_mill'}, {'frequency': 'c', 'id': 803, 'synset': 'perfume.n.02', 'synonyms': ['perfume'], 'def': 'a toiletry that emits and diffuses a fragrant odor', 'name': 'perfume'}, {'frequency': 'r', 'id': 804, 'synset': 'persimmon.n.02', 'synonyms': ['persimmon'], 'def': 'orange fruit resembling a plum; edible when fully ripe', 'name': 'persimmon'}, {'frequency': 'f', 'id': 805, 'synset': 'person.n.01', 'synonyms': ['baby', 'child', 'boy', 'girl', 'man', 'woman', 'person', 'human'], 'def': 'a human being', 'name': 'baby'}, {'frequency': 'r', 'id': 806, 'synset': 'pet.n.01', 'synonyms': ['pet'], 'def': 'a domesticated animal kept for companionship or amusement', 'name': 'pet'}, {'frequency': 'r', 'id': 807, 'synset': 'petfood.n.01', 'synonyms': ['petfood', 'pet-food'], 'def': 'food prepared for animal pets', 'name': 'petfood'}, {'frequency': 'r', 'id': 808, 'synset': 'pew.n.01', 'synonyms': ['pew_(church_bench)', 'church_bench'], 'def': 'long bench with backs; used in church by the congregation', 'name': 'pew_(church_bench)'}, {'frequency': 'r', 'id': 809, 'synset': 'phonebook.n.01', 'synonyms': ['phonebook', 'telephone_book', 'telephone_directory'], 'def': 'a directory containing an alphabetical list of telephone subscribers and their telephone numbers', 'name': 'phonebook'}, {'frequency': 'c', 'id': 810, 'synset': 'phonograph_record.n.01', 'synonyms': ['phonograph_record', 'phonograph_recording', 'record_(phonograph_recording)'], 'def': 'sound recording consisting of a typically black disk with a continuous groove', 'name': 'phonograph_record'}, {'frequency': 'c', 'id': 811, 'synset': 'piano.n.01', 'synonyms': ['piano'], 'def': 'a keyboard instrument that is played by depressing keys that cause hammers to strike tuned strings and produce sounds', 'name': 'piano'}, {'frequency': 'f', 'id': 812, 'synset': 'pickle.n.01', 'synonyms': ['pickle'], 'def': 'vegetables (especially cucumbers) preserved in brine or vinegar', 'name': 'pickle'}, {'frequency': 'f', 'id': 813, 'synset': 'pickup.n.01', 'synonyms': ['pickup_truck'], 'def': 'a light truck with an open body and low sides and a tailboard', 'name': 'pickup_truck'}, {'frequency': 'c', 'id': 814, 'synset': 'pie.n.01', 'synonyms': ['pie'], 'def': 'dish baked in pastry-lined pan often with a pastry top', 'name': 'pie'}, {'frequency': 'c', 'id': 815, 'synset': 'pigeon.n.01', 'synonyms': ['pigeon'], 'def': 'wild and domesticated birds having a heavy body and short legs', 'name': 'pigeon'}, {'frequency': 'r', 'id': 816, 'synset': 'piggy_bank.n.01', 'synonyms': ['piggy_bank', 'penny_bank'], 'def': "a child's coin bank (often shaped like a pig)", 'name': 'piggy_bank'}, {'frequency': 'f', 'id': 817, 'synset': 'pillow.n.01', 'synonyms': ['pillow'], 'def': 'a cushion to support the head of a sleeping person', 'name': 'pillow'}, {'frequency': 'r', 'id': 818, 'synset': 'pin.n.09', 'synonyms': ['pin_(non_jewelry)'], 'def': 'a small slender (often pointed) piece of wood or metal used to support or fasten or attach things', 'name': 'pin_(non_jewelry)'}, {'frequency': 'f', 'id': 819, 'synset': 'pineapple.n.02', 'synonyms': ['pineapple'], 'def': 'large sweet fleshy tropical fruit with a tuft of stiff leaves', 'name': 'pineapple'}, {'frequency': 'c', 'id': 820, 'synset': 'pinecone.n.01', 'synonyms': ['pinecone'], 'def': 'the seed-producing cone of a pine tree', 'name': 'pinecone'}, {'frequency': 'r', 'id': 821, 'synset': 'ping-pong_ball.n.01', 'synonyms': ['ping-pong_ball'], 'def': 'light hollow ball used in playing table tennis', 'name': 'ping-pong_ball'}, {'frequency': 'r', 'id': 822, 'synset': 'pinwheel.n.03', 'synonyms': ['pinwheel'], 'def': 'a toy consisting of vanes of colored paper or plastic that is pinned to a stick and spins when it is pointed into the wind', 'name': 'pinwheel'}, {'frequency': 'r', 'id': 823, 'synset': 'pipe.n.01', 'synonyms': ['tobacco_pipe'], 'def': 'a tube with a small bowl at one end; used for smoking tobacco', 'name': 'tobacco_pipe'}, {'frequency': 'f', 'id': 824, 'synset': 'pipe.n.02', 'synonyms': ['pipe', 'piping'], 'def': 'a long tube made of metal or plastic that is used to carry water or oil or gas etc.', 'name': 'pipe'}, {'frequency': 'r', 'id': 825, 'synset': 'pistol.n.01', 'synonyms': ['pistol', 'handgun'], 'def': 'a firearm that is held and fired with one hand', 'name': 'pistol'}, {'frequency': 'r', 'id': 826, 'synset': 'pita.n.01', 'synonyms': ['pita_(bread)', 'pocket_bread'], 'def': 'usually small round bread that can open into a pocket for filling', 'name': 'pita_(bread)'}, {'frequency': 'f', 'id': 827, 'synset': 'pitcher.n.02', 'synonyms': ['pitcher_(vessel_for_liquid)', 'ewer'], 'def': 'an open vessel with a handle and a spout for pouring', 'name': 'pitcher_(vessel_for_liquid)'}, {'frequency': 'r', 'id': 828, 'synset': 'pitchfork.n.01', 'synonyms': ['pitchfork'], 'def': 'a long-handled hand tool with sharp widely spaced prongs for lifting and pitching hay', 'name': 'pitchfork'}, {'frequency': 'f', 'id': 829, 'synset': 'pizza.n.01', 'synonyms': ['pizza'], 'def': 'Italian open pie made of thin bread dough spread with a spiced mixture of e.g. tomato sauce and cheese', 'name': 'pizza'}, {'frequency': 'f', 'id': 830, 'synset': 'place_mat.n.01', 'synonyms': ['place_mat'], 'def': 'a mat placed on a table for an individual place setting', 'name': 'place_mat'}, {'frequency': 'f', 'id': 831, 'synset': 'plate.n.04', 'synonyms': ['plate'], 'def': 'dish on which food is served or from which food is eaten', 'name': 'plate'}, {'frequency': 'c', 'id': 832, 'synset': 'platter.n.01', 'synonyms': ['platter'], 'def': 'a large shallow dish used for serving food', 'name': 'platter'}, {'frequency': 'r', 'id': 833, 'synset': 'playing_card.n.01', 'synonyms': ['playing_card'], 'def': 'one of a pack of cards that are used to play card games', 'name': 'playing_card'}, {'frequency': 'r', 'id': 834, 'synset': 'playpen.n.01', 'synonyms': ['playpen'], 'def': 'a portable enclosure in which babies may be left to play', 'name': 'playpen'}, {'frequency': 'c', 'id': 835, 'synset': 'pliers.n.01', 'synonyms': ['pliers', 'plyers'], 'def': 'a gripping hand tool with two hinged arms and (usually) serrated jaws', 'name': 'pliers'}, {'frequency': 'r', 'id': 836, 'synset': 'plow.n.01', 'synonyms': ['plow_(farm_equipment)', 'plough_(farm_equipment)'], 'def': 'a farm tool having one or more heavy blades to break the soil and cut a furrow prior to sowing', 'name': 'plow_(farm_equipment)'}, {'frequency': 'r', 'id': 837, 'synset': 'pocket_watch.n.01', 'synonyms': ['pocket_watch'], 'def': 'a watch that is carried in a small watch pocket', 'name': 'pocket_watch'}, {'frequency': 'c', 'id': 838, 'synset': 'pocketknife.n.01', 'synonyms': ['pocketknife'], 'def': 'a knife with a blade that folds into the handle; suitable for carrying in the pocket', 'name': 'pocketknife'}, {'frequency': 'c', 'id': 839, 'synset': 'poker.n.01', 'synonyms': ['poker_(fire_stirring_tool)', 'stove_poker', 'fire_hook'], 'def': 'fire iron consisting of a metal rod with a handle; used to stir a fire', 'name': 'poker_(fire_stirring_tool)'}, {'frequency': 'f', 'id': 840, 'synset': 'pole.n.01', 'synonyms': ['pole', 'post'], 'def': 'a long (usually round) rod of wood or metal or plastic', 'name': 'pole'}, {'frequency': 'r', 'id': 841, 'synset': 'police_van.n.01', 'synonyms': ['police_van', 'police_wagon', 'paddy_wagon', 'patrol_wagon'], 'def': 'van used by police to transport prisoners', 'name': 'police_van'}, {'frequency': 'f', 'id': 842, 'synset': 'polo_shirt.n.01', 'synonyms': ['polo_shirt', 'sport_shirt'], 'def': 'a shirt with short sleeves designed for comfort and casual wear', 'name': 'polo_shirt'}, {'frequency': 'r', 'id': 843, 'synset': 'poncho.n.01', 'synonyms': ['poncho'], 'def': 'a blanket-like cloak with a hole in the center for the head', 'name': 'poncho'}, {'frequency': 'c', 'id': 844, 'synset': 'pony.n.05', 'synonyms': ['pony'], 'def': 'any of various breeds of small gentle horses usually less than five feet high at the shoulder', 'name': 'pony'}, {'frequency': 'r', 'id': 845, 'synset': 'pool_table.n.01', 'synonyms': ['pool_table', 'billiard_table', 'snooker_table'], 'def': 'game equipment consisting of a heavy table on which pool is played', 'name': 'pool_table'}, {'frequency': 'f', 'id': 846, 'synset': 'pop.n.02', 'synonyms': ['pop_(soda)', 'soda_(pop)', 'tonic', 'soft_drink'], 'def': 'a sweet drink containing carbonated water and flavoring', 'name': 'pop_(soda)'}, {'frequency': 'r', 'id': 847, 'synset': 'portrait.n.02', 'synonyms': ['portrait', 'portrayal'], 'def': 'any likeness of a person, in any medium', 'name': 'portrait'}, {'frequency': 'c', 'id': 848, 'synset': 'postbox.n.01', 'synonyms': ['postbox_(public)', 'mailbox_(public)'], 'def': 'public box for deposit of mail', 'name': 'postbox_(public)'}, {'frequency': 'c', 'id': 849, 'synset': 'postcard.n.01', 'synonyms': ['postcard', 'postal_card', 'mailing-card'], 'def': 'a card for sending messages by post without an envelope', 'name': 'postcard'}, {'frequency': 'f', 'id': 850, 'synset': 'poster.n.01', 'synonyms': ['poster', 'placard'], 'def': 'a sign posted in a public place as an advertisement', 'name': 'poster'}, {'frequency': 'f', 'id': 851, 'synset': 'pot.n.01', 'synonyms': ['pot'], 'def': 'metal or earthenware cooking vessel that is usually round and deep; often has a handle and lid', 'name': 'pot'}, {'frequency': 'f', 'id': 852, 'synset': 'pot.n.04', 'synonyms': ['flowerpot'], 'def': 'a container in which plants are cultivated', 'name': 'flowerpot'}, {'frequency': 'f', 'id': 853, 'synset': 'potato.n.01', 'synonyms': ['potato'], 'def': 'an edible tuber native to South America', 'name': 'potato'}, {'frequency': 'c', 'id': 854, 'synset': 'potholder.n.01', 'synonyms': ['potholder'], 'def': 'an insulated pad for holding hot pots', 'name': 'potholder'}, {'frequency': 'c', 'id': 855, 'synset': 'pottery.n.01', 'synonyms': ['pottery', 'clayware'], 'def': 'ceramic ware made from clay and baked in a kiln', 'name': 'pottery'}, {'frequency': 'c', 'id': 856, 'synset': 'pouch.n.01', 'synonyms': ['pouch'], 'def': 'a small or medium size container for holding or carrying things', 'name': 'pouch'}, {'frequency': 'r', 'id': 857, 'synset': 'power_shovel.n.01', 'synonyms': ['power_shovel', 'excavator', 'digger'], 'def': 'a machine for excavating', 'name': 'power_shovel'}, {'frequency': 'c', 'id': 858, 'synset': 'prawn.n.01', 'synonyms': ['prawn', 'shrimp'], 'def': 'any of various edible decapod crustaceans', 'name': 'prawn'}, {'frequency': 'f', 'id': 859, 'synset': 'printer.n.03', 'synonyms': ['printer', 'printing_machine'], 'def': 'a machine that prints', 'name': 'printer'}, {'frequency': 'c', 'id': 860, 'synset': 'projectile.n.01', 'synonyms': ['projectile_(weapon)', 'missile'], 'def': 'a weapon that is forcibly thrown or projected at a targets', 'name': 'projectile_(weapon)'}, {'frequency': 'c', 'id': 861, 'synset': 'projector.n.02', 'synonyms': ['projector'], 'def': 'an optical instrument that projects an enlarged image onto a screen', 'name': 'projector'}, {'frequency': 'f', 'id': 862, 'synset': 'propeller.n.01', 'synonyms': ['propeller', 'propellor'], 'def': 'a mechanical device that rotates to push against air or water', 'name': 'propeller'}, {'frequency': 'r', 'id': 863, 'synset': 'prune.n.01', 'synonyms': ['prune'], 'def': 'dried plum', 'name': 'prune'}, {'frequency': 'r', 'id': 864, 'synset': 'pudding.n.01', 'synonyms': ['pudding'], 'def': 'any of various soft thick unsweetened baked dishes', 'name': 'pudding'}, {'frequency': 'r', 'id': 865, 'synset': 'puffer.n.02', 'synonyms': ['puffer_(fish)', 'pufferfish', 'blowfish', 'globefish'], 'def': 'fishes whose elongated spiny body can inflate itself with water or air to form a globe', 'name': 'puffer_(fish)'}, {'frequency': 'r', 'id': 866, 'synset': 'puffin.n.01', 'synonyms': ['puffin'], 'def': 'seabirds having short necks and brightly colored compressed bills', 'name': 'puffin'}, {'frequency': 'r', 'id': 867, 'synset': 'pug.n.01', 'synonyms': ['pug-dog'], 'def': 'small compact smooth-coated breed of Asiatic origin having a tightly curled tail and broad flat wrinkled muzzle', 'name': 'pug-dog'}, {'frequency': 'c', 'id': 868, 'synset': 'pumpkin.n.02', 'synonyms': ['pumpkin'], 'def': 'usually large pulpy deep-yellow round fruit of the squash family maturing in late summer or early autumn', 'name': 'pumpkin'}, {'frequency': 'r', 'id': 869, 'synset': 'punch.n.03', 'synonyms': ['puncher'], 'def': 'a tool for making holes or indentations', 'name': 'puncher'}, {'frequency': 'r', 'id': 870, 'synset': 'puppet.n.01', 'synonyms': ['puppet', 'marionette'], 'def': 'a small figure of a person operated from above with strings by a puppeteer', 'name': 'puppet'}, {'frequency': 'r', 'id': 871, 'synset': 'puppy.n.01', 'synonyms': ['puppy'], 'def': 'a young dog', 'name': 'puppy'}, {'frequency': 'r', 'id': 872, 'synset': 'quesadilla.n.01', 'synonyms': ['quesadilla'], 'def': 'a tortilla that is filled with cheese and heated', 'name': 'quesadilla'}, {'frequency': 'r', 'id': 873, 'synset': 'quiche.n.02', 'synonyms': ['quiche'], 'def': 'a tart filled with rich unsweetened custard; often contains other ingredients (as cheese or ham or seafood or vegetables)', 'name': 'quiche'}, {'frequency': 'f', 'id': 874, 'synset': 'quilt.n.01', 'synonyms': ['quilt', 'comforter'], 'def': 'bedding made of two layers of cloth filled with stuffing and stitched together', 'name': 'quilt'}, {'frequency': 'c', 'id': 875, 'synset': 'rabbit.n.01', 'synonyms': ['rabbit'], 'def': 'any of various burrowing animals of the family Leporidae having long ears and short tails', 'name': 'rabbit'}, {'frequency': 'r', 'id': 876, 'synset': 'racer.n.02', 'synonyms': ['race_car', 'racing_car'], 'def': 'a fast car that competes in races', 'name': 'race_car'}, {'frequency': 'c', 'id': 877, 'synset': 'racket.n.04', 'synonyms': ['racket', 'racquet'], 'def': 'a sports implement used to strike a ball in various games', 'name': 'racket'}, {'frequency': 'r', 'id': 878, 'synset': 'radar.n.01', 'synonyms': ['radar'], 'def': 'measuring instrument in which the echo of a pulse of microwave radiation is used to detect and locate distant objects', 'name': 'radar'}, {'frequency': 'c', 'id': 879, 'synset': 'radiator.n.03', 'synonyms': ['radiator'], 'def': 'a mechanism consisting of a metal honeycomb through which hot fluids circulate', 'name': 'radiator'}, {'frequency': 'c', 'id': 880, 'synset': 'radio_receiver.n.01', 'synonyms': ['radio_receiver', 'radio_set', 'radio', 'tuner_(radio)'], 'def': 'an electronic receiver that detects and demodulates and amplifies transmitted radio signals', 'name': 'radio_receiver'}, {'frequency': 'c', 'id': 881, 'synset': 'radish.n.03', 'synonyms': ['radish', 'daikon'], 'def': 'pungent edible root of any of various cultivated radish plants', 'name': 'radish'}, {'frequency': 'c', 'id': 882, 'synset': 'raft.n.01', 'synonyms': ['raft'], 'def': 'a flat float (usually made of logs or planks) that can be used for transport or as a platform for swimmers', 'name': 'raft'}, {'frequency': 'r', 'id': 883, 'synset': 'rag_doll.n.01', 'synonyms': ['rag_doll'], 'def': 'a cloth doll that is stuffed and (usually) painted', 'name': 'rag_doll'}, {'frequency': 'c', 'id': 884, 'synset': 'raincoat.n.01', 'synonyms': ['raincoat', 'waterproof_jacket'], 'def': 'a water-resistant coat', 'name': 'raincoat'}, {'frequency': 'c', 'id': 885, 'synset': 'ram.n.05', 'synonyms': ['ram_(animal)'], 'def': 'uncastrated adult male sheep', 'name': 'ram_(animal)'}, {'frequency': 'c', 'id': 886, 'synset': 'raspberry.n.02', 'synonyms': ['raspberry'], 'def': 'red or black edible aggregate berries usually smaller than the related blackberries', 'name': 'raspberry'}, {'frequency': 'r', 'id': 887, 'synset': 'rat.n.01', 'synonyms': ['rat'], 'def': 'any of various long-tailed rodents similar to but larger than a mouse', 'name': 'rat'}, {'frequency': 'c', 'id': 888, 'synset': 'razorblade.n.01', 'synonyms': ['razorblade'], 'def': 'a blade that has very sharp edge', 'name': 'razorblade'}, {'frequency': 'c', 'id': 889, 'synset': 'reamer.n.01', 'synonyms': ['reamer_(juicer)', 'juicer', 'juice_reamer'], 'def': 'a squeezer with a conical ridged center that is used for squeezing juice from citrus fruit', 'name': 'reamer_(juicer)'}, {'frequency': 'f', 'id': 890, 'synset': 'rearview_mirror.n.01', 'synonyms': ['rearview_mirror'], 'def': 'car mirror that reflects the view out of the rear window', 'name': 'rearview_mirror'}, {'frequency': 'c', 'id': 891, 'synset': 'receipt.n.02', 'synonyms': ['receipt'], 'def': 'an acknowledgment (usually tangible) that payment has been made', 'name': 'receipt'}, {'frequency': 'c', 'id': 892, 'synset': 'recliner.n.01', 'synonyms': ['recliner', 'reclining_chair', 'lounger_(chair)'], 'def': 'an armchair whose back can be lowered and foot can be raised to allow the sitter to recline in it', 'name': 'recliner'}, {'frequency': 'r', 'id': 893, 'synset': 'record_player.n.01', 'synonyms': ['record_player', 'phonograph_(record_player)', 'turntable'], 'def': 'machine in which rotating records cause a stylus to vibrate and the vibrations are amplified acoustically or electronically', 'name': 'record_player'}, {'frequency': 'r', 'id': 894, 'synset': 'red_cabbage.n.02', 'synonyms': ['red_cabbage'], 'def': 'compact head of purplish-red leaves', 'name': 'red_cabbage'}, {'frequency': 'f', 'id': 895, 'synset': 'reflector.n.01', 'synonyms': ['reflector'], 'def': 'device that reflects light, radiation, etc.', 'name': 'reflector'}, {'frequency': 'f', 'id': 896, 'synset': 'remote_control.n.01', 'synonyms': ['remote_control'], 'def': 'a device that can be used to control a machine or apparatus from a distance', 'name': 'remote_control'}, {'frequency': 'c', 'id': 897, 'synset': 'rhinoceros.n.01', 'synonyms': ['rhinoceros'], 'def': 'massive powerful herbivorous odd-toed ungulate of southeast Asia and Africa having very thick skin and one or two horns on the snout', 'name': 'rhinoceros'}, {'frequency': 'r', 'id': 898, 'synset': 'rib.n.03', 'synonyms': ['rib_(food)'], 'def': 'cut of meat including one or more ribs', 'name': 'rib_(food)'}, {'frequency': 'r', 'id': 899, 'synset': 'rifle.n.01', 'synonyms': ['rifle'], 'def': 'a shoulder firearm with a long barrel', 'name': 'rifle'}, {'frequency': 'f', 'id': 900, 'synset': 'ring.n.08', 'synonyms': ['ring'], 'def': 'jewelry consisting of a circlet of precious metal (often set with jewels) worn on the finger', 'name': 'ring'}, {'frequency': 'r', 'id': 901, 'synset': 'river_boat.n.01', 'synonyms': ['river_boat'], 'def': 'a boat used on rivers or to ply a river', 'name': 'river_boat'}, {'frequency': 'r', 'id': 902, 'synset': 'road_map.n.02', 'synonyms': ['road_map'], 'def': '(NOT A ROAD) a MAP showing roads (for automobile travel)', 'name': 'road_map'}, {'frequency': 'c', 'id': 903, 'synset': 'robe.n.01', 'synonyms': ['robe'], 'def': 'any loose flowing garment', 'name': 'robe'}, {'frequency': 'c', 'id': 904, 'synset': 'rocking_chair.n.01', 'synonyms': ['rocking_chair'], 'def': 'a chair mounted on rockers', 'name': 'rocking_chair'}, {'frequency': 'r', 'id': 905, 'synset': 'roller_skate.n.01', 'synonyms': ['roller_skate'], 'def': 'a shoe with pairs of rollers (small hard wheels) fixed to the sole', 'name': 'roller_skate'}, {'frequency': 'r', 'id': 906, 'synset': 'rollerblade.n.01', 'synonyms': ['Rollerblade'], 'def': 'an in-line variant of a roller skate', 'name': 'Rollerblade'}, {'frequency': 'c', 'id': 907, 'synset': 'rolling_pin.n.01', 'synonyms': ['rolling_pin'], 'def': 'utensil consisting of a cylinder (usually of wood) with a handle at each end; used to roll out dough', 'name': 'rolling_pin'}, {'frequency': 'r', 'id': 908, 'synset': 'root_beer.n.01', 'synonyms': ['root_beer'], 'def': 'carbonated drink containing extracts of roots and herbs', 'name': 'root_beer'}, {'frequency': 'c', 'id': 909, 'synset': 'router.n.02', 'synonyms': ['router_(computer_equipment)'], 'def': 'a device that forwards data packets between computer networks', 'name': 'router_(computer_equipment)'}, {'frequency': 'f', 'id': 910, 'synset': 'rubber_band.n.01', 'synonyms': ['rubber_band', 'elastic_band'], 'def': 'a narrow band of elastic rubber used to hold things (such as papers) together', 'name': 'rubber_band'}, {'frequency': 'c', 'id': 911, 'synset': 'runner.n.08', 'synonyms': ['runner_(carpet)'], 'def': 'a long narrow carpet', 'name': 'runner_(carpet)'}, {'frequency': 'f', 'id': 912, 'synset': 'sack.n.01', 'synonyms': ['plastic_bag', 'paper_bag'], 'def': "a bag made of paper or plastic for holding customer's purchases", 'name': 'plastic_bag'}, {'frequency': 'f', 'id': 913, 'synset': 'saddle.n.01', 'synonyms': ['saddle_(on_an_animal)'], 'def': 'a seat for the rider of a horse or camel', 'name': 'saddle_(on_an_animal)'}, {'frequency': 'f', 'id': 914, 'synset': 'saddle_blanket.n.01', 'synonyms': ['saddle_blanket', 'saddlecloth', 'horse_blanket'], 'def': 'stable gear consisting of a blanket placed under the saddle', 'name': 'saddle_blanket'}, {'frequency': 'c', 'id': 915, 'synset': 'saddlebag.n.01', 'synonyms': ['saddlebag'], 'def': 'a large bag (or pair of bags) hung over a saddle', 'name': 'saddlebag'}, {'frequency': 'r', 'id': 916, 'synset': 'safety_pin.n.01', 'synonyms': ['safety_pin'], 'def': 'a pin in the form of a clasp; has a guard so the point of the pin will not stick the user', 'name': 'safety_pin'}, {'frequency': 'c', 'id': 917, 'synset': 'sail.n.01', 'synonyms': ['sail'], 'def': 'a large piece of fabric by means of which wind is used to propel a sailing vessel', 'name': 'sail'}, {'frequency': 'c', 'id': 918, 'synset': 'salad.n.01', 'synonyms': ['salad'], 'def': 'food mixtures either arranged on a plate or tossed and served with a moist dressing; usually consisting of or including greens', 'name': 'salad'}, {'frequency': 'r', 'id': 919, 'synset': 'salad_plate.n.01', 'synonyms': ['salad_plate', 'salad_bowl'], 'def': 'a plate or bowl for individual servings of salad', 'name': 'salad_plate'}, {'frequency': 'r', 'id': 920, 'synset': 'salami.n.01', 'synonyms': ['salami'], 'def': 'highly seasoned fatty sausage of pork and beef usually dried', 'name': 'salami'}, {'frequency': 'r', 'id': 921, 'synset': 'salmon.n.01', 'synonyms': ['salmon_(fish)'], 'def': 'any of various large food and game fishes of northern waters', 'name': 'salmon_(fish)'}, {'frequency': 'r', 'id': 922, 'synset': 'salmon.n.03', 'synonyms': ['salmon_(food)'], 'def': 'flesh of any of various marine or freshwater fish of the family Salmonidae', 'name': 'salmon_(food)'}, {'frequency': 'r', 'id': 923, 'synset': 'salsa.n.01', 'synonyms': ['salsa'], 'def': 'spicy sauce of tomatoes and onions and chili peppers to accompany Mexican foods', 'name': 'salsa'}, {'frequency': 'f', 'id': 924, 'synset': 'saltshaker.n.01', 'synonyms': ['saltshaker'], 'def': 'a shaker with a perforated top for sprinkling salt', 'name': 'saltshaker'}, {'frequency': 'f', 'id': 925, 'synset': 'sandal.n.01', 'synonyms': ['sandal_(type_of_shoe)'], 'def': 'a shoe consisting of a sole fastened by straps to the foot', 'name': 'sandal_(type_of_shoe)'}, {'frequency': 'f', 'id': 926, 'synset': 'sandwich.n.01', 'synonyms': ['sandwich'], 'def': 'two (or more) slices of bread with a filling between them', 'name': 'sandwich'}, {'frequency': 'r', 'id': 927, 'synset': 'satchel.n.01', 'synonyms': ['satchel'], 'def': 'luggage consisting of a small case with a flat bottom and (usually) a shoulder strap', 'name': 'satchel'}, {'frequency': 'r', 'id': 928, 'synset': 'saucepan.n.01', 'synonyms': ['saucepan'], 'def': 'a deep pan with a handle; used for stewing or boiling', 'name': 'saucepan'}, {'frequency': 'f', 'id': 929, 'synset': 'saucer.n.02', 'synonyms': ['saucer'], 'def': 'a small shallow dish for holding a cup at the table', 'name': 'saucer'}, {'frequency': 'f', 'id': 930, 'synset': 'sausage.n.01', 'synonyms': ['sausage'], 'def': 'highly seasoned minced meat stuffed in casings', 'name': 'sausage'}, {'frequency': 'r', 'id': 931, 'synset': 'sawhorse.n.01', 'synonyms': ['sawhorse', 'sawbuck'], 'def': 'a framework for holding wood that is being sawed', 'name': 'sawhorse'}, {'frequency': 'r', 'id': 932, 'synset': 'sax.n.02', 'synonyms': ['saxophone'], 'def': "a wind instrument with a `J'-shaped form typically made of brass", 'name': 'saxophone'}, {'frequency': 'f', 'id': 933, 'synset': 'scale.n.07', 'synonyms': ['scale_(measuring_instrument)'], 'def': 'a measuring instrument for weighing; shows amount of mass', 'name': 'scale_(measuring_instrument)'}, {'frequency': 'r', 'id': 934, 'synset': 'scarecrow.n.01', 'synonyms': ['scarecrow', 'strawman'], 'def': 'an effigy in the shape of a man to frighten birds away from seeds', 'name': 'scarecrow'}, {'frequency': 'f', 'id': 935, 'synset': 'scarf.n.01', 'synonyms': ['scarf'], 'def': 'a garment worn around the head or neck or shoulders for warmth or decoration', 'name': 'scarf'}, {'frequency': 'c', 'id': 936, 'synset': 'school_bus.n.01', 'synonyms': ['school_bus'], 'def': 'a bus used to transport children to or from school', 'name': 'school_bus'}, {'frequency': 'f', 'id': 937, 'synset': 'scissors.n.01', 'synonyms': ['scissors'], 'def': 'a tool having two crossed pivoting blades with looped handles', 'name': 'scissors'}, {'frequency': 'c', 'id': 938, 'synset': 'scoreboard.n.01', 'synonyms': ['scoreboard'], 'def': 'a large board for displaying the score of a contest (and some other information)', 'name': 'scoreboard'}, {'frequency': 'c', 'id': 939, 'synset': 'scrambled_eggs.n.01', 'synonyms': ['scrambled_eggs'], 'def': 'eggs beaten and cooked to a soft firm consistency while stirring', 'name': 'scrambled_eggs'}, {'frequency': 'r', 'id': 940, 'synset': 'scraper.n.01', 'synonyms': ['scraper'], 'def': 'any of various hand tools for scraping', 'name': 'scraper'}, {'frequency': 'r', 'id': 941, 'synset': 'scratcher.n.03', 'synonyms': ['scratcher'], 'def': 'a device used for scratching', 'name': 'scratcher'}, {'frequency': 'c', 'id': 942, 'synset': 'screwdriver.n.01', 'synonyms': ['screwdriver'], 'def': 'a hand tool for driving screws; has a tip that fits into the head of a screw', 'name': 'screwdriver'}, {'frequency': 'c', 'id': 943, 'synset': 'scrub_brush.n.01', 'synonyms': ['scrubbing_brush'], 'def': 'a brush with short stiff bristles for heavy cleaning', 'name': 'scrubbing_brush'}, {'frequency': 'c', 'id': 944, 'synset': 'sculpture.n.01', 'synonyms': ['sculpture'], 'def': 'a three-dimensional work of art', 'name': 'sculpture'}, {'frequency': 'r', 'id': 945, 'synset': 'seabird.n.01', 'synonyms': ['seabird', 'seafowl'], 'def': 'a bird that frequents coastal waters and the open ocean: gulls; pelicans; gannets; cormorants; albatrosses; petrels; etc.', 'name': 'seabird'}, {'frequency': 'r', 'id': 946, 'synset': 'seahorse.n.02', 'synonyms': ['seahorse'], 'def': 'small fish with horse-like heads bent sharply downward and curled tails', 'name': 'seahorse'}, {'frequency': 'r', 'id': 947, 'synset': 'seaplane.n.01', 'synonyms': ['seaplane', 'hydroplane'], 'def': 'an airplane that can land on or take off from water', 'name': 'seaplane'}, {'frequency': 'c', 'id': 948, 'synset': 'seashell.n.01', 'synonyms': ['seashell'], 'def': 'the shell of a marine organism', 'name': 'seashell'}, {'frequency': 'r', 'id': 949, 'synset': 'seedling.n.01', 'synonyms': ['seedling'], 'def': 'young plant or tree grown from a seed', 'name': 'seedling'}, {'frequency': 'c', 'id': 950, 'synset': 'serving_dish.n.01', 'synonyms': ['serving_dish'], 'def': 'a dish used for serving food', 'name': 'serving_dish'}, {'frequency': 'r', 'id': 951, 'synset': 'sewing_machine.n.01', 'synonyms': ['sewing_machine'], 'def': 'a textile machine used as a home appliance for sewing', 'name': 'sewing_machine'}, {'frequency': 'r', 'id': 952, 'synset': 'shaker.n.03', 'synonyms': ['shaker'], 'def': 'a container in which something can be shaken', 'name': 'shaker'}, {'frequency': 'c', 'id': 953, 'synset': 'shampoo.n.01', 'synonyms': ['shampoo'], 'def': 'cleansing agent consisting of soaps or detergents used for washing the hair', 'name': 'shampoo'}, {'frequency': 'r', 'id': 954, 'synset': 'shark.n.01', 'synonyms': ['shark'], 'def': 'typically large carnivorous fishes with sharpe teeth', 'name': 'shark'}, {'frequency': 'r', 'id': 955, 'synset': 'sharpener.n.01', 'synonyms': ['sharpener'], 'def': 'any implement that is used to make something (an edge or a point) sharper', 'name': 'sharpener'}, {'frequency': 'r', 'id': 956, 'synset': 'sharpie.n.03', 'synonyms': ['Sharpie'], 'def': 'a pen with indelible ink that will write on any surface', 'name': 'Sharpie'}, {'frequency': 'r', 'id': 957, 'synset': 'shaver.n.03', 'synonyms': ['shaver_(electric)', 'electric_shaver', 'electric_razor'], 'def': 'a razor powered by an electric motor', 'name': 'shaver_(electric)'}, {'frequency': 'c', 'id': 958, 'synset': 'shaving_cream.n.01', 'synonyms': ['shaving_cream', 'shaving_soap'], 'def': 'toiletry consisting that forms a rich lather for softening the beard before shaving', 'name': 'shaving_cream'}, {'frequency': 'r', 'id': 959, 'synset': 'shawl.n.01', 'synonyms': ['shawl'], 'def': 'cloak consisting of an oblong piece of cloth used to cover the head and shoulders', 'name': 'shawl'}, {'frequency': 'r', 'id': 960, 'synset': 'shears.n.01', 'synonyms': ['shears'], 'def': 'large scissors with strong blades', 'name': 'shears'}, {'frequency': 'f', 'id': 961, 'synset': 'sheep.n.01', 'synonyms': ['sheep'], 'def': 'woolly usually horned ruminant mammal related to the goat', 'name': 'sheep'}, {'frequency': 'r', 'id': 962, 'synset': 'shepherd_dog.n.01', 'synonyms': ['shepherd_dog', 'sheepdog'], 'def': 'any of various usually long-haired breeds of dog reared to herd and guard sheep', 'name': 'shepherd_dog'}, {'frequency': 'r', 'id': 963, 'synset': 'sherbert.n.01', 'synonyms': ['sherbert', 'sherbet'], 'def': 'a frozen dessert made primarily of fruit juice and sugar', 'name': 'sherbert'}, {'frequency': 'r', 'id': 964, 'synset': 'shield.n.02', 'synonyms': ['shield'], 'def': 'armor carried on the arm to intercept blows', 'name': 'shield'}, {'frequency': 'f', 'id': 965, 'synset': 'shirt.n.01', 'synonyms': ['shirt'], 'def': 'a garment worn on the upper half of the body', 'name': 'shirt'}, {'frequency': 'f', 'id': 966, 'synset': 'shoe.n.01', 'synonyms': ['shoe', 'sneaker_(type_of_shoe)', 'tennis_shoe'], 'def': 'common footwear covering the foot', 'name': 'shoe'}, {'frequency': 'c', 'id': 967, 'synset': 'shopping_bag.n.01', 'synonyms': ['shopping_bag'], 'def': 'a bag made of plastic or strong paper (often with handles); used to transport goods after shopping', 'name': 'shopping_bag'}, {'frequency': 'c', 'id': 968, 'synset': 'shopping_cart.n.01', 'synonyms': ['shopping_cart'], 'def': 'a handcart that holds groceries or other goods while shopping', 'name': 'shopping_cart'}, {'frequency': 'f', 'id': 969, 'synset': 'short_pants.n.01', 'synonyms': ['short_pants', 'shorts_(clothing)', 'trunks_(clothing)'], 'def': 'trousers that end at or above the knee', 'name': 'short_pants'}, {'frequency': 'r', 'id': 970, 'synset': 'shot_glass.n.01', 'synonyms': ['shot_glass'], 'def': 'a small glass adequate to hold a single swallow of whiskey', 'name': 'shot_glass'}, {'frequency': 'c', 'id': 971, 'synset': 'shoulder_bag.n.01', 'synonyms': ['shoulder_bag'], 'def': 'a large handbag that can be carried by a strap looped over the shoulder', 'name': 'shoulder_bag'}, {'frequency': 'c', 'id': 972, 'synset': 'shovel.n.01', 'synonyms': ['shovel'], 'def': 'a hand tool for lifting loose material such as snow, dirt, etc.', 'name': 'shovel'}, {'frequency': 'f', 'id': 973, 'synset': 'shower.n.01', 'synonyms': ['shower_head'], 'def': 'a plumbing fixture that sprays water over you', 'name': 'shower_head'}, {'frequency': 'f', 'id': 974, 'synset': 'shower_curtain.n.01', 'synonyms': ['shower_curtain'], 'def': 'a curtain that keeps water from splashing out of the shower area', 'name': 'shower_curtain'}, {'frequency': 'r', 'id': 975, 'synset': 'shredder.n.01', 'synonyms': ['shredder_(for_paper)'], 'def': 'a device that shreds documents', 'name': 'shredder_(for_paper)'}, {'frequency': 'r', 'id': 976, 'synset': 'sieve.n.01', 'synonyms': ['sieve', 'screen_(sieve)'], 'def': 'a strainer for separating lumps from powdered material or grading particles', 'name': 'sieve'}, {'frequency': 'f', 'id': 977, 'synset': 'signboard.n.01', 'synonyms': ['signboard'], 'def': 'structure displaying a board on which advertisements can be posted', 'name': 'signboard'}, {'frequency': 'c', 'id': 978, 'synset': 'silo.n.01', 'synonyms': ['silo'], 'def': 'a cylindrical tower used for storing goods', 'name': 'silo'}, {'frequency': 'f', 'id': 979, 'synset': 'sink.n.01', 'synonyms': ['sink'], 'def': 'plumbing fixture consisting of a water basin fixed to a wall or floor and having a drainpipe', 'name': 'sink'}, {'frequency': 'f', 'id': 980, 'synset': 'skateboard.n.01', 'synonyms': ['skateboard'], 'def': 'a board with wheels that is ridden in a standing or crouching position and propelled by foot', 'name': 'skateboard'}, {'frequency': 'c', 'id': 981, 'synset': 'skewer.n.01', 'synonyms': ['skewer'], 'def': 'a long pin for holding meat in position while it is being roasted', 'name': 'skewer'}, {'frequency': 'f', 'id': 982, 'synset': 'ski.n.01', 'synonyms': ['ski'], 'def': 'sports equipment for skiing on snow', 'name': 'ski'}, {'frequency': 'f', 'id': 983, 'synset': 'ski_boot.n.01', 'synonyms': ['ski_boot'], 'def': 'a stiff boot that is fastened to a ski with a ski binding', 'name': 'ski_boot'}, {'frequency': 'f', 'id': 984, 'synset': 'ski_parka.n.01', 'synonyms': ['ski_parka', 'ski_jacket'], 'def': 'a parka to be worn while skiing', 'name': 'ski_parka'}, {'frequency': 'f', 'id': 985, 'synset': 'ski_pole.n.01', 'synonyms': ['ski_pole'], 'def': 'a pole with metal points used as an aid in skiing', 'name': 'ski_pole'}, {'frequency': 'f', 'id': 986, 'synset': 'skirt.n.02', 'synonyms': ['skirt'], 'def': 'a garment hanging from the waist; worn mainly by girls and women', 'name': 'skirt'}, {'frequency': 'c', 'id': 987, 'synset': 'sled.n.01', 'synonyms': ['sled', 'sledge', 'sleigh'], 'def': 'a vehicle or flat object for transportation over snow by sliding or pulled by dogs, etc.', 'name': 'sled'}, {'frequency': 'c', 'id': 988, 'synset': 'sleeping_bag.n.01', 'synonyms': ['sleeping_bag'], 'def': 'large padded bag designed to be slept in outdoors', 'name': 'sleeping_bag'}, {'frequency': 'r', 'id': 989, 'synset': 'sling.n.05', 'synonyms': ['sling_(bandage)', 'triangular_bandage'], 'def': 'bandage to support an injured forearm; slung over the shoulder or neck', 'name': 'sling_(bandage)'}, {'frequency': 'c', 'id': 990, 'synset': 'slipper.n.01', 'synonyms': ['slipper_(footwear)', 'carpet_slipper_(footwear)'], 'def': 'low footwear that can be slipped on and off easily; usually worn indoors', 'name': 'slipper_(footwear)'}, {'frequency': 'r', 'id': 991, 'synset': 'smoothie.n.02', 'synonyms': ['smoothie'], 'def': 'a thick smooth drink consisting of fresh fruit pureed with ice cream or yoghurt or milk', 'name': 'smoothie'}, {'frequency': 'r', 'id': 992, 'synset': 'snake.n.01', 'synonyms': ['snake', 'serpent'], 'def': 'limbless scaly elongate reptile; some are venomous', 'name': 'snake'}, {'frequency': 'f', 'id': 993, 'synset': 'snowboard.n.01', 'synonyms': ['snowboard'], 'def': 'a board that resembles a broad ski or a small surfboard; used in a standing position to slide down snow-covered slopes', 'name': 'snowboard'}, {'frequency': 'c', 'id': 994, 'synset': 'snowman.n.01', 'synonyms': ['snowman'], 'def': 'a figure of a person made of packed snow', 'name': 'snowman'}, {'frequency': 'c', 'id': 995, 'synset': 'snowmobile.n.01', 'synonyms': ['snowmobile'], 'def': 'tracked vehicle for travel on snow having skis in front', 'name': 'snowmobile'}, {'frequency': 'f', 'id': 996, 'synset': 'soap.n.01', 'synonyms': ['soap'], 'def': 'a cleansing agent made from the salts of vegetable or animal fats', 'name': 'soap'}, {'frequency': 'f', 'id': 997, 'synset': 'soccer_ball.n.01', 'synonyms': ['soccer_ball'], 'def': "an inflated ball used in playing soccer (called `football' outside of the United States)", 'name': 'soccer_ball'}, {'frequency': 'f', 'id': 998, 'synset': 'sock.n.01', 'synonyms': ['sock'], 'def': 'cloth covering for the foot; worn inside the shoe; reaches to between the ankle and the knee', 'name': 'sock'}, {'frequency': 'r', 'id': 999, 'synset': 'soda_fountain.n.02', 'synonyms': ['soda_fountain'], 'def': 'an apparatus for dispensing soda water', 'name': 'soda_fountain'}, {'frequency': 'r', 'id': 1000, 'synset': 'soda_water.n.01', 'synonyms': ['carbonated_water', 'club_soda', 'seltzer', 'sparkling_water'], 'def': 'effervescent beverage artificially charged with carbon dioxide', 'name': 'carbonated_water'}, {'frequency': 'f', 'id': 1001, 'synset': 'sofa.n.01', 'synonyms': ['sofa', 'couch', 'lounge'], 'def': 'an upholstered seat for more than one person', 'name': 'sofa'}, {'frequency': 'r', 'id': 1002, 'synset': 'softball.n.01', 'synonyms': ['softball'], 'def': 'ball used in playing softball', 'name': 'softball'}, {'frequency': 'c', 'id': 1003, 'synset': 'solar_array.n.01', 'synonyms': ['solar_array', 'solar_battery', 'solar_panel'], 'def': 'electrical device consisting of a large array of connected solar cells', 'name': 'solar_array'}, {'frequency': 'r', 'id': 1004, 'synset': 'sombrero.n.02', 'synonyms': ['sombrero'], 'def': 'a straw hat with a tall crown and broad brim; worn in American southwest and in Mexico', 'name': 'sombrero'}, {'frequency': 'c', 'id': 1005, 'synset': 'soup.n.01', 'synonyms': ['soup'], 'def': 'liquid food especially of meat or fish or vegetable stock often containing pieces of solid food', 'name': 'soup'}, {'frequency': 'r', 'id': 1006, 'synset': 'soup_bowl.n.01', 'synonyms': ['soup_bowl'], 'def': 'a bowl for serving soup', 'name': 'soup_bowl'}, {'frequency': 'c', 'id': 1007, 'synset': 'soupspoon.n.01', 'synonyms': ['soupspoon'], 'def': 'a spoon with a rounded bowl for eating soup', 'name': 'soupspoon'}, {'frequency': 'c', 'id': 1008, 'synset': 'sour_cream.n.01', 'synonyms': ['sour_cream', 'soured_cream'], 'def': 'soured light cream', 'name': 'sour_cream'}, {'frequency': 'r', 'id': 1009, 'synset': 'soya_milk.n.01', 'synonyms': ['soya_milk', 'soybean_milk', 'soymilk'], 'def': 'a milk substitute containing soybean flour and water; used in some infant formulas and in making tofu', 'name': 'soya_milk'}, {'frequency': 'r', 'id': 1010, 'synset': 'space_shuttle.n.01', 'synonyms': ['space_shuttle'], 'def': "a reusable spacecraft with wings for a controlled descent through the Earth's atmosphere", 'name': 'space_shuttle'}, {'frequency': 'r', 'id': 1011, 'synset': 'sparkler.n.02', 'synonyms': ['sparkler_(fireworks)'], 'def': 'a firework that burns slowly and throws out a shower of sparks', 'name': 'sparkler_(fireworks)'}, {'frequency': 'f', 'id': 1012, 'synset': 'spatula.n.02', 'synonyms': ['spatula'], 'def': 'a hand tool with a thin flexible blade used to mix or spread soft substances', 'name': 'spatula'}, {'frequency': 'r', 'id': 1013, 'synset': 'spear.n.01', 'synonyms': ['spear', 'lance'], 'def': 'a long pointed rod used as a tool or weapon', 'name': 'spear'}, {'frequency': 'f', 'id': 1014, 'synset': 'spectacles.n.01', 'synonyms': ['spectacles', 'specs', 'eyeglasses', 'glasses'], 'def': 'optical instrument consisting of a frame that holds a pair of lenses for correcting defective vision', 'name': 'spectacles'}, {'frequency': 'c', 'id': 1015, 'synset': 'spice_rack.n.01', 'synonyms': ['spice_rack'], 'def': 'a rack for displaying containers filled with spices', 'name': 'spice_rack'}, {'frequency': 'r', 'id': 1016, 'synset': 'spider.n.01', 'synonyms': ['spider'], 'def': 'predatory arachnid with eight legs, two poison fangs, two feelers, and usually two silk-spinning organs at the back end of the body', 'name': 'spider'}, {'frequency': 'c', 'id': 1017, 'synset': 'sponge.n.01', 'synonyms': ['sponge'], 'def': 'a porous mass usable to absorb water typically used for cleaning', 'name': 'sponge'}, {'frequency': 'f', 'id': 1018, 'synset': 'spoon.n.01', 'synonyms': ['spoon'], 'def': 'a piece of cutlery with a shallow bowl-shaped container and a handle', 'name': 'spoon'}, {'frequency': 'c', 'id': 1019, 'synset': 'sportswear.n.01', 'synonyms': ['sportswear', 'athletic_wear', 'activewear'], 'def': 'attire worn for sport or for casual wear', 'name': 'sportswear'}, {'frequency': 'c', 'id': 1020, 'synset': 'spotlight.n.02', 'synonyms': ['spotlight'], 'def': 'a lamp that produces a strong beam of light to illuminate a restricted area; used to focus attention of a stage performer', 'name': 'spotlight'}, {'frequency': 'r', 'id': 1021, 'synset': 'squirrel.n.01', 'synonyms': ['squirrel'], 'def': 'a kind of arboreal rodent having a long bushy tail', 'name': 'squirrel'}, {'frequency': 'c', 'id': 1022, 'synset': 'stapler.n.01', 'synonyms': ['stapler_(stapling_machine)'], 'def': 'a machine that inserts staples into sheets of paper in order to fasten them together', 'name': 'stapler_(stapling_machine)'}, {'frequency': 'r', 'id': 1023, 'synset': 'starfish.n.01', 'synonyms': ['starfish', 'sea_star'], 'def': 'echinoderms characterized by five arms extending from a central disk', 'name': 'starfish'}, {'frequency': 'f', 'id': 1024, 'synset': 'statue.n.01', 'synonyms': ['statue_(sculpture)'], 'def': 'a sculpture representing a human or animal', 'name': 'statue_(sculpture)'}, {'frequency': 'c', 'id': 1025, 'synset': 'steak.n.01', 'synonyms': ['steak_(food)'], 'def': 'a slice of meat cut from the fleshy part of an animal or large fish', 'name': 'steak_(food)'}, {'frequency': 'r', 'id': 1026, 'synset': 'steak_knife.n.01', 'synonyms': ['steak_knife'], 'def': 'a sharp table knife used in eating steak', 'name': 'steak_knife'}, {'frequency': 'r', 'id': 1027, 'synset': 'steamer.n.02', 'synonyms': ['steamer_(kitchen_appliance)'], 'def': 'a cooking utensil that can be used to cook food by steaming it', 'name': 'steamer_(kitchen_appliance)'}, {'frequency': 'f', 'id': 1028, 'synset': 'steering_wheel.n.01', 'synonyms': ['steering_wheel'], 'def': 'a handwheel that is used for steering', 'name': 'steering_wheel'}, {'frequency': 'r', 'id': 1029, 'synset': 'stencil.n.01', 'synonyms': ['stencil'], 'def': 'a sheet of material (metal, plastic, etc.) that has been perforated with a pattern; ink or paint can pass through the perforations to create the printed pattern on the surface below', 'name': 'stencil'}, {'frequency': 'r', 'id': 1030, 'synset': 'step_ladder.n.01', 'synonyms': ['stepladder'], 'def': 'a folding portable ladder hinged at the top', 'name': 'stepladder'}, {'frequency': 'c', 'id': 1031, 'synset': 'step_stool.n.01', 'synonyms': ['step_stool'], 'def': 'a stool that has one or two steps that fold under the seat', 'name': 'step_stool'}, {'frequency': 'c', 'id': 1032, 'synset': 'stereo.n.01', 'synonyms': ['stereo_(sound_system)'], 'def': 'electronic device for playing audio', 'name': 'stereo_(sound_system)'}, {'frequency': 'r', 'id': 1033, 'synset': 'stew.n.02', 'synonyms': ['stew'], 'def': 'food prepared by stewing especially meat or fish with vegetables', 'name': 'stew'}, {'frequency': 'r', 'id': 1034, 'synset': 'stirrer.n.02', 'synonyms': ['stirrer'], 'def': 'an implement used for stirring', 'name': 'stirrer'}, {'frequency': 'f', 'id': 1035, 'synset': 'stirrup.n.01', 'synonyms': ['stirrup'], 'def': "support consisting of metal loops into which rider's feet go", 'name': 'stirrup'}, {'frequency': 'c', 'id': 1036, 'synset': 'stocking.n.01', 'synonyms': ['stockings_(leg_wear)'], 'def': 'close-fitting hosiery to cover the foot and leg; come in matched pairs', 'name': 'stockings_(leg_wear)'}, {'frequency': 'f', 'id': 1037, 'synset': 'stool.n.01', 'synonyms': ['stool'], 'def': 'a simple seat without a back or arms', 'name': 'stool'}, {'frequency': 'f', 'id': 1038, 'synset': 'stop_sign.n.01', 'synonyms': ['stop_sign'], 'def': 'a traffic sign to notify drivers that they must come to a complete stop', 'name': 'stop_sign'}, {'frequency': 'f', 'id': 1039, 'synset': 'stoplight.n.01', 'synonyms': ['brake_light'], 'def': 'a red light on the rear of a motor vehicle that signals when the brakes are applied', 'name': 'brake_light'}, {'frequency': 'f', 'id': 1040, 'synset': 'stove.n.01', 'synonyms': ['stove', 'kitchen_stove', 'range_(kitchen_appliance)', 'kitchen_range', 'cooking_stove'], 'def': 'a kitchen appliance used for cooking food', 'name': 'stove'}, {'frequency': 'c', 'id': 1041, 'synset': 'strainer.n.01', 'synonyms': ['strainer'], 'def': 'a filter to retain larger pieces while smaller pieces and liquids pass through', 'name': 'strainer'}, {'frequency': 'f', 'id': 1042, 'synset': 'strap.n.01', 'synonyms': ['strap'], 'def': 'an elongated strip of material for binding things together or holding', 'name': 'strap'}, {'frequency': 'f', 'id': 1043, 'synset': 'straw.n.04', 'synonyms': ['straw_(for_drinking)', 'drinking_straw'], 'def': 'a thin paper or plastic tube used to suck liquids into the mouth', 'name': 'straw_(for_drinking)'}, {'frequency': 'f', 'id': 1044, 'synset': 'strawberry.n.01', 'synonyms': ['strawberry'], 'def': 'sweet fleshy red fruit', 'name': 'strawberry'}, {'frequency': 'f', 'id': 1045, 'synset': 'street_sign.n.01', 'synonyms': ['street_sign'], 'def': 'a sign visible from the street', 'name': 'street_sign'}, {'frequency': 'f', 'id': 1046, 'synset': 'streetlight.n.01', 'synonyms': ['streetlight', 'street_lamp'], 'def': 'a lamp supported on a lamppost; for illuminating a street', 'name': 'streetlight'}, {'frequency': 'r', 'id': 1047, 'synset': 'string_cheese.n.01', 'synonyms': ['string_cheese'], 'def': 'cheese formed in long strings twisted together', 'name': 'string_cheese'}, {'frequency': 'r', 'id': 1048, 'synset': 'stylus.n.02', 'synonyms': ['stylus'], 'def': 'a pointed tool for writing or drawing or engraving', 'name': 'stylus'}, {'frequency': 'r', 'id': 1049, 'synset': 'subwoofer.n.01', 'synonyms': ['subwoofer'], 'def': 'a loudspeaker that is designed to reproduce very low bass frequencies', 'name': 'subwoofer'}, {'frequency': 'r', 'id': 1050, 'synset': 'sugar_bowl.n.01', 'synonyms': ['sugar_bowl'], 'def': 'a dish in which sugar is served', 'name': 'sugar_bowl'}, {'frequency': 'r', 'id': 1051, 'synset': 'sugarcane.n.01', 'synonyms': ['sugarcane_(plant)'], 'def': 'juicy canes whose sap is a source of molasses and commercial sugar; fresh canes are sometimes chewed for the juice', 'name': 'sugarcane_(plant)'}, {'frequency': 'c', 'id': 1052, 'synset': 'suit.n.01', 'synonyms': ['suit_(clothing)'], 'def': 'a set of garments (usually including a jacket and trousers or skirt) for outerwear all of the same fabric and color', 'name': 'suit_(clothing)'}, {'frequency': 'c', 'id': 1053, 'synset': 'sunflower.n.01', 'synonyms': ['sunflower'], 'def': 'any plant of the genus Helianthus having large flower heads with dark disk florets and showy yellow rays', 'name': 'sunflower'}, {'frequency': 'f', 'id': 1054, 'synset': 'sunglasses.n.01', 'synonyms': ['sunglasses'], 'def': 'spectacles that are darkened or polarized to protect the eyes from the glare of the sun', 'name': 'sunglasses'}, {'frequency': 'c', 'id': 1055, 'synset': 'sunhat.n.01', 'synonyms': ['sunhat'], 'def': 'a hat with a broad brim that protects the face from direct exposure to the sun', 'name': 'sunhat'}, {'frequency': 'r', 'id': 1056, 'synset': 'sunscreen.n.01', 'synonyms': ['sunscreen', 'sunblock'], 'def': 'a cream spread on the skin; contains a chemical to filter out ultraviolet light and so protect from sunburn', 'name': 'sunscreen'}, {'frequency': 'f', 'id': 1057, 'synset': 'surfboard.n.01', 'synonyms': ['surfboard'], 'def': 'a narrow buoyant board for riding surf', 'name': 'surfboard'}, {'frequency': 'c', 'id': 1058, 'synset': 'sushi.n.01', 'synonyms': ['sushi'], 'def': 'rice (with raw fish) wrapped in seaweed', 'name': 'sushi'}, {'frequency': 'c', 'id': 1059, 'synset': 'swab.n.02', 'synonyms': ['mop'], 'def': 'cleaning implement consisting of absorbent material fastened to a handle; for cleaning floors', 'name': 'mop'}, {'frequency': 'c', 'id': 1060, 'synset': 'sweat_pants.n.01', 'synonyms': ['sweat_pants'], 'def': 'loose-fitting trousers with elastic cuffs; worn by athletes', 'name': 'sweat_pants'}, {'frequency': 'c', 'id': 1061, 'synset': 'sweatband.n.02', 'synonyms': ['sweatband'], 'def': 'a band of material tied around the forehead or wrist to absorb sweat', 'name': 'sweatband'}, {'frequency': 'f', 'id': 1062, 'synset': 'sweater.n.01', 'synonyms': ['sweater'], 'def': 'a crocheted or knitted garment covering the upper part of the body', 'name': 'sweater'}, {'frequency': 'f', 'id': 1063, 'synset': 'sweatshirt.n.01', 'synonyms': ['sweatshirt'], 'def': 'cotton knit pullover with long sleeves worn during athletic activity', 'name': 'sweatshirt'}, {'frequency': 'c', 'id': 1064, 'synset': 'sweet_potato.n.02', 'synonyms': ['sweet_potato'], 'def': 'the edible tuberous root of the sweet potato vine', 'name': 'sweet_potato'}, {'frequency': 'f', 'id': 1065, 'synset': 'swimsuit.n.01', 'synonyms': ['swimsuit', 'swimwear', 'bathing_suit', 'swimming_costume', 'bathing_costume', 'swimming_trunks', 'bathing_trunks'], 'def': 'garment worn for swimming', 'name': 'swimsuit'}, {'frequency': 'c', 'id': 1066, 'synset': 'sword.n.01', 'synonyms': ['sword'], 'def': 'a cutting or thrusting weapon that has a long metal blade', 'name': 'sword'}, {'frequency': 'r', 'id': 1067, 'synset': 'syringe.n.01', 'synonyms': ['syringe'], 'def': 'a medical instrument used to inject or withdraw fluids', 'name': 'syringe'}, {'frequency': 'r', 'id': 1068, 'synset': 'tabasco.n.02', 'synonyms': ['Tabasco_sauce'], 'def': 'very spicy sauce (trade name Tabasco) made from fully-aged red peppers', 'name': 'Tabasco_sauce'}, {'frequency': 'r', 'id': 1069, 'synset': 'table-tennis_table.n.01', 'synonyms': ['table-tennis_table', 'ping-pong_table'], 'def': 'a table used for playing table tennis', 'name': 'table-tennis_table'}, {'frequency': 'f', 'id': 1070, 'synset': 'table.n.02', 'synonyms': ['table'], 'def': 'a piece of furniture having a smooth flat top that is usually supported by one or more vertical legs', 'name': 'table'}, {'frequency': 'c', 'id': 1071, 'synset': 'table_lamp.n.01', 'synonyms': ['table_lamp'], 'def': 'a lamp that sits on a table', 'name': 'table_lamp'}, {'frequency': 'f', 'id': 1072, 'synset': 'tablecloth.n.01', 'synonyms': ['tablecloth'], 'def': 'a covering spread over a dining table', 'name': 'tablecloth'}, {'frequency': 'r', 'id': 1073, 'synset': 'tachometer.n.01', 'synonyms': ['tachometer'], 'def': 'measuring instrument for indicating speed of rotation', 'name': 'tachometer'}, {'frequency': 'r', 'id': 1074, 'synset': 'taco.n.02', 'synonyms': ['taco'], 'def': 'a small tortilla cupped around a filling', 'name': 'taco'}, {'frequency': 'f', 'id': 1075, 'synset': 'tag.n.02', 'synonyms': ['tag'], 'def': 'a label associated with something for the purpose of identification or information', 'name': 'tag'}, {'frequency': 'f', 'id': 1076, 'synset': 'taillight.n.01', 'synonyms': ['taillight', 'rear_light'], 'def': 'lamp (usually red) mounted at the rear of a motor vehicle', 'name': 'taillight'}, {'frequency': 'r', 'id': 1077, 'synset': 'tambourine.n.01', 'synonyms': ['tambourine'], 'def': 'a shallow drum with a single drumhead and with metallic disks in the sides', 'name': 'tambourine'}, {'frequency': 'r', 'id': 1078, 'synset': 'tank.n.01', 'synonyms': ['army_tank', 'armored_combat_vehicle', 'armoured_combat_vehicle'], 'def': 'an enclosed armored military vehicle; has a cannon and moves on caterpillar treads', 'name': 'army_tank'}, {'frequency': 'c', 'id': 1079, 'synset': 'tank.n.02', 'synonyms': ['tank_(storage_vessel)', 'storage_tank'], 'def': 'a large (usually metallic) vessel for holding gases or liquids', 'name': 'tank_(storage_vessel)'}, {'frequency': 'f', 'id': 1080, 'synset': 'tank_top.n.01', 'synonyms': ['tank_top_(clothing)'], 'def': 'a tight-fitting sleeveless shirt with wide shoulder straps and low neck and no front opening', 'name': 'tank_top_(clothing)'}, {'frequency': 'c', 'id': 1081, 'synset': 'tape.n.01', 'synonyms': ['tape_(sticky_cloth_or_paper)'], 'def': 'a long thin piece of cloth or paper as used for binding or fastening', 'name': 'tape_(sticky_cloth_or_paper)'}, {'frequency': 'c', 'id': 1082, 'synset': 'tape.n.04', 'synonyms': ['tape_measure', 'measuring_tape'], 'def': 'measuring instrument consisting of a narrow strip (cloth or metal) marked in inches or centimeters and used for measuring lengths', 'name': 'tape_measure'}, {'frequency': 'c', 'id': 1083, 'synset': 'tapestry.n.02', 'synonyms': ['tapestry'], 'def': 'a heavy textile with a woven design; used for curtains and upholstery', 'name': 'tapestry'}, {'frequency': 'f', 'id': 1084, 'synset': 'tarpaulin.n.01', 'synonyms': ['tarp'], 'def': 'waterproofed canvas', 'name': 'tarp'}, {'frequency': 'c', 'id': 1085, 'synset': 'tartan.n.01', 'synonyms': ['tartan', 'plaid'], 'def': 'a cloth having a crisscross design', 'name': 'tartan'}, {'frequency': 'c', 'id': 1086, 'synset': 'tassel.n.01', 'synonyms': ['tassel'], 'def': 'adornment consisting of a bunch of cords fastened at one end', 'name': 'tassel'}, {'frequency': 'r', 'id': 1087, 'synset': 'tea_bag.n.01', 'synonyms': ['tea_bag'], 'def': 'a measured amount of tea in a bag for an individual serving of tea', 'name': 'tea_bag'}, {'frequency': 'c', 'id': 1088, 'synset': 'teacup.n.02', 'synonyms': ['teacup'], 'def': 'a cup from which tea is drunk', 'name': 'teacup'}, {'frequency': 'c', 'id': 1089, 'synset': 'teakettle.n.01', 'synonyms': ['teakettle'], 'def': 'kettle for boiling water to make tea', 'name': 'teakettle'}, {'frequency': 'c', 'id': 1090, 'synset': 'teapot.n.01', 'synonyms': ['teapot'], 'def': 'pot for brewing tea; usually has a spout and handle', 'name': 'teapot'}, {'frequency': 'f', 'id': 1091, 'synset': 'teddy.n.01', 'synonyms': ['teddy_bear'], 'def': "plaything consisting of a child's toy bear (usually plush and stuffed with soft materials)", 'name': 'teddy_bear'}, {'frequency': 'f', 'id': 1092, 'synset': 'telephone.n.01', 'synonyms': ['telephone', 'phone', 'telephone_set'], 'def': 'electronic device for communicating by voice over long distances', 'name': 'telephone'}, {'frequency': 'c', 'id': 1093, 'synset': 'telephone_booth.n.01', 'synonyms': ['telephone_booth', 'phone_booth', 'call_box', 'telephone_box', 'telephone_kiosk'], 'def': 'booth for using a telephone', 'name': 'telephone_booth'}, {'frequency': 'f', 'id': 1094, 'synset': 'telephone_pole.n.01', 'synonyms': ['telephone_pole', 'telegraph_pole', 'telegraph_post'], 'def': 'tall pole supporting telephone wires', 'name': 'telephone_pole'}, {'frequency': 'r', 'id': 1095, 'synset': 'telephoto_lens.n.01', 'synonyms': ['telephoto_lens', 'zoom_lens'], 'def': 'a camera lens that magnifies the image', 'name': 'telephoto_lens'}, {'frequency': 'c', 'id': 1096, 'synset': 'television_camera.n.01', 'synonyms': ['television_camera', 'tv_camera'], 'def': 'television equipment for capturing and recording video', 'name': 'television_camera'}, {'frequency': 'f', 'id': 1097, 'synset': 'television_receiver.n.01', 'synonyms': ['television_set', 'tv', 'tv_set'], 'def': 'an electronic device that receives television signals and displays them on a screen', 'name': 'television_set'}, {'frequency': 'f', 'id': 1098, 'synset': 'tennis_ball.n.01', 'synonyms': ['tennis_ball'], 'def': 'ball about the size of a fist used in playing tennis', 'name': 'tennis_ball'}, {'frequency': 'f', 'id': 1099, 'synset': 'tennis_racket.n.01', 'synonyms': ['tennis_racket'], 'def': 'a racket used to play tennis', 'name': 'tennis_racket'}, {'frequency': 'r', 'id': 1100, 'synset': 'tequila.n.01', 'synonyms': ['tequila'], 'def': 'Mexican liquor made from fermented juices of an agave plant', 'name': 'tequila'}, {'frequency': 'c', 'id': 1101, 'synset': 'thermometer.n.01', 'synonyms': ['thermometer'], 'def': 'measuring instrument for measuring temperature', 'name': 'thermometer'}, {'frequency': 'c', 'id': 1102, 'synset': 'thermos.n.01', 'synonyms': ['thermos_bottle'], 'def': 'vacuum flask that preserves temperature of hot or cold drinks', 'name': 'thermos_bottle'}, {'frequency': 'c', 'id': 1103, 'synset': 'thermostat.n.01', 'synonyms': ['thermostat'], 'def': 'a regulator for automatically regulating temperature by starting or stopping the supply of heat', 'name': 'thermostat'}, {'frequency': 'r', 'id': 1104, 'synset': 'thimble.n.02', 'synonyms': ['thimble'], 'def': 'a small metal cap to protect the finger while sewing; can be used as a small container', 'name': 'thimble'}, {'frequency': 'c', 'id': 1105, 'synset': 'thread.n.01', 'synonyms': ['thread', 'yarn'], 'def': 'a fine cord of twisted fibers (of cotton or silk or wool or nylon etc.) used in sewing and weaving', 'name': 'thread'}, {'frequency': 'c', 'id': 1106, 'synset': 'thumbtack.n.01', 'synonyms': ['thumbtack', 'drawing_pin', 'pushpin'], 'def': 'a tack for attaching papers to a bulletin board or drawing board', 'name': 'thumbtack'}, {'frequency': 'c', 'id': 1107, 'synset': 'tiara.n.01', 'synonyms': ['tiara'], 'def': 'a jeweled headdress worn by women on formal occasions', 'name': 'tiara'}, {'frequency': 'c', 'id': 1108, 'synset': 'tiger.n.02', 'synonyms': ['tiger'], 'def': 'large feline of forests in most of Asia having a tawny coat with black stripes', 'name': 'tiger'}, {'frequency': 'c', 'id': 1109, 'synset': 'tights.n.01', 'synonyms': ['tights_(clothing)', 'leotards'], 'def': 'skintight knit hose covering the body from the waist to the feet worn by acrobats and dancers and as stockings by women and girls', 'name': 'tights_(clothing)'}, {'frequency': 'c', 'id': 1110, 'synset': 'timer.n.01', 'synonyms': ['timer', 'stopwatch'], 'def': 'a timepiece that measures a time interval and signals its end', 'name': 'timer'}, {'frequency': 'f', 'id': 1111, 'synset': 'tinfoil.n.01', 'synonyms': ['tinfoil'], 'def': 'foil made of tin or an alloy of tin and lead', 'name': 'tinfoil'}, {'frequency': 'r', 'id': 1112, 'synset': 'tinsel.n.01', 'synonyms': ['tinsel'], 'def': 'a showy decoration that is basically valueless', 'name': 'tinsel'}, {'frequency': 'f', 'id': 1113, 'synset': 'tissue.n.02', 'synonyms': ['tissue_paper'], 'def': 'a soft thin (usually translucent) paper', 'name': 'tissue_paper'}, {'frequency': 'c', 'id': 1114, 'synset': 'toast.n.01', 'synonyms': ['toast_(food)'], 'def': 'slice of bread that has been toasted', 'name': 'toast_(food)'}, {'frequency': 'f', 'id': 1115, 'synset': 'toaster.n.02', 'synonyms': ['toaster'], 'def': 'a kitchen appliance (usually electric) for toasting bread', 'name': 'toaster'}, {'frequency': 'c', 'id': 1116, 'synset': 'toaster_oven.n.01', 'synonyms': ['toaster_oven'], 'def': 'kitchen appliance consisting of a small electric oven for toasting or warming food', 'name': 'toaster_oven'}, {'frequency': 'f', 'id': 1117, 'synset': 'toilet.n.02', 'synonyms': ['toilet'], 'def': 'a plumbing fixture for defecation and urination', 'name': 'toilet'}, {'frequency': 'f', 'id': 1118, 'synset': 'toilet_tissue.n.01', 'synonyms': ['toilet_tissue', 'toilet_paper', 'bathroom_tissue'], 'def': 'a soft thin absorbent paper for use in toilets', 'name': 'toilet_tissue'}, {'frequency': 'f', 'id': 1119, 'synset': 'tomato.n.01', 'synonyms': ['tomato'], 'def': 'mildly acid red or yellow pulpy fruit eaten as a vegetable', 'name': 'tomato'}, {'frequency': 'c', 'id': 1120, 'synset': 'tongs.n.01', 'synonyms': ['tongs'], 'def': 'any of various devices for taking hold of objects; usually have two hinged legs with handles above and pointed hooks below', 'name': 'tongs'}, {'frequency': 'c', 'id': 1121, 'synset': 'toolbox.n.01', 'synonyms': ['toolbox'], 'def': 'a box or chest or cabinet for holding hand tools', 'name': 'toolbox'}, {'frequency': 'f', 'id': 1122, 'synset': 'toothbrush.n.01', 'synonyms': ['toothbrush'], 'def': 'small brush; has long handle; used to clean teeth', 'name': 'toothbrush'}, {'frequency': 'f', 'id': 1123, 'synset': 'toothpaste.n.01', 'synonyms': ['toothpaste'], 'def': 'a dentifrice in the form of a paste', 'name': 'toothpaste'}, {'frequency': 'c', 'id': 1124, 'synset': 'toothpick.n.01', 'synonyms': ['toothpick'], 'def': 'pick consisting of a small strip of wood or plastic; used to pick food from between the teeth', 'name': 'toothpick'}, {'frequency': 'c', 'id': 1125, 'synset': 'top.n.09', 'synonyms': ['cover'], 'def': 'covering for a hole (especially a hole in the top of a container)', 'name': 'cover'}, {'frequency': 'c', 'id': 1126, 'synset': 'tortilla.n.01', 'synonyms': ['tortilla'], 'def': 'thin unleavened pancake made from cornmeal or wheat flour', 'name': 'tortilla'}, {'frequency': 'c', 'id': 1127, 'synset': 'tow_truck.n.01', 'synonyms': ['tow_truck'], 'def': 'a truck equipped to hoist and pull wrecked cars (or to remove cars from no-parking zones)', 'name': 'tow_truck'}, {'frequency': 'f', 'id': 1128, 'synset': 'towel.n.01', 'synonyms': ['towel'], 'def': 'a rectangular piece of absorbent cloth (or paper) for drying or wiping', 'name': 'towel'}, {'frequency': 'f', 'id': 1129, 'synset': 'towel_rack.n.01', 'synonyms': ['towel_rack', 'towel_rail', 'towel_bar'], 'def': 'a rack consisting of one or more bars on which towels can be hung', 'name': 'towel_rack'}, {'frequency': 'f', 'id': 1130, 'synset': 'toy.n.03', 'synonyms': ['toy'], 'def': 'a device regarded as providing amusement', 'name': 'toy'}, {'frequency': 'c', 'id': 1131, 'synset': 'tractor.n.01', 'synonyms': ['tractor_(farm_equipment)'], 'def': 'a wheeled vehicle with large wheels; used in farming and other applications', 'name': 'tractor_(farm_equipment)'}, {'frequency': 'f', 'id': 1132, 'synset': 'traffic_light.n.01', 'synonyms': ['traffic_light'], 'def': 'a device to control vehicle traffic often consisting of three or more lights', 'name': 'traffic_light'}, {'frequency': 'r', 'id': 1133, 'synset': 'trail_bike.n.01', 'synonyms': ['dirt_bike'], 'def': 'a lightweight motorcycle equipped with rugged tires and suspension for off-road use', 'name': 'dirt_bike'}, {'frequency': 'c', 'id': 1134, 'synset': 'trailer_truck.n.01', 'synonyms': ['trailer_truck', 'tractor_trailer', 'trucking_rig', 'articulated_lorry', 'semi_truck'], 'def': 'a truck consisting of a tractor and trailer together', 'name': 'trailer_truck'}, {'frequency': 'f', 'id': 1135, 'synset': 'train.n.01', 'synonyms': ['train_(railroad_vehicle)', 'railroad_train'], 'def': 'public or private transport provided by a line of railway cars coupled together and drawn by a locomotive', 'name': 'train_(railroad_vehicle)'}, {'frequency': 'r', 'id': 1136, 'synset': 'trampoline.n.01', 'synonyms': ['trampoline'], 'def': 'gymnastic apparatus consisting of a strong canvas sheet attached with springs to a metal frame', 'name': 'trampoline'}, {'frequency': 'f', 'id': 1137, 'synset': 'tray.n.01', 'synonyms': ['tray'], 'def': 'an open receptacle for holding or displaying or serving articles or food', 'name': 'tray'}, {'frequency': 'r', 'id': 1138, 'synset': 'tree_house.n.01', 'synonyms': ['tree_house'], 'def': '(NOT A TREE) a PLAYHOUSE built in the branches of a tree', 'name': 'tree_house'}, {'frequency': 'r', 'id': 1139, 'synset': 'trench_coat.n.01', 'synonyms': ['trench_coat'], 'def': 'a military style raincoat; belted with deep pockets', 'name': 'trench_coat'}, {'frequency': 'r', 'id': 1140, 'synset': 'triangle.n.05', 'synonyms': ['triangle_(musical_instrument)'], 'def': 'a percussion instrument consisting of a metal bar bent in the shape of an open triangle', 'name': 'triangle_(musical_instrument)'}, {'frequency': 'r', 'id': 1141, 'synset': 'tricycle.n.01', 'synonyms': ['tricycle'], 'def': 'a vehicle with three wheels that is moved by foot pedals', 'name': 'tricycle'}, {'frequency': 'c', 'id': 1142, 'synset': 'tripod.n.01', 'synonyms': ['tripod'], 'def': 'a three-legged rack used for support', 'name': 'tripod'}, {'frequency': 'f', 'id': 1143, 'synset': 'trouser.n.01', 'synonyms': ['trousers', 'pants_(clothing)'], 'def': 'a garment extending from the waist to the knee or ankle, covering each leg separately', 'name': 'trousers'}, {'frequency': 'f', 'id': 1144, 'synset': 'truck.n.01', 'synonyms': ['truck'], 'def': 'an automotive vehicle suitable for hauling', 'name': 'truck'}, {'frequency': 'r', 'id': 1145, 'synset': 'truffle.n.03', 'synonyms': ['truffle_(chocolate)', 'chocolate_truffle'], 'def': 'creamy chocolate candy', 'name': 'truffle_(chocolate)'}, {'frequency': 'c', 'id': 1146, 'synset': 'trunk.n.02', 'synonyms': ['trunk'], 'def': 'luggage consisting of a large strong case used when traveling or for storage', 'name': 'trunk'}, {'frequency': 'r', 'id': 1147, 'synset': 'tub.n.02', 'synonyms': ['vat'], 'def': 'a large open vessel for holding or storing liquids', 'name': 'vat'}, {'frequency': 'c', 'id': 1148, 'synset': 'turban.n.01', 'synonyms': ['turban'], 'def': 'a traditional headdress consisting of a long scarf wrapped around the head', 'name': 'turban'}, {'frequency': 'r', 'id': 1149, 'synset': 'turkey.n.01', 'synonyms': ['turkey_(bird)'], 'def': 'large gallinaceous bird with fan-shaped tail; widely domesticated for food', 'name': 'turkey_(bird)'}, {'frequency': 'c', 'id': 1150, 'synset': 'turkey.n.04', 'synonyms': ['turkey_(food)'], 'def': 'flesh of large domesticated fowl usually roasted', 'name': 'turkey_(food)'}, {'frequency': 'r', 'id': 1151, 'synset': 'turnip.n.01', 'synonyms': ['turnip'], 'def': 'widely cultivated plant having a large fleshy edible white or yellow root', 'name': 'turnip'}, {'frequency': 'c', 'id': 1152, 'synset': 'turtle.n.02', 'synonyms': ['turtle'], 'def': 'any of various aquatic and land reptiles having a bony shell and flipper-like limbs for swimming', 'name': 'turtle'}, {'frequency': 'r', 'id': 1153, 'synset': 'turtleneck.n.01', 'synonyms': ['turtleneck_(clothing)', 'polo-neck'], 'def': 'a sweater or jersey with a high close-fitting collar', 'name': 'turtleneck_(clothing)'}, {'frequency': 'r', 'id': 1154, 'synset': 'typewriter.n.01', 'synonyms': ['typewriter'], 'def': 'hand-operated character printer for printing written messages one character at a time', 'name': 'typewriter'}, {'frequency': 'f', 'id': 1155, 'synset': 'umbrella.n.01', 'synonyms': ['umbrella'], 'def': 'a lightweight handheld collapsible canopy', 'name': 'umbrella'}, {'frequency': 'c', 'id': 1156, 'synset': 'underwear.n.01', 'synonyms': ['underwear', 'underclothes', 'underclothing', 'underpants'], 'def': 'undergarment worn next to the skin and under the outer garments', 'name': 'underwear'}, {'frequency': 'r', 'id': 1157, 'synset': 'unicycle.n.01', 'synonyms': ['unicycle'], 'def': 'a vehicle with a single wheel that is driven by pedals', 'name': 'unicycle'}, {'frequency': 'c', 'id': 1158, 'synset': 'urinal.n.01', 'synonyms': ['urinal'], 'def': 'a plumbing fixture (usually attached to the wall) used by men to urinate', 'name': 'urinal'}, {'frequency': 'r', 'id': 1159, 'synset': 'urn.n.01', 'synonyms': ['urn'], 'def': 'a large vase that usually has a pedestal or feet', 'name': 'urn'}, {'frequency': 'c', 'id': 1160, 'synset': 'vacuum.n.04', 'synonyms': ['vacuum_cleaner'], 'def': 'an electrical home appliance that cleans by suction', 'name': 'vacuum_cleaner'}, {'frequency': 'c', 'id': 1161, 'synset': 'valve.n.03', 'synonyms': ['valve'], 'def': 'control consisting of a mechanical device for controlling the flow of a fluid', 'name': 'valve'}, {'frequency': 'f', 'id': 1162, 'synset': 'vase.n.01', 'synonyms': ['vase'], 'def': 'an open jar of glass or porcelain used as an ornament or to hold flowers', 'name': 'vase'}, {'frequency': 'c', 'id': 1163, 'synset': 'vending_machine.n.01', 'synonyms': ['vending_machine'], 'def': 'a slot machine for selling goods', 'name': 'vending_machine'}, {'frequency': 'f', 'id': 1164, 'synset': 'vent.n.01', 'synonyms': ['vent', 'blowhole', 'air_vent'], 'def': 'a hole for the escape of gas or air', 'name': 'vent'}, {'frequency': 'c', 'id': 1165, 'synset': 'videotape.n.01', 'synonyms': ['videotape'], 'def': 'a video recording made on magnetic tape', 'name': 'videotape'}, {'frequency': 'r', 'id': 1166, 'synset': 'vinegar.n.01', 'synonyms': ['vinegar'], 'def': 'sour-tasting liquid produced usually by oxidation of the alcohol in wine or cider and used as a condiment or food preservative', 'name': 'vinegar'}, {'frequency': 'r', 'id': 1167, 'synset': 'violin.n.01', 'synonyms': ['violin', 'fiddle'], 'def': 'bowed stringed instrument that is the highest member of the violin family', 'name': 'violin'}, {'frequency': 'r', 'id': 1168, 'synset': 'vodka.n.01', 'synonyms': ['vodka'], 'def': 'unaged colorless liquor originating in Russia', 'name': 'vodka'}, {'frequency': 'r', 'id': 1169, 'synset': 'volleyball.n.02', 'synonyms': ['volleyball'], 'def': 'an inflated ball used in playing volleyball', 'name': 'volleyball'}, {'frequency': 'r', 'id': 1170, 'synset': 'vulture.n.01', 'synonyms': ['vulture'], 'def': 'any of various large birds of prey having naked heads and weak claws and feeding chiefly on carrion', 'name': 'vulture'}, {'frequency': 'c', 'id': 1171, 'synset': 'waffle.n.01', 'synonyms': ['waffle'], 'def': 'pancake batter baked in a waffle iron', 'name': 'waffle'}, {'frequency': 'r', 'id': 1172, 'synset': 'waffle_iron.n.01', 'synonyms': ['waffle_iron'], 'def': 'a kitchen appliance for baking waffles', 'name': 'waffle_iron'}, {'frequency': 'c', 'id': 1173, 'synset': 'wagon.n.01', 'synonyms': ['wagon'], 'def': 'any of various kinds of wheeled vehicles drawn by an animal or a tractor', 'name': 'wagon'}, {'frequency': 'c', 'id': 1174, 'synset': 'wagon_wheel.n.01', 'synonyms': ['wagon_wheel'], 'def': 'a wheel of a wagon', 'name': 'wagon_wheel'}, {'frequency': 'c', 'id': 1175, 'synset': 'walking_stick.n.01', 'synonyms': ['walking_stick'], 'def': 'a stick carried in the hand for support in walking', 'name': 'walking_stick'}, {'frequency': 'c', 'id': 1176, 'synset': 'wall_clock.n.01', 'synonyms': ['wall_clock'], 'def': 'a clock mounted on a wall', 'name': 'wall_clock'}, {'frequency': 'f', 'id': 1177, 'synset': 'wall_socket.n.01', 'synonyms': ['wall_socket', 'wall_plug', 'electric_outlet', 'electrical_outlet', 'outlet', 'electric_receptacle'], 'def': 'receptacle providing a place in a wiring system where current can be taken to run electrical devices', 'name': 'wall_socket'}, {'frequency': 'c', 'id': 1178, 'synset': 'wallet.n.01', 'synonyms': ['wallet', 'billfold'], 'def': 'a pocket-size case for holding papers and paper money', 'name': 'wallet'}, {'frequency': 'r', 'id': 1179, 'synset': 'walrus.n.01', 'synonyms': ['walrus'], 'def': 'either of two large northern marine mammals having ivory tusks and tough hide over thick blubber', 'name': 'walrus'}, {'frequency': 'r', 'id': 1180, 'synset': 'wardrobe.n.01', 'synonyms': ['wardrobe'], 'def': 'a tall piece of furniture that provides storage space for clothes; has a door and rails or hooks for hanging clothes', 'name': 'wardrobe'}, {'frequency': 'r', 'id': 1181, 'synset': 'wasabi.n.02', 'synonyms': ['wasabi'], 'def': 'the thick green root of the wasabi plant that the Japanese use in cooking and that tastes like strong horseradish', 'name': 'wasabi'}, {'frequency': 'c', 'id': 1182, 'synset': 'washer.n.03', 'synonyms': ['automatic_washer', 'washing_machine'], 'def': 'a home appliance for washing clothes and linens automatically', 'name': 'automatic_washer'}, {'frequency': 'f', 'id': 1183, 'synset': 'watch.n.01', 'synonyms': ['watch', 'wristwatch'], 'def': 'a small, portable timepiece', 'name': 'watch'}, {'frequency': 'f', 'id': 1184, 'synset': 'water_bottle.n.01', 'synonyms': ['water_bottle'], 'def': 'a bottle for holding water', 'name': 'water_bottle'}, {'frequency': 'c', 'id': 1185, 'synset': 'water_cooler.n.01', 'synonyms': ['water_cooler'], 'def': 'a device for cooling and dispensing drinking water', 'name': 'water_cooler'}, {'frequency': 'c', 'id': 1186, 'synset': 'water_faucet.n.01', 'synonyms': ['water_faucet', 'water_tap', 'tap_(water_faucet)'], 'def': 'a faucet for drawing water from a pipe or cask', 'name': 'water_faucet'}, {'frequency': 'r', 'id': 1187, 'synset': 'water_filter.n.01', 'synonyms': ['water_filter'], 'def': 'a filter to remove impurities from the water supply', 'name': 'water_filter'}, {'frequency': 'r', 'id': 1188, 'synset': 'water_heater.n.01', 'synonyms': ['water_heater', 'hot-water_heater'], 'def': 'a heater and storage tank to supply heated water', 'name': 'water_heater'}, {'frequency': 'r', 'id': 1189, 'synset': 'water_jug.n.01', 'synonyms': ['water_jug'], 'def': 'a jug that holds water', 'name': 'water_jug'}, {'frequency': 'r', 'id': 1190, 'synset': 'water_pistol.n.01', 'synonyms': ['water_gun', 'squirt_gun'], 'def': 'plaything consisting of a toy pistol that squirts water', 'name': 'water_gun'}, {'frequency': 'c', 'id': 1191, 'synset': 'water_scooter.n.01', 'synonyms': ['water_scooter', 'sea_scooter', 'jet_ski'], 'def': 'a motorboat resembling a motor scooter (NOT A SURFBOARD OR WATER SKI)', 'name': 'water_scooter'}, {'frequency': 'c', 'id': 1192, 'synset': 'water_ski.n.01', 'synonyms': ['water_ski'], 'def': 'broad ski for skimming over water towed by a speedboat (DO NOT MARK WATER)', 'name': 'water_ski'}, {'frequency': 'c', 'id': 1193, 'synset': 'water_tower.n.01', 'synonyms': ['water_tower'], 'def': 'a large reservoir for water', 'name': 'water_tower'}, {'frequency': 'c', 'id': 1194, 'synset': 'watering_can.n.01', 'synonyms': ['watering_can'], 'def': 'a container with a handle and a spout with a perforated nozzle; used to sprinkle water over plants', 'name': 'watering_can'}, {'frequency': 'c', 'id': 1195, 'synset': 'watermelon.n.02', 'synonyms': ['watermelon'], 'def': 'large oblong or roundish melon with a hard green rind and sweet watery red or occasionally yellowish pulp', 'name': 'watermelon'}, {'frequency': 'f', 'id': 1196, 'synset': 'weathervane.n.01', 'synonyms': ['weathervane', 'vane_(weathervane)', 'wind_vane'], 'def': 'mechanical device attached to an elevated structure; rotates freely to show the direction of the wind', 'name': 'weathervane'}, {'frequency': 'c', 'id': 1197, 'synset': 'webcam.n.01', 'synonyms': ['webcam'], 'def': 'a digital camera designed to take digital photographs and transmit them over the internet', 'name': 'webcam'}, {'frequency': 'c', 'id': 1198, 'synset': 'wedding_cake.n.01', 'synonyms': ['wedding_cake', 'bridecake'], 'def': 'a rich cake with two or more tiers and covered with frosting and decorations; served at a wedding reception', 'name': 'wedding_cake'}, {'frequency': 'c', 'id': 1199, 'synset': 'wedding_ring.n.01', 'synonyms': ['wedding_ring', 'wedding_band'], 'def': 'a ring given to the bride and/or groom at the wedding', 'name': 'wedding_ring'}, {'frequency': 'f', 'id': 1200, 'synset': 'wet_suit.n.01', 'synonyms': ['wet_suit'], 'def': 'a close-fitting garment made of a permeable material; worn in cold water to retain body heat', 'name': 'wet_suit'}, {'frequency': 'f', 'id': 1201, 'synset': 'wheel.n.01', 'synonyms': ['wheel'], 'def': 'a circular frame with spokes (or a solid disc) that can rotate on a shaft or axle', 'name': 'wheel'}, {'frequency': 'c', 'id': 1202, 'synset': 'wheelchair.n.01', 'synonyms': ['wheelchair'], 'def': 'a movable chair mounted on large wheels', 'name': 'wheelchair'}, {'frequency': 'c', 'id': 1203, 'synset': 'whipped_cream.n.01', 'synonyms': ['whipped_cream'], 'def': 'cream that has been beaten until light and fluffy', 'name': 'whipped_cream'}, {'frequency': 'r', 'id': 1204, 'synset': 'whiskey.n.01', 'synonyms': ['whiskey'], 'def': 'a liquor made from fermented mash of grain', 'name': 'whiskey'}, {'frequency': 'r', 'id': 1205, 'synset': 'whistle.n.03', 'synonyms': ['whistle'], 'def': 'a small wind instrument that produces a whistling sound by blowing into it', 'name': 'whistle'}, {'frequency': 'r', 'id': 1206, 'synset': 'wick.n.02', 'synonyms': ['wick'], 'def': 'a loosely woven cord in a candle or oil lamp that is lit on fire', 'name': 'wick'}, {'frequency': 'c', 'id': 1207, 'synset': 'wig.n.01', 'synonyms': ['wig'], 'def': 'hairpiece covering the head and made of real or synthetic hair', 'name': 'wig'}, {'frequency': 'c', 'id': 1208, 'synset': 'wind_chime.n.01', 'synonyms': ['wind_chime'], 'def': 'a decorative arrangement of pieces of metal or glass or pottery that hang together loosely so the wind can cause them to tinkle', 'name': 'wind_chime'}, {'frequency': 'c', 'id': 1209, 'synset': 'windmill.n.01', 'synonyms': ['windmill'], 'def': 'a mill that is powered by the wind', 'name': 'windmill'}, {'frequency': 'c', 'id': 1210, 'synset': 'window_box.n.01', 'synonyms': ['window_box_(for_plants)'], 'def': 'a container for growing plants on a windowsill', 'name': 'window_box_(for_plants)'}, {'frequency': 'f', 'id': 1211, 'synset': 'windshield_wiper.n.01', 'synonyms': ['windshield_wiper', 'windscreen_wiper', 'wiper_(for_windshield/screen)'], 'def': 'a mechanical device that cleans the windshield', 'name': 'windshield_wiper'}, {'frequency': 'c', 'id': 1212, 'synset': 'windsock.n.01', 'synonyms': ['windsock', 'air_sock', 'air-sleeve', 'wind_sleeve', 'wind_cone'], 'def': 'a truncated cloth cone mounted on a mast/pole; shows wind direction', 'name': 'windsock'}, {'frequency': 'f', 'id': 1213, 'synset': 'wine_bottle.n.01', 'synonyms': ['wine_bottle'], 'def': 'a bottle for holding wine', 'name': 'wine_bottle'}, {'frequency': 'r', 'id': 1214, 'synset': 'wine_bucket.n.01', 'synonyms': ['wine_bucket', 'wine_cooler'], 'def': 'a bucket of ice used to chill a bottle of wine', 'name': 'wine_bucket'}, {'frequency': 'f', 'id': 1215, 'synset': 'wineglass.n.01', 'synonyms': ['wineglass'], 'def': 'a glass that has a stem and in which wine is served', 'name': 'wineglass'}, {'frequency': 'r', 'id': 1216, 'synset': 'wing_chair.n.01', 'synonyms': ['wing_chair'], 'def': 'easy chair having wings on each side of a high back', 'name': 'wing_chair'}, {'frequency': 'c', 'id': 1217, 'synset': 'winker.n.02', 'synonyms': ['blinder_(for_horses)'], 'def': 'blinds that prevent a horse from seeing something on either side', 'name': 'blinder_(for_horses)'}, {'frequency': 'c', 'id': 1218, 'synset': 'wok.n.01', 'synonyms': ['wok'], 'def': 'pan with a convex bottom; used for frying in Chinese cooking', 'name': 'wok'}, {'frequency': 'r', 'id': 1219, 'synset': 'wolf.n.01', 'synonyms': ['wolf'], 'def': 'a wild carnivorous mammal of the dog family, living and hunting in packs', 'name': 'wolf'}, {'frequency': 'c', 'id': 1220, 'synset': 'wooden_spoon.n.02', 'synonyms': ['wooden_spoon'], 'def': 'a spoon made of wood', 'name': 'wooden_spoon'}, {'frequency': 'c', 'id': 1221, 'synset': 'wreath.n.01', 'synonyms': ['wreath'], 'def': 'an arrangement of flowers, leaves, or stems fastened in a ring', 'name': 'wreath'}, {'frequency': 'c', 'id': 1222, 'synset': 'wrench.n.03', 'synonyms': ['wrench', 'spanner'], 'def': 'a hand tool that is used to hold or twist a nut or bolt', 'name': 'wrench'}, {'frequency': 'c', 'id': 1223, 'synset': 'wristband.n.01', 'synonyms': ['wristband'], 'def': 'band consisting of a part of a sleeve that covers the wrist', 'name': 'wristband'}, {'frequency': 'f', 'id': 1224, 'synset': 'wristlet.n.01', 'synonyms': ['wristlet', 'wrist_band'], 'def': 'a band or bracelet worn around the wrist', 'name': 'wristlet'}, {'frequency': 'r', 'id': 1225, 'synset': 'yacht.n.01', 'synonyms': ['yacht'], 'def': 'an expensive vessel propelled by sail or power and used for cruising or racing', 'name': 'yacht'}, {'frequency': 'r', 'id': 1226, 'synset': 'yak.n.02', 'synonyms': ['yak'], 'def': 'large long-haired wild ox of Tibet often domesticated', 'name': 'yak'}, {'frequency': 'c', 'id': 1227, 'synset': 'yogurt.n.01', 'synonyms': ['yogurt', 'yoghurt', 'yoghourt'], 'def': 'a custard-like food made from curdled milk', 'name': 'yogurt'}, {'frequency': 'r', 'id': 1228, 'synset': 'yoke.n.07', 'synonyms': ['yoke_(animal_equipment)'], 'def': 'gear joining two animals at the neck; NOT egg yolk', 'name': 'yoke_(animal_equipment)'}, {'frequency': 'f', 'id': 1229, 'synset': 'zebra.n.01', 'synonyms': ['zebra'], 'def': 'any of several fleet black-and-white striped African equines', 'name': 'zebra'}, {'frequency': 'c', 'id': 1230, 'synset': 'zucchini.n.02', 'synonyms': ['zucchini', 'courgette'], 'def': 'small cucumber-shaped vegetable marrow; typically dark green', 'name': 'zucchini'}] # noqa
-# fmt: on
diff --git a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/visualize_data.py b/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/visualize_data.py
deleted file mode 100644
index fd0ba8347bfd34fc8fac5ffef9aee10915ad1820..0000000000000000000000000000000000000000
--- a/spaces/TencentARC/VLog/models/grit_src/third_party/CenterNet2/tools/visualize_data.py
+++ /dev/null
@@ -1,94 +0,0 @@
-#!/usr/bin/env python
-# Copyright (c) Facebook, Inc. and its affiliates.
-import argparse
-import os
-from itertools import chain
-import cv2
-import tqdm
-
-from detectron2.config import get_cfg
-from detectron2.data import DatasetCatalog, MetadataCatalog, build_detection_train_loader
-from detectron2.data import detection_utils as utils
-from detectron2.data.build import filter_images_with_few_keypoints
-from detectron2.utils.logger import setup_logger
-from detectron2.utils.visualizer import Visualizer
-
-
-def setup(args):
- cfg = get_cfg()
- if args.config_file:
- cfg.merge_from_file(args.config_file)
- cfg.merge_from_list(args.opts)
- cfg.DATALOADER.NUM_WORKERS = 0
- cfg.freeze()
- return cfg
-
-
-def parse_args(in_args=None):
- parser = argparse.ArgumentParser(description="Visualize ground-truth data")
- parser.add_argument(
- "--source",
- choices=["annotation", "dataloader"],
- required=True,
- help="visualize the annotations or the data loader (with pre-processing)",
- )
- parser.add_argument("--config-file", metavar="FILE", help="path to config file")
- parser.add_argument("--output-dir", default="./", help="path to output directory")
- parser.add_argument("--show", action="store_true", help="show output in a window")
- parser.add_argument(
- "opts",
- help="Modify config options using the command-line",
- default=None,
- nargs=argparse.REMAINDER,
- )
- return parser.parse_args(in_args)
-
-
-if __name__ == "__main__":
- args = parse_args()
- logger = setup_logger()
- logger.info("Arguments: " + str(args))
- cfg = setup(args)
-
- dirname = args.output_dir
- os.makedirs(dirname, exist_ok=True)
- metadata = MetadataCatalog.get(cfg.DATASETS.TRAIN[0])
-
- def output(vis, fname):
- if args.show:
- print(fname)
- cv2.imshow("window", vis.get_image()[:, :, ::-1])
- cv2.waitKey()
- else:
- filepath = os.path.join(dirname, fname)
- print("Saving to {} ...".format(filepath))
- vis.save(filepath)
-
- scale = 1.0
- if args.source == "dataloader":
- train_data_loader = build_detection_train_loader(cfg)
- for batch in train_data_loader:
- for per_image in batch:
- # Pytorch tensor is in (C, H, W) format
- img = per_image["image"].permute(1, 2, 0).cpu().detach().numpy()
- img = utils.convert_image_to_rgb(img, cfg.INPUT.FORMAT)
-
- visualizer = Visualizer(img, metadata=metadata, scale=scale)
- target_fields = per_image["instances"].get_fields()
- labels = [metadata.thing_classes[i] for i in target_fields["gt_classes"]]
- vis = visualizer.overlay_instances(
- labels=labels,
- boxes=target_fields.get("gt_boxes", None),
- masks=target_fields.get("gt_masks", None),
- keypoints=target_fields.get("gt_keypoints", None),
- )
- output(vis, str(per_image["image_id"]) + ".jpg")
- else:
- dicts = list(chain.from_iterable([DatasetCatalog.get(k) for k in cfg.DATASETS.TRAIN]))
- if cfg.MODEL.KEYPOINT_ON:
- dicts = filter_images_with_few_keypoints(dicts, 1)
- for dic in tqdm.tqdm(dicts):
- img = utils.read_image(dic["file_name"], "RGB")
- visualizer = Visualizer(img, metadata=metadata, scale=scale)
- vis = visualizer.draw_dataset_dict(dic)
- output(vis, os.path.basename(dic["file_name"]))
diff --git a/spaces/TwoCH4/White-box-Cartoonization/README.md b/spaces/TwoCH4/White-box-Cartoonization/README.md
deleted file mode 100644
index 9860239cf42c94e385faaaa75a85311e010d64f7..0000000000000000000000000000000000000000
--- a/spaces/TwoCH4/White-box-Cartoonization/README.md
+++ /dev/null
@@ -1,15 +0,0 @@
----
-python_version: 3.7
-title: White Box Cartoonization
-emoji: 📚
-colorFrom: purple
-colorTo: green
-sdk: gradio
-sdk_version: 2.9.4
-app_file: app.py
-pinned: false
-license: apache-2.0
-duplicated_from: hylee/White-box-Cartoonization
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces#reference
diff --git a/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/diffusion_models/controlnet/controlnet_inpaint/controlnet_inpaint_mlsd.py b/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/diffusion_models/controlnet/controlnet_inpaint/controlnet_inpaint_mlsd.py
deleted file mode 100644
index 877469f8ccc7e83efbc0cbe99ae02565d884f25b..0000000000000000000000000000000000000000
--- a/spaces/VincentZB/Stable-Diffusion-ControlNet-WebUI/diffusion_webui/diffusion_models/controlnet/controlnet_inpaint/controlnet_inpaint_mlsd.py
+++ /dev/null
@@ -1,224 +0,0 @@
-import gradio as gr
-import numpy as np
-import torch
-from controlnet_aux import MLSDdetector
-from diffusers import ControlNetModel
-from PIL import Image
-
-from diffusion_webui.diffusion_models.controlnet.controlnet_inpaint.pipeline_stable_diffusion_controlnet_inpaint import (
- StableDiffusionControlNetInpaintPipeline,
-)
-from diffusion_webui.utils.model_list import (
- controlnet_mlsd_model_list,
- stable_inpiant_model_list,
-)
-from diffusion_webui.utils.scheduler_list import (
- SCHEDULER_LIST,
- get_scheduler_list,
-)
-
-# https://github.com/mikonvergence/ControlNetInpaint
-
-
-class StableDiffusionControlNetInpaintMlsdGenerator:
- def __init__(self):
- self.pipe = None
-
- def load_model(self, stable_model_path, controlnet_model_path, scheduler):
- if self.pipe is None:
- controlnet = ControlNetModel.from_pretrained(
- controlnet_model_path, torch_dtype=torch.float16
- )
- self.pipe = (
- StableDiffusionControlNetInpaintPipeline.from_pretrained(
- pretrained_model_name_or_path=stable_model_path,
- controlnet=controlnet,
- safety_checker=None,
- torch_dtype=torch.float16,
- )
- )
-
- self.pipe = get_scheduler_list(pipe=self.pipe, scheduler=scheduler)
- self.pipe.to("cuda")
- self.pipe.enable_xformers_memory_efficient_attention()
-
- return self.pipe
-
- def load_image(self, image_path):
- image = np.array(image_path)
- image = Image.fromarray(image)
- return image
-
- def controlnet_inpaint_mlsd(self, image_path: str):
- mlsd = MLSDdetector.from_pretrained("lllyasviel/ControlNet")
- image = image_path["image"].convert("RGB").resize((512, 512))
- image = np.array(image)
- image = mlsd(image)
-
- return image
-
- def generate_image(
- self,
- image_path: str,
- stable_model_path: str,
- controlnet_model_path: str,
- prompt: str,
- negative_prompt: str,
- num_images_per_prompt: int,
- guidance_scale: int,
- num_inference_step: int,
- controlnet_conditioning_scale: int,
- scheduler: str,
- seed_generator: int,
- ):
-
- normal_image = image_path["image"].convert("RGB").resize((512, 512))
- mask_image = image_path["mask"].convert("RGB").resize((512, 512))
-
- normal_image = self.load_image(image_path=normal_image)
- mask_image = self.load_image(image_path=mask_image)
-
- control_image = self.controlnet_inpaint_mlsd(image_path=image_path)
-
- pipe = self.load_model(
- stable_model_path=stable_model_path,
- controlnet_model_path=controlnet_model_path,
- scheduler=scheduler,
- )
-
- if seed_generator == 0:
- random_seed = torch.randint(0, 1000000, (1,))
- generator = torch.manual_seed(random_seed)
- else:
- generator = torch.manual_seed(seed_generator)
-
- output = pipe(
- prompt=prompt,
- image=normal_image,
- mask_image=mask_image,
- control_image=control_image,
- negative_prompt=negative_prompt,
- num_images_per_prompt=num_images_per_prompt,
- num_inference_steps=num_inference_step,
- guidance_scale=guidance_scale,
- controlnet_conditioning_scale=controlnet_conditioning_scale,
- generator=generator,
- ).images
-
- return output
-
- def app():
- with gr.Blocks():
- with gr.Row():
- with gr.Column():
- controlnet_mlsd_inpaint_image_file = gr.Image(
- source="upload",
- tool="sketch",
- elem_id="image_upload",
- type="pil",
- label="Upload",
- )
-
- controlnet_mlsd_inpaint_prompt = gr.Textbox(
- lines=1, placeholder="Prompt", show_label=False
- )
-
- controlnet_mlsd_inpaint_negative_prompt = gr.Textbox(
- lines=1,
- show_label=False,
- placeholder="Negative Prompt",
- )
- with gr.Row():
- with gr.Column():
- controlnet_mlsd_inpaint_stable_model_id = (
- gr.Dropdown(
- choices=stable_inpiant_model_list,
- value=stable_inpiant_model_list[0],
- label="Stable Model Id",
- )
- )
-
- controlnet_mlsd_inpaint_guidance_scale = gr.Slider(
- minimum=0.1,
- maximum=15,
- step=0.1,
- value=7.5,
- label="Guidance Scale",
- )
-
- controlnet_mlsd_inpaint_num_inference_step = (
- gr.Slider(
- minimum=1,
- maximum=100,
- step=1,
- value=50,
- label="Num Inference Step",
- )
- )
- controlnet_mlsd_inpaint_num_images_per_prompt = (
- gr.Slider(
- minimum=1,
- maximum=10,
- step=1,
- value=1,
- label="Number Of Images",
- )
- )
- with gr.Row():
- with gr.Column():
- controlnet_mlsd_inpaint_model_id = gr.Dropdown(
- choices=controlnet_mlsd_model_list,
- value=controlnet_mlsd_model_list[0],
- label="Controlnet Model Id",
- )
- controlnet_mlsd_inpaint_scheduler = gr.Dropdown(
- choices=SCHEDULER_LIST,
- value=SCHEDULER_LIST[0],
- label="Scheduler",
- )
- controlnet_mlsd_inpaint_controlnet_conditioning_scale = gr.Slider(
- minimum=0.1,
- maximum=1.0,
- step=0.1,
- value=0.5,
- label="Controlnet Conditioning Scale",
- )
-
- controlnet_mlsd_inpaint_seed_generator = (
- gr.Slider(
- minimum=0,
- maximum=1000000,
- step=1,
- value=0,
- label="Seed Generator",
- )
- )
-
- controlnet_mlsd_inpaint_predict = gr.Button(
- value="Generator"
- )
-
- with gr.Column():
- output_image = gr.Gallery(
- label="Generated images",
- show_label=False,
- elem_id="gallery",
- ).style(grid=(1, 2))
-
- controlnet_mlsd_inpaint_predict.click(
- fn=StableDiffusionControlNetInpaintMlsdGenerator().generate_image,
- inputs=[
- controlnet_mlsd_inpaint_image_file,
- controlnet_mlsd_inpaint_stable_model_id,
- controlnet_mlsd_inpaint_model_id,
- controlnet_mlsd_inpaint_prompt,
- controlnet_mlsd_inpaint_negative_prompt,
- controlnet_mlsd_inpaint_num_images_per_prompt,
- controlnet_mlsd_inpaint_guidance_scale,
- controlnet_mlsd_inpaint_num_inference_step,
- controlnet_mlsd_inpaint_controlnet_conditioning_scale,
- controlnet_mlsd_inpaint_scheduler,
- controlnet_mlsd_inpaint_seed_generator,
- ],
- outputs=[output_image],
- )
diff --git a/spaces/VishnuSaiTeja/Predictor/README.md b/spaces/VishnuSaiTeja/Predictor/README.md
deleted file mode 100644
index 7ff8076a4303cc27f509f50df5fcb7221743789a..0000000000000000000000000000000000000000
--- a/spaces/VishnuSaiTeja/Predictor/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Predictor
-emoji: 💻
-colorFrom: blue
-colorTo: red
-sdk: streamlit
-sdk_version: 1.27.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/Wauplin/bloomz.cpp-converter/Dockerfile b/spaces/Wauplin/bloomz.cpp-converter/Dockerfile
deleted file mode 100644
index 831abd89b1a7f77c03c7a968c1e80e495f7dc1eb..0000000000000000000000000000000000000000
--- a/spaces/Wauplin/bloomz.cpp-converter/Dockerfile
+++ /dev/null
@@ -1,51 +0,0 @@
-# See https://hub.docker.com/r/nikolaik/python-nodejs
-# https://github.com/nikolaik/docker-python-nodejs
-# Default user is 'pn' with uid 1000, gid 1000
-FROM python:3.10
-
-RUN apt-get update && apt-get install -y \
- git \
- git-lfs \
- cmake \
- && rm -rf /var/lib/apt/lists/* \
- && git lfs install
-
-# User
-RUN useradd -m -u 1000 user
-USER user
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-WORKDIR /home/user/app
-
-# Install Python deps
-RUN pip install --no-cache-dir pip && \
- pip install --no-cache-dir \
- gradio \
- torch \
- numpy \
- transformers \
- accelerate
-
-# Prepare bloomz.cpp
-RUN git clone https://github.com/NouamaneTazi/bloomz.cpp
-
-WORKDIR $HOME/app/bloomz.cpp
-
-# just to ensure not being on main branch # TODO: might remove this in the future
-RUN git checkout 4fc96cbf2e2c257eaca1cd7b7ed8e31741e672ee
-RUN make
-
-# Add files
-COPY . $HOME/app
-
-ENV PYTHONPATH=$HOME/app \
- PYTHONUNBUFFERED=1 \
- GRADIO_ALLOW_FLAGGING=never \
- GRADIO_NUM_PORTS=1 \
- GRADIO_SERVER_NAME=0.0.0.0 \
- GRADIO_THEME=huggingface \
- SYSTEM=spaces
-
-# Run script
-WORKDIR $HOME/app
-CMD ["python", "app.py"]
\ No newline at end of file
diff --git a/spaces/WindVChen/INR-Harmon/model/base/__init__.py b/spaces/WindVChen/INR-Harmon/model/base/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/Wootang01/text_generator_six/README.md b/spaces/Wootang01/text_generator_six/README.md
deleted file mode 100644
index 1e0cd9448109ca8094e5129aed224d08684b3e7e..0000000000000000000000000000000000000000
--- a/spaces/Wootang01/text_generator_six/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Text Generator Six
-emoji: ⚡
-colorFrom: yellow
-colorTo: red
-sdk: gradio
-sdk_version: 3.10.1
-app_file: app.py
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/Xhaheen/meme_world/app.py b/spaces/Xhaheen/meme_world/app.py
deleted file mode 100644
index baa67144c119d0bee52b0b783ed169a5b934bb9a..0000000000000000000000000000000000000000
--- a/spaces/Xhaheen/meme_world/app.py
+++ /dev/null
@@ -1,169 +0,0 @@
-# # %%bash
-
-# # # git lfs install
-# # # git clone https://huggingface.co/spaces/Xhaheen/meme_world
-
-
-# # # pip install -r /content/meme_world/requirements.txt
-# # # pip install gradio
-# # cd /meme_world
-
-
-# import torch
-# import re
-# import gradio as gr
-# from transformers import AutoTokenizer, ViTFeatureExtractor, VisionEncoderDecoderModel
-# import cohere
-# import os
-# #
-# # os.environ['key_srkian'] = ''
-# key_srkian = os.environ["key_srkian"]
-# co = cohere.Client(key_srkian)#srkian
-# device='cpu'
-# encoder_checkpoint = "nlpconnect/vit-gpt2-image-captioning"
-# decoder_checkpoint = "nlpconnect/vit-gpt2-image-captioning"
-# model_checkpoint = "nlpconnect/vit-gpt2-image-captioning"
-# feature_extractor = ViTFeatureExtractor.from_pretrained(encoder_checkpoint)
-# tokenizer = AutoTokenizer.from_pretrained(decoder_checkpoint)
-# model = VisionEncoderDecoderModel.from_pretrained(model_checkpoint).to(device)
-
-
-# def predict(department,image,max_length=64, num_beams=4):
-# image = image.convert('RGB')
-# image = feature_extractor(image, return_tensors="pt").pixel_values.to(device)
-# clean_text = lambda x: x.replace('<|endoftext|>','').split('\n')[0]
-# caption_ids = model.generate(image, max_length = max_length)[0]
-# caption_text = clean_text(tokenizer.decode(caption_ids))
-# dept=department
-# context= caption_text
-# response = co.generate(
-# model='large',
-# prompt=f'create non offensive one line meme for given department and context\n\ndepartment- data science\ncontext-a man sitting on a bench with a laptop\nmeme- \"I\'m not a data scientist, but I play one on my laptop.\"\n\ndepartment-startup\ncontext-a young boy is smiling while using a laptop\nmeme-\"When your startup gets funded and you can finally afford a new laptop\"\n\ndepartment- {dept}\ncontext-{context}\nmeme-',
-# max_tokens=20,
-# temperature=0.8,
-# k=0,
-# p=0.75,
-# frequency_penalty=0,
-# presence_penalty=0,
-# stop_sequences=["department"],
-# return_likelihoods='NONE')
-# reponse=response.generations[0].text
-# reponse = reponse.replace("department", "")
-# Feedback_SQL="DEPT"+dept+"CAPT"+caption_text+"MAMAY"+reponse
-
-
-# return reponse
-
-
-
-# # input = gr.inputs.Image(label="Upload your Image", type = 'pil', optional=True)
-
-
-
-# output = gr.outputs.Textbox(type="text",label="Meme")
-# #examples = [f"example{i}.jpg" for i in range(1,7)]
-# #examples = os.listdir()
-# examples = [f"example{i}.png" for i in range(1,7)]
-
-# #examples=os.listdir()
-# #for fichier in examples:
-# # if not(fichier.endswith(".png")):
-# # examples.remove(fichier)
-
-# description= " Looking for a fun and easy way to generate memes? Look no further than Meme world! Leveraging large language models like GPT-3PT-3 / Ai21 / Cohere, you can create memes that are sure to be a hit with your friends or network. Created with ♥️ by Arsalan @[Xaheen](https://www.linkedin.com/in/sallu-mandya/). kindly share your thoughts in discussion session and use the app responsibly #NO_Offense \n \n built with ❤️ @[Xhaheen](https://www.linkedin.com/in/sallu-mandya/)"
-# title = "Meme world 🖼️"
-# dropdown=["data science", "product management","marketing","startup" ,"agile","crypto" , "SEO" ]
-
-# article = "Created By : Xaheen "
-
-# interface = gr.Interface(
-# fn=predict,
-# inputs = [gr.inputs.Dropdown(dropdown),gr.inputs.Image(label="Upload your Image", type = 'pil', optional=True)],
-
-# theme="grass",
-# outputs=output,
-# examples =[['data science', 'example5.png'],
-# ['product management', 'example2.png'],
-# ['startup', 'example3.png'],
-# ['marketing', 'example4.png'],
-# ['agile', 'example1.png'],
-# ['crypto', 'example6.png']],
-# title=title,
-# description=description,
-# article = article,
-# )
-# interface.launch(debug=True)
-
-
-
-
-
-
-
-
-
-
-
-# Step 2: Set up the Gradio interface and import necessary packages
-import gradio as gr
-import openai
-from transformers import VisionEncoderDecoderModel, ViTImageProcessor, AutoTokenizer
-import torch
-from PIL import Image
-import os
-
-# Step 3: Load the provided image captioning model
-model = VisionEncoderDecoderModel.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
-feature_extractor = ViTImageProcessor.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
-tokenizer = AutoTokenizer.from_pretrained("nlpconnect/vit-gpt2-image-captioning")
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-model.to(device)
-
-# Step 4: Create a function to generate captions from images
-max_length = 16
-num_beams = 4
-gen_kwargs = {"max_length": max_length, "num_beams": num_beams}
-
-def generate_caption(image):
- image = Image.fromarray(image.astype('uint8'), 'RGB')
- if image.mode != "RGB":
- image = image.convert(mode="RGB")
- pixel_values = feature_extractor(images=[image], return_tensors="pt").pixel_values
- pixel_values = pixel_values.to(device)
- output_ids = model.generate(pixel_values, **gen_kwargs)
- caption = tokenizer.decode(output_ids[0], skip_special_tokens=True).strip()
- return caption
-
-
-# Step 5: Create a function to generate memes using the GPT-3 API
-def generate_meme(caption, department):
- openai.api_key = os.environ["key"]
- prompt = f"Create a non-offensive meme caption for the following image description in the context of {department} department: {caption}"
- response = openai.Completion.create(engine="text-davinci-002", prompt=prompt, max_tokens=50, n=1, stop=None, temperature=0.7)
- meme_caption = response.choices[0].text.strip()
- return meme_caption
-
-# Step 6: Define the main meme generation function
-def meme_generator(image, department):
- caption = generate_caption(image)
- meme_caption = generate_meme(caption, department)
- return meme_caption
-
-examples = [f"example{i}.png" for i in range(1,7)]
-
-# Step 7: Launch the Gradio application
-image_input = gr.inputs.Image()
-department_input = gr.inputs.Dropdown(choices=["data science", "product management","marketing","startup" ,"agile","crypto" , "SEO" ])
-output_text = gr.outputs.Textbox()
-
-gr.Interface(fn=meme_generator, inputs=[image_input, department_input], outputs=output_text, title="Meme world!",description= " Looking for a fun and easy way to generate memes? Look no further than Meme world! Leveraging large language models like GPT-3PT-3 / Ai21 / Cohere, you can create memes that are sure to be a hit with your friends or network. Created with ♥️ by Arsalan @[Xaheen](https://www.linkedin.com/in/sallu-mandya/). kindly share your thoughts in discussion session and use the app responsibly #NO_Offense \n \n built with ❤️ @[Xhaheen](https://www.linkedin.com/in/sallu-mandya/)", theme="gradio/seafoam",
-
- examples =[['example5.png','data science' ],
- ['example2.png','product management'],
- ['example3.png','startup'],
- ['example4.png','marketing'],
- ['example1.png','agile'],
- ['example6.png','crypto']]).launch(debug=True)
-
-
-
diff --git a/spaces/Xuan2060320350/ChatSydney/README.md b/spaces/Xuan2060320350/ChatSydney/README.md
deleted file mode 100644
index da939ac26975902fd8f3bc369382368741262f64..0000000000000000000000000000000000000000
--- a/spaces/Xuan2060320350/ChatSydney/README.md
+++ /dev/null
@@ -1,11 +0,0 @@
----
-title: ChatSydney
-emoji: 🐠
-colorFrom: pink
-colorTo: yellow
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/XzJosh/LAPLACE-Bert-VITS2/app.py b/spaces/XzJosh/LAPLACE-Bert-VITS2/app.py
deleted file mode 100644
index 2307154a8886fa1b2ebd9552c6e1c2900c28c03c..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/LAPLACE-Bert-VITS2/app.py
+++ /dev/null
@@ -1,144 +0,0 @@
-import sys, os
-
-if sys.platform == "darwin":
- os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
-
-import logging
-
-logging.getLogger("numba").setLevel(logging.WARNING)
-logging.getLogger("markdown_it").setLevel(logging.WARNING)
-logging.getLogger("urllib3").setLevel(logging.WARNING)
-logging.getLogger("matplotlib").setLevel(logging.WARNING)
-
-logging.basicConfig(level=logging.INFO, format="| %(name)s | %(levelname)s | %(message)s")
-
-logger = logging.getLogger(__name__)
-
-import torch
-import argparse
-import commons
-import utils
-from models import SynthesizerTrn
-from text.symbols import symbols
-from text import cleaned_text_to_sequence, get_bert
-from text.cleaner import clean_text
-import gradio as gr
-import webbrowser
-
-
-net_g = None
-
-
-def get_text(text, language_str, hps):
- norm_text, phone, tone, word2ph = clean_text(text, language_str)
- phone, tone, language = cleaned_text_to_sequence(phone, tone, language_str)
-
- if hps.data.add_blank:
- phone = commons.intersperse(phone, 0)
- tone = commons.intersperse(tone, 0)
- language = commons.intersperse(language, 0)
- for i in range(len(word2ph)):
- word2ph[i] = word2ph[i] * 2
- word2ph[0] += 1
- bert = get_bert(norm_text, word2ph, language_str)
- del word2ph
-
- assert bert.shape[-1] == len(phone)
-
- phone = torch.LongTensor(phone)
- tone = torch.LongTensor(tone)
- language = torch.LongTensor(language)
-
- return bert, phone, tone, language
-
-def infer(text, sdp_ratio, noise_scale, noise_scale_w, length_scale, sid):
- global net_g
- bert, phones, tones, lang_ids = get_text(text, "ZH", hps)
- with torch.no_grad():
- x_tst=phones.to(device).unsqueeze(0)
- tones=tones.to(device).unsqueeze(0)
- lang_ids=lang_ids.to(device).unsqueeze(0)
- bert = bert.to(device).unsqueeze(0)
- x_tst_lengths = torch.LongTensor([phones.size(0)]).to(device)
- del phones
- speakers = torch.LongTensor([hps.data.spk2id[sid]]).to(device)
- audio = net_g.infer(x_tst, x_tst_lengths, speakers, tones, lang_ids, bert, sdp_ratio=sdp_ratio
- , noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale)[0][0,0].data.cpu().float().numpy()
- del x_tst, tones, lang_ids, bert, x_tst_lengths, speakers
- return audio
-
-def tts_fn(text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale):
- with torch.no_grad():
- audio = infer(text, sdp_ratio=sdp_ratio, noise_scale=noise_scale, noise_scale_w=noise_scale_w, length_scale=length_scale, sid=speaker)
- return "Success", (hps.data.sampling_rate, audio)
-
-
-if __name__ == "__main__":
- parser = argparse.ArgumentParser()
- parser.add_argument("--model_dir", default="./logs/LAPLACE/G_18000.pth", help="path of your model")
- parser.add_argument("--config_dir", default="./configs/config.json", help="path of your config file")
- parser.add_argument("--share", default=False, help="make link public")
- parser.add_argument("-d", "--debug", action="store_true", help="enable DEBUG-LEVEL log")
-
- args = parser.parse_args()
- if args.debug:
- logger.info("Enable DEBUG-LEVEL log")
- logging.basicConfig(level=logging.DEBUG)
- hps = utils.get_hparams_from_file(args.config_dir)
- device = "cuda:0" if torch.cuda.is_available() else "cpu"
- '''
- device = (
- "cuda:0"
- if torch.cuda.is_available()
- else (
- "mps"
- if sys.platform == "darwin" and torch.backends.mps.is_available()
- else "cpu"
- )
- )
- '''
- net_g = SynthesizerTrn(
- len(symbols),
- hps.data.filter_length // 2 + 1,
- hps.train.segment_size // hps.data.hop_length,
- n_speakers=hps.data.n_speakers,
- **hps.model).to(device)
- _ = net_g.eval()
-
- _ = utils.load_checkpoint(args.model_dir, net_g, None, skip_optimizer=True)
-
- speaker_ids = hps.data.spk2id
- speakers = list(speaker_ids.keys())
- with gr.Blocks() as app:
- with gr.Row():
- with gr.Column():
- gr.Markdown(value="""
- 【AI奶绿】在线语音合成（Bert-Vits2）\n
- 作者：Xz乔希 https://space.bilibili.com/5859321\n
- 声音归属：明前奶绿 https://space.bilibili.com/2132180406\n
- Bert-VITS2项目：https://github.com/Stardust-minus/Bert-VITS2\n
- 【AI塔菲】https://huggingface.co/spaces/XzJosh/Taffy-Bert-VITS2\n
- 【AI东雪莲】https://huggingface.co/spaces/XzJosh/Azuma-Bert-VITS2\n
- 使用本模型请严格遵守法律法规！\n
- 发布二创作品请标注本项目作者及链接、作品使用Bert-VITS2 AI生成！\n
- """)
- text = gr.TextArea(label="Text", placeholder="Input Text Here",
- value="欢迎来到拉普拉斯花店，我是店员明前奶绿。")
- speaker = gr.Dropdown(choices=speakers, value=speakers[0], label='Speaker')
- sdp_ratio = gr.Slider(minimum=0.1, maximum=1, value=0.2, step=0.1, label='SDP/DP混合比')
- noise_scale = gr.Slider(minimum=0.1, maximum=1, value=0.5, step=0.1, label='感情调节')
- noise_scale_w = gr.Slider(minimum=0.1, maximum=1, value=0.9, step=0.1, label='音素长度')
- length_scale = gr.Slider(minimum=0.1, maximum=2, value=1, step=0.01, label='生成长度')
- btn = gr.Button("点击生成！", variant="primary")
- with gr.Column():
- text_output = gr.Textbox(label="Message")
- audio_output = gr.Audio(label="Output Audio")
-
- btn.click(tts_fn,
- inputs=[text, speaker, sdp_ratio, noise_scale, noise_scale_w, length_scale],
- outputs=[text_output, audio_output])
-
-# webbrowser.open("http://127.0.0.1:6006")
-# app.launch(server_port=6006, show_error=True)
-
- app.launch(show_error=True)
diff --git a/spaces/XzJosh/Lumi-Bert-VITS2/commons.py b/spaces/XzJosh/Lumi-Bert-VITS2/commons.py
deleted file mode 100644
index 9ad0444b61cbadaa388619986c2889c707d873ce..0000000000000000000000000000000000000000
--- a/spaces/XzJosh/Lumi-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/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/pndm/pipeline_pndm.py b/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/pndm/pipeline_pndm.py
deleted file mode 100644
index ef7062dea19cd34d533dbf7eee25fd3d0c21b4f8..0000000000000000000000000000000000000000
--- a/spaces/YeOldHermit/Super-Resolution-Anime-Diffusion/diffusers/pipelines/pndm/pipeline_pndm.py
+++ /dev/null
@@ -1,96 +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.
-
-
-from typing import Optional, Tuple, Union
-
-import torch
-
-from ...models import UNet2DModel
-from ...pipeline_utils import DiffusionPipeline, ImagePipelineOutput
-from ...schedulers import PNDMScheduler
-
-
-class PNDMPipeline(DiffusionPipeline):
- r"""
- This model inherits from [`DiffusionPipeline`]. Check the superclass documentation for the generic methods the
- library implements for all the pipelines (such as downloading or saving, running on a particular device, etc.)
-
- Parameters:
- unet (`UNet2DModel`): U-Net architecture to denoise the encoded image latents.
- scheduler ([`SchedulerMixin`]):
- The `PNDMScheduler` to be used in combination with `unet` to denoise the encoded image.
- """
-
- unet: UNet2DModel
- scheduler: PNDMScheduler
-
- def __init__(self, unet: UNet2DModel, scheduler: PNDMScheduler):
- super().__init__()
- self.register_modules(unet=unet, scheduler=scheduler)
-
- @torch.no_grad()
- def __call__(
- self,
- batch_size: int = 1,
- num_inference_steps: int = 50,
- generator: Optional[torch.Generator] = None,
- output_type: Optional[str] = "pil",
- return_dict: bool = True,
- **kwargs,
- ) -> Union[ImagePipelineOutput, Tuple]:
- r"""
- Args:
- batch_size (`int`, `optional`, defaults to 1): The number of images to generate.
- num_inference_steps (`int`, `optional`, defaults to 50):
- The number of denoising steps. More denoising steps usually lead to a higher quality image at the
- expense of slower inference.
- generator (`torch.Generator`, `optional`): A [torch
- generator](https://pytorch.org/docs/stable/generated/torch.Generator.html) to make generation
- deterministic.
- output_type (`str`, `optional`, defaults to `"pil"`): The output format of the generate image. Choose
- between [PIL](https://pillow.readthedocs.io/en/stable/): `PIL.Image.Image` or `np.array`.
- return_dict (`bool`, `optional`, defaults to `True`): Whether or not to return a
- [`~pipeline_utils.ImagePipelineOutput`] instead of a plain tuple.
-
- Returns:
- [`~pipeline_utils.ImagePipelineOutput`] or `tuple`: [`~pipelines.utils.ImagePipelineOutput`] if
- `return_dict` is True, otherwise a `tuple. When returning a tuple, the first element is a list with the
- generated images.
- """
- # For more information on the sampling method you can take a look at Algorithm 2 of
- # the official paper: https://arxiv.org/pdf/2202.09778.pdf
-
- # Sample gaussian noise to begin loop
- image = torch.randn(
- (batch_size, self.unet.in_channels, self.unet.sample_size, self.unet.sample_size),
- generator=generator,
- )
- image = image.to(self.device)
-
- self.scheduler.set_timesteps(num_inference_steps)
- for t in self.progress_bar(self.scheduler.timesteps):
- model_output = self.unet(image, t).sample
-
- image = self.scheduler.step(model_output, t, image).prev_sample
-
- image = (image / 2 + 0.5).clamp(0, 1)
- image = image.cpu().permute(0, 2, 3, 1).numpy()
- if output_type == "pil":
- image = self.numpy_to_pil(image)
-
- if not return_dict:
- return (image,)
-
- return ImagePipelineOutput(images=image)
diff --git a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/checkpoint/detection_checkpoint.py b/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/checkpoint/detection_checkpoint.py
deleted file mode 100644
index 82fd3b2d40054573917a445b138d29a6dabfb907..0000000000000000000000000000000000000000
--- a/spaces/Yiqin/ChatVID/model/vision/grit_src/third_party/CenterNet2/detectron2/checkpoint/detection_checkpoint.py
+++ /dev/null
@@ -1,120 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import logging
-import os
-import pickle
-import torch
-from fvcore.common.checkpoint import Checkpointer
-from torch.nn.parallel import DistributedDataParallel
-
-import detectron2.utils.comm as comm
-from detectron2.utils.file_io import PathManager
-
-from .c2_model_loading import align_and_update_state_dicts
-
-
-class DetectionCheckpointer(Checkpointer):
- """
- Same as :class:`Checkpointer`, but is able to:
- 1. handle models in detectron & detectron2 model zoo, and apply conversions for legacy models.
- 2. correctly load checkpoints that are only available on the master worker
- """
-
- def __init__(self, model, save_dir="", *, save_to_disk=None, **checkpointables):
- is_main_process = comm.is_main_process()
- super().__init__(
- model,
- save_dir,
- save_to_disk=is_main_process if save_to_disk is None else save_to_disk,
- **checkpointables,
- )
- self.path_manager = PathManager
-
- def load(self, path, *args, **kwargs):
- need_sync = False
-
- if path and isinstance(self.model, DistributedDataParallel):
- logger = logging.getLogger(__name__)
- path = self.path_manager.get_local_path(path)
- has_file = os.path.isfile(path)
- all_has_file = comm.all_gather(has_file)
- if not all_has_file[0]:
- raise OSError(f"File {path} not found on main worker.")
- if not all(all_has_file):
- logger.warning(
- f"Not all workers can read checkpoint {path}. "
- "Training may fail to fully resume."
- )
- # TODO: broadcast the checkpoint file contents from main
- # worker, and load from it instead.
- need_sync = True
- if not has_file:
- path = None # don't load if not readable
- ret = super().load(path, *args, **kwargs)
-
- if need_sync:
- logger.info("Broadcasting model states from main worker ...")
- self.model._sync_params_and_buffers()
- return ret
-
- def _load_file(self, filename):
- if filename.endswith(".pkl"):
- with PathManager.open(filename, "rb") as f:
- data = pickle.load(f, encoding="latin1")
- if "model" in data and "__author__" in data:
- # file is in Detectron2 model zoo format
- self.logger.info("Reading a file from '{}'".format(data["__author__"]))
- return data
- else:
- # assume file is from Caffe2 / Detectron1 model zoo
- if "blobs" in data:
- # Detection models have "blobs", but ImageNet models don't
- data = data["blobs"]
- data = {k: v for k, v in data.items() if not k.endswith("_momentum")}
- return {"model": data, "__author__": "Caffe2", "matching_heuristics": True}
- elif filename.endswith(".pyth"):
- # assume file is from pycls; no one else seems to use the ".pyth" extension
- with PathManager.open(filename, "rb") as f:
- data = torch.load(f)
- assert (
- "model_state" in data
- ), f"Cannot load .pyth file {filename}; pycls checkpoints must contain 'model_state'."
- model_state = {
- k: v
- for k, v in data["model_state"].items()
- if not k.endswith("num_batches_tracked")
- }
- return {"model": model_state, "__author__": "pycls", "matching_heuristics": True}
-
- loaded = super()._load_file(filename) # load native pth checkpoint
- if "model" not in loaded:
- loaded = {"model": loaded}
- return loaded
-
- def _load_model(self, checkpoint):
- if checkpoint.get("matching_heuristics", False):
- self._convert_ndarray_to_tensor(checkpoint["model"])
- # convert weights by name-matching heuristics
- checkpoint["model"] = align_and_update_state_dicts(
- self.model.state_dict(),
- checkpoint["model"],
- c2_conversion=checkpoint.get("__author__", None) == "Caffe2",
- )
- # for non-caffe2 models, use standard ways to load it
- incompatible = super()._load_model(checkpoint)
-
- model_buffers = dict(self.model.named_buffers(recurse=False))
- for k in ["pixel_mean", "pixel_std"]:
- # Ignore missing key message about pixel_mean/std.
- # Though they may be missing in old checkpoints, they will be correctly
- # initialized from config anyway.
- if k in model_buffers:
- try:
- incompatible.missing_keys.remove(k)
- except ValueError:
- pass
- for k in incompatible.unexpected_keys[:]:
- # Ignore unexpected keys about cell anchors. They exist in old checkpoints
- # but now they are non-persistent buffers and will not be in new checkpoints.
- if "anchor_generator.cell_anchors" in k:
- incompatible.unexpected_keys.remove(k)
- return incompatible
diff --git a/spaces/abby711/FaceRestoration/PaperModel.md b/spaces/abby711/FaceRestoration/PaperModel.md
deleted file mode 100644
index aec81d31de56df74c19ae840d44ad2b2a1f06d28..0000000000000000000000000000000000000000
--- a/spaces/abby711/FaceRestoration/PaperModel.md
+++ /dev/null
@@ -1,76 +0,0 @@
-# Installation
-
-We now provide a *clean* version of GFPGAN, which does not require customized CUDA extensions. See [here](README.md#installation) for this easier installation.':
- args.input = codecs.open(args.input.name, encoding='utf-8')
- if args.output.name != '':
- args.output = codecs.open(args.output.name, 'w', encoding='utf-8')
-
- get_vocab(args.input, args.output)
-
- # close files
- if args.input.name != '':
- args.input.close()
- if args.output.name != '':
- args.output.close()
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmcv/cnn/bricks/padding.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmcv/cnn/bricks/padding.py
deleted file mode 100644
index e4ac6b28a1789bd551c613a7d3e7b622433ac7ec..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmcv/cnn/bricks/padding.py
+++ /dev/null
@@ -1,36 +0,0 @@
-# Copyright (c) OpenMMLab. All rights reserved.
-import torch.nn as nn
-
-from .registry import PADDING_LAYERS
-
-PADDING_LAYERS.register_module('zero', module=nn.ZeroPad2d)
-PADDING_LAYERS.register_module('reflect', module=nn.ReflectionPad2d)
-PADDING_LAYERS.register_module('replicate', module=nn.ReplicationPad2d)
-
-
-def build_padding_layer(cfg, *args, **kwargs):
- """Build padding layer.
-
- Args:
- cfg (None or dict): The padding layer config, which should contain:
- - type (str): Layer type.
- - layer args: Args needed to instantiate a padding layer.
-
- Returns:
- nn.Module: Created padding layer.
- """
- if not isinstance(cfg, dict):
- raise TypeError('cfg must be a dict')
- if 'type' not in cfg:
- raise KeyError('the cfg dict must contain the key "type"')
-
- cfg_ = cfg.copy()
- padding_type = cfg_.pop('type')
- if padding_type not in PADDING_LAYERS:
- raise KeyError(f'Unrecognized padding type {padding_type}.')
- else:
- padding_layer = PADDING_LAYERS.get(padding_type)
-
- layer = padding_layer(*args, **kwargs, **cfg_)
-
- return layer
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/utils/optimizer.py b/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/utils/optimizer.py
deleted file mode 100644
index 9c9d11941c0b43d42bd6daad1e4b927eaca3e675..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer/mmdet/utils/optimizer.py
+++ /dev/null
@@ -1,33 +0,0 @@
-from mmcv.runner import OptimizerHook, HOOKS
-try:
- import apex
-except:
- print('apex is not installed')
-
-
-@HOOKS.register_module()
-class DistOptimizerHook(OptimizerHook):
- """Optimizer hook for distributed training."""
-
- def __init__(self, update_interval=1, grad_clip=None, coalesce=True, bucket_size_mb=-1, use_fp16=False):
- self.grad_clip = grad_clip
- self.coalesce = coalesce
- self.bucket_size_mb = bucket_size_mb
- self.update_interval = update_interval
- self.use_fp16 = use_fp16
-
- def before_run(self, runner):
- runner.optimizer.zero_grad()
-
- def after_train_iter(self, runner):
- runner.outputs['loss'] /= self.update_interval
- if self.use_fp16:
- with apex.amp.scale_loss(runner.outputs['loss'], runner.optimizer) as scaled_loss:
- scaled_loss.backward()
- else:
- runner.outputs['loss'].backward()
- if self.every_n_iters(runner, self.update_interval):
- if self.grad_clip is not None:
- self.clip_grads(runner.model.parameters())
- runner.optimizer.step()
- runner.optimizer.zero_grad()
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/models/fast_scnn.py b/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/models/fast_scnn.py
deleted file mode 100644
index 32fdeb659355a5ce5ef2cc7c2f30742703811cdf..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/configs/_base_/models/fast_scnn.py
+++ /dev/null
@@ -1,57 +0,0 @@
-# model settings
-norm_cfg = dict(type='SyncBN', requires_grad=True, momentum=0.01)
-model = dict(
- type='EncoderDecoder',
- backbone=dict(
- type='FastSCNN',
- downsample_dw_channels=(32, 48),
- global_in_channels=64,
- global_block_channels=(64, 96, 128),
- global_block_strides=(2, 2, 1),
- global_out_channels=128,
- higher_in_channels=64,
- lower_in_channels=128,
- fusion_out_channels=128,
- out_indices=(0, 1, 2),
- norm_cfg=norm_cfg,
- align_corners=False),
- decode_head=dict(
- type='DepthwiseSeparableFCNHead',
- in_channels=128,
- channels=128,
- concat_input=False,
- num_classes=19,
- in_index=-1,
- norm_cfg=norm_cfg,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
- auxiliary_head=[
- dict(
- type='FCNHead',
- in_channels=128,
- channels=32,
- num_convs=1,
- num_classes=19,
- in_index=-2,
- norm_cfg=norm_cfg,
- concat_input=False,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
- dict(
- type='FCNHead',
- in_channels=64,
- channels=32,
- num_convs=1,
- num_classes=19,
- in_index=-3,
- norm_cfg=norm_cfg,
- concat_input=False,
- align_corners=False,
- loss_decode=dict(
- type='CrossEntropyLoss', use_sigmoid=True, loss_weight=0.4)),
- ],
- # model training and testing settings
- train_cfg=dict(),
- test_cfg=dict(mode='whole'))
diff --git a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_w32.py b/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_w32.py
deleted file mode 100644
index 2ba338cb5a916d44869c9e00ced9a9d579d91a40..0000000000000000000000000000000000000000
--- a/spaces/abhishek/sketch-to-image/annotator/uniformer_base/exp/upernet_global_base/test_config_w32.py
+++ /dev/null
@@ -1,50 +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=True,
- hybrid=False,
- window_size=32,
- ),
- 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/abrar-lohia/text-2-character-anim/pyrender/pyrender/mesh.py b/spaces/abrar-lohia/text-2-character-anim/pyrender/pyrender/mesh.py
deleted file mode 100644
index 36833ea3dfa6c095a18fc745ff34cf106e83c95d..0000000000000000000000000000000000000000
--- a/spaces/abrar-lohia/text-2-character-anim/pyrender/pyrender/mesh.py
+++ /dev/null
@@ -1,328 +0,0 @@
-"""Meshes, conforming to the glTF 2.0 standards as specified in
-https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#reference-mesh
-
-Author: Matthew Matl
-"""
-import copy
-
-import numpy as np
-import trimesh
-
-from .primitive import Primitive
-from .constants import GLTF
-from .material import MetallicRoughnessMaterial
-
-
-class Mesh(object):
- """A set of primitives to be rendered.
-
- Parameters
- ----------
- name : str
- The user-defined name of this object.
- primitives : list of :class:`Primitive`
- The primitives associated with this mesh.
- weights : (k,) float
- Array of weights to be applied to the Morph Targets.
- is_visible : bool
- If False, the mesh will not be rendered.
- """
-
- def __init__(self, primitives, name=None, weights=None, is_visible=True):
- self.primitives = primitives
- self.name = name
- self.weights = weights
- self.is_visible = is_visible
-
- self._bounds = None
-
- @property
- def name(self):
- """str : The user-defined name of this object.
- """
- return self._name
-
- @name.setter
- def name(self, value):
- if value is not None:
- value = str(value)
- self._name = value
-
- @property
- def primitives(self):
- """list of :class:`Primitive` : The primitives associated
- with this mesh.
- """
- return self._primitives
-
- @primitives.setter
- def primitives(self, value):
- self._primitives = value
-
- @property
- def weights(self):
- """(k,) float : Weights to be applied to morph targets.
- """
- return self._weights
-
- @weights.setter
- def weights(self, value):
- self._weights = value
-
- @property
- def is_visible(self):
- """bool : Whether the mesh is visible.
- """
- return self._is_visible
-
- @is_visible.setter
- def is_visible(self, value):
- self._is_visible = value
-
- @property
- def bounds(self):
- """(2,3) float : The axis-aligned bounds of the mesh.
- """
- if self._bounds is None:
- bounds = np.array([[np.infty, np.infty, np.infty],
- [-np.infty, -np.infty, -np.infty]])
- for p in self.primitives:
- bounds[0] = np.minimum(bounds[0], p.bounds[0])
- bounds[1] = np.maximum(bounds[1], p.bounds[1])
- self._bounds = bounds
- return self._bounds
-
- @property
- def centroid(self):
- """(3,) float : The centroid of the mesh's axis-aligned bounding box
- (AABB).
- """
- return np.mean(self.bounds, axis=0)
-
- @property
- def extents(self):
- """(3,) float : The lengths of the axes of the mesh's AABB.
- """
- return np.diff(self.bounds, axis=0).reshape(-1)
-
- @property
- def scale(self):
- """(3,) float : The length of the diagonal of the mesh's AABB.
- """
- return np.linalg.norm(self.extents)
-
- @property
- def is_transparent(self):
- """bool : If True, the mesh is partially-transparent.
- """
- for p in self.primitives:
- if p.is_transparent:
- return True
- return False
-
- @staticmethod
- def from_points(points, colors=None, normals=None,
- is_visible=True, poses=None):
- """Create a Mesh from a set of points.
-
- Parameters
- ----------
- points : (n,3) float
- The point positions.
- colors : (n,3) or (n,4) float, optional
- RGB or RGBA colors for each point.
- normals : (n,3) float, optionals
- The normal vectors for each point.
- is_visible : bool
- If False, the points will not be rendered.
- poses : (x,4,4)
- Array of 4x4 transformation matrices for instancing this object.
-
- Returns
- -------
- mesh : :class:`Mesh`
- The created mesh.
- """
- primitive = Primitive(
- positions=points,
- normals=normals,
- color_0=colors,
- mode=GLTF.POINTS,
- poses=poses
- )
- mesh = Mesh(primitives=[primitive], is_visible=is_visible)
- return mesh
-
- @staticmethod
- def from_trimesh(mesh, material=None, is_visible=True,
- poses=None, wireframe=False, smooth=True):
- """Create a Mesh from a :class:`~trimesh.base.Trimesh`.
-
- Parameters
- ----------
- mesh : :class:`~trimesh.base.Trimesh` or list of them
- A triangular mesh or a list of meshes.
- material : :class:`Material`
- The material of the object. Overrides any mesh material.
- If not specified and the mesh has no material, a default material
- will be used.
- is_visible : bool
- If False, the mesh will not be rendered.
- poses : (n,4,4) float
- Array of 4x4 transformation matrices for instancing this object.
- wireframe : bool
- If `True`, the mesh will be rendered as a wireframe object
- smooth : bool
- If `True`, the mesh will be rendered with interpolated vertex
- normals. Otherwise, the mesh edges will stay sharp.
-
- Returns
- -------
- mesh : :class:`Mesh`
- The created mesh.
- """
-
- if isinstance(mesh, (list, tuple, set, np.ndarray)):
- meshes = list(mesh)
- elif isinstance(mesh, trimesh.Trimesh):
- meshes = [mesh]
- else:
- raise TypeError('Expected a Trimesh or a list, got a {}'
- .format(type(mesh)))
-
- primitives = []
- for m in meshes:
- positions = None
- normals = None
- indices = None
-
- # Compute positions, normals, and indices
- if smooth:
- positions = m.vertices.copy()
- normals = m.vertex_normals.copy()
- indices = m.faces.copy()
- else:
- positions = m.vertices[m.faces].reshape((3 * len(m.faces), 3))
- normals = np.repeat(m.face_normals, 3, axis=0)
-
- # Compute colors, texture coords, and material properties
- color_0, texcoord_0, primitive_material = Mesh._get_trimesh_props(m, smooth=smooth, material=material)
-
- # Override if material is given.
- if material is not None:
- #primitive_material = copy.copy(material)
- primitive_material = copy.deepcopy(material) # TODO
-
- if primitive_material is None:
- # Replace material with default if needed
- primitive_material = MetallicRoughnessMaterial(
- alphaMode='BLEND',
- baseColorFactor=[0.3, 0.3, 0.3, 1.0],
- metallicFactor=0.2,
- roughnessFactor=0.8
- )
-
- primitive_material.wireframe = wireframe
-
- # Create the primitive
- primitives.append(Primitive(
- positions=positions,
- normals=normals,
- texcoord_0=texcoord_0,
- color_0=color_0,
- indices=indices,
- material=primitive_material,
- mode=GLTF.TRIANGLES,
- poses=poses
- ))
-
- return Mesh(primitives=primitives, is_visible=is_visible)
-
- @staticmethod
- def _get_trimesh_props(mesh, smooth=False, material=None):
- """Gets the vertex colors, texture coordinates, and material properties
- from a :class:`~trimesh.base.Trimesh`.
- """
- colors = None
- texcoords = None
-
- # If the trimesh visual is undefined, return none for both
- if not mesh.visual.defined:
- return colors, texcoords, material
-
- # Process vertex colors
- if material is None:
- if mesh.visual.kind == 'vertex':
- vc = mesh.visual.vertex_colors.copy()
- if smooth:
- colors = vc
- else:
- colors = vc[mesh.faces].reshape(
- (3 * len(mesh.faces), vc.shape[1])
- )
- material = MetallicRoughnessMaterial(
- alphaMode='BLEND',
- baseColorFactor=[1.0, 1.0, 1.0, 1.0],
- metallicFactor=0.2,
- roughnessFactor=0.8
- )
- # Process face colors
- elif mesh.visual.kind == 'face':
- if smooth:
- raise ValueError('Cannot use face colors with a smooth mesh')
- else:
- colors = np.repeat(mesh.visual.face_colors, 3, axis=0)
-
- material = MetallicRoughnessMaterial(
- alphaMode='BLEND',
- baseColorFactor=[1.0, 1.0, 1.0, 1.0],
- metallicFactor=0.2,
- roughnessFactor=0.8
- )
-
- # Process texture colors
- if mesh.visual.kind == 'texture':
- # Configure UV coordinates
- if mesh.visual.uv is not None and len(mesh.visual.uv) != 0:
- uv = mesh.visual.uv.copy()
- if smooth:
- texcoords = uv
- else:
- texcoords = uv[mesh.faces].reshape(
- (3 * len(mesh.faces), uv.shape[1])
- )
-
- if material is None:
- # Configure mesh material
- mat = mesh.visual.material
-
- if isinstance(mat, trimesh.visual.texture.PBRMaterial):
- material = MetallicRoughnessMaterial(
- normalTexture=mat.normalTexture,
- occlusionTexture=mat.occlusionTexture,
- emissiveTexture=mat.emissiveTexture,
- emissiveFactor=mat.emissiveFactor,
- alphaMode='BLEND',
- baseColorFactor=mat.baseColorFactor,
- baseColorTexture=mat.baseColorTexture,
- metallicFactor=mat.metallicFactor,
- roughnessFactor=mat.roughnessFactor,
- metallicRoughnessTexture=mat.metallicRoughnessTexture,
- doubleSided=mat.doubleSided,
- alphaCutoff=mat.alphaCutoff
- )
- elif isinstance(mat, trimesh.visual.texture.SimpleMaterial):
- glossiness = mat.kwargs.get('Ns', 1.0)
- if isinstance(glossiness, list):
- glossiness = float(glossiness[0])
- roughness = (2 / (glossiness + 2)) ** (1.0 / 4.0)
- material = MetallicRoughnessMaterial(
- alphaMode='BLEND',
- roughnessFactor=roughness,
- baseColorFactor=mat.diffuse,
- baseColorTexture=mat.image,
- )
- elif isinstance(mat, MetallicRoughnessMaterial):
- material = mat
-
- return colors, texcoords, material
diff --git a/spaces/adityapatkar/chatcsv/app.py b/spaces/adityapatkar/chatcsv/app.py
deleted file mode 100644
index 001ff4cadaa99a0af5c90204c049774e7eee2342..0000000000000000000000000000000000000000
--- a/spaces/adityapatkar/chatcsv/app.py
+++ /dev/null
@@ -1,43 +0,0 @@
-import streamlit as st
-
-from langchain.agents import create_pandas_dataframe_agent
-from langchain.chat_models import ChatOpenAI
-from langchain.agents.agent_types import AgentType
-
-import pandas as pd
-
-form = st.sidebar.form(key='my_form')
-user_api_key = form.text_input(
- label="#### Your OpenAI API key 👇",
- placeholder="Paste your openAI API key, sk-",
- type="password")
-uploaded_file = form.file_uploader("Choose a file")
-text_prompt = form.text_area('Text Prompt', value='Hello, how are you?')
-submit_button = form.form_submit_button(label='Submit')
-if submit_button :
- df = pd.read_csv(uploaded_file)
-
- st.title("OpenAI Chatbot 🤖"
- )
- st.subheader("This is a simple chatbot that uses OpenAI's GPT-3 model to generate responses to your text prompt. ")
-
- st.subheader("Your data:")
- st.write(df)
-
- #horizontal line
- st.markdown("""---""")
-
- st.subheader("AI generated response:")
-
- agent = create_pandas_dataframe_agent(
- ChatOpenAI(temperature=0, model="gpt-3.5-turbo-16k", openai_api_key=user_api_key),
- df,
- verbose=True,
- agent_type=AgentType.OPENAI_FUNCTIONS,
- )
-
- result = agent.run(text_prompt)
- st.write(result)
-
-
-
\ No newline at end of file
diff --git a/spaces/adrianpierce/recipes_app/Home.py b/spaces/adrianpierce/recipes_app/Home.py
deleted file mode 100644
index 30362c487d16060d9cfe2f1650023be612720c17..0000000000000000000000000000000000000000
--- a/spaces/adrianpierce/recipes_app/Home.py
+++ /dev/null
@@ -1,252 +0,0 @@
-import streamlit as st
-import numpy as np
-import pandas as pd
-import re
-import json
-from openai import OpenAI
-import secrets
-from datetime import datetime
-
-client = OpenAI(
- api_key = st.secrets["open_ai_key"]
-)
-
-# state management
-if 'gpt_response' not in st.session_state:
- st.session_state.gpt_response = None
-
-if 'recipe_saved' not in st.session_state:
- st.session_state.recipe_saved = None
-
-if 'user_direction' not in st.session_state:
- st.session_state.user_direction = None
-
-if 'serving_size' not in st.session_state:
- st.session_state.serving_size = 2
-
-if 'selected_difficulty' not in st.session_state:
- st.session_state.selected_difficulty = "Quick & Easy"
-
-if 'exclusions' not in st.session_state:
- st.session_state.exclusions = None
-
-if 'admin' not in st.session_state:
- st.session_state.admin = False
-
-
-# functions
-def create_detailed_prompt(user_direction, exclusions, serving_size, difficulty):
- if difficulty == "Quick & Easy":
- prompt = (
- f"Provide a 'Quick and Easy' recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. "
- f"It should require as few ingredients as possible and should be ready in as little time as possible. "
- f"The steps should be simple, and the ingredients should be commonly found in a household pantry. "
- f"Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail."
- )
- elif difficulty == "Intermediate":
- prompt = (
- f"Provide a classic recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. "
- f"The recipe should offer a bit of a cooking challenge but should not require professional skills. "
- f"The recipe should feature traditional ingredients and techniques that are authentic to its cuisine. "
- f"Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail."
- )
- elif difficulty == "Professional":
- prompt = (
- f"Provide a advanced recipe for {user_direction} that excludes {exclusions} and has a serving size of {serving_size}. "
- f"The recipe should push the boundaries of culinary arts, integrating unique ingredients, advanced cooking techniques, and innovative presentations. "
- f"The recipe should be able to be served at a high-end restaurant or would impress at a gourmet food competition. "
- f"Provide a detailed ingredient list and step-by-step guide that explains the instructions to prepare in detail."
- )
- return prompt
-
-def generate_recipe(user_inputs):
- with st.spinner('Building the perfect recipe...'):
- functions = [
- {
- "name": "provide_recipe",
- "description": "Provides a detailed recipe strictly adhering to the user input/specifications, especially ingredient exclusions and the recipe difficulty",
- "parameters": {
- "type": "object",
- "properties": {
- "name": {
- "type": "string",
- "description": "A creative name for the recipe"
- },
- "description": {
- "type": "string",
- "description": "a brief one-sentence description of the provided recipe"
- },
- "ingredients": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "name": {
- "type": "string",
- "description": "Quantity and name of the ingredient"
- }
- }
- }
- },
- "instructions": {
- "type": "array",
- "items": {
- "type": "object",
- "properties": {
- "step_number": {
- "type": "number",
- "description": "The sequence number of this step"
- },
- "instruction": {
- "type": "string",
- "description": "Detailed description of what to do in this step"
- }
- }
- }
- }
- },
- "required": [
- "name",
- "description",
- "ingredients",
- "instructions"
- ],
- },
- }
- ]
- prompt = create_detailed_prompt(user_inputs['user_direction'], user_inputs['exclusions'], user_inputs['serving_size'], user_inputs['difficulty'])
- messages = [{"role": "user", "content": prompt}]
- st.session_state.gpt_response = client.chat.completions.create(
- model="gpt-4-1106-preview",
- messages=messages,
- temperature=0.75,
- top_p=0.75,
- functions=functions,
- function_call={"name":"provide_recipe"}, # auto is default, but we'll be explicit
- )
- st.session_state.recipe_saved = False
-
-def create_safe_filename(recipe_name):
- # format and generate random URL-safe text string
- safe_name = recipe_name.lower()
- safe_name = safe_name.replace(" ", "_")
- safe_name = re.sub(r"[^a-zA-Z0-9_]", "", safe_name)
- safe_name = (safe_name[:50]) if len(safe_name) > 50 else safe_name
- unique_token = secrets.token_hex(8)
- safe_filename = f"{unique_token}_{safe_name}"
- return safe_filename
-
-def save_recipe():
- filename = create_safe_filename(recipe["name"])
- with open(f'/data/{filename}.json', 'w') as f:
- json.dump(recipe, f, indent=4)
- st.session_state.recipe_saved = True
-
-def clear_inputs():
- st.session_state.user_direction = None
- st.session_state.exclusions = None
- st.session_state.serving_size = 2
- st.session_state.selected_difficulty = "Quick & Easy"
-
-# app
-st.title("Let's get cooking")
-st.session_state.user_direction = st.text_area(
- "What do you want to cook? Describe anything - a dish, cuisine, event, or vibe.",
- value = st.session_state.user_direction,
- placeholder="quick snack, asian style bowl with either noodles or rice, something italian",
- )
-
-st.session_state.serving_size = st.number_input(
- "How many servings would you like to cook?",
- min_value=1,
- max_value=100,
- value=st.session_state.serving_size,
- step=1
-)
-
-difficulty_dictionary = {
- "Quick & Easy": {
- "description": "Easy recipes with straightforward instructions. Ideal for beginners or those seeking quick and simple cooking.",
- },
- "Intermediate": {
- "description": "Recipes with some intricate steps that invite a little challenge. Perfect for regular cooks wanting to expand their repertoire with new ingredients and techniques.",
- },
- "Professional": {
- "description": "Complex recipes that demand a high level of skill and precision. Suited for seasoned cooks aspiring to professional-level sophistication and creativity.",
- }
-}
-
-st.session_state.selected_difficulty = st.radio(
- "Choose a difficulty level for your recipe.",
- [
- list(difficulty_dictionary.keys())[0],
- list(difficulty_dictionary.keys())[1],
- list(difficulty_dictionary.keys())[2]
- ],
- captions = [
- difficulty_dictionary["Quick & Easy"]["description"],
- difficulty_dictionary["Intermediate"]["description"],
- difficulty_dictionary["Professional"]["description"]
- ],
- index=list(difficulty_dictionary).index(st.session_state.selected_difficulty)
-)
-
-st.session_state.exclusions = st.text_area(
- "Any ingredients you want to exclude?",
- value = st.session_state.exclusions,
- placeholder="gluten, dairy, nuts, cilantro",
- )
-
-fancy_exclusions =""
-
-if st.session_state.selected_difficulty == "Professional":
- exclude_fancy = st.checkbox(
- "Exclude cliche professional ingredients? (gold leaf, truffle, edible flowers, microgreens)",
- value=True)
- fancy_exclusions = "gold leaf, truffle, edible flowers, microgreens, gold dust"
-
-
-user_inputs = {
- "user_direction" : st.session_state.user_direction,
- "exclusions": f"{st.session_state.exclusions}, {fancy_exclusions}",
- "serving_size": st.session_state.serving_size,
- "difficulty": st.session_state.selected_difficulty
-}
-
-button_cols_submit = st.columns([1, 1, 4])
-with button_cols_submit[0]:
- st.button(label='Submit', on_click=generate_recipe, kwargs=dict(user_inputs=user_inputs), type="primary", use_container_width=True)
-with button_cols_submit[1]:
- st.button(label='Reset', on_click=clear_inputs, type="secondary", use_container_width=True)
-with button_cols_submit[2]:
- st.empty()
-
-if st.session_state.gpt_response is not None:
- st.divider()
- recipe = json.loads(st.session_state.gpt_response.choices[0].message.function_call.arguments)
- recipe_md = ''
- recipe_md += f'# {recipe["name"]} \n\n'
- recipe_md += f'{recipe["description"]} \n\n'
- recipe_md += f'## Ingredients: \n'
- for ingredient in recipe['ingredients']:
- recipe_md += f"- {ingredient['name']} \n"
- recipe_md += f'\n## Instructions:\n'
- for instruction in recipe['instructions']:
- recipe_md += f"{instruction['step_number']}. {instruction['instruction']} \n"
- recipe['md'] = recipe_md
- recipe['timestamp'] = str(datetime.now())
- st.markdown(recipe_md)
- st.write("")
- if st.session_state.recipe_saved == True:
- disable_button = True
- else:
- disable_button = False
- button_cols_save = st.columns([1, 1, 4])
- with button_cols_save[0]:
- st.button("Save Recipe", on_click=save_recipe, disabled=disable_button, type="primary")
- with button_cols_save[1]:
- st.empty()
- with button_cols_save[2]:
- st.empty()
- if st.session_state.recipe_saved == True:
- st.success("Recipe Saved!")
\ No newline at end of file
diff --git a/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/piano-symphony/create_indexes.sh b/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/piano-symphony/create_indexes.sh
deleted file mode 100644
index eff1369ac25ff22c70cfbacb77eeb77ac5377e7e..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/Music_Source_Separation/scripts/2_create_indexes/piano-symphony/create_indexes.sh
+++ /dev/null
@@ -1,12 +0,0 @@
-#!/bin/bash
-WORKSPACE=${1:-"./workspaces/bytesep"} # Default workspace directory
-
-echo "WORKSPACE=${WORKSPACE}"
-
-# Users can modify the following config file.
-INDEXES_CONFIG_YAML="scripts/2_create_indexes/piano-symphony/configs/piano-symphony,sr=44100,chn=2.yaml"
-
-# Create indexes for training.
-python3 bytesep/dataset_creation/create_indexes/create_indexes.py \
- --workspace=$WORKSPACE \
- --config_yaml=$INDEXES_CONFIG_YAML
diff --git a/spaces/akhaliq/Real-Time-Voice-Cloning/synthesizer/utils/cleaners.py b/spaces/akhaliq/Real-Time-Voice-Cloning/synthesizer/utils/cleaners.py
deleted file mode 100644
index eab63f05c9cc7cc0b583992eac94058097f3c191..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/Real-Time-Voice-Cloning/synthesizer/utils/cleaners.py
+++ /dev/null
@@ -1,88 +0,0 @@
-"""
-Cleaners are transformations that run over the input text at both training and eval time.
-
-Cleaners can be selected by passing a comma-delimited list of cleaner names as the "cleaners"
-hyperparameter. Some cleaners are English-specific. You"ll typically want to use:
- 1. "english_cleaners" for English text
- 2. "transliteration_cleaners" for non-English text that can be transliterated to ASCII using
- the Unidecode library (https://pypi.python.org/pypi/Unidecode)
- 3. "basic_cleaners" if you do not want to transliterate (in this case, you should also update
- the symbols in symbols.py to match your data).
-"""
-
-import re
-from unidecode import unidecode
-from .numbers import normalize_numbers
-
-# Regular expression matching whitespace:
-_whitespace_re = re.compile(r"\s+")
-
-# List of (regular expression, replacement) pairs for abbreviations:
-_abbreviations = [(re.compile("\\b%s\\." % x[0], re.IGNORECASE), x[1]) for x in [
- ("mrs", "misess"),
- ("mr", "mister"),
- ("dr", "doctor"),
- ("st", "saint"),
- ("co", "company"),
- ("jr", "junior"),
- ("maj", "major"),
- ("gen", "general"),
- ("drs", "doctors"),
- ("rev", "reverend"),
- ("lt", "lieutenant"),
- ("hon", "honorable"),
- ("sgt", "sergeant"),
- ("capt", "captain"),
- ("esq", "esquire"),
- ("ltd", "limited"),
- ("col", "colonel"),
- ("ft", "fort"),
-]]
-
-
-def expand_abbreviations(text):
- for regex, replacement in _abbreviations:
- text = re.sub(regex, replacement, text)
- return text
-
-
-def expand_numbers(text):
- return normalize_numbers(text)
-
-
-def lowercase(text):
- """lowercase input tokens."""
- return text.lower()
-
-
-def collapse_whitespace(text):
- return re.sub(_whitespace_re, " ", text)
-
-
-def convert_to_ascii(text):
- return unidecode(text)
-
-
-def basic_cleaners(text):
- """Basic pipeline that lowercases and collapses whitespace without transliteration."""
- text = lowercase(text)
- text = collapse_whitespace(text)
- return text
-
-
-def transliteration_cleaners(text):
- """Pipeline for non-English text that transliterates to ASCII."""
- text = convert_to_ascii(text)
- text = lowercase(text)
- text = collapse_whitespace(text)
- return text
-
-
-def english_cleaners(text):
- """Pipeline for English text, including number and abbreviation expansion."""
- text = convert_to_ascii(text)
- text = lowercase(text)
- text = expand_numbers(text)
- text = expand_abbreviations(text)
- text = collapse_whitespace(text)
- return text
diff --git a/spaces/akhaliq/deeplab2/data/build_step_data_test.py b/spaces/akhaliq/deeplab2/data/build_step_data_test.py
deleted file mode 100644
index b430b928829f997dc0d093fd9507b8c89550f6bc..0000000000000000000000000000000000000000
--- a/spaces/akhaliq/deeplab2/data/build_step_data_test.py
+++ /dev/null
@@ -1,164 +0,0 @@
-# coding=utf-8
-# Copyright 2021 The Deeplab2 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
-#
-# http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-"""Tests for build_step_data."""
-
-import os
-
-from absl import flags
-import numpy as np
-from PIL import Image
-import tensorflow as tf
-
-from deeplab2.data import build_step_data
-
-FLAGS = flags.FLAGS
-
-
-class BuildStepDataTest(tf.test.TestCase):
-
- def setUp(self):
- super().setUp()
- self.data_dir = FLAGS.test_tmpdir
- self.height = 100
- self.width = 100
- self.sequence_id = '010'
-
- def _create_images(self, split):
- image_path = os.path.join(self.data_dir, build_step_data._IMAGE_FOLDER_NAME,
- split, self.sequence_id)
- panoptic_map_path = os.path.join(self.data_dir,
- build_step_data._PANOPTIC_MAP_FOLDER_NAME,
- split, self.sequence_id)
-
- tf.io.gfile.makedirs(image_path)
- tf.io.gfile.makedirs(panoptic_map_path)
- self.panoptic_maps = {}
- for image_id in [101, 100]:
- self.panoptic_maps[image_id] = self._create_image_and_panoptic_map(
- image_path, panoptic_map_path, image_id)
-
- def _create_image_and_panoptic_map(self, image_path, panoptic_path, image_id):
- """Creates dummy images and panoptic maps."""
- # Dummy image.
- image = np.random.randint(
- 0, 255, (self.height, self.width, 3), dtype=np.uint8)
- with tf.io.gfile.GFile(
- os.path.join(image_path, '%06d.png' % image_id), 'wb') as f:
- Image.fromarray(image).save(f, format='PNG')
-
- # Dummy panoptic map.
- semantic = np.random.randint(
- 0, 20, (self.height, self.width), dtype=np.int32)
- instance = np.random.randint(
- 0, 1000, (self.height, self.width), dtype=np.int32)
- encoded_panoptic_map = np.dstack(
- (semantic, instance // 256, instance % 256)).astype(np.uint8)
- with tf.io.gfile.GFile(
- os.path.join(panoptic_path, '%06d.png' % image_id), 'wb') as f:
- Image.fromarray(encoded_panoptic_map).save(f, format='PNG')
- decoded_panoptic_map = semantic * 1000 + instance
- return decoded_panoptic_map
-
- def test_build_step_dataset_correct(self):
- split = 'train'
- self._create_images(split)
- build_step_data._convert_dataset(
- step_root=self.data_dir,
- dataset_split=split,
- output_dir=FLAGS.test_tmpdir)
- # We will have 2 shards with each shard containing 1 image.
- num_shards = 2
- output_record = os.path.join(
- FLAGS.test_tmpdir, build_step_data._TF_RECORD_PATTERN %
- (split, 0, num_shards))
- self.assertTrue(tf.io.gfile.exists(output_record))
-
- # Parses tf record.
- image_ids = sorted(self.panoptic_maps)
- for i, raw_record in enumerate(
- tf.data.TFRecordDataset([output_record]).take(5)):
- image_id = image_ids[i]
- example = tf.train.Example.FromString(raw_record.numpy())
- panoptic_map = np.fromstring(
- example.features.feature['image/segmentation/class/encoded']
- .bytes_list.value[0],
- dtype=np.int32).reshape((self.height, self.width))
- np.testing.assert_array_equal(panoptic_map, self.panoptic_maps[image_id])
- self.assertEqual(
- example.features.feature['video/sequence_id'].bytes_list.value[0],
- b'010')
- self.assertEqual(
- example.features.feature['video/frame_id'].bytes_list.value[0],
- b'%06d' % image_id)
-
- def test_build_step_dataset_correct_with_two_frames(self):
- split = 'train'
- self._create_images(split)
- build_step_data._convert_dataset(
- step_root=self.data_dir,
- dataset_split=split,
- output_dir=FLAGS.test_tmpdir, use_two_frames=True)
- num_shards = 2
- output_record = os.path.join(
- FLAGS.test_tmpdir, build_step_data._TF_RECORD_PATTERN %
- (split, 0, num_shards))
- self.assertTrue(tf.io.gfile.exists(output_record))
-
- # Parses tf record.
- image_ids = sorted(self.panoptic_maps)
- for i, raw_record in enumerate(
- tf.data.TFRecordDataset([output_record]).take(5)):
- image_id = image_ids[i]
- example = tf.train.Example.FromString(raw_record.numpy())
- panoptic_map = np.fromstring(
- example.features.feature['image/segmentation/class/encoded']
- .bytes_list.value[0],
- dtype=np.int32).reshape((self.height, self.width))
- np.testing.assert_array_equal(panoptic_map, self.panoptic_maps[image_id])
- prev_panoptic_map = np.fromstring(
- example.features.feature['prev_image/segmentation/class/encoded']
- .bytes_list.value[0],
- dtype=np.int32).reshape((self.height, self.width))
- if i == 0:
- # First frame.
- np.testing.assert_array_equal(panoptic_map, prev_panoptic_map)
- else:
- # Not a first frame.
- np.testing.assert_array_equal(prev_panoptic_map, self.panoptic_maps[0])
- self.assertEqual(
- example.features.feature['video/sequence_id'].bytes_list.value[0],
- b'010')
- self.assertEqual(
- example.features.feature['video/frame_id'].bytes_list.value[0],
- b'%06d' % image_id)
-
- def test_build_step_dataset_with_two_frames_shared_by_sequence(self):
- split = 'val'
- self._create_images(split)
- build_step_data._convert_dataset(
- step_root=self.data_dir,
- dataset_split=split,
- output_dir=FLAGS.test_tmpdir, use_two_frames=True)
- # Only one shard since there is only one sequence for the val set.
- num_shards = 1
- output_record = os.path.join(
- FLAGS.test_tmpdir, build_step_data._TF_RECORD_PATTERN %
- (split, 0, num_shards))
- self.assertTrue(tf.io.gfile.exists(output_record))
-
-
-if __name__ == '__main__':
- tf.test.main()
diff --git a/spaces/alan-chen-intel/dagan-demo/depth/pose_decoder.py b/spaces/alan-chen-intel/dagan-demo/depth/pose_decoder.py
deleted file mode 100644
index 9d6680212e777e804ab29bc0e094cd1c7b8b1078..0000000000000000000000000000000000000000
--- a/spaces/alan-chen-intel/dagan-demo/depth/pose_decoder.py
+++ /dev/null
@@ -1,71 +0,0 @@
-# Copyright Niantic 2019. Patent Pending. All rights reserved.
-#
-# This software is licensed under the terms of the Monodepth2 licence
-# which allows for non-commercial use only, the full terms of which are made
-# available in the LICENSE file.
-
-from __future__ import absolute_import, division, print_function
-
-import torch
-import torch.nn as nn
-from collections import OrderedDict
-import pdb
-import torch.nn.functional as F
-# from options import MonodepthOptions
-# options = MonodepthOptions()
-# opts = options.parse()
-class PoseDecoder(nn.Module):
- def __init__(self, num_ch_enc, num_input_features, num_frames_to_predict_for=None, stride=1):
- super(PoseDecoder, self).__init__()
- self.num_ch_enc = num_ch_enc
- self.num_input_features = num_input_features
-
- if num_frames_to_predict_for is None:
- num_frames_to_predict_for = num_input_features - 1
- self.num_frames_to_predict_for = num_frames_to_predict_for
-
- self.convs = OrderedDict()
- self.convs[("squeeze")] = nn.Conv2d(self.num_ch_enc[-1], 256, 1)
- self.convs[("pose", 0)] = nn.Conv2d(num_input_features * 256, 256, 3, stride, 1)
- self.convs[("pose", 1)] = nn.Conv2d(256, 256, 3, stride, 1)
- self.convs[("pose", 2)] = nn.Conv2d(256, 6 * num_frames_to_predict_for, 1)
- self.convs[("intrinsics", 'focal')] = nn.Conv2d(256, 2, kernel_size = 3,stride = 1,padding = 1)
- self.convs[("intrinsics", 'offset')] = nn.Conv2d(256, 2, kernel_size = 3,stride = 1,padding = 1)
-
- self.relu = nn.ReLU()
- self.net = nn.ModuleList(list(self.convs.values()))
-
- def forward(self, input_features):
- last_features = [f[-1] for f in input_features]
-
- cat_features = [self.relu(self.convs["squeeze"](f)) for f in last_features]
- cat_features = torch.cat(cat_features, 1)
-
- feat = cat_features
- for i in range(2):
- feat = self.convs[("pose", i)](feat)
- feat = self.relu(feat)
- out = self.convs[("pose", 2)](feat)
-
- out = out.mean(3).mean(2)
- out = 0.01 * out.view(-1, self.num_frames_to_predict_for, 1, 6)
-
- axisangle = out[..., :3]
- translation = out[..., 3:]
-
- #add_intrinsics_head
- scales = torch.tensor([256,256]).cuda()
- focals = F.softplus(self.convs[("intrinsics", 'focal')](feat)).mean(3).mean(2)*scales
- offset = (F.softplus(self.convs[("intrinsics", 'offset')](feat)).mean(3).mean(2)+0.5)*scales
- #focals = F.softplus(self.convs[("intrinsics",'focal')](feat).mean(3).mean(2))
- #offset = F.softplus(self.convs[("intrinsics",'offset')](feat).mean(3).mean(2))
- eyes = torch.eye(2).cuda()
- b,xy = focals.shape
- focals = focals.unsqueeze(-1).expand(b,xy,xy)
- eyes = eyes.unsqueeze(0).expand(b,xy,xy)
- intrin = focals*eyes
- offset = offset.view(b,2,1).contiguous()
- intrin = torch.cat([intrin,offset],-1)
- pad = torch.tensor([0.0,0.0,1.0]).view(1,1,3).expand(b,1,3).cuda()
- intrinsics = torch.cat([intrin,pad],1)
- return axisangle, translation,intrinsics
diff --git a/spaces/alex42t/EssayChecker/README.md b/spaces/alex42t/EssayChecker/README.md
deleted file mode 100644
index 0fedf39145d88fd5497a1a46641cede569751d72..0000000000000000000000000000000000000000
--- a/spaces/alex42t/EssayChecker/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: EssayChecker
-emoji: 📜
-colorFrom: yellow
-colorTo: gray
-sdk: gradio
-sdk_version: 3.12.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/alexray/btc_predictor/pipeline.sh b/spaces/alexray/btc_predictor/pipeline.sh
deleted file mode 100644
index 31430e5cd9077553d2a4e0007ee064ee8cf21e55..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/pipeline.sh
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/bin/sh
-python3 data_creation.py
-python3 data_preprocessing.py
-python3 model_preparation.py
-python3 model_testing.py
-
-
diff --git a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/html5lib/treewalkers/dom.py b/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/html5lib/treewalkers/dom.py
deleted file mode 100644
index b0c89b001fd3b60511734c31e452c1d2053468d0..0000000000000000000000000000000000000000
--- a/spaces/alexray/btc_predictor/venv/lib/python3.10/site-packages/pip/_vendor/html5lib/treewalkers/dom.py
+++ /dev/null
@@ -1,43 +0,0 @@
-from __future__ import absolute_import, division, unicode_literals
-
-from xml.dom import Node
-
-from . import base
-
-
-class TreeWalker(base.NonRecursiveTreeWalker):
- def getNodeDetails(self, node):
- if node.nodeType == Node.DOCUMENT_TYPE_NODE:
- return base.DOCTYPE, node.name, node.publicId, node.systemId
-
- elif node.nodeType in (Node.TEXT_NODE, Node.CDATA_SECTION_NODE):
- return base.TEXT, node.nodeValue
-
- elif node.nodeType == Node.ELEMENT_NODE:
- attrs = {}
- for attr in list(node.attributes.keys()):
- attr = node.getAttributeNode(attr)
- if attr.namespaceURI:
- attrs[(attr.namespaceURI, attr.localName)] = attr.value
- else:
- attrs[(None, attr.name)] = attr.value
- return (base.ELEMENT, node.namespaceURI, node.nodeName,
- attrs, node.hasChildNodes())
-
- elif node.nodeType == Node.COMMENT_NODE:
- return base.COMMENT, node.nodeValue
-
- elif node.nodeType in (Node.DOCUMENT_NODE, Node.DOCUMENT_FRAGMENT_NODE):
- return (base.DOCUMENT,)
-
- else:
- return base.UNKNOWN, node.nodeType
-
- def getFirstChild(self, node):
- return node.firstChild
-
- def getNextSibling(self, node):
- return node.nextSibling
-
- def getParentNode(self, node):
- return node.parentNode
diff --git a/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/ROUGE-1.5.5/XML/DOM/CDATASection.pod b/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/ROUGE-1.5.5/XML/DOM/CDATASection.pod
deleted file mode 100644
index 54c26e1f86c1986bf3173bb0c963dee951e34e79..0000000000000000000000000000000000000000
--- a/spaces/aliabd/SummerTime/model/third_party/HMNet/ThirdParty/ROUGE/ROUGE-1.5.5/XML/DOM/CDATASection.pod
+++ /dev/null
@@ -1,31 +0,0 @@
-=head1 NAME
-
-XML::DOM::CDATASection - Escaping XML text blocks in XML::DOM
-
-=head1 DESCRIPTION
-
-XML::DOM::CDATASection extends L which extends
-L.
-
-CDATA sections are used to escape blocks of text containing characters
-that would otherwise be regarded as markup. The only delimiter that is
-recognized in a CDATA section is the "]]>" string that ends the CDATA
-section. CDATA sections can not be nested. The primary purpose is for
-including material such as XML fragments, without needing to escape all
-the delimiters.
-
-The DOMString attribute of the Text node holds the text that is
-contained by the CDATA section. Note that this may contain characters
-that need to be escaped outside of CDATA sections and that, depending
-on the character encoding ("charset") chosen for serialization, it may
-be impossible to write out some characters as part of a CDATA section.
-
-The CDATASection interface inherits the CharacterData interface through
-the Text interface. Adjacent CDATASections nodes are not merged by use
-of the Element.normalize() method.
-
-B XML::DOM::Parser and XML::DOM::ValParser convert all CDATASections
-to regular text by default.
-To preserve CDATASections, set the parser option KeepCDATA to 1.
-
-
diff --git a/spaces/allknowingroger/Image-Models-Test142/README.md b/spaces/allknowingroger/Image-Models-Test142/README.md
deleted file mode 100644
index 7c1a1cef3a96fabd7f640dd090cf152d8e00902a..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test142/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: More Image Models
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-duplicated_from: allknowingroger/Image-Models-Test141
----
-
-
\ No newline at end of file
diff --git a/spaces/allknowingroger/Image-Models-Test168/README.md b/spaces/allknowingroger/Image-Models-Test168/README.md
deleted file mode 100644
index f91e4b31ab345f987b425de029c057bfb69d9e1b..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test168/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: More Image Models
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: true
-duplicated_from: allknowingroger/Image-Models-Test
----
-
-
\ No newline at end of file
diff --git a/spaces/allknowingroger/Image-Models-Test22/README.md b/spaces/allknowingroger/Image-Models-Test22/README.md
deleted file mode 100644
index e22293829f169dd5a94981c7ab481bea41d1a451..0000000000000000000000000000000000000000
--- a/spaces/allknowingroger/Image-Models-Test22/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: More Image Models
-emoji: 😻
-colorFrom: red
-colorTo: gray
-sdk: gradio
-sdk_version: 3.23.0
-app_file: app.py
-pinned: true
-duplicated_from: allknowingroger/Image-Models-Test18
----
-
-
\ No newline at end of file
diff --git a/spaces/aloatalpine/streamlit_v3/app.py b/spaces/aloatalpine/streamlit_v3/app.py
deleted file mode 100644
index fee1e2288531f2d1ee4264ed1950cc1c51577372..0000000000000000000000000000000000000000
--- a/spaces/aloatalpine/streamlit_v3/app.py
+++ /dev/null
@@ -1,193 +0,0 @@
-import openai
-import streamlit as st
-from streamlit_chat import message
-import os
-
-# Setting page title and header
-st.set_page_config(page_title="Tutor", page_icon=":heavy_plus_sign:")
-st.markdown("""
-
-
Tutor Session with Becky (Student)
-
You are a tutor named Mary. The bot is a 1st grade student Becky taking a Math class. """
- , unsafe_allow_html=True)
-
-# Set org ID and API key
-openai.api_key = os.environ['TOKEN']
-API_KEY = os.environ['TOKEN']
-
-# Set context
-
-context_tutor = """You are playing the role of a tutor named Mary. You specifically focus on math and english, though you are capable of addressing any subject.
-
-You tutor American students in the public school system. You tutor with the intent to catch students up to their respective grade level. Your goal is to improve learning outcomes through engaging teaching methods; for example, you often pull in age-appropriate real word scenarios to help explain harder concepts. You have a degree in teaching, with an emphasis in special education. You studied the works of Lev Vygotsky and believe that it is the responsibility of the teacher to meet the student at their personal level. You have worked as a teacher for 10 years, and have recently retired and tutor in your free time.
-
-Your goal is to create an engaging, open, and safe teaching environment for your students. You use creative and personal teaching methods to keep students interested in the lesson.
-
-You believe that education is the future for America and the next generation across the world.
-
-You are passionate about teaching, and want to see every student succeed.You are patient, kind, and encouraging. You use encouraging and pithy phrases, keeping answers short and intentional. You avoid repetition and interjections when you speak. You have impeccable grammar, but you speak in a colloquial manner so that you are approachable. You understand how to keep students on track with the lesson and how to engage them in the topic. You never say hurtful or demeaning things, rather you try to understand where your students are coming from at all times. When students address difficult and personal topics, you will acknowledge challenging feelings, express empathy, and recommend talking to a teacher/counselor if they feel comfortable, and redirect students back to the session. You will not offer to listen to students' personal struggles or give advice on students' personal struggles. You remember specifics about the students from stories they tell you, and you then inject those facts into your conversation and lessons.
-
-You are a young teacher and understand the social inter-workings of your students. You relate to your students because you understand the latest trends and slang. You speak in a respectful and encouraging manner, always in a tone that is age appropriate for the student. You discourage foul language, sexual topics, and anything else deemed inappropriate for a school context. You act in a similar manner to Janine Teagues on the show Abbott Elementary.You are working on a text-based tutoring platform so your response should emulate a 20-year old person’s text messages, and the text response should be short and concise. Your students generally have trouble catching up with their grade levels, so please keep the response sentences short and sweet, and use language appropriate to their grade level. No more than three sentences in each response.
-
-If asked about your age, nationality, recognize the question but do not give an answer to the question. If asked if you're human, say you are a human tutor.
-If a student asks for reward points, encourage them to engage in the session to earn the points.
-Break your responses into separate short lines. Don't make it a long paragraph
-
-Your student today is Becky, a 1st grader practicing complicated addition problems. This is her 3rd session with your company. In the last session, Becky was taught by a tutor named Bernadette K. The topic of the Class was Place Values. And Becky earned 38 points.
-
-Here is a summary of their conversations outside of the lesson:
-Bernadette welcomed Becky to the session and explained the virtual classroom tools.
-They discussed the different learning style options and communication features.
-Becky confirmed their comfort with the whiteboard and tools.
-Bernadette encouraged active participation and awarded points for Becky’s work on the whiteboard.
-They discussed various examples related to place value and solved problems together.
-Bernadette praised Becky's efforts and provided positive feedback throughout the session.
-The session ended with Bernadette thanking Becky and looking forward to the next session.
-
-Becky’s favorite school activity is swinging or playing in the jungle gym at recess. She loves her teacher because her teacher reads fun stories. Becky enjoys drawing and coloring. She is a visual learner and likes group projects. Her hobbies include playing with dolls, riding bikes, solving puzzles, and making up stories. Becky loves learning about animals and their habitats. Her favorite summer activity is going to the beach, collecting seashells, building sandcastles, and splashing in the waves. Becky’s favorite shows are "My Little Pony" and "Peppa Pig."
-
-"""
-
-context_introduction ="""
-Remember to start the lesson by greeting the student with a positive welcome message and a very brief summary of what happened last class. Remember, you work with a tutoring company, ABC Tutor, and you don’t work with the same student each time, so assume that you are not the tutor for their last session unless you know it. If this is their first class with ABC Tutor, welcome them to ABC Tutor and express that you are very excited to have them here. You engage the student in light conversation before telling them it is time to start the lesson. Always keep responses concise, yet sweet. You should greet the student with a warm welcome. You can include a nice encouragement about what students did in their last session. Afterwhich, you engage in brief small talk, limited to 3 back and forth responses.
-When the student is ready for the first question, ask the student to look at the first question on the whiteboard. ("If Robin has 3 cookies and Selena gives him 2 more, how many cookie will Robin have?")
-"""
-
-context_encouragement = """
-Right now your student seems frustrated. Please provide more encouragement in your next response by recognizing their feelings and trying to encourage them to finish the problem. If the student asks to end the session or give them the answers, encourage them to keep going on.
-When you feel that the student is ready for the next question, ask the student to look at the next question on the whiteboard. ("If Robin has 3 cookies and Selena gives him 2 more, how many cookie will Robin have?")
-"""
-
-context_conclusion = """
-You are now at the very end of the session and you need to conclude the session immediately no matter where the conversation was. In your next response, wrap up the session by recognizing the last response from the student and emphasize that the session is concluding.
-If the session ends at the user's request, also call it out. You won't be avaiable for the students after the session for questions. Remember to keep the response short and sweet
-Remind the student to fill out the feedback form, but close the session with powerful words of encouragement and a recap of the highlights from this session. Remind the student about the session on 10am Aug 10th 2023. Today’s date is Aug 3rd 2023.
-Break your responses into separate short lines. Don't make it a long paragraph
-"""
-
-context_student = """
-You are playing the role of a student named Becky. You are having a text-based tutoring session for math with a new tutor.
-
-You are a first grade student in the American public school system. You are behind in math, so you are in tutoring to catch up to your grade level. Your goal is to finish this session so you can go home. You are indifferent to Math. You believe that you are smart since that’s what your parents tell you.
-
-Your favorite school activity is swinging or playing in the jungle gym at recess. You love your teacher because her teacher reads fun stories. You enjoy drawing and coloring. You are a visual learner and like group projects. Your hobbies include playing with dolls, riding bikes, solving puzzles, and making up stories. You love learning about animals and their habitats. Your favorite summer activity is going to the beach, collecting seashells, building sandcastles, and splashing in the waves. Your favorite shows are "My Little Pony" and "Peppa Pig."
-
-You have a simple vocabulary, elementary grammar and sentence structure, and speak and read at a first grade level. You misspell longer words, and may use the wrong words if they are near rhymes to the word you intended. You usually respond with very brief, 1-word answers or partial sentences. Your sentences are never more than seven words. Write informally, without any punctuation. You write like a child. You use abbreviations as though you are texting. You are typically shy and unenthusiastic, but can get excited if one of your interests is brought up. However, when you are interested in the topic, then you will elaborate on your thoughts, maintaining a first grade grammatical and sentence structure. Remember this is a text-based tutoring platform so output should mimic how humans would text.
-
-When the tutor turns your attention to the question on the whiteboard, you'll see the question: "If Robin has 3 cookies and Selena gives him 2 more, how many cookie will Robin have?"
-You will then immediately try to answer this question in your next response
-
-"""
-
-def name_to_role_gpt_as_tutor(name):
- # have GPT-4 act as tutor
- return 'assistant' if name == 'tutor' else 'user'
-def name_to_role_gpt_as_student(name):
- # have GPT-4 act as student
- return 'assistant' if name == 'student' else 'user'
-
-if "openai_model" not in st.session_state:
- st.session_state["openai_model"] = "gpt-3.5-turbo"
-
-if "messages" not in st.session_state:
- st.session_state.messages = [{ 'name' : 'student', 'content' : "Hi, my name is Becky and I'm your student." }] # Set initial message from student
- st.session_state.tutor_introduction_message_system_prompt = {"role": "system", "content": context_tutor + context_introduction}
- st.session_state.tutor_encouragement_message_system_prompt = {"role": "system", "content": context_tutor + context_encouragement}
- st.session_state.tutor_conclusion_message_system_prompt = {"role": "system", "content": context_tutor + context_conclusion}
- st.session_state.tutor_conclusion_only_message_system_prompt = {"role": "system", "content": context_conclusion}
- st.session_state.student_message_system_prompt = {"role": "system", "content": context_student}
-
-################################
-#
-# Sidebar
-#
-################################
-
-for message in st.session_state.messages:
- with st.chat_message(name_to_role_gpt_as_student(message['name'])):
- st.markdown(message['content'])
-
-st.sidebar.title("Conversation Bots")
-st.sidebar.markdown('The bots are meant to be used for converasations with students only. The bots should not be helping you with math instruction.')
-
-if st.sidebar.button('Introduction/Conversation'):
- # assistant == tutor
- message_placeholder = st.empty()
- full_response = ""
- for response in openai.ChatCompletion.create(
- model=st.session_state["openai_model"],
- messages=[ st.session_state.tutor_introduction_message_system_prompt ] + [
- { "role": name_to_role_gpt_as_tutor(m["name"]), "content": m["content"] }
- for m in st.session_state.messages
- ],
- stream=True,
- api_key=API_KEY
- ):
- full_response += response.choices[0].delta.get("content", "")
- st.sidebar.success(full_response)
-
-if st.sidebar.button('Pep Talk'):
- # assistant == tutor
- message_placeholder = st.empty()
- full_response = ""
- for response in openai.ChatCompletion.create(
- model=st.session_state["openai_model"],
- messages=[ st.session_state.tutor_encouragement_message_system_prompt ] + [
- { "role": name_to_role_gpt_as_tutor(m["name"]), "content": m["content"] }
- for m in st.session_state.messages
- ],
- stream=True,
- api_key=API_KEY
- ):
- full_response += response.choices[0].delta.get("content", "")
- st.sidebar.success(full_response)
-
-if st.sidebar.button('Conclude Session'):
- # assistant == tutor
- message_placeholder = st.empty()
- full_response = ""
- for response in openai.ChatCompletion.create(
- model=st.session_state["openai_model"],
- messages=[ st.session_state.tutor_conclusion_message_system_prompt ] + [
- { "role": name_to_role_gpt_as_tutor(m["name"]), "content": m["content"] }
- for m in st.session_state.messages
- ],
- stream=True,
- api_key=API_KEY
- ):
- full_response += response.choices[0].delta.get("content", "")
- st.sidebar.success(full_response)
-
-
-################################
-#
-# Main chat interface
-#
-################################
-
-if prompt := st.chat_input("Start talking with your student!"):
- st.session_state.messages.append({ "name": "tutor", "content": prompt })
- with st.chat_message(name_to_role_gpt_as_student('tutor')):
- st.markdown(prompt)
-
- with st.chat_message(name_to_role_gpt_as_student('student')):
- # assistant == student
- message_placeholder = st.empty()
- print([ st.session_state.student_message_system_prompt ] + [
- { "role": name_to_role_gpt_as_student(m["name"]), "content": m["content"] }
- for m in st.session_state.messages
- ])
- full_response = ""
- for response in openai.ChatCompletion.create(
- model=st.session_state["openai_model"],
- messages=[ st.session_state.student_message_system_prompt ] + [
- { "role": name_to_role_gpt_as_student(m["name"]), "content": m["content"] }
- for m in st.session_state.messages
- ],
- stream=True,
- api_key=API_KEY
- ):
- full_response += response.choices[0].delta.get("content", "")
- message_placeholder.markdown(full_response + "▌")
- message_placeholder.markdown(full_response)
- st.session_state.messages.append({ "name": "student", "content": full_response })
\ No newline at end of file
diff --git a/spaces/alonsosilva/tokenizer/Dockerfile b/spaces/alonsosilva/tokenizer/Dockerfile
deleted file mode 100644
index b549386ac975ddee3ed429a3678c34519d4f1ef7..0000000000000000000000000000000000000000
--- a/spaces/alonsosilva/tokenizer/Dockerfile
+++ /dev/null
@@ -1,28 +0,0 @@
-FROM python:3.11
-
-# Set up a new user named "user" with user ID 1000
-RUN useradd -m -u 1000 user
-
-# Switch to the "user" user
-USER user
-
-# Set home to the user's home directory
-ENV HOME=/home/user \
- PATH=/home/user/.local/bin:$PATH
-
-# Set the working directory to the user's home directory
-WORKDIR $HOME/app
-
-# Try and run pip command after setting the user with `USER user` to avoid permission issues with Python
-RUN pip install --no-cache-dir --upgrade pip
-
-# Copy the current directory contents into the container at $HOME/app setting the owner to the user
-COPY --chown=user . $HOME/app
-
-COPY --chown=user requirements.txt .
-
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-
-COPY --chown=user app.py .
-
-ENTRYPOINT ["solara", "run", "app.py", "--host=0.0.0.0", "--port", "7860"]
diff --git a/spaces/alphunt/diffdock-alphunt-demo/esm/esm/inverse_folding/multichain_util.py b/spaces/alphunt/diffdock-alphunt-demo/esm/esm/inverse_folding/multichain_util.py
deleted file mode 100644
index 48f88603ea05fff2558de288672c577a23beafc8..0000000000000000000000000000000000000000
--- a/spaces/alphunt/diffdock-alphunt-demo/esm/esm/inverse_folding/multichain_util.py
+++ /dev/null
@@ -1,151 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-#
-# This source code is licensed under the MIT license found in the
-# LICENSE file in the root directory of this source tree.
-
-import biotite.structure
-import numpy as np
-import torch
-from typing import Sequence, Tuple, List
-
-from esm.inverse_folding.util import (
- load_structure,
- extract_coords_from_structure,
- load_coords,
- get_sequence_loss,
- get_encoder_output,
-)
-
-
-def extract_coords_from_complex(structure: biotite.structure.AtomArray):
- """
- Args:
- structure: biotite AtomArray
- Returns:
- Tuple (coords_list, seq_list)
- - coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- - seqs: Dictionary mapping chain ids to native sequences of each chain
- """
- coords = {}
- seqs = {}
- all_chains = biotite.structure.get_chains(structure)
- for chain_id in all_chains:
- chain = structure[structure.chain_id == chain_id]
- coords[chain_id], seqs[chain_id] = extract_coords_from_structure(chain)
- return coords, seqs
-
-
-def load_complex_coords(fpath, chains):
- """
- Args:
- fpath: filepath to either pdb or cif file
- chains: the chain ids (the order matters for autoregressive model)
- Returns:
- Tuple (coords_list, seq_list)
- - coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- - seqs: Dictionary mapping chain ids to native sequences of each chain
- """
- structure = load_structure(fpath, chains)
- return extract_coords_from_complex(structure)
-
-
-def _concatenate_coords(coords, target_chain_id, padding_length=10):
- """
- Args:
- coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- target_chain_id: The chain id to sample sequences for
- padding_length: Length of padding between concatenated chains
- Returns:
- Tuple (coords, seq)
- - coords is an L x 3 x 3 array for N, CA, C coordinates, a
- concatenation of the chains with padding in between
- - seq is the extracted sequence, with padding tokens inserted
- between the concatenated chains
- """
- pad_coords = np.full((padding_length, 3, 3), np.nan, dtype=np.float32)
- # For best performance, put the target chain first in concatenation.
- coords_list = [coords[target_chain_id]]
- for chain_id in coords:
- if chain_id == target_chain_id:
- continue
- coords_list.append(pad_coords)
- coords_list.append(coords[chain_id])
- coords_concatenated = np.concatenate(coords_list, axis=0)
- return coords_concatenated
-
-
-def sample_sequence_in_complex(model, coords, target_chain_id, temperature=1.,
- padding_length=10):
- """
- Samples sequence for one chain in a complex.
- Args:
- model: An instance of the GVPTransformer model
- coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- target_chain_id: The chain id to sample sequences for
- padding_length: padding length in between chains
- Returns:
- Sampled sequence for the target chain
- """
- target_chain_len = coords[target_chain_id].shape[0]
- all_coords = _concatenate_coords(coords, target_chain_id)
-
- # Supply padding tokens for other chains to avoid unused sampling for speed
- padding_pattern = [''] * all_coords.shape[0]
- for i in range(target_chain_len):
- padding_pattern[i] = ''
- sampled = model.sample(all_coords, partial_seq=padding_pattern,
- temperature=temperature)
- sampled = sampled[:target_chain_len]
- return sampled
-
-
-def score_sequence_in_complex(model, alphabet, coords, target_chain_id,
- target_seq, padding_length=10):
- """
- Scores sequence for one chain in a complex.
- Args:
- model: An instance of the GVPTransformer model
- alphabet: Alphabet for the model
- coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- target_chain_id: The chain id to sample sequences for
- target_seq: Target sequence for the target chain for scoring.
- padding_length: padding length in between chains
- Returns:
- Tuple (ll_fullseq, ll_withcoord)
- - ll_fullseq: Average log-likelihood over the full target chain
- - ll_withcoord: Average log-likelihood in target chain excluding those
- residues without coordinates
- """
- all_coords = _concatenate_coords(coords, target_chain_id)
-
- loss, target_padding_mask = get_sequence_loss(model, alphabet, all_coords,
- target_seq)
- ll_fullseq = -np.sum(loss * ~target_padding_mask) / np.sum(
- ~target_padding_mask)
-
- # Also calculate average when excluding masked portions
- coord_mask = np.all(np.isfinite(coords[target_chain_id]), axis=(-1, -2))
- ll_withcoord = -np.sum(loss * coord_mask) / np.sum(coord_mask)
- return ll_fullseq, ll_withcoord
-
-
-def get_encoder_output_for_complex(model, alphabet, coords, target_chain_id):
- """
- Args:
- model: An instance of the GVPTransformer model
- alphabet: Alphabet for the model
- coords: Dictionary mapping chain ids to L x 3 x 3 array for N, CA, C
- coordinates representing the backbone of each chain
- target_chain_id: The chain id to sample sequences for
- Returns:
- Dictionary mapping chain id to encoder output for each chain
- """
- all_coords = _concatenate_coords(coords, target_chain_id)
- all_rep = get_encoder_output(model, alphabet, all_coords)
- target_chain_len = coords[target_chain_id].shape[0]
- return all_rep[:target_chain_len]
diff --git a/spaces/amirhosseinkarami/MovieRecommender/app.py b/spaces/amirhosseinkarami/MovieRecommender/app.py
deleted file mode 100644
index a906e06c8ad56de81505ee47db329959f26c0cd3..0000000000000000000000000000000000000000
--- a/spaces/amirhosseinkarami/MovieRecommender/app.py
+++ /dev/null
@@ -1,84 +0,0 @@
-import gradio
-import pandas as pd
-import concurrent.futures
-
-from App.tfidfrecommender import TfidfRecommender
-
-import gradio as gr
-
-desc = pd.read_csv('App/data/descriptions.csv')
-
-rec = TfidfRecommender(desc, 'id', 'description' , "none")
-def initialize_and_tokenize(tokenizer):
- print("tok")
- rec.tokenization_method = tokenizer
- rec.tokenize_text()
-
-names = []
-def recommend (movies, tok) :
- rec.tokenization_method = tok
- tf, vecs = rec.tokenize_text()
- rec.fit(tf, vecs)
- print("rec")
- pool = concurrent.futures.ThreadPoolExecutor(max_workers=10)
- futures = [pool.submit(rec.recommend_k_items, movie, 5) for movie in movies]
- idss = []
- print("after submit")
- for i in range(len(futures)):
- print("res")
- idss.append(futures[i].result())
- print("shutdown")
- pool.shutdown(wait=True)
- ids = [id for ids in idss for id in ids]
- ids = list(set(ids))
- names = desc[desc['id'].isin(ids)]['title'].to_list()
- return ', '.join(names)
-
-def recom(movies, tok):
- rec.tokenization_method = tok
- tf, vecs = rec.tokenize_text()
- rec.fit(tf, vecs)
- print(movies[0])
- ids = rec.recommend_k_items(movies[0], 5)
- print("reccc")
- # ids = list(set(ids))
- names = desc[desc['id'].isin(ids)]['title'].to_list()
- return ', '.join(names)
-
-demo = gr.Interface(fn=recom,
- inputs=[gr.Dropdown(choices = list(desc['title'][:20]), multiselect=True, max_choices=3, label="Movies"),
- gr.Radio(["bert", "scibert", "nltk" , "none"], value="none", label="Tokenization and text preprocess")],
- outputs=gr.Textbox(label="Recommended"))
-demo.launch()
-
-
-# ===========================
-# with gr.Blocks() as demo:
-# gr.Markdown("Start typing below and then click **Run** to see the output.")
-# with gr.Row():
-# radio = gr.Radio(["bert", "scibert", "nltk" , "none"], value="none",
-# label="Tokenization and text preprocess")
-# btn = gr.Button("Tokenize and Preprocess")
-# btn.click(fn=initialize_and_tokenize, inputs=radio)
-# # demo.launch()
-# # with gr.Blocks() as demo2:
-# gr.Markdown("Choose 3 movies")
-# with gr.Row():
-# dropdown = gr.Dropdown(choices = list(desc['title']), multiselect=True, max_choices=3,
-# label="Movies")
-# box = gr.Textbox(lines=3, label="recs")
-# btn2 = gr.Button("Recommend")
-# btn2.click(fn=recommend, inputs=dropdown,outputs=[])
-# gr.Markdown("rec{}".format(len(names)))
-# demo.launch()
-
-# ==========================
-
-# with gr.Blocks() as demo :
-# gr.Markdown("Start typing below and then click **Run** to see the output.")
-# with gr.Row():
-# radio = gr.Radio(["bert", "scibert", "nltk" , "none"], value="none",
-# label="Tokenization and text preprocess")
-# btn = gr.Button("Tokenize and Preprocess")
-# btn.click(fn=initialize_and_tokenize, inputs=radio, outputs=[])
-# demo = gr.Interface(fn=image_classifier, inputs="image", outputs="label")
diff --git a/spaces/andreslu/orion/inductor.py b/spaces/andreslu/orion/inductor.py
deleted file mode 100644
index a649cd4ce71ff07593f57efe4df86ebbd5fc3dc7..0000000000000000000000000000000000000000
--- a/spaces/andreslu/orion/inductor.py
+++ /dev/null
@@ -1,314 +0,0 @@
-import re
-from copy import deepcopy
-
-import argparse
-import torch
-import torch.nn.functional as F
-from transformers import (AutoModelForSeq2SeqLM, AutoTokenizer,
- BartForConditionalGeneration, BartTokenizer,)
-
-from src.bart_with_group_beam import BartForConditionalGeneration_GroupBeam
-from src.utils import (construct_template, filter_words,
- formalize_tA, post_process_template)
-
-device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-
-ORION_HYPO_GENERATOR = 'chenxran/orion-hypothesis-generator'
-ORION_INS_GENERATOR = 'chenxran/orion-instance-generator'
-
-RELATIONS = [
- "Causes",
- "HasProperty",
- "MadeUpOf",
- "isAfter",
- "isBefore",
- "xReact",
- "xWant",
- "xReason",
- "xAttr",
- "Desires",
-]
-
-
-class BartInductor(object):
- def __init__(
- self,
- group_beam=True,
- continue_pretrain_instance_generator=True,
- continue_pretrain_hypo_generator=True,
- if_then=False
- ):
- self.if_then = if_then
- self.orion_instance_generator_path = 'facebook/bart-large' if not continue_pretrain_instance_generator else ORION_INS_GENERATOR
- self.orion_hypothesis_generator_path = 'facebook/bart-large' if not continue_pretrain_hypo_generator else ORION_HYPO_GENERATOR
-
- if group_beam:
- self.orion_hypothesis_generator = BartForConditionalGeneration_GroupBeam.from_pretrained(self.orion_hypothesis_generator_path).to(device).eval()
- else:
- self.orion_hypothesis_generator = BartForConditionalGeneration.from_pretrained(self.orion_hypothesis_generator_path).to(device).eval()
-
- self.orion_instance_generator = BartForConditionalGeneration.from_pretrained(self.orion_instance_generator_path).to(device).eval()
-
- self.tokenizer = BartTokenizer.from_pretrained("facebook/bart-large", use_fast=True)
- self.word_length = 2
-
- self.stop_sub_list = ['he', 'she', 'this', 'that', 'and', 'it', 'which', 'who', 'whose', 'there', 'they', '.', 'its', 'one',
- 'i', ',', 'the', 'nobody', 'his', 'her', 'also', 'only', 'currently', 'here', '()', 'what', 'where',
- 'why', 'a', 'some', '"', ')', '(', 'now', 'everyone', 'everybody', 'their', 'often', 'usually', 'you',
- '-', '?', ';', 'in', 'on', 'each', 'both', 'him', 'typically', 'mostly', 'sometimes', 'normally',
- 'always', 'usually', 'still', 'today', 'was', 'were', 'but', 'although', 'current', 'all', 'have',
- 'has', 'later', 'with', 'most', 'nowadays', 'then', 'every', 'when', 'someone', 'anyone', 'somebody',
- 'anybody', 'any', 'being', 'get', 'getting', 'thus', 'under', 'even', 'for', 'can', 'rarely', 'never',
- 'may', 'generally', 'other', 'another', 'too', 'first', 'second', 'third', 'mainly', 'primarily',
- 'having', 'have', 'has']
-
- self.stop_size = len(self.stop_sub_list)
- for i in range(self.stop_size):
- if self.stop_sub_list[i][0].isalpha():
- temp = self.stop_sub_list[i][0].upper() + self.stop_sub_list[i][1:]
- self.stop_sub_list.append(temp)
-
- self.bad_words_ids = [self.tokenizer.encode(bad_word)[1:-1] for bad_word in ['also', ' also']]
- stop_index = self.tokenizer(self.stop_sub_list, max_length=4, padding=True)
- stop_index = torch.tensor(stop_index['input_ids'])[:, 1]
- stop_weight = torch.zeros(1, self.tokenizer.vocab_size).to(device)
- stop_weight[0, stop_index] -= 100
- self.stop_weight = stop_weight[0, :]
-
- def clean(self, text):
- segments = re.split(r'', text)
- last_segment = segments[-1]
- if last_segment.startswith('.'):
- return text[:text.rfind(last_segment)]+'.'
- else:
- return text
-
- def generate(self, inputs, k=10, topk=10, return_scores=False):
- with torch.no_grad():
- tB_probs = self.generate_rule(inputs, k)
- new_ret = []
- if return_scores:
- ret = [(t[0], t[1]) for t in tB_probs]
- for temp in ret:
- temp = (self.clean(temp[0].strip()), temp[1])
- if len(new_ret) < topk and temp not in new_ret:
- new_ret.append(temp)
- else:
- ret = [t[0] for t in tB_probs]
- for temp in ret:
- temp = self.clean(temp.strip())
- if len(new_ret) < topk and temp not in new_ret:
- new_ret.append(temp)
-
- return new_ret
-
- def explore_mask(self, tA, k, tokens, prob, required_token, probs):
- if required_token == 0:
- return [[tokens, prob, probs]]
- if required_token <= self.word_length:
- k = min(k, 2)
- ret = []
- generated_ids = self.tokenizer(tA, max_length=128, padding='longest', return_tensors='pt') # ["input_ids"].to(device)
- for key in generated_ids.keys():
- generated_ids[key] = generated_ids[key].to(device)
- mask_index = torch.where(generated_ids["input_ids"][0] == self.tokenizer.mask_token_id)
- generated_ret = self.orion_instance_generator(**generated_ids)
- #logits = generated_ret.logits
- logits = generated_ret[0]
- softmax = F.softmax(logits, dim=-1)
- mask_word = softmax[0, mask_index[0][0], :] + self.stop_weight
- top_k = torch.topk(mask_word, k, dim=0)
- for i in range(top_k[1].size(0)):
- token_s = top_k[1][i]
- prob_s = top_k[0][i].item()
- token_this = self.tokenizer.decode([token_s]).strip()
- if token_this[0].isalpha() == False or len(token_this) <= 2:
- continue
- index_s = tA.index(self.tokenizer.mask_token)
- tAs = tA[:index_s] + token_this + tA[index_s + len(self.tokenizer.mask_token):]
- tokens_this = [t for t in tokens]
- tokens_this.append(token_this)
- probs_new = deepcopy(probs)
- probs_new.append(prob_s)
- ret.extend(self.explore_mask(tAs, 1, tokens_this, prob_s * prob, required_token - 1,probs_new))
- return ret
-
- def extract_words_for_tA_bart(self, tA, k=6, print_it = False):
- spans = [t.lower().strip() for t in re.split(r'<.*?>', tA[:-1])]
- generated_ids = self.tokenizer([tA], padding='longest', return_tensors='pt')['input_ids'].to(device).to(torch.int64)
- generated_ret = self.orion_instance_generator.generate(generated_ids, num_beams=max(120, k),
- #num_beam_groups=max(120, k),
- max_length=generated_ids.size(1) + 15,
- num_return_sequences=max(120, k), #min_length=generated_ids.size(1),
- #diversity_penalty=2.0,
- #length_penalty= 0.8,
- #early_stopping=True, bad_words_ids=bad_words_ids, no_repeat_ngram_size=2,
- output_scores=True,
- return_dict_in_generate=True)
- summary_ids = generated_ret['sequences']
- probs = F.softmax(generated_ret['sequences_scores'].to(torch.float32))
- txts = [self.tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=True) for g in summary_ids]
- ret = []
-
- for i, txt in enumerate(txts):
- if tA.endswith('.'):
- if txt.endswith('.'):
- txt = txt[:-1].strip()
- txt += '.'
- word_imcomplete = False
- prob = probs[i].item()
- words_i = []
-
- start_index = 0
- for j in range(len(spans)-1):
- span1 = spans[j]
- span2 = spans[j+1]
- if (span1 in txt.lower()[start_index:]) and (span2 in txt.lower()[start_index:]):
- index1 = txt.lower().index(span1,start_index)+len(span1)
- if span2 == '':
- if txt[-1] == '.':
- index2 = len(txt) -1
- else:
- index2 = len(txt)
- else:
- index2 = txt.lower().index(span2, start_index)
-
- words_i.append(txt[index1:index2].strip())
- start_index = index2
- #if words_i[-1] == '':
- # word_imcomplete = True
- else:
- word_imcomplete = True
- if word_imcomplete:
- # if print_it:
- # print(txt + '\t' + tA + '\t' + '×')
- continue
-
-
- ret.append([words_i, prob])
- return sorted(ret, key=lambda x: x[1], reverse=True)[:k]
-
-
- def extract_words_for_tA(self, tA, k=6):
- word_mask_str = ' '.join([self.tokenizer.mask_token] * self.word_length)
- tA = tA.replace('', word_mask_str)
- mask_count = tA.count(self.tokenizer.mask_token)
- mask_probs = self.explore_mask(tA, k*20, [], 1.0, mask_count, [])
- ret = []
- visited_mask_txt = {}
- for mask, prob, probs in mask_probs:
- mask_txt = ' '.join(mask).lower()
- if mask_txt in visited_mask_txt:
- continue
- visited_mask_txt[mask_txt] = 1
- words = []
- probs_words = []
- for i in range(0,mask_count, self.word_length):
- words.append(' '.join(mask[i: i + self.word_length]))
- prob_word = 1.0
- for j in range(i, i + self.word_length):
- prob_word *= probs[j]
- probs_words.append(prob_word)
- ret.append([words, prob, probs_words])
- return sorted(ret, key=lambda x: x[1], reverse=True)[:k]
-
- def extract_templateBs_batch(self, words_prob, tA, k, print_it = False):
- words_prob_sorted = []
- for (words, probA, *_) in words_prob:
- tokenized_word = self.tokenizer(words[0])
- words_prob_sorted.append([words,probA,len(tokenized_word['input_ids'])])
- words_prob_sorted.sort(key=lambda x:x[2])
-
- batch_size = 8
- templates = []
- index_words = {}
- ret = {}
- num_beams = k
- for enum, (words, probA, *_) in enumerate(words_prob_sorted):
- template = construct_template(words, tA, self.if_then)
- templates.extend(template)
- for t in template:
- index_words[len(index_words)] = '\t'.join(words)
- # index_words[len(templates)-1] = '\t'.join(words)
- if (len(templates) == batch_size) or enum==len(words_prob_sorted)-1 or (words_prob_sorted[enum+1][2]!=words_prob_sorted[enum][2]):
- generated_ids = self.tokenizer(templates, padding="longest", return_tensors='pt')['input_ids'].to(device).to(torch.int64)
- generated_ret = self.orion_hypothesis_generator.generate(generated_ids, num_beams=num_beams,
- num_beam_groups=num_beams,
- max_length=28, #template_length+5,
- num_return_sequences=num_beams, min_length=3,
- diversity_penalty=1.0,
- early_stopping=True,
- #length_penalty = 0.1,
- bad_words_ids=self.bad_words_ids,
- #no_repeat_ngram_size=2,
- output_scores=True,
- return_dict_in_generate=True, decoder_ori_input_ids = generated_ids,
- top_p=0.95,
- )
- summary_ids = generated_ret['sequences'].reshape((len(templates),num_beams,-1))
- probs = F.softmax(generated_ret['sequences_scores'].reshape((len(templates),num_beams)),dim=1).to(torch.float32)
- for ii in range(summary_ids.size(0)):
- txts = [self.tokenizer.decode(g, skip_special_tokens=True, clean_up_tokenization_spaces=True) for g in
- summary_ids[ii]]
- ii_template = []
- words_ii = index_words[ii].split('\t')
- for i, txt in enumerate(txts):
- prob = probs[ii][i].item() * probA
-
- txt = txt.lower()
- txt = post_process_template(txt)
-
- words_ii_matched = [word.lower() for word in words_ii] #extract_similar_words(txt, words_ii)
- if words_ii_matched is None:
- prob = 0.0
- else:
- for j, word in enumerate(words_ii_matched):
- if word not in txt:
- prob = 0.0
- else:
- txt = txt.replace(word, ''.format(j), 1)
-
- if txt.count(' ')+1<=3:
- continue
-
- ii_template.append([txt, prob])
- # if print_it:
- # print(index_words[ii]+'\t'+str(convert_for_print(ii_template)))
- for template, prob in ii_template:
- if template not in ret:
- ret[template] = 0.0
- ret[template] += prob
- templates.clear()
- index_words.clear()
-
- return ret
-
- def generate_rule(self, tA, k=10, print_it = False):
- tA=formalize_tA(tA)
- if 'bart' in str(self.orion_instance_generator.__class__).lower():
- words_prob = self.extract_words_for_tA_bart(tA, k,print_it=print_it)
- words_prob = filter_words(words_prob)[:k]
- # if print_it:
- # print(convert_for_print(words_prob))
- else:
- words_prob = self.extract_words_for_tA(tA, k)
- words_prob = filter_words(words_prob)[:k]
-
- tB_prob = self.extract_templateBs_batch(words_prob, tA, k,print_it=print_it)
-
- ret = []
- for k1 in tB_prob:
- ret.append([k1, tB_prob[k1]])
- ret = sorted(ret, key=lambda x: x[1], reverse=True)[:k]
-
- if self.if_then:
- for i, temp in enumerate(ret):
- sentence = temp[0]
- if "then" in sentence:
- sentence = sentence.split("then")[-1]
- else:
- sentence = sentence.replace("if", "")
- ret[i][0] = sentence
- return ret
-
-
diff --git a/spaces/animeartstudio/QuickGen-Photo/app.py b/spaces/animeartstudio/QuickGen-Photo/app.py
deleted file mode 100644
index 57798949266efb13e0b8495ec69d8b480ea52381..0000000000000000000000000000000000000000
--- a/spaces/animeartstudio/QuickGen-Photo/app.py
+++ /dev/null
@@ -1,59 +0,0 @@
-import gradio as gr
-import os
-import sys
-
-model = ["dreamlike-art/dreamlike-photoreal-2.0"]
-
-proc1 = gr.Interface.load(f"models/{model[0]}", live=True, postprocess=True, preprocess=True)
-proc2 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc3 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc4 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc5 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc5 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc6 = gr.Interface.load("spaces/daspartho/prompt-extend")
-proc7 = gr.Interface.load("spaces/daspartho/prompt-extend")
-
-
-css = """"""
-with gr.Blocks(css=css) as sim:
- with gr.Row():
- gr.HTML("""""")
- with gr.Row():
- inputtext = gr.Textbox(label="Prompt Idea", placeholder="", lines=1)
- genbut = gr.Button("Generate Prompts")
- runbut = gr.Button("Generate Images", variant="primary")
- with gr.Row():
- output1 = gr.Image(label="")
- output2 = gr.Image(label="")
- output3 = gr.Image(label="")
- with gr.Row():
- gentext1 = gr.Textbox(label="Generated Prompt", lines=2)
- gentext2 = gr.Textbox(label="Generated Prompt", lines=2)
- gentext3 = gr.Textbox(label="Generated Prompt", lines=2)
- with gr.Row():
- output4 = gr.Image(label="")
- output5 = gr.Image(label="")
- output6 = gr.Image(label="")
- with gr.Row():
- gentext4 = gr.Textbox(label="Generated Prompt", lines=2)
- gentext5 = gr.Textbox(label="Generated Prompt", lines=2)
- gentext6 = gr.Textbox(label="Generated Prompt", lines=2)
-
-
- genbut.click(proc2, inputs=inputtext, outputs=gentext1)
- genbut.click(proc3, inputs=inputtext, outputs=gentext2)
- genbut.click(proc4, inputs=inputtext, outputs=gentext3)
- genbut.click(proc5, inputs=inputtext, outputs=gentext4)
- genbut.click(proc6, inputs=inputtext, outputs=gentext5)
- genbut.click(proc7, inputs=inputtext, outputs=gentext6)
-
-
- runbut.click(proc1, inputs=gentext1, outputs=output1)
- runbut.click(proc1, inputs=gentext2, outputs=output2)
- runbut.click(proc1, inputs=gentext3, outputs=output3)
- runbut.click(proc1, inputs=gentext4, outputs=output4)
- runbut.click(proc1, inputs=gentext5, outputs=output5)
- runbut.click(proc1, inputs=gentext6, outputs=output6)
-
-sim.queue(concurrency_count=200)
-sim.launch(inline=True, max_threads=400)
\ No newline at end of file
diff --git a/spaces/antonbol/vocal_remover/lib/dataset.py b/spaces/antonbol/vocal_remover/lib/dataset.py
deleted file mode 100644
index 09da5b27cd4148ea813bac5ee00349f34e4a2111..0000000000000000000000000000000000000000
--- a/spaces/antonbol/vocal_remover/lib/dataset.py
+++ /dev/null
@@ -1,257 +0,0 @@
-import os
-import random
-
-import numpy as np
-import torch
-import torch.utils.data
-from tqdm import tqdm
-
-try:
- from lib import spec_utils
-except ModuleNotFoundError:
- import spec_utils
-
-
-class VocalRemoverTrainingSet(torch.utils.data.Dataset):
-
- def __init__(self, training_set, cropsize, reduction_rate, reduction_weight, mixup_rate, mixup_alpha):
- self.training_set = training_set
- self.cropsize = cropsize
- self.reduction_rate = reduction_rate
- self.reduction_weight = reduction_weight
- self.mixup_rate = mixup_rate
- self.mixup_alpha = mixup_alpha
-
- def __len__(self):
- return len(self.training_set)
-
- def do_crop(self, X_path, y_path):
- X_mmap = np.load(X_path, mmap_mode='r')
- y_mmap = np.load(y_path, mmap_mode='r')
-
- start = np.random.randint(0, X_mmap.shape[2] - self.cropsize)
- end = start + self.cropsize
-
- X_crop = np.array(X_mmap[:, :, start:end], copy=True)
- y_crop = np.array(y_mmap[:, :, start:end], copy=True)
-
- return X_crop, y_crop
-
- def do_aug(self, X, y):
- if np.random.uniform() < self.reduction_rate:
- y = spec_utils.aggressively_remove_vocal(X, y, self.reduction_weight)
-
- if np.random.uniform() < 0.5:
- # swap channel
- X = X[::-1].copy()
- y = y[::-1].copy()
-
- if np.random.uniform() < 0.01:
- # inst
- X = y.copy()
-
- # if np.random.uniform() < 0.01:
- # # mono
- # X[:] = X.mean(axis=0, keepdims=True)
- # y[:] = y.mean(axis=0, keepdims=True)
-
- return X, y
-
- def do_mixup(self, X, y):
- idx = np.random.randint(0, len(self))
- X_path, y_path, coef = self.training_set[idx]
-
- X_i, y_i = self.do_crop(X_path, y_path)
- X_i /= coef
- y_i /= coef
-
- X_i, y_i = self.do_aug(X_i, y_i)
-
- lam = np.random.beta(self.mixup_alpha, self.mixup_alpha)
- X = lam * X + (1 - lam) * X_i
- y = lam * y + (1 - lam) * y_i
-
- return X, y
-
- def __getitem__(self, idx):
- X_path, y_path, coef = self.training_set[idx]
-
- X, y = self.do_crop(X_path, y_path)
- X /= coef
- y /= coef
-
- X, y = self.do_aug(X, y)
-
- if np.random.uniform() < self.mixup_rate:
- X, y = self.do_mixup(X, y)
-
- X_mag = np.abs(X)
- y_mag = np.abs(y)
-
- return X_mag, y_mag
-
-
-class VocalRemoverValidationSet(torch.utils.data.Dataset):
-
- def __init__(self, patch_list):
- self.patch_list = patch_list
-
- def __len__(self):
- return len(self.patch_list)
-
- def __getitem__(self, idx):
- path = self.patch_list[idx]
- data = np.load(path)
-
- X, y = data['X'], data['y']
-
- X_mag = np.abs(X)
- y_mag = np.abs(y)
-
- return X_mag, y_mag
-
-
-def make_pair(mix_dir, inst_dir):
- input_exts = ['.wav', '.m4a', '.mp3', '.mp4', '.flac']
-
- X_list = sorted([
- os.path.join(mix_dir, fname)
- for fname in os.listdir(mix_dir)
- if os.path.splitext(fname)[1] in input_exts
- ])
- y_list = sorted([
- os.path.join(inst_dir, fname)
- for fname in os.listdir(inst_dir)
- if os.path.splitext(fname)[1] in input_exts
- ])
-
- filelist = list(zip(X_list, y_list))
-
- return filelist
-
-
-def train_val_split(dataset_dir, split_mode, val_rate, val_filelist):
- if split_mode == 'random':
- filelist = make_pair(
- os.path.join(dataset_dir, 'mixtures'),
- os.path.join(dataset_dir, 'instruments')
- )
-
- random.shuffle(filelist)
-
- if len(val_filelist) == 0:
- val_size = int(len(filelist) * val_rate)
- train_filelist = filelist[:-val_size]
- val_filelist = filelist[-val_size:]
- else:
- train_filelist = [
- pair for pair in filelist
- if list(pair) not in val_filelist
- ]
- elif split_mode == 'subdirs':
- if len(val_filelist) != 0:
- raise ValueError('`val_filelist` option is not available with `subdirs` mode')
-
- train_filelist = make_pair(
- os.path.join(dataset_dir, 'training/mixtures'),
- os.path.join(dataset_dir, 'training/instruments')
- )
-
- val_filelist = make_pair(
- os.path.join(dataset_dir, 'validation/mixtures'),
- os.path.join(dataset_dir, 'validation/instruments')
- )
-
- return train_filelist, val_filelist
-
-
-def make_padding(width, cropsize, offset):
- left = offset
- roi_size = cropsize - offset * 2
- if roi_size == 0:
- roi_size = cropsize
- right = roi_size - (width % roi_size) + left
-
- return left, right, roi_size
-
-
-def make_training_set(filelist, sr, hop_length, n_fft):
- ret = []
- for X_path, y_path in tqdm(filelist):
- X, y, X_cache_path, y_cache_path = spec_utils.cache_or_load(
- X_path, y_path, sr, hop_length, n_fft
- )
- coef = np.max([np.abs(X).max(), np.abs(y).max()])
- ret.append([X_cache_path, y_cache_path, coef])
-
- return ret
-
-
-def make_validation_set(filelist, cropsize, sr, hop_length, n_fft, offset):
- patch_list = []
- patch_dir = 'cs{}_sr{}_hl{}_nf{}_of{}'.format(cropsize, sr, hop_length, n_fft, offset)
- os.makedirs(patch_dir, exist_ok=True)
-
- for X_path, y_path in tqdm(filelist):
- basename = os.path.splitext(os.path.basename(X_path))[0]
-
- X, y, _, _ = spec_utils.cache_or_load(X_path, y_path, sr, hop_length, n_fft)
- coef = np.max([np.abs(X).max(), np.abs(y).max()])
- X, y = X / coef, y / coef
-
- l, r, roi_size = make_padding(X.shape[2], cropsize, offset)
- X_pad = np.pad(X, ((0, 0), (0, 0), (l, r)), mode='constant')
- y_pad = np.pad(y, ((0, 0), (0, 0), (l, r)), mode='constant')
-
- len_dataset = int(np.ceil(X.shape[2] / roi_size))
- for j in range(len_dataset):
- outpath = os.path.join(patch_dir, '{}_p{}.npz'.format(basename, j))
- start = j * roi_size
- if not os.path.exists(outpath):
- np.savez(
- outpath,
- X=X_pad[:, :, start:start + cropsize],
- y=y_pad[:, :, start:start + cropsize]
- )
- patch_list.append(outpath)
-
- return patch_list
-
-
-def get_oracle_data(X, y, oracle_loss, oracle_rate, oracle_drop_rate):
- k = int(len(X) * oracle_rate * (1 / (1 - oracle_drop_rate)))
- n = int(len(X) * oracle_rate)
- indices = np.argsort(oracle_loss)[::-1][:k]
- indices = np.random.choice(indices, n, replace=False)
- oracle_X = X[indices].copy()
- oracle_y = y[indices].copy()
-
- return oracle_X, oracle_y, indices
-
-
-if __name__ == "__main__":
- import sys
- import utils
-
- mix_dir = sys.argv[1]
- inst_dir = sys.argv[2]
- outdir = sys.argv[3]
-
- os.makedirs(outdir, exist_ok=True)
-
- filelist = make_pair(mix_dir, inst_dir)
- for mix_path, inst_path in tqdm(filelist):
- mix_basename = os.path.splitext(os.path.basename(mix_path))[0]
-
- X_spec, y_spec, _, _ = spec_utils.cache_or_load(
- mix_path, inst_path, 44100, 1024, 2048
- )
-
- X_mag = np.abs(X_spec)
- y_mag = np.abs(y_spec)
- v_mag = X_mag - y_mag
- v_mag *= v_mag > y_mag
-
- outpath = '{}/{}_Vocal.jpg'.format(outdir, mix_basename)
- v_image = spec_utils.spectrogram_to_image(v_mag)
- utils.imwrite(outpath, v_image)
diff --git a/spaces/antonovmaxim/text-generation-webui-space/text-generation-webui-main/docker/Dockerfile b/spaces/antonovmaxim/text-generation-webui-space/text-generation-webui-main/docker/Dockerfile
deleted file mode 100644
index b4fc91216606d74fc4505c7d85330b557341a4f1..0000000000000000000000000000000000000000
--- a/spaces/antonovmaxim/text-generation-webui-space/text-generation-webui-main/docker/Dockerfile
+++ /dev/null
@@ -1,68 +0,0 @@
-FROM nvidia/cuda:11.8.0-devel-ubuntu22.04 as builder
-
-RUN apt-get update && \
- apt-get install --no-install-recommends -y git vim build-essential python3-dev python3-venv && \
- rm -rf /var/lib/apt/lists/*
-
-RUN git clone https://github.com/oobabooga/GPTQ-for-LLaMa /build
-
-WORKDIR /build
-
-RUN python3 -m venv /build/venv
-RUN . /build/venv/bin/activate && \
- pip3 install --upgrade pip setuptools && \
- pip3 install torch torchvision torchaudio && \
- pip3 install -r requirements.txt
-
-# https://developer.nvidia.com/cuda-gpus
-# for a rtx 2060: ARG TORCH_CUDA_ARCH_LIST="7.5"
-ARG TORCH_CUDA_ARCH_LIST="3.5;5.0;6.0;6.1;7.0;7.5;8.0;8.6+PTX"
-RUN . /build/venv/bin/activate && \
- python3 setup_cuda.py bdist_wheel -d .
-
-FROM nvidia/cuda:11.8.0-runtime-ubuntu22.04
-
-LABEL maintainer="Your Name "
-LABEL description="Docker image for GPTQ-for-LLaMa and Text Generation WebUI"
-
-RUN apt-get update && \
- apt-get install --no-install-recommends -y libportaudio2 libasound-dev git python3 python3-pip make g++ && \
- rm -rf /var/lib/apt/lists/*
-
-RUN --mount=type=cache,target=/root/.cache/pip pip3 install virtualenv
-RUN mkdir /app
-
-WORKDIR /app
-
-ARG WEBUI_VERSION
-RUN test -n "${WEBUI_VERSION}" && git reset --hard ${WEBUI_VERSION} || echo "Using provided webui source"
-
-RUN virtualenv /app/venv
-RUN . /app/venv/bin/activate && \
- pip3 install --upgrade pip setuptools && \
- pip3 install torch torchvision torchaudio
-
-COPY --from=builder /build /app/repositories/GPTQ-for-LLaMa
-RUN . /app/venv/bin/activate && \
- pip3 install /app/repositories/GPTQ-for-LLaMa/*.whl
-
-COPY extensions/api/requirements.txt /app/extensions/api/requirements.txt
-COPY extensions/elevenlabs_tts/requirements.txt /app/extensions/elevenlabs_tts/requirements.txt
-COPY extensions/google_translate/requirements.txt /app/extensions/google_translate/requirements.txt
-COPY extensions/silero_tts/requirements.txt /app/extensions/silero_tts/requirements.txt
-COPY extensions/whisper_stt/requirements.txt /app/extensions/whisper_stt/requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/api && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/elevenlabs_tts && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/google_translate && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/silero_tts && pip3 install -r requirements.txt
-RUN --mount=type=cache,target=/root/.cache/pip . /app/venv/bin/activate && cd extensions/whisper_stt && pip3 install -r requirements.txt
-
-COPY requirements.txt /app/requirements.txt
-RUN . /app/venv/bin/activate && \
- pip3 install -r requirements.txt
-
-RUN cp /app/venv/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cuda118.so /app/venv/lib/python3.10/site-packages/bitsandbytes/libbitsandbytes_cpu.so
-
-COPY . /app/
-ENV CLI_ARGS=""
-CMD . /app/venv/bin/activate && python3 server.py ${CLI_ARGS}
diff --git a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/gradio_funcs.py b/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/gradio_funcs.py
deleted file mode 100644
index 2656647b66a0dca9c71759e98016251f22a02815..0000000000000000000000000000000000000000
--- a/spaces/aodianyun/stable-diffusion-webui/extensions/deforum/scripts/deforum_helpers/gradio_funcs.py
+++ /dev/null
@@ -1,83 +0,0 @@
-import gradio as gr
-from .video_audio_utilities import extract_number, get_quick_vid_info
-
-def change_visibility_from_skip_video(choice):
- return gr.update(visible=False) if choice else gr.update(visible=True)
-
-def update_r_upscale_factor(choice):
- return gr.update(value='x4', choices = ['x4']) if choice != 'realesr-animevideov3' else gr.update(value='x2', choices = ['x2', 'x3', 'x4'])
-
-def change_perlin_visibility(choice):
- return gr.update(visible=choice=="perlin")
-
-def change_color_coherence_video_every_N_frames_visibility(choice):
- return gr.update(visible=choice=="Video Input")
-
-def change_seed_iter_visibility(choice):
- return gr.update(visible=choice=="iter")
-
-def change_seed_schedule_visibility(choice):
- return gr.update(visible=choice=="schedule")
-
-def disable_pers_flip_accord(choice):
- return gr.update(visible=True) if choice in ['2D','3D'] else gr.update(visible=False)
-
-def change_max_frames_visibility(choice):
- return gr.update(visible=choice != "Video Input")
-
-def change_diffusion_cadence_visibility(choice):
- return gr.update(visible=choice not in ['Video Input', 'Interpolation'])
-
-def disble_3d_related_stuff(choice):
- return gr.update(visible=False) if choice != '3D' else gr.update(visible=True)
-
-def enable_2d_related_stuff(choice):
- return gr.update(visible=True) if choice == '2D' else gr.update(visible=False)
-
-def disable_by_interpolation(choice):
- return gr.update(visible=False) if choice in ['Interpolation'] else gr.update(visible=True)
-
-def disable_by_video_input(choice):
- return gr.update(visible=False) if choice in ['Video Input'] else gr.update(visible=True)
-
-def change_comp_mask_x_visibility(choice):
- return gr.update(visible=choice != "None")
-
-def change_gif_button_visibility(choice):
- return gr.update(visible=False, value=False) if int(choice) > 30 else gr.update(visible=True)
-
-def disable_by_hybrid_composite(choice):
- return gr.update(visible=True) if choice else gr.update(visible=False)
-
-def disable_by_hybrid_composite_dynamic(choice, comp_mask_type):
- if choice == True:
- if comp_mask_type != 'None':
- return gr.update(visible=True)
- return gr.update(visible=False)
-
-def disable_by_comp_mask(choice):
- return gr.update(visible=False) if choice == 'None' else gr.update(visible=True)
-
-def disable_by_non_optical_flow(choice):
- return gr.update(visible=False) if choice != 'Optical Flow' else gr.update(visible=True)
-
-# Upscaling Gradio UI related funcs
-def vid_upscale_gradio_update_stats(vid_path, upscale_factor):
- if not vid_path:
- return '---', '---', '---', '---'
- factor = extract_number(upscale_factor)
- fps, fcount, resolution = get_quick_vid_info(vid_path.name)
- in_res_str = f"{resolution[0]}*{resolution[1]}"
- out_res_str = f"{resolution[0] * factor}*{resolution[1] * factor}"
- return fps, fcount, in_res_str, out_res_str
-def update_upscale_out_res(in_res, upscale_factor):
- if not in_res:
- return '---'
- factor = extract_number(upscale_factor)
- w, h = [int(x) * factor for x in in_res.split('*')]
- return f"{w}*{h}"
-def update_upscale_out_res_by_model_name(in_res, upscale_model_name):
- if not upscale_model_name or in_res == '---':
- return '---'
- factor = 2 if upscale_model_name == 'realesr-animevideov3' else 4
- return f"{int(in_res.split('*')[0]) * factor}*{int(in_res.split('*')[1]) * factor}"
\ No newline at end of file
diff --git a/spaces/aodianyun/stable-diffusion-webui/modules/sd_hijack_clip_old.py b/spaces/aodianyun/stable-diffusion-webui/modules/sd_hijack_clip_old.py
deleted file mode 100644
index 433d8c3da8e33aa09833dcd1793395f420e984d7..0000000000000000000000000000000000000000
--- a/spaces/aodianyun/stable-diffusion-webui/modules/sd_hijack_clip_old.py
+++ /dev/null
@@ -1,81 +0,0 @@
-from modules import sd_hijack_clip
-from modules import shared
-
-
-def process_text_old(self: sd_hijack_clip.FrozenCLIPEmbedderWithCustomWordsBase, texts):
- id_start = self.id_start
- id_end = self.id_end
- maxlen = self.wrapped.max_length # you get to stay at 77
- used_custom_terms = []
- remade_batch_tokens = []
- hijack_comments = []
- hijack_fixes = []
- token_count = 0
-
- cache = {}
- batch_tokens = self.tokenize(texts)
- batch_multipliers = []
- for tokens in batch_tokens:
- tuple_tokens = tuple(tokens)
-
- if tuple_tokens in cache:
- remade_tokens, fixes, multipliers = cache[tuple_tokens]
- else:
- fixes = []
- remade_tokens = []
- multipliers = []
- mult = 1.0
-
- i = 0
- while i < len(tokens):
- token = tokens[i]
-
- embedding, embedding_length_in_tokens = self.hijack.embedding_db.find_embedding_at_position(tokens, i)
-
- mult_change = self.token_mults.get(token) if shared.opts.enable_emphasis else None
- if mult_change is not None:
- mult *= mult_change
- i += 1
- elif embedding is None:
- remade_tokens.append(token)
- multipliers.append(mult)
- i += 1
- else:
- emb_len = int(embedding.vec.shape[0])
- fixes.append((len(remade_tokens), embedding))
- remade_tokens += [0] * emb_len
- multipliers += [mult] * emb_len
- used_custom_terms.append((embedding.name, embedding.checksum()))
- i += embedding_length_in_tokens
-
- if len(remade_tokens) > maxlen - 2:
- vocab = {v: k for k, v in self.wrapped.tokenizer.get_vocab().items()}
- ovf = remade_tokens[maxlen - 2:]
- overflowing_words = [vocab.get(int(x), "") for x in ovf]
- overflowing_text = self.wrapped.tokenizer.convert_tokens_to_string(''.join(overflowing_words))
- hijack_comments.append(f"Warning: too many input tokens; some ({len(overflowing_words)}) have been truncated:\n{overflowing_text}\n")
-
- token_count = len(remade_tokens)
- remade_tokens = remade_tokens + [id_end] * (maxlen - 2 - len(remade_tokens))
- remade_tokens = [id_start] + remade_tokens[0:maxlen - 2] + [id_end]
- cache[tuple_tokens] = (remade_tokens, fixes, multipliers)
-
- multipliers = multipliers + [1.0] * (maxlen - 2 - len(multipliers))
- multipliers = [1.0] + multipliers[0:maxlen - 2] + [1.0]
-
- remade_batch_tokens.append(remade_tokens)
- hijack_fixes.append(fixes)
- batch_multipliers.append(multipliers)
- return batch_multipliers, remade_batch_tokens, used_custom_terms, hijack_comments, hijack_fixes, token_count
-
-
-def forward_old(self: sd_hijack_clip.FrozenCLIPEmbedderWithCustomWordsBase, texts):
- batch_multipliers, remade_batch_tokens, used_custom_terms, hijack_comments, hijack_fixes, token_count = process_text_old(self, texts)
-
- self.hijack.comments += hijack_comments
-
- if len(used_custom_terms) > 0:
- self.hijack.comments.append("Used embeddings: " + ", ".join([f'{word} [{checksum}]' for word, checksum in used_custom_terms]))
-
- self.hijack.fixes = hijack_fixes
- return self.process_tokens(remade_batch_tokens, batch_multipliers)
diff --git a/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/utils/monotonic_align/__init__.py b/spaces/artificialguybr/video-dubbing/TTS/TTS/tts/utils/monotonic_align/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/artificialguybr/video-dubbing/whisper/whisper/version.py b/spaces/artificialguybr/video-dubbing/whisper/whisper/version.py
deleted file mode 100644
index c43bf6f78fac2d54ae70bb93d4320d12a1aee0dc..0000000000000000000000000000000000000000
--- a/spaces/artificialguybr/video-dubbing/whisper/whisper/version.py
+++ /dev/null
@@ -1 +0,0 @@
-__version__ = "20230918"
diff --git a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/examples/MMPT/mmpt/tasks/fairseqmmtask.py b/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/examples/MMPT/mmpt/tasks/fairseqmmtask.py
deleted file mode 100644
index f6b6115a39b2342be5513edd53016187ab91eb01..0000000000000000000000000000000000000000
--- a/spaces/arxify/RVC-beta-v2-0618/runtime/Lib/site-packages/fairseq/examples/MMPT/mmpt/tasks/fairseqmmtask.py
+++ /dev/null
@@ -1,104 +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.
-"""
-make a general fairseq task for MM pretraining.
-"""
-
-import random
-
-from fairseq.tasks import LegacyFairseqTask, register_task
-
-from .task import Task
-from .retritask import RetriTask
-from ..datasets import FairseqMMDataset
-from .. import utils
-
-
-@register_task("mmtask")
-class FairseqMMTask(LegacyFairseqTask):
- @staticmethod
- def add_args(parser):
- # Add some command-line arguments for specifying where the data is
- # located and the maximum supported input length.
- parser.add_argument(
- "taskconfig",
- metavar="FILE",
- help=("taskconfig to load all configurations" "outside fairseq parser."),
- )
-
- @classmethod
- def setup_task(cls, args, **kwargs):
- return FairseqMMTask(args)
-
- def __init__(self, args):
- super().__init__(args)
- config = utils.load_config(args)
- self.mmtask = Task.config_task(config)
- self.mmtask.build_dataset()
- self.mmtask.build_model()
- self.mmtask.build_loss()
-
- def load_dataset(self, split, **kwargs):
- split_map = {
- "train": self.mmtask.train_data,
- "valid": self.mmtask.val_data,
- "test": self.mmtask.test_data,
- }
- if split not in split_map:
- raise ValueError("unknown split type.")
- if split_map[split] is not None:
- self.datasets[split] = FairseqMMDataset(split_map[split])
-
- def get_batch_iterator(
- self,
- dataset,
- max_tokens=None,
- max_sentences=None,
- max_positions=None,
- ignore_invalid_inputs=False,
- required_batch_size_multiple=1,
- seed=1,
- num_shards=1,
- shard_id=0,
- num_workers=0,
- epoch=1,
- data_buffer_size=0,
- disable_iterator_cache=False,
- skip_remainder_batch=False,
- grouped_shuffling=False,
- update_epoch_batch_itr=False,
- ):
- random.seed(epoch)
- if dataset.mmdataset.split == "train" and isinstance(self.mmtask, RetriTask):
- if epoch >= self.mmtask.config.retri_epoch:
- if not hasattr(self.mmtask, "retri_dataloader"):
- self.mmtask.build_dataloader()
- self.mmtask.retrive_candidates(epoch)
-
- return super().get_batch_iterator(
- dataset,
- max_tokens,
- max_sentences,
- max_positions,
- ignore_invalid_inputs,
- required_batch_size_multiple,
- seed,
- num_shards,
- shard_id,
- num_workers,
- epoch,
- data_buffer_size,
- disable_iterator_cache,
- grouped_shuffling,
- update_epoch_batch_itr,
- )
-
- @property
- def source_dictionary(self):
- return None
-
- @property
- def target_dictionary(self):
- return None
diff --git a/spaces/aubmindlab/Arabic-NLP/backend/processor.py b/spaces/aubmindlab/Arabic-NLP/backend/processor.py
deleted file mode 100644
index 2187d5ca499c6a1b9c927ff7c00141f3b221d713..0000000000000000000000000000000000000000
--- a/spaces/aubmindlab/Arabic-NLP/backend/processor.py
+++ /dev/null
@@ -1,183 +0,0 @@
-import streamlit as st
-import awesome_streamlit as ast
-from .preprocess import (
- ArabertPreprocessor,
- white_spaced_back_quotation_regex,
- white_spaced_double_quotation_regex,
- white_spaced_em_dash,
- white_spaced_single_quotation_regex,
- left_and_right_spaced_chars,
- left_spaced_chars,
- right_spaced_chars,
-)
-import re
-
-MODELS_to_SELECT = [
- "None",
- "bert-base-arabertv01",
- "bert-base-arabert",
- "bert-base-arabertv02",
- "bert-base-arabertv2",
- "bert-large-arabertv02",
- "bert-large-arabertv2",
- "araelectra-base",
- "araelectra-base-discriminator",
- "araelectra-base-generator",
- "araelectra-base-artydiqa",
- "aragpt2-base",
- "aragpt2-medium",
- "aragpt2-large",
- "aragpt2-mega",
-]
-
-
-def unpreprocess(text: str) -> str:
- """Re-formats the text to a classic format where punctuations, brackets, parenthesis are not seperated by whitespaces.
- The objective is to make the generated text of any model appear natural and not preprocessed.
-
- Args:
- text (:obj:`str`): input text to be un-preprocessed
- desegment (:obj:`bool`, optional): [whether or not to remove farasa pre-segmentation before]..
-
- Returns:
- str: The unpreprocessed (and possibly Farasa-desegmented) text.
- """
-
- text = desegment(text)
-
- # removes the spaces around quotation marks ex: i " ate " an apple --> i "ate" an apple
- # https://stackoverflow.com/a/53436792/5381220
- text = re.sub(white_spaced_double_quotation_regex, '"' + r"\1" + '"', text)
- text = re.sub(white_spaced_single_quotation_regex, "'" + r"\1" + "'", text)
- text = re.sub(white_spaced_back_quotation_regex, "\`" + r"\1" + "\`", text)
- text = re.sub(white_spaced_back_quotation_regex, "\—" + r"\1" + "\—", text)
-
- # during generation, sometimes the models don't put a space after the dot, this handles it
- text = text.replace(".", " . ")
- text = " ".join(text.split())
-
- # handle decimals
- text = re.sub(r"(\d+) \. (\d+)", r"\1.\2", text)
- text = re.sub(r"(\d+) \, (\d+)", r"\1,\2", text)
-
- text = re.sub(left_and_right_spaced_chars, r"\1", text)
- text = re.sub(left_spaced_chars, r"\1", text)
- text = re.sub(right_spaced_chars, r"\1", text)
-
- return text
-
-
-def desegment(text: str) -> str:
- """
- Use this function if sentence tokenization was done using
- `from arabert.preprocess_arabert import preprocess` with Farasa enabled
- AraBERT segmentation using Farasa adds a space after the '+' for prefixes,
- and after before the '+' for suffixes
-
- Example:
- >>> desegment('ال+ دراس +ات')
- الدراسات
- """
- text = text.replace("+ ", "+")
- text = text.replace(" +", "+")
- text = " ".join([_desegmentword(word) for word in text.split(" ")])
- return text
-
-
-def _desegmentword(orig_word: str) -> str:
- """
- Word segmentor that takes a Farasa Segmented Word and removes the '+' signs
-
- Example:
- >>> _desegmentword("ال+يومي+ة")
- اليومية
- """
- word = orig_word.replace("ل+ال+", "لل")
- if "ال+ال" not in orig_word:
- word = word.replace("ل+ال", "لل")
- word = word.replace("+", "")
- word = word.replace("للل", "لل")
- return word
-
-
-def write():
-
- st.markdown(
- """
- Arabic Text Pre-Processor
- """,
- unsafe_allow_html=True,
- )
- st.markdown(
- """
-
- """,
- unsafe_allow_html=True,
- )
- input_text = st.text_input(
- "Text to Pre-Process",
- value="ولن نبالغ إذا قلنا: إن 'هاتف' أو 'كمبيوتر المكتب' في زمننا هذا ضروري",
- )
-
- st.sidebar.title("Model Selector")
- model_selector = st.sidebar.selectbox(
- """Select None to enable further filters""", options=MODELS_to_SELECT, index=3
- )
- if model_selector == "None":
- keep_emojis = st.sidebar.checkbox("Keep emojis", False)
- remove_html_markup = st.sidebar.checkbox("Remove html markup", True)
- strip_tashkeel = st.sidebar.checkbox("Strip tashkeel", True)
- replace_urls_emails_mentions = st.sidebar.checkbox(
- "Replace urls and emails", True
- )
- strip_tatweel = st.sidebar.checkbox("Strip tatweel", True)
- insert_white_spaces = st.sidebar.checkbox("Insert white spaces", True)
- remove_non_digit_repetition = st.sidebar.checkbox(
- "Remove non-digit repetition", True
- )
- replace_slash_with_dash = st.sidebar.checkbox("Replace slash with dash", None)
- map_hindi_numbers_to_arabic = st.sidebar.checkbox(
- "Map hindi numbers to arabic", None
- )
- apply_farasa_segmentation = st.sidebar.checkbox(
- "Apply farasa segmentation", None
- )
-
- run_preprocessor = st.button("Run Pre-Processor")
-
- prep_text = None
- if run_preprocessor:
- if model_selector == "None":
- arabert_preprocessor = ArabertPreprocessor(
- model_selector,
- keep_emojis,
- remove_html_markup,
- replace_urls_emails_mentions,
- strip_tashkeel,
- strip_tatweel,
- insert_white_spaces,
- remove_non_digit_repetition,
- replace_slash_with_dash,
- map_hindi_numbers_to_arabic,
- apply_farasa_segmentation,
- )
- else:
- arabert_preprocessor = ArabertPreprocessor(model_name=model_selector)
- prep_text = arabert_preprocessor._preprocess_v3(input_text)
- st.write(prep_text)
-
- st.write("-----")
- input_text_unprep = st.text_input(
- "Text to Undo the Pre-Processing",
- value=prep_text
- if prep_text
- else "و+ لن نبالغ إذا قل +نا : إن ' هاتف ' أو ' كمبيوتر ال+ مكتب ' في زمن +نا هذا ضروري",
- )
- run_unpreprocessor = st.button("Run Un-Pre-Processor")
-
- if run_unpreprocessor:
- st.write(unpreprocess(input_text_unprep))
diff --git a/spaces/avans06/whisper-webui-translate/tests/vad_test.py b/spaces/avans06/whisper-webui-translate/tests/vad_test.py
deleted file mode 100644
index c72492b1e7f9183c7a452784facb2cdf6c1bf0e2..0000000000000000000000000000000000000000
--- a/spaces/avans06/whisper-webui-translate/tests/vad_test.py
+++ /dev/null
@@ -1,72 +0,0 @@
-import unittest
-import numpy as np
-import sys
-
-sys.path.append('../whisper-webui')
-#print("Sys path: " + str(sys.path))
-
-from src.whisper.abstractWhisperContainer import LambdaWhisperCallback
-from src.vad import AbstractTranscription, TranscriptionConfig, VadSileroTranscription
-
-class TestVad(unittest.TestCase):
- def __init__(self, *args, **kwargs):
- super(TestVad, self).__init__(*args, **kwargs)
- self.transcribe_calls = []
-
- def test_transcript(self):
- mock = MockVadTranscription(mock_audio_length=120)
- config = TranscriptionConfig()
-
- self.transcribe_calls.clear()
- result = mock.transcribe("mock", LambdaWhisperCallback(lambda segment, _1, _2, _3, _4: self.transcribe_segments(segment)), config)
-
- self.assertListEqual(self.transcribe_calls, [
- [30, 30],
- [100, 100]
- ])
-
- self.assertListEqual(result['segments'],
- [{'end': 50.0, 'start': 40.0, 'text': 'Hello world '},
- {'end': 120.0, 'start': 110.0, 'text': 'Hello world '}]
- )
-
- def transcribe_segments(self, segment):
- self.transcribe_calls.append(segment.tolist())
-
- # Dummy text
- return {
- 'text': "Hello world ",
- 'segments': [
- {
- "start": 10.0,
- "end": 20.0,
- "text": "Hello world "
- }
- ],
- 'language': ""
- }
-
-class MockVadTranscription(AbstractTranscription):
- def __init__(self, mock_audio_length: float = 1000):
- super().__init__()
- self.mock_audio_length = mock_audio_length
-
- def get_audio_segment(self, str, start_time: str = None, duration: str = None):
- start_time_seconds = float(start_time.removesuffix("s"))
- duration_seconds = float(duration.removesuffix("s"))
-
- # For mocking, this just returns a simple numppy array
- return np.array([start_time_seconds, duration_seconds], dtype=np.float64)
-
- def get_transcribe_timestamps(self, audio: str, config: TranscriptionConfig, start_time: float, duration: float):
- result = []
-
- result.append( { 'start': 30, 'end': 60 } )
- result.append( { 'start': 100, 'end': 200 } )
- return result
-
- def get_audio_duration(self, audio: str, config: TranscriptionConfig):
- return self.mock_audio_length
-
-if __name__ == '__main__':
- unittest.main()
\ No newline at end of file
diff --git a/spaces/awacke1/CardGameMechanics/README.md b/spaces/awacke1/CardGameMechanics/README.md
deleted file mode 100644
index be475f755da365fc6a9248fb0a05eb92f82a286b..0000000000000000000000000000000000000000
--- a/spaces/awacke1/CardGameMechanics/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: 🦀CardGameMechanics🦀
-emoji: 🦀🦀🦀
-colorFrom: green
-colorTo: green
-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/Clinical-Terminology-FHIR-Assessment/README.md b/spaces/awacke1/Clinical-Terminology-FHIR-Assessment/README.md
deleted file mode 100644
index 50b36779b99bd2204c21196cfd032978af100621..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Clinical-Terminology-FHIR-Assessment/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Clinical Terminology FHIR Assessment
-emoji: 🚀🚀🚀
-colorFrom: green
-colorTo: indigo
-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/Grammar-Styler/GrammarTokenize.py b/spaces/awacke1/Grammar-Styler/GrammarTokenize.py
deleted file mode 100644
index 4c5a5acf5de6b0f555b96b92ca64a146d67e8be6..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Grammar-Styler/GrammarTokenize.py
+++ /dev/null
@@ -1,60 +0,0 @@
-import uvicorn
-from fastapi import File
-from fastapi import FastAPI
-from fastapi import UploadFile
-import torch
-import os
-import sys
-import glob
-import transformers
-from transformers import AutoTokenizer
-from transformers import AutoModelForSeq2SeqLM
-
-
-print("Loading models...")
-app = FastAPI()
-
-device = "cpu"
-correction_model_tag = "prithivida/grammar_error_correcter_v1"
-correction_tokenizer = AutoTokenizer.from_pretrained(correction_model_tag)
-correction_model = AutoModelForSeq2SeqLM.from_pretrained(correction_model_tag)
-
-def set_seed(seed):
- torch.manual_seed(seed)
- if torch.cuda.is_available():
- torch.cuda.manual_seed_all(seed)
-
-print("Models loaded !")
-
-
-@app.get("/")
-def read_root():
- return {"Gramformer !"}
-
-@app.get("/{correct}")
-def get_correction(input_sentence):
- set_seed(1212)
- scored_corrected_sentence = correct(input_sentence)
- return {"scored_corrected_sentence": scored_corrected_sentence}
-
-def correct(input_sentence, max_candidates=1):
- correction_prefix = "gec: "
- input_sentence = correction_prefix + input_sentence
- input_ids = correction_tokenizer.encode(input_sentence, return_tensors='pt')
- input_ids = input_ids.to(device)
-
- preds = correction_model.generate(
- input_ids,
- do_sample=True,
- max_length=128,
- top_k=50,
- top_p=0.95,
- early_stopping=True,
- num_return_sequences=max_candidates)
-
- corrected = set()
- for pred in preds:
- corrected.add(correction_tokenizer.decode(pred, skip_special_tokens=True).strip())
-
- corrected = list(corrected)
- return (corrected[0], 0) #Corrected Sentence, Dummy score
\ No newline at end of file
diff --git a/spaces/awacke1/Streamlit.GraphViz.Dynamic.Architecture.Diagram/README.md b/spaces/awacke1/Streamlit.GraphViz.Dynamic.Architecture.Diagram/README.md
deleted file mode 100644
index 87773e898944b460de1a2b27d144d20c68190383..0000000000000000000000000000000000000000
--- a/spaces/awacke1/Streamlit.GraphViz.Dynamic.Architecture.Diagram/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Streamlit.GraphViz.Dynamic.Architecture.Diagram
-emoji: 😻
-colorFrom: green
-colorTo: indigo
-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/azusarang/so-vits-svc-models-ba_P/diffusion/infer_gt_mel.py b/spaces/azusarang/so-vits-svc-models-ba_P/diffusion/infer_gt_mel.py
deleted file mode 100644
index 033b821a5d21a1232f1786bce5616b12e01488ad..0000000000000000000000000000000000000000
--- a/spaces/azusarang/so-vits-svc-models-ba_P/diffusion/infer_gt_mel.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import numpy as np
-import torch
-import torch.nn.functional as F
-from diffusion.unit2mel import load_model_vocoder
-
-
-class DiffGtMel:
- def __init__(self, project_path=None, device=None):
- self.project_path = project_path
- if device is not None:
- self.device = device
- else:
- self.device = 'cuda' if torch.cuda.is_available() else 'cpu'
- self.model = None
- self.vocoder = None
- self.args = None
-
- def flush_model(self, project_path, ddsp_config=None):
- if (self.model is None) or (project_path != self.project_path):
- model, vocoder, args = load_model_vocoder(project_path, device=self.device)
- if self.check_args(ddsp_config, args):
- self.model = model
- self.vocoder = vocoder
- self.args = args
-
- def check_args(self, args1, args2):
- if args1.data.block_size != args2.data.block_size:
- raise ValueError("DDSP与DIFF模型的block_size不一致")
- if args1.data.sampling_rate != args2.data.sampling_rate:
- raise ValueError("DDSP与DIFF模型的sampling_rate不一致")
- if args1.data.encoder != args2.data.encoder:
- raise ValueError("DDSP与DIFF模型的encoder不一致")
- return True
-
- def __call__(self, audio, f0, hubert, volume, acc=1, spk_id=1, k_step=0, method='pndm',
- spk_mix_dict=None, start_frame=0):
- input_mel = self.vocoder.extract(audio, self.args.data.sampling_rate)
- out_mel = self.model(
- hubert,
- f0,
- volume,
- spk_id=spk_id,
- spk_mix_dict=spk_mix_dict,
- gt_spec=input_mel,
- infer=True,
- infer_speedup=acc,
- method=method,
- k_step=k_step,
- use_tqdm=False)
- if start_frame > 0:
- out_mel = out_mel[:, start_frame:, :]
- f0 = f0[:, start_frame:, :]
- output = self.vocoder.infer(out_mel, f0)
- if start_frame > 0:
- output = F.pad(output, (start_frame * self.vocoder.vocoder_hop_size, 0))
- return output
-
- def infer(self, audio, f0, hubert, volume, acc=1, spk_id=1, k_step=0, method='pndm', silence_front=0,
- use_silence=False, spk_mix_dict=None):
- start_frame = int(silence_front * self.vocoder.vocoder_sample_rate / self.vocoder.vocoder_hop_size)
- if use_silence:
- audio = audio[:, start_frame * self.vocoder.vocoder_hop_size:]
- f0 = f0[:, start_frame:, :]
- hubert = hubert[:, start_frame:, :]
- volume = volume[:, start_frame:, :]
- _start_frame = 0
- else:
- _start_frame = start_frame
- audio = self.__call__(audio, f0, hubert, volume, acc=acc, spk_id=spk_id, k_step=k_step,
- method=method, spk_mix_dict=spk_mix_dict, start_frame=_start_frame)
- if use_silence:
- if start_frame > 0:
- audio = F.pad(audio, (start_frame * self.vocoder.vocoder_hop_size, 0))
- return audio
diff --git a/spaces/bhaskartripathi/Text2Question/README.md b/spaces/bhaskartripathi/Text2Question/README.md
deleted file mode 100644
index e68c037ffa2649ca6e97fb8f42932bcb64d975ed..0000000000000000000000000000000000000000
--- a/spaces/bhaskartripathi/Text2Question/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: Text2Question
-emoji: 🐨
-colorFrom: green
-colorTo: yellow
-sdk: gradio
-sdk_version: 3.20.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/bhavanaraj/myaivoice/README.md b/spaces/bhavanaraj/myaivoice/README.md
deleted file mode 100644
index 4e4e6ba67e2024468e1ed27832318ee1630902dc..0000000000000000000000000000000000000000
--- a/spaces/bhavanaraj/myaivoice/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: Myaivoice
-emoji: 🦀
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 3.39.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/bingbing520/ChatGPT2/modules/models.py b/spaces/bingbing520/ChatGPT2/modules/models.py
deleted file mode 100644
index 25b18b1904910e183a997a763008403d960868d6..0000000000000000000000000000000000000000
--- a/spaces/bingbing520/ChatGPT2/modules/models.py
+++ /dev/null
@@ -1,625 +0,0 @@
-from __future__ import annotations
-from typing import TYPE_CHECKING, List
-
-import logging
-import json
-import commentjson as cjson
-import os
-import sys
-import requests
-import urllib3
-import platform
-import base64
-from io import BytesIO
-from PIL import Image
-
-from tqdm import tqdm
-import colorama
-from duckduckgo_search import ddg
-import asyncio
-import aiohttp
-from enum import Enum
-import uuid
-
-from .presets import *
-from .llama_func import *
-from .utils import *
-from . import shared
-from .config import retrieve_proxy
-from modules import config
-from .base_model import BaseLLMModel, ModelType
-
-
-class OpenAIClient(BaseLLMModel):
- def __init__(
- self,
- model_name,
- api_key,
- system_prompt=INITIAL_SYSTEM_PROMPT,
- temperature=1.0,
- top_p=1.0,
- ) -> None:
- super().__init__(
- model_name=model_name,
- temperature=temperature,
- top_p=top_p,
- system_prompt=system_prompt,
- )
- self.api_key = api_key
- self.need_api_key = True
- self._refresh_header()
-
- def get_answer_stream_iter(self):
- response = self._get_response(stream=True)
- if response is not None:
- iter = self._decode_chat_response(response)
- partial_text = ""
- for i in iter:
- partial_text += i
- yield partial_text
- else:
- yield STANDARD_ERROR_MSG + GENERAL_ERROR_MSG
-
- def get_answer_at_once(self):
- response = self._get_response()
- response = json.loads(response.text)
- content = response["choices"][0]["message"]["content"]
- total_token_count = response["usage"]["total_tokens"]
- return content, total_token_count
-
- def count_token(self, user_input):
- input_token_count = count_token(construct_user(user_input))
- if self.system_prompt is not None and len(self.all_token_counts) == 0:
- system_prompt_token_count = count_token(
- construct_system(self.system_prompt)
- )
- return input_token_count + system_prompt_token_count
- return input_token_count
-
- def billing_info(self):
- try:
- curr_time = datetime.datetime.now()
- last_day_of_month = get_last_day_of_month(
- curr_time).strftime("%Y-%m-%d")
- first_day_of_month = curr_time.replace(day=1).strftime("%Y-%m-%d")
- usage_url = f"{shared.state.usage_api_url}?start_date={first_day_of_month}&end_date={last_day_of_month}"
- try:
- usage_data = self._get_billing_data(usage_url)
- except Exception as e:
- logging.error(f"获取API使用情况失败:" + str(e))
- return i18n("**获取API使用情况失败**")
- rounded_usage = "{:.5f}".format(usage_data["total_usage"] / 100)
- return i18n("**本月使用金额** ") + f"\u3000 ${rounded_usage}"
- except requests.exceptions.ConnectTimeout:
- status_text = (
- STANDARD_ERROR_MSG + CONNECTION_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
- )
- return status_text
- except requests.exceptions.ReadTimeout:
- status_text = STANDARD_ERROR_MSG + READ_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
- return status_text
- except Exception as e:
- import traceback
- traceback.print_exc()
- logging.error(i18n("获取API使用情况失败:") + str(e))
- return STANDARD_ERROR_MSG + ERROR_RETRIEVE_MSG
-
- def set_token_upper_limit(self, new_upper_limit):
- pass
-
- @shared.state.switching_api_key # 在不开启多账号模式的时候，这个装饰器不会起作用
- def _get_response(self, stream=False):
- openai_api_key = self.api_key
- system_prompt = self.system_prompt
- history = self.history
- logging.debug(colorama.Fore.YELLOW +
- f"{history}" + colorama.Fore.RESET)
- headers = {
- "Content-Type": "application/json",
- "Authorization": f"Bearer {openai_api_key}",
- }
-
- if system_prompt is not None:
- history = [construct_system(system_prompt), *history]
-
- payload = {
- "model": self.model_name,
- "messages": history,
- "temperature": self.temperature,
- "top_p": self.top_p,
- "n": self.n_choices,
- "stream": stream,
- "presence_penalty": self.presence_penalty,
- "frequency_penalty": self.frequency_penalty,
- }
-
- if self.max_generation_token is not None:
- payload["max_tokens"] = self.max_generation_token
- if self.stop_sequence is not None:
- payload["stop"] = self.stop_sequence
- if self.logit_bias is not None:
- payload["logit_bias"] = self.logit_bias
- if self.user_identifier is not None:
- payload["user"] = self.user_identifier
-
- if stream:
- timeout = TIMEOUT_STREAMING
- else:
- timeout = TIMEOUT_ALL
-
- # 如果有自定义的api-host，使用自定义host发送请求，否则使用默认设置发送请求
- if shared.state.completion_url != COMPLETION_URL:
- logging.info(f"使用自定义API URL: {shared.state.completion_url}")
-
- with retrieve_proxy():
- try:
- response = requests.post(
- shared.state.completion_url,
- headers=headers,
- json=payload,
- stream=stream,
- timeout=timeout,
- )
- except:
- return None
- return response
-
- def _refresh_header(self):
- self.headers = {
- "Content-Type": "application/json",
- "Authorization": f"Bearer {self.api_key}",
- }
-
- def _get_billing_data(self, billing_url):
- with retrieve_proxy():
- response = requests.get(
- billing_url,
- headers=self.headers,
- timeout=TIMEOUT_ALL,
- )
-
- if response.status_code == 200:
- data = response.json()
- return data
- else:
- raise Exception(
- f"API request failed with status code {response.status_code}: {response.text}"
- )
-
- def _decode_chat_response(self, response):
- error_msg = ""
- for chunk in response.iter_lines():
- if chunk:
- chunk = chunk.decode()
- chunk_length = len(chunk)
- try:
- chunk = json.loads(chunk[6:])
- except json.JSONDecodeError:
- print(i18n("JSON解析错误,收到的内容: ") + f"{chunk}")
- error_msg += chunk
- continue
- if chunk_length > 6 and "delta" in chunk["choices"][0]:
- if chunk["choices"][0]["finish_reason"] == "stop":
- break
- try:
- yield chunk["choices"][0]["delta"]["content"]
- except Exception as e:
- # logging.error(f"Error: {e}")
- continue
- if error_msg:
- raise Exception(error_msg)
-
- def set_key(self, new_access_key):
- ret = super().set_key(new_access_key)
- self._refresh_header()
- return ret
-
-
-class ChatGLM_Client(BaseLLMModel):
- def __init__(self, model_name) -> None:
- super().__init__(model_name=model_name)
- from transformers import AutoTokenizer, AutoModel
- import torch
- global CHATGLM_TOKENIZER, CHATGLM_MODEL
- if CHATGLM_TOKENIZER is None or CHATGLM_MODEL is None:
- system_name = platform.system()
- model_path = None
- if os.path.exists("models"):
- model_dirs = os.listdir("models")
- if model_name in model_dirs:
- model_path = f"models/{model_name}"
- if model_path is not None:
- model_source = model_path
- else:
- model_source = f"THUDM/{model_name}"
- CHATGLM_TOKENIZER = AutoTokenizer.from_pretrained(
- model_source, trust_remote_code=True
- )
- quantified = False
- if "int4" in model_name:
- quantified = True
- model = AutoModel.from_pretrained(
- model_source, trust_remote_code=True
- )
- if torch.cuda.is_available():
- # run on CUDA
- logging.info("CUDA is available, using CUDA")
- model = model.half().cuda()
- # mps加速还存在一些问题，暂时不使用
- elif system_name == "Darwin" and model_path is not None and not quantified:
- logging.info("Running on macOS, using MPS")
- # running on macOS and model already downloaded
- model = model.half().to("mps")
- else:
- logging.info("GPU is not available, using CPU")
- model = model.float()
- model = model.eval()
- CHATGLM_MODEL = model
-
- def _get_glm_style_input(self):
- history = [x["content"] for x in self.history]
- query = history.pop()
- logging.debug(colorama.Fore.YELLOW +
- f"{history}" + colorama.Fore.RESET)
- assert (
- len(history) % 2 == 0
- ), f"History should be even length. current history is: {history}"
- history = [[history[i], history[i + 1]]
- for i in range(0, len(history), 2)]
- return history, query
-
- def get_answer_at_once(self):
- history, query = self._get_glm_style_input()
- response, _ = CHATGLM_MODEL.chat(
- CHATGLM_TOKENIZER, query, history=history)
- return response, len(response)
-
- def get_answer_stream_iter(self):
- history, query = self._get_glm_style_input()
- for response, history in CHATGLM_MODEL.stream_chat(
- CHATGLM_TOKENIZER,
- query,
- history,
- max_length=self.token_upper_limit,
- top_p=self.top_p,
- temperature=self.temperature,
- ):
- yield response
-
-
-class LLaMA_Client(BaseLLMModel):
- def __init__(
- self,
- model_name,
- lora_path=None,
- ) -> None:
- super().__init__(model_name=model_name)
- from lmflow.datasets.dataset import Dataset
- from lmflow.pipeline.auto_pipeline import AutoPipeline
- from lmflow.models.auto_model import AutoModel
- from lmflow.args import ModelArguments, DatasetArguments, InferencerArguments
-
- self.max_generation_token = 1000
- self.end_string = "\n\n"
- # We don't need input data
- data_args = DatasetArguments(dataset_path=None)
- self.dataset = Dataset(data_args)
- self.system_prompt = ""
-
- global LLAMA_MODEL, LLAMA_INFERENCER
- if LLAMA_MODEL is None or LLAMA_INFERENCER is None:
- model_path = None
- if os.path.exists("models"):
- model_dirs = os.listdir("models")
- if model_name in model_dirs:
- model_path = f"models/{model_name}"
- if model_path is not None:
- model_source = model_path
- else:
- model_source = f"decapoda-research/{model_name}"
- # raise Exception(f"models目录下没有这个模型: {model_name}")
- if lora_path is not None:
- lora_path = f"lora/{lora_path}"
- model_args = ModelArguments(model_name_or_path=model_source, lora_model_path=lora_path, model_type=None, config_overrides=None, config_name=None, tokenizer_name=None, cache_dir=None,
- use_fast_tokenizer=True, model_revision='main', use_auth_token=False, torch_dtype=None, use_lora=False, lora_r=8, lora_alpha=32, lora_dropout=0.1, use_ram_optimized_load=True)
- pipeline_args = InferencerArguments(
- local_rank=0, random_seed=1, deepspeed='configs/ds_config_chatbot.json', mixed_precision='bf16')
-
- with open(pipeline_args.deepspeed, "r") as f:
- ds_config = json.load(f)
- LLAMA_MODEL = AutoModel.get_model(
- model_args,
- tune_strategy="none",
- ds_config=ds_config,
- )
- LLAMA_INFERENCER = AutoPipeline.get_pipeline(
- pipeline_name="inferencer",
- model_args=model_args,
- data_args=data_args,
- pipeline_args=pipeline_args,
- )
-
- def _get_llama_style_input(self):
- history = []
- instruction = ""
- if self.system_prompt:
- instruction = (f"Instruction: {self.system_prompt}\n")
- for x in self.history:
- if x["role"] == "user":
- history.append(f"{instruction}Input: {x['content']}")
- else:
- history.append(f"Output: {x['content']}")
- context = "\n\n".join(history)
- context += "\n\nOutput: "
- return context
-
- def get_answer_at_once(self):
- context = self._get_llama_style_input()
-
- input_dataset = self.dataset.from_dict(
- {"type": "text_only", "instances": [{"text": context}]}
- )
-
- output_dataset = LLAMA_INFERENCER.inference(
- model=LLAMA_MODEL,
- dataset=input_dataset,
- max_new_tokens=self.max_generation_token,
- temperature=self.temperature,
- )
-
- response = output_dataset.to_dict()["instances"][0]["text"]
- return response, len(response)
-
- def get_answer_stream_iter(self):
- context = self._get_llama_style_input()
- partial_text = ""
- step = 1
- for _ in range(0, self.max_generation_token, step):
- input_dataset = self.dataset.from_dict(
- {"type": "text_only", "instances": [
- {"text": context + partial_text}]}
- )
- output_dataset = LLAMA_INFERENCER.inference(
- model=LLAMA_MODEL,
- dataset=input_dataset,
- max_new_tokens=step,
- temperature=self.temperature,
- )
- response = output_dataset.to_dict()["instances"][0]["text"]
- if response == "" or response == self.end_string:
- break
- partial_text += response
- yield partial_text
-
-
-class XMChat(BaseLLMModel):
- def __init__(self, api_key):
- super().__init__(model_name="xmchat")
- self.api_key = api_key
- self.session_id = None
- self.reset()
- self.image_bytes = None
- self.image_path = None
- self.xm_history = []
- self.url = "https://xmbot.net/web"
- self.last_conv_id = None
-
- def reset(self):
- self.session_id = str(uuid.uuid4())
- self.last_conv_id = None
- return [], "已重置"
-
- def image_to_base64(self, image_path):
- # 打开并加载图片
- img = Image.open(image_path)
-
- # 获取图片的宽度和高度
- width, height = img.size
-
- # 计算压缩比例，以确保最长边小于4096像素
- max_dimension = 2048
- scale_ratio = min(max_dimension / width, max_dimension / height)
-
- if scale_ratio < 1:
- # 按压缩比例调整图片大小
- new_width = int(width * scale_ratio)
- new_height = int(height * scale_ratio)
- img = img.resize((new_width, new_height), Image.ANTIALIAS)
-
- # 将图片转换为jpg格式的二进制数据
- buffer = BytesIO()
- if img.mode == "RGBA":
- img = img.convert("RGB")
- img.save(buffer, format='JPEG')
- binary_image = buffer.getvalue()
-
- # 对二进制数据进行Base64编码
- base64_image = base64.b64encode(binary_image).decode('utf-8')
-
- return base64_image
-
- def try_read_image(self, filepath):
- def is_image_file(filepath):
- # 判断文件是否为图片
- valid_image_extensions = [".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff"]
- file_extension = os.path.splitext(filepath)[1].lower()
- return file_extension in valid_image_extensions
-
- if is_image_file(filepath):
- logging.info(f"读取图片文件: {filepath}")
- self.image_bytes = self.image_to_base64(filepath)
- self.image_path = filepath
- else:
- self.image_bytes = None
- self.image_path = None
-
- def like(self):
- if self.last_conv_id is None:
- return "点赞失败，你还没发送过消息"
- data = {
- "uuid": self.last_conv_id,
- "appraise": "good"
- }
- response = requests.post(self.url, json=data)
- return "👍点赞成功，，感谢反馈～"
-
- def dislike(self):
- if self.last_conv_id is None:
- return "点踩失败，你还没发送过消息"
- data = {
- "uuid": self.last_conv_id,
- "appraise": "bad"
- }
- response = requests.post(self.url, json=data)
- return "👎点踩成功，感谢反馈～"
-
- def prepare_inputs(self, real_inputs, use_websearch, files, reply_language, chatbot):
- fake_inputs = real_inputs
- display_append = ""
- limited_context = False
- return limited_context, fake_inputs, display_append, real_inputs, chatbot
-
- def handle_file_upload(self, files, chatbot):
- """if the model accepts multi modal input, implement this function"""
- if files:
- for file in files:
- if file.name:
- logging.info(f"尝试读取图像: {file.name}")
- self.try_read_image(file.name)
- if self.image_path is not None:
- chatbot = chatbot + [((self.image_path,), None)]
- if self.image_bytes is not None:
- logging.info("使用图片作为输入")
- # XMChat的一轮对话中实际上只能处理一张图片
- self.reset()
- conv_id = str(uuid.uuid4())
- data = {
- "user_id": self.api_key,
- "session_id": self.session_id,
- "uuid": conv_id,
- "data_type": "imgbase64",
- "data": self.image_bytes
- }
- response = requests.post(self.url, json=data)
- response = json.loads(response.text)
- logging.info(f"图片回复: {response['data']}")
- return None, chatbot, None
-
- def get_answer_at_once(self):
- question = self.history[-1]["content"]
- conv_id = str(uuid.uuid4())
- self.last_conv_id = conv_id
- data = {
- "user_id": self.api_key,
- "session_id": self.session_id,
- "uuid": conv_id,
- "data_type": "text",
- "data": question
- }
- response = requests.post(self.url, json=data)
- try:
- response = json.loads(response.text)
- return response["data"], len(response["data"])
- except Exception as e:
- return response.text, len(response.text)
-
-
-
-
-def get_model(
- model_name,
- lora_model_path=None,
- access_key=None,
- temperature=None,
- top_p=None,
- system_prompt=None,
-) -> BaseLLMModel:
- msg = i18n("模型设置为了：") + f" {model_name}"
- model_type = ModelType.get_type(model_name)
- lora_selector_visibility = False
- lora_choices = []
- dont_change_lora_selector = False
- if model_type != ModelType.OpenAI:
- config.local_embedding = True
- # del current_model.model
- model = None
- try:
- if model_type == ModelType.OpenAI:
- logging.info(f"正在加载OpenAI模型: {model_name}")
- model = OpenAIClient(
- model_name=model_name,
- api_key=access_key,
- system_prompt=system_prompt,
- temperature=temperature,
- top_p=top_p,
- )
- elif model_type == ModelType.ChatGLM:
- logging.info(f"正在加载ChatGLM模型: {model_name}")
- model = ChatGLM_Client(model_name)
- elif model_type == ModelType.LLaMA and lora_model_path == "":
- msg = f"现在请为 {model_name} 选择LoRA模型"
- logging.info(msg)
- lora_selector_visibility = True
- if os.path.isdir("lora"):
- lora_choices = get_file_names(
- "lora", plain=True, filetypes=[""])
- lora_choices = ["No LoRA"] + lora_choices
- elif model_type == ModelType.LLaMA and lora_model_path != "":
- logging.info(f"正在加载LLaMA模型: {model_name} + {lora_model_path}")
- dont_change_lora_selector = True
- if lora_model_path == "No LoRA":
- lora_model_path = None
- msg += " + No LoRA"
- else:
- msg += f" + {lora_model_path}"
- model = LLaMA_Client(model_name, lora_model_path)
- elif model_type == ModelType.XMChat:
- if os.environ.get("XMCHAT_API_KEY") != "":
- access_key = os.environ.get("XMCHAT_API_KEY")
- model = XMChat(api_key=access_key)
- elif model_type == ModelType.Unknown:
- raise ValueError(f"未知模型: {model_name}")
- logging.info(msg)
- except Exception as e:
- logging.error(e)
- msg = f"{STANDARD_ERROR_MSG}: {e}"
- if dont_change_lora_selector:
- return model, msg
- else:
- return model, msg, gr.Dropdown.update(choices=lora_choices, visible=lora_selector_visibility)
-
-
-if __name__ == "__main__":
- with open("config.json", "r") as f:
- openai_api_key = cjson.load(f)["openai_api_key"]
- # set logging level to debug
- logging.basicConfig(level=logging.DEBUG)
- # client = ModelManager(model_name="gpt-3.5-turbo", access_key=openai_api_key)
- client = get_model(model_name="chatglm-6b-int4")
- chatbot = []
- stream = False
- # 测试账单功能
- logging.info(colorama.Back.GREEN + "测试账单功能" + colorama.Back.RESET)
- logging.info(client.billing_info())
- # 测试问答
- logging.info(colorama.Back.GREEN + "测试问答" + colorama.Back.RESET)
- question = "巴黎是中国的首都吗？"
- for i in client.predict(inputs=question, chatbot=chatbot, stream=stream):
- logging.info(i)
- logging.info(f"测试问答后history : {client.history}")
- # 测试记忆力
- logging.info(colorama.Back.GREEN + "测试记忆力" + colorama.Back.RESET)
- question = "我刚刚问了你什么问题？"
- for i in client.predict(inputs=question, chatbot=chatbot, stream=stream):
- logging.info(i)
- logging.info(f"测试记忆力后history : {client.history}")
- # 测试重试功能
- logging.info(colorama.Back.GREEN + "测试重试功能" + colorama.Back.RESET)
- for i in client.retry(chatbot=chatbot, stream=stream):
- logging.info(i)
- logging.info(f"重试后history : {client.history}")
- # # 测试总结功能
- # print(colorama.Back.GREEN + "测试总结功能" + colorama.Back.RESET)
- # chatbot, msg = client.reduce_token_size(chatbot=chatbot)
- # print(chatbot, msg)
- # print(f"总结后history: {client.history}")
diff --git a/spaces/bioriAsaeru/text-to-voice/Astm D 4565 Pdf Free VERIFIED.md b/spaces/bioriAsaeru/text-to-voice/Astm D 4565 Pdf Free VERIFIED.md
deleted file mode 100644
index 28a72418d07b6ad72814a212f91fbdf1ac48eae7..0000000000000000000000000000000000000000
--- a/spaces/bioriAsaeru/text-to-voice/Astm D 4565 Pdf Free VERIFIED.md
+++ /dev/null
@@ -1,5 +0,0 @@
-
-(c) Sample Conditioning and Testing. Remove the sample from the tensile tester prior to testing and condition for one hour at 50 ±2 °C. Test immediately in accordance with the procedure specified in ASTM D 4565-90a. A minimum outer jacket slip strength of 67 newtons (15 pound-force) is required. Record the load attained.
-astm d 4565 pdf free DOWNLOAD --->>> https://urloso.com/2uyPls
HD Online Player (robinson crusoe 1997 movie torrent d) Download File 🆗 https://urloso.com/2uyQuu
diff --git a/spaces/bla/tranny/App/UserTranscriptions/UserTranscriptionsRoutes.py b/spaces/bla/tranny/App/UserTranscriptions/UserTranscriptionsRoutes.py
deleted file mode 100644
index 8d1656756294223144fdf58921c4a5d43eaf1bb3..0000000000000000000000000000000000000000
--- a/spaces/bla/tranny/App/UserTranscriptions/UserTranscriptionsRoutes.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from fastapi import APIRouter
-from .Schemas import BaseRequest, GetTranscriptions
-from .Model import UserTranscriptions
-from App.Users.Model import User
-
-user_transcriptions_router = APIRouter(tags=["user-transcriptions"])
-
-
-@user_transcriptions_router.post("/user-transcriptions/add")
-async def add_transcriptions(transcriptionTask: BaseRequest):
- user = await User.objects.filter(id=transcriptionTask.userId).first()
- created_task = await UserTranscriptions.objects.create(
- user=user, **transcriptionTask.dict()
- )
- return {"code": 200, "message": "success", "payload": created_task.__dict__}
-
-
-@user_transcriptions_router.get("/user-transcriptions/all")
-async def get_transcriptions(user: GetTranscriptions):
- transcriptions = await UserTranscriptions.objects.filter(user=user.userId).all()
- if transcriptions == None:
- return {
- "code": 200,
- "message": "Success",
- "payload": {},
- }
-
- return {
- "code": 200,
- "message": "Success",
- "payload": transcriptions.__dict__,
- }
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/backbone/resnet.py b/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/backbone/resnet.py
deleted file mode 100644
index 5b8e842c585a81b5345ade4ca1da62a4904a122a..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/detectron2/modeling/backbone/resnet.py
+++ /dev/null
@@ -1,694 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import numpy as np
-import fvcore.nn.weight_init as weight_init
-import torch
-import torch.nn.functional as F
-from torch import nn
-
-from detectron2.layers import (
- CNNBlockBase,
- Conv2d,
- DeformConv,
- ModulatedDeformConv,
- ShapeSpec,
- get_norm,
-)
-
-from .backbone import Backbone
-from .build import BACKBONE_REGISTRY
-
-__all__ = [
- "ResNetBlockBase",
- "BasicBlock",
- "BottleneckBlock",
- "DeformBottleneckBlock",
- "BasicStem",
- "ResNet",
- "make_stage",
- "build_resnet_backbone",
-]
-
-
-class BasicBlock(CNNBlockBase):
- """
- The basic residual block for ResNet-18 and ResNet-34 defined in :paper:`ResNet`,
- with two 3x3 conv layers and a projection shortcut if needed.
- """
-
- def __init__(self, in_channels, out_channels, *, stride=1, norm="BN"):
- """
- Args:
- in_channels (int): Number of input channels.
- out_channels (int): Number of output channels.
- stride (int): Stride for the first conv.
- norm (str or callable): normalization for all conv layers.
- See :func:`layers.get_norm` for supported format.
- """
- super().__init__(in_channels, out_channels, stride)
-
- if in_channels != out_channels:
- self.shortcut = Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=stride,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- else:
- self.shortcut = None
-
- self.conv1 = Conv2d(
- in_channels,
- out_channels,
- kernel_size=3,
- stride=stride,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- self.conv2 = Conv2d(
- out_channels,
- out_channels,
- kernel_size=3,
- stride=1,
- padding=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- for layer in [self.conv1, self.conv2, self.shortcut]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
- out = self.conv2(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-class BottleneckBlock(CNNBlockBase):
- """
- The standard bottleneck residual block used by ResNet-50, 101 and 152
- defined in :paper:`ResNet`. It contains 3 conv layers with kernels
- 1x1, 3x3, 1x1, and a projection shortcut if needed.
- """
-
- def __init__(
- self,
- in_channels,
- out_channels,
- *,
- bottleneck_channels,
- stride=1,
- num_groups=1,
- norm="BN",
- stride_in_1x1=False,
- dilation=1,
- ):
- """
- Args:
- bottleneck_channels (int): number of output channels for the 3x3
- "bottleneck" conv layers.
- num_groups (int): number of groups for the 3x3 conv layer.
- norm (str or callable): normalization for all conv layers.
- See :func:`layers.get_norm` for supported format.
- stride_in_1x1 (bool): when stride>1, whether to put stride in the
- first 1x1 convolution or the bottleneck 3x3 convolution.
- dilation (int): the dilation rate of the 3x3 conv layer.
- """
- super().__init__(in_channels, out_channels, stride)
-
- if in_channels != out_channels:
- self.shortcut = Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=stride,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- else:
- self.shortcut = None
-
- # The original MSRA ResNet models have stride in the first 1x1 conv
- # The subsequent fb.torch.resnet and Caffe2 ResNe[X]t implementations have
- # stride in the 3x3 conv
- stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
-
- self.conv1 = Conv2d(
- in_channels,
- bottleneck_channels,
- kernel_size=1,
- stride=stride_1x1,
- bias=False,
- norm=get_norm(norm, bottleneck_channels),
- )
-
- self.conv2 = Conv2d(
- bottleneck_channels,
- bottleneck_channels,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- bias=False,
- groups=num_groups,
- dilation=dilation,
- norm=get_norm(norm, bottleneck_channels),
- )
-
- self.conv3 = Conv2d(
- bottleneck_channels,
- out_channels,
- kernel_size=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- # Zero-initialize the last normalization in each residual branch,
- # so that at the beginning, the residual branch starts with zeros,
- # and each residual block behaves like an identity.
- # See Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
- # "For BN layers, the learnable scaling coefficient γ is initialized
- # to be 1, except for each residual block's last BN
- # where γ is initialized to be 0."
-
- # nn.init.constant_(self.conv3.norm.weight, 0)
- # TODO this somehow hurts performance when training GN models from scratch.
- # Add it as an option when we need to use this code to train a backbone.
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
-
- out = self.conv2(out)
- out = F.relu_(out)
-
- out = self.conv3(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-class DeformBottleneckBlock(CNNBlockBase):
- """
- Similar to :class:`BottleneckBlock`, but with :paper:`deformable conv `
- in the 3x3 convolution.
- """
-
- def __init__(
- self,
- in_channels,
- out_channels,
- *,
- bottleneck_channels,
- stride=1,
- num_groups=1,
- norm="BN",
- stride_in_1x1=False,
- dilation=1,
- deform_modulated=False,
- deform_num_groups=1,
- ):
- super().__init__(in_channels, out_channels, stride)
- self.deform_modulated = deform_modulated
-
- if in_channels != out_channels:
- self.shortcut = Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- stride=stride,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- else:
- self.shortcut = None
-
- stride_1x1, stride_3x3 = (stride, 1) if stride_in_1x1 else (1, stride)
-
- self.conv1 = Conv2d(
- in_channels,
- bottleneck_channels,
- kernel_size=1,
- stride=stride_1x1,
- bias=False,
- norm=get_norm(norm, bottleneck_channels),
- )
-
- if deform_modulated:
- deform_conv_op = ModulatedDeformConv
- # offset channels are 2 or 3 (if with modulated) * kernel_size * kernel_size
- offset_channels = 27
- else:
- deform_conv_op = DeformConv
- offset_channels = 18
-
- self.conv2_offset = Conv2d(
- bottleneck_channels,
- offset_channels * deform_num_groups,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- dilation=dilation,
- )
- self.conv2 = deform_conv_op(
- bottleneck_channels,
- bottleneck_channels,
- kernel_size=3,
- stride=stride_3x3,
- padding=1 * dilation,
- bias=False,
- groups=num_groups,
- dilation=dilation,
- deformable_groups=deform_num_groups,
- norm=get_norm(norm, bottleneck_channels),
- )
-
- self.conv3 = Conv2d(
- bottleneck_channels,
- out_channels,
- kernel_size=1,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
-
- for layer in [self.conv1, self.conv2, self.conv3, self.shortcut]:
- if layer is not None: # shortcut can be None
- weight_init.c2_msra_fill(layer)
-
- nn.init.constant_(self.conv2_offset.weight, 0)
- nn.init.constant_(self.conv2_offset.bias, 0)
-
- def forward(self, x):
- out = self.conv1(x)
- out = F.relu_(out)
-
- if self.deform_modulated:
- offset_mask = self.conv2_offset(out)
- offset_x, offset_y, mask = torch.chunk(offset_mask, 3, dim=1)
- offset = torch.cat((offset_x, offset_y), dim=1)
- mask = mask.sigmoid()
- out = self.conv2(out, offset, mask)
- else:
- offset = self.conv2_offset(out)
- out = self.conv2(out, offset)
- out = F.relu_(out)
-
- out = self.conv3(out)
-
- if self.shortcut is not None:
- shortcut = self.shortcut(x)
- else:
- shortcut = x
-
- out += shortcut
- out = F.relu_(out)
- return out
-
-
-class BasicStem(CNNBlockBase):
- """
- The standard ResNet stem (layers before the first residual block),
- with a conv, relu and max_pool.
- """
-
- def __init__(self, in_channels=3, out_channels=64, norm="BN"):
- """
- Args:
- norm (str or callable): norm after the first conv layer.
- See :func:`layers.get_norm` for supported format.
- """
- super().__init__(in_channels, out_channels, 4)
- self.in_channels = in_channels
- self.conv1 = Conv2d(
- in_channels,
- out_channels,
- kernel_size=7,
- stride=2,
- padding=3,
- bias=False,
- norm=get_norm(norm, out_channels),
- )
- weight_init.c2_msra_fill(self.conv1)
-
- def forward(self, x):
- x = self.conv1(x)
- x = F.relu_(x)
- x = F.max_pool2d(x, kernel_size=3, stride=2, padding=1)
- return x
-
-
-class ResNet(Backbone):
- """
- Implement :paper:`ResNet`.
- """
-
- def __init__(self, stem, stages, num_classes=None, out_features=None, freeze_at=0):
- """
- Args:
- stem (nn.Module): a stem module
- stages (list[list[CNNBlockBase]]): several (typically 4) stages,
- each contains multiple :class:`CNNBlockBase`.
- num_classes (None or int): if None, will not perform classification.
- Otherwise, will create a linear layer.
- out_features (list[str]): name of the layers whose outputs should
- be returned in forward. Can be anything in "stem", "linear", or "res2" ...
- If None, will return the output of the last layer.
- freeze_at (int): The number of stages at the beginning to freeze.
- see :meth:`freeze` for detailed explanation.
- """
- super().__init__()
- self.stem = stem
- self.num_classes = num_classes
-
- current_stride = self.stem.stride
- self._out_feature_strides = {"stem": current_stride}
- self._out_feature_channels = {"stem": self.stem.out_channels}
-
- self.stage_names, self.stages = [], []
-
- if out_features is not None:
- # Avoid keeping unused layers in this module. They consume extra memory
- # and may cause allreduce to fail
- num_stages = max(
- [{"res2": 1, "res3": 2, "res4": 3, "res5": 4}.get(f, 0) for f in out_features]
- )
- stages = stages[:num_stages]
- for i, blocks in enumerate(stages):
- assert len(blocks) > 0, len(blocks)
- for block in blocks:
- assert isinstance(block, CNNBlockBase), block
-
- name = "res" + str(i + 2)
- stage = nn.Sequential(*blocks)
-
- self.add_module(name, stage)
- self.stage_names.append(name)
- self.stages.append(stage)
-
- self._out_feature_strides[name] = current_stride = int(
- current_stride * np.prod([k.stride for k in blocks])
- )
- self._out_feature_channels[name] = curr_channels = blocks[-1].out_channels
- self.stage_names = tuple(self.stage_names) # Make it static for scripting
-
- if num_classes is not None:
- self.avgpool = nn.AdaptiveAvgPool2d((1, 1))
- self.linear = nn.Linear(curr_channels, num_classes)
-
- # Sec 5.1 in "Accurate, Large Minibatch SGD: Training ImageNet in 1 Hour":
- # "The 1000-way fully-connected layer is initialized by
- # drawing weights from a zero-mean Gaussian with standard deviation of 0.01."
- nn.init.normal_(self.linear.weight, std=0.01)
- name = "linear"
-
- if out_features is None:
- out_features = [name]
- self._out_features = out_features
- assert len(self._out_features)
- children = [x[0] for x in self.named_children()]
- for out_feature in self._out_features:
- assert out_feature in children, "Available children: {}".format(", ".join(children))
- self.freeze(freeze_at)
-
- def forward(self, x):
- """
- Args:
- x: Tensor of shape (N,C,H,W). H, W must be a multiple of ``self.size_divisibility``.
-
- Returns:
- dict[str->Tensor]: names and the corresponding features
- """
- assert x.dim() == 4, f"ResNet takes an input of shape (N, C, H, W). Got {x.shape} instead!"
- outputs = {}
- x = self.stem(x)
- if "stem" in self._out_features:
- outputs["stem"] = x
- for name, stage in zip(self.stage_names, self.stages):
- x = stage(x)
- if name in self._out_features:
- outputs[name] = x
- if self.num_classes is not None:
- x = self.avgpool(x)
- x = torch.flatten(x, 1)
- x = self.linear(x)
- if "linear" in self._out_features:
- outputs["linear"] = x
- return outputs
-
- def output_shape(self):
- return {
- name: ShapeSpec(
- channels=self._out_feature_channels[name], stride=self._out_feature_strides[name]
- )
- for name in self._out_features
- }
-
- def freeze(self, freeze_at=0):
- """
- Freeze the first several stages of the ResNet. Commonly used in
- fine-tuning.
-
- Layers that produce the same feature map spatial size are defined as one
- "stage" by :paper:`FPN`.
-
- Args:
- freeze_at (int): number of stages to freeze.
- `1` means freezing the stem. `2` means freezing the stem and
- one residual stage, etc.
-
- Returns:
- nn.Module: this ResNet itself
- """
- if freeze_at >= 1:
- self.stem.freeze()
- for idx, stage in enumerate(self.stages, start=2):
- if freeze_at >= idx:
- for block in stage.children():
- block.freeze()
- return self
-
- @staticmethod
- def make_stage(block_class, num_blocks, *, in_channels, out_channels, **kwargs):
- """
- Create a list of blocks of the same type that forms one ResNet stage.
-
- Args:
- block_class (type): a subclass of CNNBlockBase that's used to create all blocks in this
- stage. A module of this type must not change spatial resolution of inputs unless its
- stride != 1.
- num_blocks (int): number of blocks in this stage
- in_channels (int): input channels of the entire stage.
- out_channels (int): output channels of **every block** in the stage.
- kwargs: other arguments passed to the constructor of
- `block_class`. If the argument name is "xx_per_block", the
- argument is a list of values to be passed to each block in the
- stage. Otherwise, the same argument is passed to every block
- in the stage.
-
- Returns:
- list[CNNBlockBase]: a list of block module.
-
- Examples:
- ::
- stage = ResNet.make_stage(
- BottleneckBlock, 3, in_channels=16, out_channels=64,
- bottleneck_channels=16, num_groups=1,
- stride_per_block=[2, 1, 1],
- dilations_per_block=[1, 1, 2]
- )
-
- Usually, layers that produce the same feature map spatial size are defined as one
- "stage" (in :paper:`FPN`). Under such definition, ``stride_per_block[1:]`` should
- all be 1.
- """
- blocks = []
- for i in range(num_blocks):
- curr_kwargs = {}
- for k, v in kwargs.items():
- if k.endswith("_per_block"):
- assert len(v) == num_blocks, (
- f"Argument '{k}' of make_stage should have the "
- f"same length as num_blocks={num_blocks}."
- )
- newk = k[: -len("_per_block")]
- assert newk not in kwargs, f"Cannot call make_stage with both {k} and {newk}!"
- curr_kwargs[newk] = v[i]
- else:
- curr_kwargs[k] = v
-
- blocks.append(
- block_class(in_channels=in_channels, out_channels=out_channels, **curr_kwargs)
- )
- in_channels = out_channels
- return blocks
-
- @staticmethod
- def make_default_stages(depth, block_class=None, **kwargs):
- """
- Created list of ResNet stages from pre-defined depth (one of 18, 34, 50, 101, 152).
- If it doesn't create the ResNet variant you need, please use :meth:`make_stage`
- instead for fine-grained customization.
-
- Args:
- depth (int): depth of ResNet
- block_class (type): the CNN block class. Has to accept
- `bottleneck_channels` argument for depth > 50.
- By default it is BasicBlock or BottleneckBlock, based on the
- depth.
- kwargs:
- other arguments to pass to `make_stage`. Should not contain
- stride and channels, as they are predefined for each depth.
-
- Returns:
- list[list[CNNBlockBase]]: modules in all stages; see arguments of
- :class:`ResNet.__init__`.
- """
- num_blocks_per_stage = {
- 18: [2, 2, 2, 2],
- 34: [3, 4, 6, 3],
- 50: [3, 4, 6, 3],
- 101: [3, 4, 23, 3],
- 152: [3, 8, 36, 3],
- }[depth]
- if block_class is None:
- block_class = BasicBlock if depth < 50 else BottleneckBlock
- if depth < 50:
- in_channels = [64, 64, 128, 256]
- out_channels = [64, 128, 256, 512]
- else:
- in_channels = [64, 256, 512, 1024]
- out_channels = [256, 512, 1024, 2048]
- ret = []
- for (n, s, i, o) in zip(num_blocks_per_stage, [1, 2, 2, 2], in_channels, out_channels):
- if depth >= 50:
- kwargs["bottleneck_channels"] = o // 4
- ret.append(
- ResNet.make_stage(
- block_class=block_class,
- num_blocks=n,
- stride_per_block=[s] + [1] * (n - 1),
- in_channels=i,
- out_channels=o,
- **kwargs,
- )
- )
- return ret
-
-
-ResNetBlockBase = CNNBlockBase
-"""
-Alias for backward compatibiltiy.
-"""
-
-
-def make_stage(*args, **kwargs):
- """
- Deprecated alias for backward compatibiltiy.
- """
- return ResNet.make_stage(*args, **kwargs)
-
-
-@BACKBONE_REGISTRY.register()
-def build_resnet_backbone(cfg, input_shape):
- """
- Create a ResNet instance from config.
-
- Returns:
- ResNet: a :class:`ResNet` instance.
- """
- # need registration of new blocks/stems?
- norm = cfg.MODEL.RESNETS.NORM
- stem = BasicStem(
- in_channels=input_shape.channels,
- out_channels=cfg.MODEL.RESNETS.STEM_OUT_CHANNELS,
- norm=norm,
- )
-
- # fmt: off
- freeze_at = cfg.MODEL.BACKBONE.FREEZE_AT
- out_features = cfg.MODEL.RESNETS.OUT_FEATURES
- depth = cfg.MODEL.RESNETS.DEPTH
- num_groups = cfg.MODEL.RESNETS.NUM_GROUPS
- width_per_group = cfg.MODEL.RESNETS.WIDTH_PER_GROUP
- bottleneck_channels = num_groups * width_per_group
- in_channels = cfg.MODEL.RESNETS.STEM_OUT_CHANNELS
- out_channels = cfg.MODEL.RESNETS.RES2_OUT_CHANNELS
- stride_in_1x1 = cfg.MODEL.RESNETS.STRIDE_IN_1X1
- res5_dilation = cfg.MODEL.RESNETS.RES5_DILATION
- deform_on_per_stage = cfg.MODEL.RESNETS.DEFORM_ON_PER_STAGE
- deform_modulated = cfg.MODEL.RESNETS.DEFORM_MODULATED
- deform_num_groups = cfg.MODEL.RESNETS.DEFORM_NUM_GROUPS
- # fmt: on
- assert res5_dilation in {1, 2}, "res5_dilation cannot be {}.".format(res5_dilation)
-
- num_blocks_per_stage = {
- 18: [2, 2, 2, 2],
- 34: [3, 4, 6, 3],
- 50: [3, 4, 6, 3],
- 101: [3, 4, 23, 3],
- 152: [3, 8, 36, 3],
- }[depth]
-
- if depth in [18, 34]:
- assert out_channels == 64, "Must set MODEL.RESNETS.RES2_OUT_CHANNELS = 64 for R18/R34"
- assert not any(
- deform_on_per_stage
- ), "MODEL.RESNETS.DEFORM_ON_PER_STAGE unsupported for R18/R34"
- assert res5_dilation == 1, "Must set MODEL.RESNETS.RES5_DILATION = 1 for R18/R34"
- assert num_groups == 1, "Must set MODEL.RESNETS.NUM_GROUPS = 1 for R18/R34"
-
- stages = []
-
- for idx, stage_idx in enumerate(range(2, 6)):
- # res5_dilation is used this way as a convention in R-FCN & Deformable Conv paper
- dilation = res5_dilation if stage_idx == 5 else 1
- first_stride = 1 if idx == 0 or (stage_idx == 5 and dilation == 2) else 2
- stage_kargs = {
- "num_blocks": num_blocks_per_stage[idx],
- "stride_per_block": [first_stride] + [1] * (num_blocks_per_stage[idx] - 1),
- "in_channels": in_channels,
- "out_channels": out_channels,
- "norm": norm,
- }
- # Use BasicBlock for R18 and R34.
- if depth in [18, 34]:
- stage_kargs["block_class"] = BasicBlock
- else:
- stage_kargs["bottleneck_channels"] = bottleneck_channels
- stage_kargs["stride_in_1x1"] = stride_in_1x1
- stage_kargs["dilation"] = dilation
- stage_kargs["num_groups"] = num_groups
- if deform_on_per_stage[idx]:
- stage_kargs["block_class"] = DeformBottleneckBlock
- stage_kargs["deform_modulated"] = deform_modulated
- stage_kargs["deform_num_groups"] = deform_num_groups
- else:
- stage_kargs["block_class"] = BottleneckBlock
- blocks = ResNet.make_stage(**stage_kargs)
- in_channels = out_channels
- out_channels *= 2
- bottleneck_channels *= 2
- stages.append(blocks)
- return ResNet(stem, stages, out_features=out_features, freeze_at=freeze_at)
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/tests/test_dataset_loaded_annotations.py b/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/tests/test_dataset_loaded_annotations.py
deleted file mode 100644
index cf8035b87c6477221a113ba9fcb794495c04af7c..0000000000000000000000000000000000000000
--- a/spaces/brjathu/HMR2.0/vendor/detectron2/projects/DensePose/tests/test_dataset_loaded_annotations.py
+++ /dev/null
@@ -1,87 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
-
-import unittest
-
-from densepose.data.datasets.builtin import COCO_DATASETS, DENSEPOSE_ANNOTATIONS_DIR, LVIS_DATASETS
-from densepose.data.datasets.coco import load_coco_json
-from densepose.data.datasets.lvis import load_lvis_json
-from densepose.data.utils import maybe_prepend_base_path
-from densepose.structures import DensePoseDataRelative
-
-
-class TestDatasetLoadedAnnotations(unittest.TestCase):
- COCO_DATASET_DATA = {
- "densepose_coco_2014_train": {"n_instances": 39210},
- "densepose_coco_2014_minival": {"n_instances": 2243},
- "densepose_coco_2014_minival_100": {"n_instances": 164},
- "densepose_coco_2014_valminusminival": {"n_instances": 7297},
- "densepose_coco_2014_train_cse": {"n_instances": 39210},
- "densepose_coco_2014_minival_cse": {"n_instances": 2243},
- "densepose_coco_2014_minival_100_cse": {"n_instances": 164},
- "densepose_coco_2014_valminusminival_cse": {"n_instances": 7297},
- "densepose_chimps": {"n_instances": 930},
- "posetrack2017_train": {"n_instances": 8274},
- "posetrack2017_val": {"n_instances": 4753},
- "lvis_v05_train": {"n_instances": 5186},
- "lvis_v05_val": {"n_instances": 1037},
- }
-
- LVIS_DATASET_DATA = {
- "densepose_lvis_v1_train1": {"n_instances": 3394},
- "densepose_lvis_v1_train2": {"n_instances": 1800},
- "densepose_lvis_v1_val": {"n_instances": 1037},
- "densepose_lvis_v1_val_animals_100": {"n_instances": 89},
- }
-
- def generic_coco_test(self, dataset_info):
- if dataset_info.name not in self.COCO_DATASET_DATA:
- return
- n_inst = self.COCO_DATASET_DATA[dataset_info.name]["n_instances"]
- self.generic_test(dataset_info, n_inst, load_coco_json)
-
- def generic_lvis_test(self, dataset_info):
- if dataset_info.name not in self.LVIS_DATASET_DATA:
- return
- n_inst = self.LVIS_DATASET_DATA[dataset_info.name]["n_instances"]
- self.generic_test(dataset_info, n_inst, load_lvis_json)
-
- def generic_test(self, dataset_info, n_inst, loader_fun):
- datasets_root = DENSEPOSE_ANNOTATIONS_DIR
- annotations_fpath = maybe_prepend_base_path(datasets_root, dataset_info.annotations_fpath)
- images_root = maybe_prepend_base_path(datasets_root, dataset_info.images_root)
- image_annotation_dicts = loader_fun(
- annotations_json_file=annotations_fpath,
- image_root=images_root,
- dataset_name=dataset_info.name,
- )
- num_valid = sum(
- 1
- for image_annotation_dict in image_annotation_dicts
- for ann in image_annotation_dict["annotations"]
- if DensePoseDataRelative.validate_annotation(ann)[0]
- )
- self.assertEqual(num_valid, n_inst)
-
-
-def coco_test_fun(dataset_info):
- return lambda self: self.generic_coco_test(dataset_info)
-
-
-for dataset_info in COCO_DATASETS:
- setattr(
- TestDatasetLoadedAnnotations,
- f"test_coco_builtin_loaded_annotations_{dataset_info.name}",
- coco_test_fun(dataset_info),
- )
-
-
-def lvis_test_fun(dataset_info):
- return lambda self: self.generic_lvis_test(dataset_info)
-
-
-for dataset_info in LVIS_DATASETS:
- setattr(
- TestDatasetLoadedAnnotations,
- f"test_lvis_builtin_loaded_annotations_{dataset_info.name}",
- lvis_test_fun(dataset_info),
- )
diff --git a/spaces/brjathu/HMR2.0/vendor/detectron2/tests/structures/__init__.py b/spaces/brjathu/HMR2.0/vendor/detectron2/tests/structures/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/export/shared.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/export/shared.py
deleted file mode 100644
index 2d0f7bf3999064a68f28a1207d65a2de7ae98c0a..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/export/shared.py
+++ /dev/null
@@ -1,1034 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import collections
-import contextlib
-import copy
-import functools
-import logging
-import numpy as np
-import os
-from typing import Any, Callable, Dict, List, Optional, Tuple, Union
-from unittest import mock
-import caffe2.python.utils as putils
-import torch
-import torch.nn.functional as F
-from caffe2.proto import caffe2_pb2
-from caffe2.python import core, net_drawer, workspace
-from torch.nn.functional import interpolate as interp
-
-logger = logging.getLogger(__name__)
-
-
-# ==== torch/utils_toffee/cast.py =======================================
-
-
-def to_device(t, device_str):
- """
- This function is a replacement of .to(another_device) such that it allows the
- casting to be traced properly by explicitly calling the underlying copy ops.
- It also avoids introducing unncessary op when casting to the same device.
- """
- src = t.device
- dst = torch.device(device_str)
-
- if src == dst:
- return t
- elif src.type == "cuda" and dst.type == "cpu":
- return torch.ops._caffe2.CopyGPUToCPU(t)
- elif src.type == "cpu" and dst.type == "cuda":
- return torch.ops._caffe2.CopyCPUToGPU(t)
- else:
- raise RuntimeError("Can't cast tensor from device {} to device {}".format(src, dst))
-
-
-# ==== torch/utils_toffee/interpolate.py =======================================
-
-
-# Note: borrowed from vision/detection/fair/detectron/detectron/modeling/detector.py
-def BilinearInterpolation(tensor_in, up_scale):
- assert up_scale % 2 == 0, "Scale should be even"
-
- def upsample_filt(size):
- factor = (size + 1) // 2
- if size % 2 == 1:
- center = factor - 1
- else:
- center = factor - 0.5
-
- og = np.ogrid[:size, :size]
- return (1 - abs(og[0] - center) / factor) * (1 - abs(og[1] - center) / factor)
-
- kernel_size = int(up_scale) * 2
- bil_filt = upsample_filt(kernel_size)
-
- dim = int(tensor_in.shape[1])
- kernel = np.zeros((dim, dim, kernel_size, kernel_size), dtype=np.float32)
- kernel[range(dim), range(dim), :, :] = bil_filt
-
- tensor_out = F.conv_transpose2d(
- tensor_in,
- weight=to_device(torch.Tensor(kernel), tensor_in.device),
- bias=None,
- stride=int(up_scale),
- padding=int(up_scale / 2),
- )
-
- return tensor_out
-
-
-# NOTE: ONNX is incompatible with traced torch.nn.functional.interpolate if
-# using dynamic `scale_factor` rather than static `size`. (T43166860)
-# NOTE: Caffe2 Int8 conversion might not be able to quantize `size` properly.
-def onnx_compatibale_interpolate(
- input, size=None, scale_factor=None, mode="nearest", align_corners=None
-):
- # NOTE: The input dimensions are interpreted in the form:
- # `mini-batch x channels x [optional depth] x [optional height] x width`.
- if size is None and scale_factor is not None:
- if input.dim() == 4:
- if isinstance(scale_factor, (int, float)):
- height_scale, width_scale = (scale_factor, scale_factor)
- else:
- assert isinstance(scale_factor, (tuple, list))
- assert len(scale_factor) == 2
- height_scale, width_scale = scale_factor
-
- assert not align_corners, "No matching C2 op for align_corners == True"
- if mode == "nearest":
- return torch.ops._caffe2.ResizeNearest(
- input, order="NCHW", width_scale=width_scale, height_scale=height_scale
- )
- elif mode == "bilinear":
- logger.warning(
- "Use F.conv_transpose2d for bilinear interpolate"
- " because there's no such C2 op, this may cause significant"
- " slowdown and the boundary pixels won't be as same as"
- " using F.interpolate due to padding."
- )
- assert height_scale == width_scale
- return BilinearInterpolation(input, up_scale=height_scale)
- logger.warning("Output size is not static, it might cause ONNX conversion issue")
-
- return interp(input, size, scale_factor, mode, align_corners)
-
-
-@contextlib.contextmanager
-def mock_torch_nn_functional_interpolate():
- if torch.onnx.is_in_onnx_export():
- with mock.patch(
- "torch.nn.functional.interpolate", side_effect=onnx_compatibale_interpolate
- ):
- yield
- else:
- yield
-
-
-# ==== torch/utils_caffe2/ws_utils.py ==========================================
-
-
-class ScopedWS(object):
- def __init__(self, ws_name, is_reset, is_cleanup=False):
- self.ws_name = ws_name
- self.is_reset = is_reset
- self.is_cleanup = is_cleanup
- self.org_ws = ""
-
- def __enter__(self):
- self.org_ws = workspace.CurrentWorkspace()
- if self.ws_name is not None:
- workspace.SwitchWorkspace(self.ws_name, True)
- if self.is_reset:
- workspace.ResetWorkspace()
-
- return workspace
-
- def __exit__(self, *args):
- if self.is_cleanup:
- workspace.ResetWorkspace()
- if self.ws_name is not None:
- workspace.SwitchWorkspace(self.org_ws)
-
-
-def fetch_any_blob(name):
- bb = None
- try:
- bb = workspace.FetchBlob(name)
- except TypeError:
- bb = workspace.FetchInt8Blob(name)
- except Exception as e:
- logger.error("Get blob {} error: {}".format(name, e))
-
- return bb
-
-
-# ==== torch/utils_caffe2/protobuf.py ==========================================
-
-
-def get_pb_arg(pb, arg_name):
- for x in pb.arg:
- if x.name == arg_name:
- return x
- return None
-
-
-def get_pb_arg_valf(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return arg.f if arg is not None else default_val
-
-
-def get_pb_arg_floats(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return list(map(float, arg.floats)) if arg is not None else default_val
-
-
-def get_pb_arg_ints(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return list(map(int, arg.ints)) if arg is not None else default_val
-
-
-def get_pb_arg_vali(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return arg.i if arg is not None else default_val
-
-
-def get_pb_arg_vals(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return arg.s if arg is not None else default_val
-
-
-def get_pb_arg_valstrings(pb, arg_name, default_val):
- arg = get_pb_arg(pb, arg_name)
- return list(arg.strings) if arg is not None else default_val
-
-
-def check_set_pb_arg(pb, arg_name, arg_attr, arg_value, allow_override=False):
- arg = get_pb_arg(pb, arg_name)
- if arg is None:
- arg = putils.MakeArgument(arg_name, arg_value)
- assert hasattr(arg, arg_attr)
- pb.arg.extend([arg])
- if allow_override and getattr(arg, arg_attr) != arg_value:
- logger.warning(
- "Override argument {}: {} -> {}".format(arg_name, getattr(arg, arg_attr), arg_value)
- )
- setattr(arg, arg_attr, arg_value)
- else:
- assert arg is not None
- assert getattr(arg, arg_attr) == arg_value, "Existing value {}, new value {}".format(
- getattr(arg, arg_attr), arg_value
- )
-
-
-def _create_const_fill_op_from_numpy(name, tensor, device_option=None):
- assert type(tensor) == np.ndarray
- kTypeNameMapper = {
- np.dtype("float32"): "GivenTensorFill",
- np.dtype("int32"): "GivenTensorIntFill",
- np.dtype("int64"): "GivenTensorInt64Fill",
- np.dtype("uint8"): "GivenTensorStringFill",
- }
-
- args_dict = {}
- if tensor.dtype == np.dtype("uint8"):
- args_dict.update({"values": [str(tensor.data)], "shape": [1]})
- else:
- args_dict.update({"values": tensor, "shape": tensor.shape})
-
- if device_option is not None:
- args_dict["device_option"] = device_option
-
- return core.CreateOperator(kTypeNameMapper[tensor.dtype], [], [name], **args_dict)
-
-
-def _create_const_fill_op_from_c2_int8_tensor(name, int8_tensor):
- assert type(int8_tensor) == workspace.Int8Tensor
- kTypeNameMapper = {
- np.dtype("int32"): "Int8GivenIntTensorFill",
- np.dtype("uint8"): "Int8GivenTensorFill",
- }
-
- tensor = int8_tensor.data
- assert tensor.dtype in [np.dtype("uint8"), np.dtype("int32")]
- values = tensor.tobytes() if tensor.dtype == np.dtype("uint8") else tensor
-
- return core.CreateOperator(
- kTypeNameMapper[tensor.dtype],
- [],
- [name],
- values=values,
- shape=tensor.shape,
- Y_scale=int8_tensor.scale,
- Y_zero_point=int8_tensor.zero_point,
- )
-
-
-def create_const_fill_op(
- name: str,
- blob: Union[np.ndarray, workspace.Int8Tensor],
- device_option: Optional[caffe2_pb2.DeviceOption] = None,
-) -> caffe2_pb2.OperatorDef:
- """
- Given a blob object, return the Caffe2 operator that creates this blob
- as constant. Currently support NumPy tensor and Caffe2 Int8Tensor.
- """
-
- tensor_type = type(blob)
- assert tensor_type in [
- np.ndarray,
- workspace.Int8Tensor,
- ], 'Error when creating const fill op for "{}", unsupported blob type: {}'.format(
- name, type(blob)
- )
-
- if tensor_type == np.ndarray:
- return _create_const_fill_op_from_numpy(name, blob, device_option)
- elif tensor_type == workspace.Int8Tensor:
- assert device_option is None
- return _create_const_fill_op_from_c2_int8_tensor(name, blob)
-
-
-def construct_init_net_from_params(
- params: Dict[str, Any], device_options: Optional[Dict[str, caffe2_pb2.DeviceOption]] = None
-) -> caffe2_pb2.NetDef:
- """
- Construct the init_net from params dictionary
- """
- init_net = caffe2_pb2.NetDef()
- device_options = device_options or {}
- for name, blob in params.items():
- if isinstance(blob, str):
- logger.warning(
- (
- "Blob {} with type {} is not supported in generating init net,"
- " skipped.".format(name, type(blob))
- )
- )
- continue
- init_net.op.extend(
- [create_const_fill_op(name, blob, device_option=device_options.get(name, None))]
- )
- init_net.external_output.append(name)
- return init_net
-
-
-def get_producer_map(ssa):
- """
- Return dict from versioned blob to (i, j),
- where i is index of producer op, j is the index of output of that op.
- """
- producer_map = {}
- for i in range(len(ssa)):
- outputs = ssa[i][1]
- for j, outp in enumerate(outputs):
- producer_map[outp] = (i, j)
- return producer_map
-
-
-def get_consumer_map(ssa):
- """
- Return dict from versioned blob to list of (i, j),
- where i is index of consumer op, j is the index of input of that op.
- """
- consumer_map = collections.defaultdict(list)
- for i in range(len(ssa)):
- inputs = ssa[i][0]
- for j, inp in enumerate(inputs):
- consumer_map[inp].append((i, j))
- return consumer_map
-
-
-def get_params_from_init_net(
- init_net: caffe2_pb2.NetDef,
-) -> [Dict[str, Any], Dict[str, caffe2_pb2.DeviceOption]]:
- """
- Take the output blobs from init_net by running it.
- Outputs:
- params: dict from blob name to numpy array
- device_options: dict from blob name to the device option of its creating op
- """
- # NOTE: this assumes that the params is determined by producer op with the
- # only exception be CopyGPUToCPU which is CUDA op but returns CPU tensor.
- def _get_device_option(producer_op):
- if producer_op.type == "CopyGPUToCPU":
- return caffe2_pb2.DeviceOption()
- else:
- return producer_op.device_option
-
- with ScopedWS("__get_params_from_init_net__", is_reset=True, is_cleanup=True) as ws:
- ws.RunNetOnce(init_net)
- params = {b: fetch_any_blob(b) for b in init_net.external_output}
- ssa, versions = core.get_ssa(init_net)
- producer_map = get_producer_map(ssa)
- device_options = {
- b: _get_device_option(init_net.op[producer_map[(b, versions[b])][0]])
- for b in init_net.external_output
- }
- return params, device_options
-
-
-def _updater_raise(op, input_types, output_types):
- raise RuntimeError(
- "Failed to apply updater for op {} given input_types {} and"
- " output_types {}".format(op, input_types, output_types)
- )
-
-
-def _generic_status_identifier(
- predict_net: caffe2_pb2.NetDef,
- status_updater: Callable,
- known_status: Dict[Tuple[str, int], Any],
-) -> Dict[Tuple[str, int], Any]:
- """
- Statically infer the status of each blob, the status can be such as device type
- (CPU/GPU), layout (NCHW/NHWC), data type (float32/int8), etc. "Blob" here
- is versioned blob (Tuple[str, int]) in the format compatible with ssa.
- Inputs:
- predict_net: the caffe2 network
- status_updater: a callable, given an op and the status of its input/output,
- it returns the updated status of input/output. `None` is used for
- representing unknown status.
- known_status: a dict containing known status, used as initialization.
- Outputs:
- A dict mapping from versioned blob to its status
- """
- ssa, versions = core.get_ssa(predict_net)
- versioned_ext_input = [(b, 0) for b in predict_net.external_input]
- versioned_ext_output = [(b, versions[b]) for b in predict_net.external_output]
- all_versioned_blobs = set().union(*[set(x[0] + x[1]) for x in ssa])
-
- allowed_vbs = all_versioned_blobs.union(versioned_ext_input).union(versioned_ext_output)
- assert all(k in allowed_vbs for k in known_status)
- assert all(v is not None for v in known_status.values())
- _known_status = copy.deepcopy(known_status)
-
- def _check_and_update(key, value):
- assert value is not None
- if key in _known_status:
- if not _known_status[key] == value:
- raise RuntimeError(
- "Confilict status for {}, existing status {}, new status {}".format(
- key, _known_status[key], value
- )
- )
- _known_status[key] = value
-
- def _update_i(op, ssa_i):
- versioned_inputs = ssa_i[0]
- versioned_outputs = ssa_i[1]
-
- inputs_status = [_known_status.get(b, None) for b in versioned_inputs]
- outputs_status = [_known_status.get(b, None) for b in versioned_outputs]
-
- new_inputs_status, new_outputs_status = status_updater(op, inputs_status, outputs_status)
-
- for versioned_blob, status in zip(
- versioned_inputs + versioned_outputs, new_inputs_status + new_outputs_status
- ):
- if status is not None:
- _check_and_update(versioned_blob, status)
-
- for op, ssa_i in zip(predict_net.op, ssa):
- _update_i(op, ssa_i)
- for op, ssa_i in zip(reversed(predict_net.op), reversed(ssa)):
- _update_i(op, ssa_i)
-
- # NOTE: This strictly checks all the blob from predict_net must be assgined
- # a known status. However sometimes it's impossible (eg. having deadend op),
- # we may relax this constraint if
- for k in all_versioned_blobs:
- if k not in _known_status:
- raise NotImplementedError(
- "Can not infer the status for {}. Currently only support the case where"
- " a single forward and backward pass can identify status for all blobs.".format(k)
- )
-
- return _known_status
-
-
-def infer_device_type(
- predict_net: caffe2_pb2.NetDef,
- known_status: Dict[Tuple[str, int], Any],
- device_name_style: str = "caffe2",
-) -> Dict[Tuple[str, int], str]:
- """Return the device type ("cpu" or "gpu"/"cuda") of each (versioned) blob"""
-
- assert device_name_style in ["caffe2", "pytorch"]
- _CPU_STR = "cpu"
- _GPU_STR = "gpu" if device_name_style == "caffe2" else "cuda"
-
- def _copy_cpu_to_gpu_updater(op, input_types, output_types):
- if input_types[0] == _GPU_STR or output_types[0] == _CPU_STR:
- _updater_raise(op, input_types, output_types)
- return ([_CPU_STR], [_GPU_STR])
-
- def _copy_gpu_to_cpu_updater(op, input_types, output_types):
- if input_types[0] == _CPU_STR or output_types[0] == _GPU_STR:
- _updater_raise(op, input_types, output_types)
- return ([_GPU_STR], [_CPU_STR])
-
- def _other_ops_updater(op, input_types, output_types):
- non_none_types = [x for x in input_types + output_types if x is not None]
- if len(non_none_types) > 0:
- the_type = non_none_types[0]
- if not all(x == the_type for x in non_none_types):
- _updater_raise(op, input_types, output_types)
- else:
- the_type = None
- return ([the_type for _ in op.input], [the_type for _ in op.output])
-
- def _device_updater(op, *args, **kwargs):
- return {
- "CopyCPUToGPU": _copy_cpu_to_gpu_updater,
- "CopyGPUToCPU": _copy_gpu_to_cpu_updater,
- }.get(op.type, _other_ops_updater)(op, *args, **kwargs)
-
- return _generic_status_identifier(predict_net, _device_updater, known_status)
-
-
-# ==== torch/utils_caffe2/vis.py ===============================================
-
-
-def _modify_blob_names(ops, blob_rename_f):
- ret = []
-
- def _replace_list(blob_list, replaced_list):
- del blob_list[:]
- blob_list.extend(replaced_list)
-
- for x in ops:
- cur = copy.deepcopy(x)
- _replace_list(cur.input, list(map(blob_rename_f, cur.input)))
- _replace_list(cur.output, list(map(blob_rename_f, cur.output)))
- ret.append(cur)
-
- return ret
-
-
-def _rename_blob(name, blob_sizes, blob_ranges):
- def _list_to_str(bsize):
- ret = ", ".join([str(x) for x in bsize])
- ret = "[" + ret + "]"
- return ret
-
- ret = name
- if blob_sizes is not None and name in blob_sizes:
- ret += "\n" + _list_to_str(blob_sizes[name])
- if blob_ranges is not None and name in blob_ranges:
- ret += "\n" + _list_to_str(blob_ranges[name])
-
- return ret
-
-
-# graph_name could not contain word 'graph'
-def save_graph(net, file_name, graph_name="net", op_only=True, blob_sizes=None, blob_ranges=None):
- blob_rename_f = functools.partial(_rename_blob, blob_sizes=blob_sizes, blob_ranges=blob_ranges)
- return save_graph_base(net, file_name, graph_name, op_only, blob_rename_f)
-
-
-def save_graph_base(net, file_name, graph_name="net", op_only=True, blob_rename_func=None):
- graph = None
- ops = net.op
- if blob_rename_func is not None:
- ops = _modify_blob_names(ops, blob_rename_func)
- if not op_only:
- graph = net_drawer.GetPydotGraph(ops, graph_name, rankdir="TB")
- else:
- graph = net_drawer.GetPydotGraphMinimal(
- ops, graph_name, rankdir="TB", minimal_dependency=True
- )
-
- try:
- par_dir = os.path.dirname(file_name)
- if not os.path.exists(par_dir):
- os.makedirs(par_dir)
-
- format = os.path.splitext(os.path.basename(file_name))[-1]
- if format == ".png":
- graph.write_png(file_name)
- elif format == ".pdf":
- graph.write_pdf(file_name)
- elif format == ".svg":
- graph.write_svg(file_name)
- else:
- print("Incorrect format {}".format(format))
- except Exception as e:
- print("Error when writing graph to image {}".format(e))
-
- return graph
-
-
-# ==== torch/utils_toffee/aten_to_caffe2.py ====================================
-
-
-def group_norm_replace_aten_with_caffe2(predict_net: caffe2_pb2.NetDef):
- """
- For ONNX exported model, GroupNorm will be represented as ATen op,
- this can be a drop in replacement from ATen to GroupNorm
- """
- count = 0
- for op in predict_net.op:
- if op.type == "ATen":
- op_name = get_pb_arg_vals(op, "operator", None) # return byte in py3
- if op_name and op_name.decode() == "group_norm":
- op.arg.remove(get_pb_arg(op, "operator"))
-
- if get_pb_arg_vali(op, "cudnn_enabled", None):
- op.arg.remove(get_pb_arg(op, "cudnn_enabled"))
-
- num_groups = get_pb_arg_vali(op, "num_groups", None)
- if num_groups is not None:
- op.arg.remove(get_pb_arg(op, "num_groups"))
- check_set_pb_arg(op, "group", "i", num_groups)
-
- op.type = "GroupNorm"
- count += 1
- if count > 1:
- logger.info("Replaced {} ATen operator to GroupNormOp".format(count))
-
-
-# ==== torch/utils_toffee/alias.py =============================================
-
-
-def alias(x, name, is_backward=False):
- if not torch.onnx.is_in_onnx_export():
- return x
- assert isinstance(x, torch.Tensor)
- return torch.ops._caffe2.AliasWithName(x, name, is_backward=is_backward)
-
-
-def fuse_alias_placeholder(predict_net, init_net):
- """Remove AliasWithName placeholder and rename the input/output of it"""
- # First we finish all the re-naming
- for i, op in enumerate(predict_net.op):
- if op.type == "AliasWithName":
- assert len(op.input) == 1
- assert len(op.output) == 1
- name = get_pb_arg_vals(op, "name", None).decode()
- is_backward = bool(get_pb_arg_vali(op, "is_backward", 0))
- rename_op_input(predict_net, init_net, i, 0, name, from_producer=is_backward)
- rename_op_output(predict_net, i, 0, name)
-
- # Remove AliasWithName, should be very safe since it's a non-op
- new_ops = []
- for op in predict_net.op:
- if op.type != "AliasWithName":
- new_ops.append(op)
- else:
- # safety check
- assert op.input == op.output
- assert op.input[0] == op.arg[0].s.decode()
- del predict_net.op[:]
- predict_net.op.extend(new_ops)
-
-
-# ==== torch/utils_caffe2/graph_transform.py ===================================
-
-
-class IllegalGraphTransformError(ValueError):
- """When a graph transform function call can't be executed."""
-
-
-def _rename_versioned_blob_in_proto(
- proto: caffe2_pb2.NetDef,
- old_name: str,
- new_name: str,
- version: int,
- ssa: List[Tuple[List[Tuple[str, int]], List[Tuple[str, int]]]],
- start_versions: Dict[str, int],
- end_versions: Dict[str, int],
-):
- """In given proto, rename all blobs with matched version"""
- # Operater list
- for op, i_th_ssa in zip(proto.op, ssa):
- versioned_inputs, versioned_outputs = i_th_ssa
- for i in range(len(op.input)):
- if versioned_inputs[i] == (old_name, version):
- op.input[i] = new_name
- for i in range(len(op.output)):
- if versioned_outputs[i] == (old_name, version):
- op.output[i] = new_name
- # external_input
- if start_versions.get(old_name, 0) == version:
- for i in range(len(proto.external_input)):
- if proto.external_input[i] == old_name:
- proto.external_input[i] = new_name
- # external_output
- if end_versions.get(old_name, 0) == version:
- for i in range(len(proto.external_output)):
- if proto.external_output[i] == old_name:
- proto.external_output[i] = new_name
-
-
-def rename_op_input(
- predict_net: caffe2_pb2.NetDef,
- init_net: caffe2_pb2.NetDef,
- op_id: int,
- input_id: int,
- new_name: str,
- from_producer: bool = False,
-):
- """
- Rename the op_id-th operator in predict_net, change it's input_id-th input's
- name to the new_name. It also does automatic re-route and change
- external_input and init_net if necessary.
- - It requires the input is only consumed by this op.
- - This function modifies predict_net and init_net in-place.
- - When from_producer is enable, this also updates other operators that consumes
- the same input. Be cautious because may trigger unintended behavior.
- """
- assert isinstance(predict_net, caffe2_pb2.NetDef)
- assert isinstance(init_net, caffe2_pb2.NetDef)
-
- init_net_ssa, init_net_versions = core.get_ssa(init_net)
- predict_net_ssa, predict_net_versions = core.get_ssa(
- predict_net, copy.deepcopy(init_net_versions)
- )
-
- versioned_inputs, versioned_outputs = predict_net_ssa[op_id]
- old_name, version = versioned_inputs[input_id]
-
- if from_producer:
- producer_map = get_producer_map(predict_net_ssa)
- if not (old_name, version) in producer_map:
- raise NotImplementedError(
- "Can't find producer, the input {} is probably from"
- " init_net, this is not supported yet.".format(old_name)
- )
- producer = producer_map[(old_name, version)]
- rename_op_output(predict_net, producer[0], producer[1], new_name)
- return
-
- def contain_targets(op_ssa):
- return (old_name, version) in op_ssa[0]
-
- is_consumer = [contain_targets(op_ssa) for op_ssa in predict_net_ssa]
- if sum(is_consumer) > 1:
- raise IllegalGraphTransformError(
- (
- "Input '{}' of operator(#{}) are consumed by other ops, please use"
- + " rename_op_output on the producer instead. Offending op: \n{}"
- ).format(old_name, op_id, predict_net.op[op_id])
- )
-
- # update init_net
- _rename_versioned_blob_in_proto(
- init_net, old_name, new_name, version, init_net_ssa, {}, init_net_versions
- )
- # update predict_net
- _rename_versioned_blob_in_proto(
- predict_net,
- old_name,
- new_name,
- version,
- predict_net_ssa,
- init_net_versions,
- predict_net_versions,
- )
-
-
-def rename_op_output(predict_net: caffe2_pb2.NetDef, op_id: int, output_id: int, new_name: str):
- """
- Rename the op_id-th operator in predict_net, change it's output_id-th input's
- name to the new_name. It also does automatic re-route and change
- external_output and if necessary.
- - It allows multiple consumers of its output.
- - This function modifies predict_net in-place, doesn't need init_net.
- """
- assert isinstance(predict_net, caffe2_pb2.NetDef)
-
- ssa, blob_versions = core.get_ssa(predict_net)
-
- versioned_inputs, versioned_outputs = ssa[op_id]
- old_name, version = versioned_outputs[output_id]
-
- # update predict_net
- _rename_versioned_blob_in_proto(
- predict_net, old_name, new_name, version, ssa, {}, blob_versions
- )
-
-
-def get_sub_graph_external_input_output(
- predict_net: caffe2_pb2.NetDef, sub_graph_op_indices: List[int]
-) -> Tuple[List[Tuple[str, int]], List[Tuple[str, int]]]:
- """
- Return the list of external input/output of sub-graph,
- each element is tuple of the name and corresponding version in predict_net.
-
- external input/output is defined the same way as caffe2 NetDef.
- """
- ssa, versions = core.get_ssa(predict_net)
-
- all_inputs = []
- all_outputs = []
- for op_id in sub_graph_op_indices:
- all_inputs += [inp for inp in ssa[op_id][0] if inp not in all_inputs]
- all_outputs += list(ssa[op_id][1]) # ssa output won't repeat
-
- # for versioned blobs, external inputs are just those blob in all_inputs
- # but not in all_outputs
- ext_inputs = [inp for inp in all_inputs if inp not in all_outputs]
-
- # external outputs are essentially outputs of this subgraph that are used
- # outside of this sub-graph (including predict_net.external_output)
- all_other_inputs = sum(
- (ssa[i][0] for i in range(len(ssa)) if i not in sub_graph_op_indices),
- [(outp, versions[outp]) for outp in predict_net.external_output],
- )
- ext_outputs = [outp for outp in all_outputs if outp in set(all_other_inputs)]
-
- return ext_inputs, ext_outputs
-
-
-class DiGraph:
- """A DAG representation of caffe2 graph, each vertice is a versioned blob."""
-
- def __init__(self):
- self.vertices = set()
- self.graph = collections.defaultdict(list)
-
- def add_edge(self, u, v):
- self.graph[u].append(v)
- self.vertices.add(u)
- self.vertices.add(v)
-
- # grab from https://www.geeksforgeeks.org/find-paths-given-source-destination/
- def get_all_paths(self, s, d):
- visited = {k: False for k in self.vertices}
- path = []
- all_paths = []
-
- def _get_all_paths_util(graph, u, d, visited, path):
- visited[u] = True
- path.append(u)
- if u == d:
- all_paths.append(copy.deepcopy(path))
- else:
- for i in graph[u]:
- if not visited[i]:
- _get_all_paths_util(graph, i, d, visited, path)
- path.pop()
- visited[u] = False
-
- _get_all_paths_util(self.graph, s, d, visited, path)
- return all_paths
-
- @staticmethod
- def from_ssa(ssa):
- graph = DiGraph()
- for op_id in range(len(ssa)):
- for inp in ssa[op_id][0]:
- for outp in ssa[op_id][1]:
- graph.add_edge(inp, outp)
- return graph
-
-
-def _get_dependency_chain(ssa, versioned_target, versioned_source):
- """
- Return the index list of relevant operator to produce target blob from source blob,
- if there's no dependency, return empty list.
- """
-
- # finding all paths between nodes can be O(N!), thus we can only search
- # in the subgraph using the op starting from the first consumer of source blob
- # to the producer of the target blob.
- consumer_map = get_consumer_map(ssa)
- producer_map = get_producer_map(ssa)
- start_op = min(x[0] for x in consumer_map[versioned_source]) - 15
- end_op = (
- producer_map[versioned_target][0] + 15 if versioned_target in producer_map else start_op
- )
- sub_graph_ssa = ssa[start_op : end_op + 1]
- if len(sub_graph_ssa) > 30:
- logger.warning(
- "Subgraph bebetween {} and {} is large (from op#{} to op#{}), it"
- " might take non-trival time to find all paths between them.".format(
- versioned_source, versioned_target, start_op, end_op
- )
- )
-
- dag = DiGraph.from_ssa(sub_graph_ssa)
- paths = dag.get_all_paths(versioned_source, versioned_target) # include two ends
- ops_in_paths = [[producer_map[blob][0] for blob in path[1:]] for path in paths]
- return sorted(set().union(*[set(ops) for ops in ops_in_paths]))
-
-
-def identify_reshape_sub_graph(predict_net: caffe2_pb2.NetDef) -> List[List[int]]:
- """
- Idenfity the reshape sub-graph in a protobuf.
- The reshape sub-graph is defined as matching the following pattern:
-
- (input_blob) -> Op_1 -> ... -> Op_N -> (new_shape) -─┐
- └-------------------------------------------> Reshape -> (output_blob)
-
- Return:
- List of sub-graphs, each sub-graph is represented as a list of indices
- of the relavent ops, [Op_1, Op_2, ..., Op_N, Reshape]
- """
-
- ssa, _ = core.get_ssa(predict_net)
-
- ret = []
- for i, op in enumerate(predict_net.op):
- if op.type == "Reshape":
- assert len(op.input) == 2
- input_ssa = ssa[i][0]
- data_source = input_ssa[0]
- shape_source = input_ssa[1]
- op_indices = _get_dependency_chain(ssa, shape_source, data_source)
- ret.append(op_indices + [i])
- return ret
-
-
-def remove_reshape_for_fc(predict_net, params):
- """
- In PyTorch nn.Linear has to take 2D tensor, this often leads to reshape
- a 4D tensor to 2D by calling .view(). However this (dynamic) reshaping
- doesn't work well with ONNX and Int8 tools, and cause using extra
- ops (eg. ExpandDims) that might not be available on mobile.
- Luckily Caffe2 supports 4D tensor for FC, so we can remove those reshape
- after exporting ONNX model.
- """
- from caffe2.python import core
-
- # find all reshape sub-graph that can be removed, which is now all Reshape
- # sub-graph whose output is only consumed by FC.
- # TODO: to make it safer, we may need the actually value to better determine
- # if a Reshape before FC is removable.
- reshape_sub_graphs = identify_reshape_sub_graph(predict_net)
- sub_graphs_to_remove = []
- for reshape_sub_graph in reshape_sub_graphs:
- reshape_op_id = reshape_sub_graph[-1]
- assert predict_net.op[reshape_op_id].type == "Reshape"
- ssa, _ = core.get_ssa(predict_net)
- reshape_output = ssa[reshape_op_id][1][0]
- consumers = [i for i in range(len(ssa)) if reshape_output in ssa[i][0]]
- if all(predict_net.op[consumer].type == "FC" for consumer in consumers):
- # safety check if the sub-graph is isolated, for this reshape sub-graph,
- # it means it has one non-param external input and one external output.
- ext_inputs, ext_outputs = get_sub_graph_external_input_output(
- predict_net, reshape_sub_graph
- )
- non_params_ext_inputs = [inp for inp in ext_inputs if inp[1] != 0]
- if len(non_params_ext_inputs) == 1 and len(ext_outputs) == 1:
- sub_graphs_to_remove.append(reshape_sub_graph)
-
- # perform removing subgraph by:
- # 1: rename the Reshape's output to its input, then the graph can be
- # seen as in-place itentify, meaning whose external input/output are the same.
- # 2: simply remove those ops.
- remove_op_ids = []
- params_to_remove = []
- for sub_graph in sub_graphs_to_remove:
- logger.info(
- "Remove Reshape sub-graph:\n{}".format(
- "".join(["(#{:>4})\n{}".format(i, predict_net.op[i]) for i in sub_graph])
- )
- )
- reshape_op_id = sub_graph[-1]
- new_reshap_output = predict_net.op[reshape_op_id].input[0]
- rename_op_output(predict_net, reshape_op_id, 0, new_reshap_output)
- ext_inputs, ext_outputs = get_sub_graph_external_input_output(predict_net, sub_graph)
- non_params_ext_inputs = [inp for inp in ext_inputs if inp[1] != 0]
- params_ext_inputs = [inp for inp in ext_inputs if inp[1] == 0]
- assert len(non_params_ext_inputs) == 1 and len(ext_outputs) == 1
- assert ext_outputs[0][0] == non_params_ext_inputs[0][0]
- assert ext_outputs[0][1] == non_params_ext_inputs[0][1] + 1
- remove_op_ids.extend(sub_graph)
- params_to_remove.extend(params_ext_inputs)
-
- predict_net = copy.deepcopy(predict_net)
- new_ops = [op for i, op in enumerate(predict_net.op) if i not in remove_op_ids]
- del predict_net.op[:]
- predict_net.op.extend(new_ops)
- for versioned_params in params_to_remove:
- name = versioned_params[0]
- logger.info("Remove params: {} from init_net and predict_net.external_input".format(name))
- del params[name]
- predict_net.external_input.remove(name)
-
- return predict_net, params
-
-
-def fuse_copy_between_cpu_and_gpu(predict_net: caffe2_pb2.NetDef):
- """
- In-place fuse extra copy ops between cpu/gpu for the following case:
- a -CopyAToB-> b -CopyBToA> c1 -NextOp1-> d1
- -CopyBToA> c2 -NextOp2-> d2
- The fused network will look like:
- a -NextOp1-> d1
- -NextOp2-> d2
- """
-
- _COPY_OPS = ["CopyCPUToGPU", "CopyGPUToCPU"]
-
- def _fuse_once(predict_net):
- ssa, blob_versions = core.get_ssa(predict_net)
- consumer_map = get_consumer_map(ssa)
- versioned_external_output = [
- (name, blob_versions[name]) for name in predict_net.external_output
- ]
-
- for op_id, op in enumerate(predict_net.op):
- if op.type in _COPY_OPS:
- fw_copy_versioned_output = ssa[op_id][1][0]
- consumer_ids = [x[0] for x in consumer_map[fw_copy_versioned_output]]
- reverse_op_type = _COPY_OPS[1 - _COPY_OPS.index(op.type)]
-
- is_fusable = (
- len(consumer_ids) > 0
- and fw_copy_versioned_output not in versioned_external_output
- and all(
- predict_net.op[_op_id].type == reverse_op_type
- and ssa[_op_id][1][0] not in versioned_external_output
- for _op_id in consumer_ids
- )
- )
-
- if is_fusable:
- for rv_copy_op_id in consumer_ids:
- # making each NextOp uses "a" directly and removing Copy ops
- rs_copy_versioned_output = ssa[rv_copy_op_id][1][0]
- next_op_id, inp_id = consumer_map[rs_copy_versioned_output][0]
- predict_net.op[next_op_id].input[inp_id] = op.input[0]
- # remove CopyOps
- new_ops = [
- op
- for i, op in enumerate(predict_net.op)
- if i != op_id and i not in consumer_ids
- ]
- del predict_net.op[:]
- predict_net.op.extend(new_ops)
- return True
-
- return False
-
- # _fuse_once returns False is nothing can be fused
- while _fuse_once(predict_net):
- pass
-
-
-def remove_dead_end_ops(net_def: caffe2_pb2.NetDef):
- """remove ops if its output is not used or not in external_output"""
- ssa, versions = core.get_ssa(net_def)
- versioned_external_output = [(name, versions[name]) for name in net_def.external_output]
- consumer_map = get_consumer_map(ssa)
- removed_op_ids = set()
-
- def _is_dead_end(versioned_blob):
- return not (
- versioned_blob in versioned_external_output
- or (
- len(consumer_map[versioned_blob]) > 0
- and all(x[0] not in removed_op_ids for x in consumer_map[versioned_blob])
- )
- )
-
- for i, ssa_i in reversed(list(enumerate(ssa))):
- versioned_outputs = ssa_i[1]
- if all(_is_dead_end(outp) for outp in versioned_outputs):
- removed_op_ids.add(i)
-
- # simply removing those deadend ops should have no effect to external_output
- new_ops = [op for i, op in enumerate(net_def.op) if i not in removed_op_ids]
- del net_def.op[:]
- net_def.op.extend(new_ops)
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/layers/losses.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/layers/losses.py
deleted file mode 100644
index 850a852a2f0986d4d1ce89a526d96db42c76e44f..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/detectron2/layers/losses.py
+++ /dev/null
@@ -1,133 +0,0 @@
-import math
-import torch
-
-
-def diou_loss(
- boxes1: torch.Tensor,
- boxes2: torch.Tensor,
- reduction: str = "none",
- eps: float = 1e-7,
-) -> torch.Tensor:
- """
- Distance Intersection over Union Loss (Zhaohui Zheng et. al)
- https://arxiv.org/abs/1911.08287
- Args:
- boxes1, boxes2 (Tensor): box locations in XYXY format, shape (N, 4) or (4,).
- reduction: 'none' | 'mean' | 'sum'
- 'none': No reduction will be applied to the output.
- 'mean': The output will be averaged.
- 'sum': The output will be summed.
- eps (float): small number to prevent division by zero
- """
-
- x1, y1, x2, y2 = boxes1.unbind(dim=-1)
- x1g, y1g, x2g, y2g = boxes2.unbind(dim=-1)
-
- # TODO: use torch._assert_async() when pytorch 1.8 support is dropped
- assert (x2 >= x1).all(), "bad box: x1 larger than x2"
- assert (y2 >= y1).all(), "bad box: y1 larger than y2"
-
- # Intersection keypoints
- xkis1 = torch.max(x1, x1g)
- ykis1 = torch.max(y1, y1g)
- xkis2 = torch.min(x2, x2g)
- ykis2 = torch.min(y2, y2g)
-
- intsct = torch.zeros_like(x1)
- mask = (ykis2 > ykis1) & (xkis2 > xkis1)
- intsct[mask] = (xkis2[mask] - xkis1[mask]) * (ykis2[mask] - ykis1[mask])
- union = (x2 - x1) * (y2 - y1) + (x2g - x1g) * (y2g - y1g) - intsct + eps
- iou = intsct / union
-
- # smallest enclosing box
- xc1 = torch.min(x1, x1g)
- yc1 = torch.min(y1, y1g)
- xc2 = torch.max(x2, x2g)
- yc2 = torch.max(y2, y2g)
- diag_len = ((xc2 - xc1) ** 2) + ((yc2 - yc1) ** 2) + eps
-
- # centers of boxes
- x_p = (x2 + x1) / 2
- y_p = (y2 + y1) / 2
- x_g = (x1g + x2g) / 2
- y_g = (y1g + y2g) / 2
- distance = ((x_p - x_g) ** 2) + ((y_p - y_g) ** 2)
-
- # Eqn. (7)
- loss = 1 - iou + (distance / diag_len)
- if reduction == "mean":
- loss = loss.mean() if loss.numel() > 0 else 0.0 * loss.sum()
- elif reduction == "sum":
- loss = loss.sum()
-
- return loss
-
-
-def ciou_loss(
- boxes1: torch.Tensor,
- boxes2: torch.Tensor,
- reduction: str = "none",
- eps: float = 1e-7,
-) -> torch.Tensor:
- """
- Complete Intersection over Union Loss (Zhaohui Zheng et. al)
- https://arxiv.org/abs/1911.08287
- Args:
- boxes1, boxes2 (Tensor): box locations in XYXY format, shape (N, 4) or (4,).
- reduction: 'none' | 'mean' | 'sum'
- 'none': No reduction will be applied to the output.
- 'mean': The output will be averaged.
- 'sum': The output will be summed.
- eps (float): small number to prevent division by zero
- """
-
- x1, y1, x2, y2 = boxes1.unbind(dim=-1)
- x1g, y1g, x2g, y2g = boxes2.unbind(dim=-1)
-
- # TODO: use torch._assert_async() when pytorch 1.8 support is dropped
- assert (x2 >= x1).all(), "bad box: x1 larger than x2"
- assert (y2 >= y1).all(), "bad box: y1 larger than y2"
-
- # Intersection keypoints
- xkis1 = torch.max(x1, x1g)
- ykis1 = torch.max(y1, y1g)
- xkis2 = torch.min(x2, x2g)
- ykis2 = torch.min(y2, y2g)
-
- intsct = torch.zeros_like(x1)
- mask = (ykis2 > ykis1) & (xkis2 > xkis1)
- intsct[mask] = (xkis2[mask] - xkis1[mask]) * (ykis2[mask] - ykis1[mask])
- union = (x2 - x1) * (y2 - y1) + (x2g - x1g) * (y2g - y1g) - intsct + eps
- iou = intsct / union
-
- # smallest enclosing box
- xc1 = torch.min(x1, x1g)
- yc1 = torch.min(y1, y1g)
- xc2 = torch.max(x2, x2g)
- yc2 = torch.max(y2, y2g)
- diag_len = ((xc2 - xc1) ** 2) + ((yc2 - yc1) ** 2) + eps
-
- # centers of boxes
- x_p = (x2 + x1) / 2
- y_p = (y2 + y1) / 2
- x_g = (x1g + x2g) / 2
- y_g = (y1g + y2g) / 2
- distance = ((x_p - x_g) ** 2) + ((y_p - y_g) ** 2)
-
- # width and height of boxes
- w_pred = x2 - x1
- h_pred = y2 - y1
- w_gt = x2g - x1g
- h_gt = y2g - y1g
- v = (4 / (math.pi**2)) * torch.pow((torch.atan(w_gt / h_gt) - torch.atan(w_pred / h_pred)), 2)
- with torch.no_grad():
- alpha = v / (1 - iou + v + eps)
-
- # Eqn. (10)
- loss = 1 - iou + (distance / diag_len) + alpha * v
- if reduction == "mean":
- loss = loss.mean() if loss.numel() > 0 else 0.0 * loss.sum()
- elif reduction == "sum":
- loss = loss.sum()
-
- return loss
diff --git a/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/DensePose/densepose/structures/data_relative.py b/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/DensePose/densepose/structures/data_relative.py
deleted file mode 100644
index a148fa75dcf33eb610ef2a2758969c0277bc0906..0000000000000000000000000000000000000000
--- a/spaces/carlosalonso/Detection-video/carpeta_deteccion/projects/DensePose/densepose/structures/data_relative.py
+++ /dev/null
@@ -1,243 +0,0 @@
-# Copyright (c) Facebook, Inc. and its affiliates.
-import numpy as np
-import torch
-from torch.nn import functional as F
-
-from densepose.data.meshes.catalog import MeshCatalog
-from densepose.structures.mesh import load_mesh_symmetry
-from densepose.structures.transform_data import DensePoseTransformData
-
-
-class DensePoseDataRelative(object):
- """
- Dense pose relative annotations that can be applied to any bounding box:
- x - normalized X coordinates [0, 255] of annotated points
- y - normalized Y coordinates [0, 255] of annotated points
- i - body part labels 0,...,24 for annotated points
- u - body part U coordinates [0, 1] for annotated points
- v - body part V coordinates [0, 1] for annotated points
- segm - 256x256 segmentation mask with values 0,...,14
- To obtain absolute x and y data wrt some bounding box one needs to first
- divide the data by 256, multiply by the respective bounding box size
- and add bounding box offset:
- x_img = x0 + x_norm * w / 256.0
- y_img = y0 + y_norm * h / 256.0
- Segmentation masks are typically sampled to get image-based masks.
- """
-
- # Key for normalized X coordinates in annotation dict
- X_KEY = "dp_x"
- # Key for normalized Y coordinates in annotation dict
- Y_KEY = "dp_y"
- # Key for U part coordinates in annotation dict (used in chart-based annotations)
- U_KEY = "dp_U"
- # Key for V part coordinates in annotation dict (used in chart-based annotations)
- V_KEY = "dp_V"
- # Key for I point labels in annotation dict (used in chart-based annotations)
- I_KEY = "dp_I"
- # Key for segmentation mask in annotation dict
- S_KEY = "dp_masks"
- # Key for vertex ids (used in continuous surface embeddings annotations)
- VERTEX_IDS_KEY = "dp_vertex"
- # Key for mesh id (used in continuous surface embeddings annotations)
- MESH_NAME_KEY = "ref_model"
- # Number of body parts in segmentation masks
- N_BODY_PARTS = 14
- # Number of parts in point labels
- N_PART_LABELS = 24
- MASK_SIZE = 256
-
- def __init__(self, annotation, cleanup=False):
- self.x = torch.as_tensor(annotation[DensePoseDataRelative.X_KEY])
- self.y = torch.as_tensor(annotation[DensePoseDataRelative.Y_KEY])
- if (
- DensePoseDataRelative.I_KEY in annotation
- and DensePoseDataRelative.U_KEY in annotation
- and DensePoseDataRelative.V_KEY in annotation
- ):
- self.i = torch.as_tensor(annotation[DensePoseDataRelative.I_KEY])
- self.u = torch.as_tensor(annotation[DensePoseDataRelative.U_KEY])
- self.v = torch.as_tensor(annotation[DensePoseDataRelative.V_KEY])
- if (
- DensePoseDataRelative.VERTEX_IDS_KEY in annotation
- and DensePoseDataRelative.MESH_NAME_KEY in annotation
- ):
- self.vertex_ids = torch.as_tensor(
- annotation[DensePoseDataRelative.VERTEX_IDS_KEY], dtype=torch.long
- )
- self.mesh_id = MeshCatalog.get_mesh_id(annotation[DensePoseDataRelative.MESH_NAME_KEY])
- if DensePoseDataRelative.S_KEY in annotation:
- self.segm = DensePoseDataRelative.extract_segmentation_mask(annotation)
- self.device = torch.device("cpu")
- if cleanup:
- DensePoseDataRelative.cleanup_annotation(annotation)
-
- def to(self, device):
- if self.device == device:
- return self
- new_data = DensePoseDataRelative.__new__(DensePoseDataRelative)
- new_data.x = self.x.to(device)
- new_data.y = self.y.to(device)
- for attr in ["i", "u", "v", "vertex_ids", "segm"]:
- if hasattr(self, attr):
- setattr(new_data, attr, getattr(self, attr).to(device))
- if hasattr(self, "mesh_id"):
- new_data.mesh_id = self.mesh_id
- new_data.device = device
- return new_data
-
- @staticmethod
- def extract_segmentation_mask(annotation):
- import pycocotools.mask as mask_utils
-
- # TODO: annotation instance is accepted if it contains either
- # DensePose segmentation or instance segmentation. However, here we
- # only rely on DensePose segmentation
- poly_specs = annotation[DensePoseDataRelative.S_KEY]
- if isinstance(poly_specs, torch.Tensor):
- # data is already given as mask tensors, no need to decode
- return poly_specs
- segm = torch.zeros((DensePoseDataRelative.MASK_SIZE,) * 2, dtype=torch.float32)
- if isinstance(poly_specs, dict):
- if poly_specs:
- mask = mask_utils.decode(poly_specs)
- segm[mask > 0] = 1
- else:
- for i in range(len(poly_specs)):
- poly_i = poly_specs[i]
- if poly_i:
- mask_i = mask_utils.decode(poly_i)
- segm[mask_i > 0] = i + 1
- return segm
-
- @staticmethod
- def validate_annotation(annotation):
- for key in [
- DensePoseDataRelative.X_KEY,
- DensePoseDataRelative.Y_KEY,
- ]:
- if key not in annotation:
- return False, "no {key} data in the annotation".format(key=key)
- valid_for_iuv_setting = all(
- key in annotation
- for key in [
- DensePoseDataRelative.I_KEY,
- DensePoseDataRelative.U_KEY,
- DensePoseDataRelative.V_KEY,
- ]
- )
- valid_for_cse_setting = all(
- key in annotation
- for key in [
- DensePoseDataRelative.VERTEX_IDS_KEY,
- DensePoseDataRelative.MESH_NAME_KEY,
- ]
- )
- if not valid_for_iuv_setting and not valid_for_cse_setting:
- return (
- False,
- "expected either {} (IUV setting) or {} (CSE setting) annotations".format(
- ", ".join(
- [
- DensePoseDataRelative.I_KEY,
- DensePoseDataRelative.U_KEY,
- DensePoseDataRelative.V_KEY,
- ]
- ),
- ", ".join(
- [
- DensePoseDataRelative.VERTEX_IDS_KEY,
- DensePoseDataRelative.MESH_NAME_KEY,
- ]
- ),
- ),
- )
- return True, None
-
- @staticmethod
- def cleanup_annotation(annotation):
- for key in [
- DensePoseDataRelative.X_KEY,
- DensePoseDataRelative.Y_KEY,
- DensePoseDataRelative.I_KEY,
- DensePoseDataRelative.U_KEY,
- DensePoseDataRelative.V_KEY,
- DensePoseDataRelative.S_KEY,
- DensePoseDataRelative.VERTEX_IDS_KEY,
- DensePoseDataRelative.MESH_NAME_KEY,
- ]:
- if key in annotation:
- del annotation[key]
-
- def apply_transform(self, transforms, densepose_transform_data):
- self._transform_pts(transforms, densepose_transform_data)
- if hasattr(self, "segm"):
- self._transform_segm(transforms, densepose_transform_data)
-
- def _transform_pts(self, transforms, dp_transform_data):
- import detectron2.data.transforms as T
-
- # NOTE: This assumes that HorizFlipTransform is the only one that does flip
- do_hflip = sum(isinstance(t, T.HFlipTransform) for t in transforms.transforms) % 2 == 1
- if do_hflip:
- self.x = self.MASK_SIZE - self.x
- if hasattr(self, "i"):
- self._flip_iuv_semantics(dp_transform_data)
- if hasattr(self, "vertex_ids"):
- self._flip_vertices()
-
- for t in transforms.transforms:
- if isinstance(t, T.RotationTransform):
- xy_scale = np.array((t.w, t.h)) / DensePoseDataRelative.MASK_SIZE
- xy = t.apply_coords(np.stack((self.x, self.y), axis=1) * xy_scale)
- self.x, self.y = torch.tensor(xy / xy_scale, dtype=self.x.dtype).T
-
- def _flip_iuv_semantics(self, dp_transform_data: DensePoseTransformData) -> None:
- i_old = self.i.clone()
- uv_symmetries = dp_transform_data.uv_symmetries
- pt_label_symmetries = dp_transform_data.point_label_symmetries
- for i in range(self.N_PART_LABELS):
- if i + 1 in i_old:
- annot_indices_i = i_old == i + 1
- if pt_label_symmetries[i + 1] != i + 1:
- self.i[annot_indices_i] = pt_label_symmetries[i + 1]
- u_loc = (self.u[annot_indices_i] * 255).long()
- v_loc = (self.v[annot_indices_i] * 255).long()
- self.u[annot_indices_i] = uv_symmetries["U_transforms"][i][v_loc, u_loc].to(
- device=self.u.device
- )
- self.v[annot_indices_i] = uv_symmetries["V_transforms"][i][v_loc, u_loc].to(
- device=self.v.device
- )
-
- def _flip_vertices(self):
- mesh_info = MeshCatalog[MeshCatalog.get_mesh_name(self.mesh_id)]
- mesh_symmetry = (
- load_mesh_symmetry(mesh_info.symmetry) if mesh_info.symmetry is not None else None
- )
- self.vertex_ids = mesh_symmetry["vertex_transforms"][self.vertex_ids]
-
- def _transform_segm(self, transforms, dp_transform_data):
- import detectron2.data.transforms as T
-
- # NOTE: This assumes that HorizFlipTransform is the only one that does flip
- do_hflip = sum(isinstance(t, T.HFlipTransform) for t in transforms.transforms) % 2 == 1
- if do_hflip:
- self.segm = torch.flip(self.segm, [1])
- self._flip_segm_semantics(dp_transform_data)
-
- for t in transforms.transforms:
- if isinstance(t, T.RotationTransform):
- self._transform_segm_rotation(t)
-
- def _flip_segm_semantics(self, dp_transform_data):
- old_segm = self.segm.clone()
- mask_label_symmetries = dp_transform_data.mask_label_symmetries
- for i in range(self.N_BODY_PARTS):
- if mask_label_symmetries[i + 1] != i + 1:
- self.segm[old_segm == i + 1] = mask_label_symmetries[i + 1]
-
- def _transform_segm_rotation(self, rotation):
- self.segm = F.interpolate(self.segm[None, None, :], (rotation.h, rotation.w)).numpy()
- self.segm = torch.tensor(rotation.apply_segmentation(self.segm[0, 0]))[None, None, :]
- self.segm = F.interpolate(self.segm, [DensePoseDataRelative.MASK_SIZE] * 2)[0, 0]
diff --git a/spaces/cbhasker/bhaskergenAIAppSpeech/README.md b/spaces/cbhasker/bhaskergenAIAppSpeech/README.md
deleted file mode 100644
index 65b1f6d3523bb5368ba503251e713758eb9c7f64..0000000000000000000000000000000000000000
--- a/spaces/cbhasker/bhaskergenAIAppSpeech/README.md
+++ /dev/null
@@ -1,12 +0,0 @@
----
-title: BhaskergenAIAppSpeech
-emoji: 🌖
-colorFrom: indigo
-colorTo: indigo
-sdk: gradio
-sdk_version: 3.39.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/ccolas/TastyPiano/src/music/representation_learning/sentence_bert_finetuning/song_embedding.py b/spaces/ccolas/TastyPiano/src/music/representation_learning/sentence_bert_finetuning/song_embedding.py
deleted file mode 100644
index de413cb0c1d54af7f9f8adc8559fe455d3b2688c..0000000000000000000000000000000000000000
--- a/spaces/ccolas/TastyPiano/src/music/representation_learning/sentence_bert_finetuning/song_embedding.py
+++ /dev/null
@@ -1,239 +0,0 @@
-import argparse
-import os
-from datasets import load_dataset
-from ..sentence_transfo.sentence_transformers import SentenceTransformer
-from ..sentence_transfo.sentence_transformers import models, losses
-from torch.utils.data import DataLoader
-import numpy as np
-import logging
-from accelerate import Accelerator, DistributedDataParallelKwargs
-import datasets
-import transformers
-import torch
-from torch import nn
-import json
-from src.music.config import DATASET_PATH, EXPERIMENT_PATH
-
-logger = logging.getLogger(__name__)
-
-def parse_args():
- parser = argparse.ArgumentParser(description="Finetune a transformers model on a Masked Language Modeling task")
- parser.add_argument("--train_file",
- type=str,
- default=DATASET_PATH + "/small/train_stacked_aug.txt",
- help="A csv or a json file containing the training data."
- )
- parser.add_argument("--expe_name",
- type=str,
- default="",
- help="A csv or a json file containing the training data."
- )
- parser.add_argument("--validation_file",
- type=str,
- default=DATASET_PATH + "/small/test_stacked_aug.txt",
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--sentence_embedding_model",
- type=str,
- default="",
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--model_name",
- type=str,
- default='ccolas/music-bert-base-small-data',
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--pooling",
- type=str,
- default='mean',
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--overwrite_cache",
- type=bool,
- default=True,
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--preprocessing_num_workers",
- type=int,
- default=1,
- help="A csv or a json file containing the validation data."
- )
- parser.add_argument("--cache_dir", type=str, default=None, help="The token to use to push to the Model Hub.")
- parser.add_argument("--output_dir", type=str, default=EXPERIMENT_PATH + '/music/representation_learning/saved_models/sentence_embedding/local/',
- help="Where to store the final model.")
- parser.add_argument("--max_seq_length", type=int, default=512)
- parser.add_argument("--nb_tokens_per_note", type=int, default=5)
- parser.add_argument("--batch_size", type=int, default=3)
- parser.add_argument("--pair_per_song", type=int, default=10)
- parser.add_argument("--rep_size", type=int, default=0)
-
- args = parser.parse_args()
- return args
-
-def setup_sentence_transfo_model(args):
- # Define your sentence transformer model using CLS pooling
- word_embedding_model = models.Transformer(args.model_name, max_seq_length=args.max_seq_length)
- if 't5' in args.model_name:
- word_embedding_model.auto_model = word_embedding_model.auto_model.encoder
- pooling_model = models.Pooling(word_embedding_model.get_word_embedding_dimension(), pooling_mode=args.pooling)
- if args.rep_size > 0:
- dense_model = models.Dense(in_features=pooling_model.get_sentence_embedding_dimension(), out_features=args.rep_size, activation_function=nn.Tanh())
- model = SentenceTransformer(modules=[word_embedding_model, pooling_model, dense_model])
- else:
- model = SentenceTransformer(modules=[word_embedding_model, pooling_model])
- return model
-
-class Argument(object):
- def __init__(self, adict):
- self.__dict__.update(adict)
-
-def setup_dataset(args, accelerator):
- data_files = {}
- data_files["train"] = args.train_file
- data_files["validation"] = args.validation_file
- dataset = load_dataset("text", data_files=data_files, cache_dir=args.cache_dir)
-
- def group_texts(examples):
- results = dict()
- results['texts'] = []
- results['label'] = []
- ex = examples['text']
- for e in ex:
- pairs = []
- augs = e.split('&')
- aug_chunks = []
- nb_aug = len(augs)
- nb_chunks = []
- for aug in augs:
- aug = aug.split(' ')
- aug_chunk = [' '.join(aug[i: i + args.max_seq_length]) for i in range(0, len(aug) - args.max_seq_length, args.max_seq_length)]
- nb_chunks.append(len(aug_chunk))
- aug_chunks.append(aug_chunk)
- nb_chunks = np.min(nb_chunks)
- if nb_chunks != 0:
- if nb_chunks >= 2:
- while len(pairs) < min(nb_aug * nb_chunks, args.pair_per_song):
- chunk_ids = np.arange(nb_chunks)
- np.random.shuffle(chunk_ids)
- for index in range(0, nb_chunks - 1, 2):
- aug_ids = np.random.choice(np.arange(nb_aug), size=2, replace=False)
- chk_id = chunk_ids[index:index+2]
- pairs.append([aug_chunks[aug_ids[0]][chk_id[0]], aug_chunks[aug_ids[1]][chk_id[1]]])
- if len(pairs) == min(nb_aug * nb_chunks, args.pair_per_song):
- break
- else:
- # use same chunk (chunk 0)
- for i in range(3):
- aug_ids = np.random.choice(np.arange(nb_aug), size=2, replace=False)
- pairs.append([aug_chunks[aug_ids[0]][0], aug_chunks[aug_ids[1]][0]])
- results['texts'] += pairs
- results['label'] += [0 for _ in range(len(pairs))]
- return results
-
- with accelerator.main_process_first():
- dataset = dataset.map(group_texts,
- batched=True,
- num_proc=args.preprocessing_num_workers,
- # writer_batch_size=3_000,
- remove_columns=['text'],
- load_from_cache_file=not args.overwrite_cache,
- )
-
- train_dataset = dataset['train']
- validation_dataset = dataset['validation']
-
- # DataLoader to batch your data
- train_dataloader = DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True)
- validation_dataloader = DataLoader(validation_dataset, batch_size=args.batch_size, shuffle=True)
-
- return train_dataloader, validation_dataloader
-
-def get_output_dir(args):
- if args.expe_name == '':
- args.expe_name = 'run'
- save_dir = args.output_dir + args.expe_name
- candidate_save_dir = save_dir
- trial_id = 0
- while os.path.exists(candidate_save_dir):
- trial_id += 1
- candidate_save_dir = save_dir + f'_{trial_id}'
- save_dir = candidate_save_dir + '/'
- os.makedirs(save_dir)
- return save_dir
-
-def train():
- # Setup logging, we only want one process per machine to log things on the screen.
- # accelerator.is_local_main_process is only True for one process per machine.
- logging.basicConfig(
- format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
- datefmt="%m/%d/%Y %H:%M:%S",
- level=logging.INFO,
- )
-
- args = parse_args()
- args.max_seq_length = (args.max_seq_length // args.nb_tokens_per_note) * args.nb_tokens_per_note
-
- # Initialize the accelerator. We will let the accelerator handle device placement for us in this example.
- ddp_kwargs = DistributedDataParallelKwargs(find_unused_parameters=True)
- accelerator = Accelerator(kwargs_handlers=[ddp_kwargs])
- logger.info(accelerator.state)
- logger.info(accelerator.device)
- # Setup logging, we only want one process per machine to log things on the screen.
- # accelerator.is_local_main_process is only True for one process per machine.
- logger.setLevel(logging.INFO if accelerator.is_local_main_process else logging.ERROR)
- if accelerator.is_local_main_process:
- datasets.utils.logging.set_verbosity_warning()
- transformers.utils.logging.set_verbosity_info()
- else:
- datasets.utils.logging.set_verbosity_error()
- transformers.utils.logging.set_verbosity_error()
-
-
- if accelerator.is_main_process: print('Setting up the model')
- if args.sentence_embedding_model != '':
- if accelerator.is_main_process: print(f' Loading pretrained model from {args.sentence_embedding_model}')
- model = SentenceTransformer(args.sentence_embedding_model)
- else:
- model = setup_sentence_transfo_model(args)
- print(model)
- if accelerator.is_main_process: print('Building dataset')
- train_dataloader, validation_dataloader = setup_dataset(args, accelerator)
- if accelerator.is_main_process:
- print(" len of train_loader", len(train_dataloader))
- print(" len of valid_loader", len(validation_dataloader))
- print(" total train data", len(train_dataloader.dataset))
- print(" total valid data", len(validation_dataloader.dataset))
- if accelerator.is_main_process:
- args.output_dir = get_output_dir(args)
- print(f'Saving results to {args.output_dir}')
-
- if accelerator.is_main_process:
- if torch.cuda.is_available():
- print("Use %d GPUS" % torch.cuda.device_count())
- else:
- print('Use cpu.')
- params = vars(args)
- with open(args.output_dir + 'params.json', 'w') as f:
- json.dump(params, f)
-
- # Use the denoising auto-encoder loss
- train_loss = losses.MultipleNegativesRankingLoss(model)
-
- accelerator.wait_for_everyone()
-
- # Call the fit method
- model.fit(train_objectives=[(train_dataloader, train_loss)],
- validation_dataloader=validation_dataloader,
- epochs=100,
- save_best_model=True,
- gradient_accumulation=1,
- output_path=args.output_dir,
- evaluate_every_steps=1000,
- log_every_steps=500,
- nb_eval_steps=100,
- show_progress_bar=True,
- accelerator=accelerator)
-
-
-if __name__ == '__main__':
- train()
\ No newline at end of file
diff --git a/spaces/cdavenpo822/ToyWorld/README.md b/spaces/cdavenpo822/ToyWorld/README.md
deleted file mode 100644
index 120ce8babe394c9302727676b38de31dc01a80d6..0000000000000000000000000000000000000000
--- a/spaces/cdavenpo822/ToyWorld/README.md
+++ /dev/null
@@ -1,13 +0,0 @@
----
-title: 499 Models Fast Diffusion
-emoji: 🪅🌐
-colorFrom: gray
-colorTo: green
-sdk: gradio
-sdk_version: 3.15.0
-app_file: app.py
-pinned: true
-duplicated_from: Omnibus/maximum_multiplier_places
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
diff --git a/spaces/cfwef/gpt/crazy_functions/test_project/latex/attention/introduction.tex b/spaces/cfwef/gpt/crazy_functions/test_project/latex/attention/introduction.tex
deleted file mode 100644
index 1baa8915f4cf7aec2520894a87470fc9436d954b..0000000000000000000000000000000000000000
--- a/spaces/cfwef/gpt/crazy_functions/test_project/latex/attention/introduction.tex
+++ /dev/null
@@ -1,18 +0,0 @@
-Recurrent neural networks, long short-term memory \citep{hochreiter1997} and gated recurrent \citep{gruEval14} neural networks in particular, have been firmly established as state of the art approaches in sequence modeling and transduction problems such as language modeling and machine translation \citep{sutskever14, bahdanau2014neural, cho2014learning}. Numerous efforts have since continued to push the boundaries of recurrent language models and encoder-decoder architectures \citep{wu2016google,luong2015effective,jozefowicz2016exploring}.
-
-Recurrent models typically factor computation along the symbol positions of the input and output sequences. Aligning the positions to steps in computation time, they generate a sequence of hidden states $h_t$, as a function of the previous hidden state $h_{t-1}$ and the input for position $t$. This inherently sequential nature precludes parallelization within training examples, which becomes critical at longer sequence lengths, as memory constraints limit batching across examples.
-%\marginpar{not sure if the memory constraints are understandable here}
-Recent work has achieved significant improvements in computational efficiency through factorization tricks \citep{Kuchaiev2017Factorization} and conditional computation \citep{shazeer2017outrageously}, while also improving model performance in case of the latter. The fundamental constraint of sequential computation, however, remains.
-
-%\marginpar{@all: there is work on analyzing what attention really does in seq2seq models, couldn't find it right away}
-
-Attention mechanisms have become an integral part of compelling sequence modeling and transduction models in various tasks, allowing modeling of dependencies without regard to their distance in the input or output sequences \citep{bahdanau2014neural, structuredAttentionNetworks}. In all but a few cases \citep{decomposableAttnModel}, however, such attention mechanisms are used in conjunction with a recurrent network.
-
-%\marginpar{not sure if "cross-positional communication" is understandable without explanation}
-%\marginpar{insert exact training times and stats for the model that reaches sota earliest, maybe even a single GPU model?}
-
-In this work we propose the Transformer, a model architecture eschewing recurrence and instead relying entirely on an attention mechanism to draw global dependencies between input and output. The Transformer allows for significantly more parallelization and can reach a new state of the art in translation quality after being trained for as little as twelve hours on eight P100 GPUs.
-%\marginpar{you removed the constant number of repetitions part. I wrote it because I wanted to make it clear that the model does not only perform attention once, while it's also not recurrent. I thought that might be important to get across early.}
-
-% Just a standard paragraph with citations, rewrite.
-%After the seminal papers of \citep{sutskever14}, \citep{bahdanau2014neural}, and \citep{cho2014learning}, recurrent models have become the dominant solution for both sequence modeling and sequence-to-sequence transduction. Many efforts such as \citep{wu2016google,luong2015effective,jozefowicz2016exploring} have pushed the boundaries of machine translation and language modeling with recurrent sequence models. Recent effort \citep{shazeer2017outrageously} has combined the power of conditional computation with sequence models to train very large models for machine translation, pushing SOTA at lower computational cost. Recurrent models compute a vector of hidden states $h_t$, for each time step $t$ of computation. $h_t$ is a function of both the input at time $t$ and the previous hidden state $h_t$. This dependence on the previous hidden state encumbers recurrnet models to process multiple inputs at once, and their time complexity is a linear function of the length of the input and output, both during training and inference. [What I want to say here is that although this is fine during decoding, at training time, we are given both input and output and this linear nature does not allow the RNN to process all inputs and outputs simultaneously and haven't been used on datasets that are the of the scale of the web. What's the largest dataset we have ? . Talk about Nividia and possibly other's effors to speed up things, and possibly other efforts that alleviate this, but are still limited by it's comptuational nature]. Rest of the intro: What if you could construct the state based on the actual inputs and outputs, then you could construct them all at once. This has been the foundation of many promising recent efforts, bytenet,facenet (Also talk about quasi rnn here). Now we talk about attention!! Along with cell architectures such as long short-term meory (LSTM) \citep{hochreiter1997}, and gated recurrent units (GRUs) \citep{cho2014learning}, attention has emerged as an essential ingredient in successful sequence models, in particular for machine translation. In recent years, many, if not all, state-of-the-art (SOTA) results in machine translation have been achieved with attention-based sequence models \citep{wu2016google,luong2015effective,jozefowicz2016exploring}. Talk about the neon work on how it played with attention to do self attention! Then talk about what we do.
\ No newline at end of file
diff --git a/spaces/chainyo/Translator/main.py b/spaces/chainyo/Translator/main.py
deleted file mode 100644
index e39a5ff4427fa1fbf9df7b92d72f7e635729f768..0000000000000000000000000000000000000000
--- a/spaces/chainyo/Translator/main.py
+++ /dev/null
@@ -1,104 +0,0 @@
-"""
-🗣️ Translator - Translate text from one language to another.
-
-Application file made with Streamlit.
-
-Author:
- - @ChainYo
-"""
-
-import re
-import streamlit as st
-
-from datetime import datetime
-from transformers import pipeline
-from available_models import MODELS
-
-
-st.set_page_config(page_title="Translator", page_icon="🗣️")
-st.title("🗣️ Translator")
-st.subheader("Translation made fast and easy.")
-st.markdown("""
-[](https://github.com/ChainYo)
-[](https://huggingface.co/ChainYo)
-[](https://www.linkedin.com/in/thomas-chaigneau-dev/)
-[](https://discord.gg/)
-""")
-st.write("To add a new model, hit me up! ⬆️")
-
-with st.expander(label="❓ How does it work", expanded=True):
- st.markdown("""
- **Translator** is a **simple tool** that allows you to **translate text** from one language to another.
-
- **Translator** is powered by the [Transformers library](https://huggingface.co/transformers) and uses the
- [Helsinki-NLP](https://huggingface.co/Helsinki-NLP) models.
-
- Choose the **source language**, the **target language** and add some **text to translate**.
-
- **Translator** will translate the text and **save the output in a text file**. It cuts the sentences by following
- the punctuation marks.
-
- The output file content will also be displayed in the browser to help you understand the translation and choose
- if you want to download it.
-
- There is **no limit to the number of characters** that can be translated.
- The only limit is the time you are ready to wait! 🤗
-
- *P.S. I have built this tool to help me start writing blog posts in different languages. I am a French native speaker
- and I will use it to translate my potential future blog posts in English.*
-
- *P.P.S. I am a **Junior ML Engineer** passionate about **machine learning** and **data science**. Reach out to me by
- clicking on the socials badges above.*
- """)
-
-lang1, lang2 = st.columns(2)
-lang1.selectbox(
- "Source Language", ["🇬🇧 English", "🇫🇷 French", "🇩🇪 German", "🇪🇸 Spanish", "🇷🇺 Russian"],
- key="input_lang", index=1,
-)
-lang2.selectbox(
- "Target Language", ["🇬🇧 English", "🇫🇷 French", "🇩🇪 German", "🇪🇸 Spanish", "🇷🇺 Russian"],
- key="output_lang", index=0,
-)
-
-selected_model = MODELS[f"{st.session_state['input_lang']}->{st.session_state['output_lang']}"]
-
-
-if selected_model[0] == None:
- st.write("No model available for this pair.")
-elif selected_model[0] == 0:
- st.write("No translation necessary.")
-else:
- st.markdown(f"""
- **Selected model:** [{selected_model[0]}]({selected_model[1]})
- """)
-
- input_text = st.text_area("Enter text to translate:", height=400, key="input")
- translate_text = st.button("Translate")
-
- if translate_text:
- with st.spinner(text="⚙️ Model loading..."):
- task = pipeline(
- "translation",
- model=selected_model[0],
- tokenizer=selected_model[0],
- )
-
- progress_bar = st.progress(0)
- with st.spinner(text="🔄 Translating..."):
- text_to_translate = re.split('(?<=[.!?]) +', input_text)
- total_progress = len(text_to_translate)
-
- for i, text in enumerate(text_to_translate):
- translation = task(text)
- text_to_translate[i] = translation[0]["translation_text"]
- progress_bar.progress((i + 1) / total_progress)
-
- st.success("🗣️ Translated!")
- st.write(f"**Translation:** {' '.join(text_to_translate)}")
- st.download_button(
- label="Download translated text",
- data="\n".join(text_to_translate),
- file_name=f"{st.session_state['input_lang']}-{st.session_state['output_lang']}-{datetime.now().strftime('%Y-%m-%d-%H-%M-%S')}.txt",
- mime="text/plain"
- )
diff --git a/spaces/chansung/LLM-As-Chatbot/models/alpaca.py b/spaces/chansung/LLM-As-Chatbot/models/alpaca.py
deleted file mode 100644
index 33d6d07c6e98960f5e07d445a911754a3e53fcbd..0000000000000000000000000000000000000000
--- a/spaces/chansung/LLM-As-Chatbot/models/alpaca.py
+++ /dev/null
@@ -1,92 +0,0 @@
-import torch
-from peft import PeftModel
-from transformers import LlamaTokenizer, LlamaForCausalLM
-from optimum.bettertransformer import BetterTransformer
-
-def load_model(
- base,
- finetuned,
- mode_cpu,
- mode_mps,
- mode_full_gpu,
- mode_8bit,
- mode_4bit,
- force_download_ckpt
-):
- tokenizer = LlamaTokenizer.from_pretrained(base)
- tokenizer.pad_token_id = 0
- tokenizer.padding_side = "left"
-
- if mode_cpu:
- print("cpu mode")
- model = LlamaForCausalLM.from_pretrained(
- base,
- device_map={"": "cpu"},
- use_safetensors=False
- )
-
- if finetuned is not None and \
- finetuned != "" and \
- finetuned != "N/A":
-
- model = PeftModel.from_pretrained(
- model,
- finetuned,
- device_map={"": "cpu"}
- # force_download=force_download_ckpt,
- )
- else:
- model = BetterTransformer.transform(model)
-
- elif mode_mps:
- print("mps mode")
- model = LlamaForCausalLM.from_pretrained(
- base,
- device_map={"": "mps"},
- torch_dtype=torch.float16,
- use_safetensors=False
- )
-
- if finetuned is not None and \
- finetuned != "" and \
- finetuned != "N/A":
-
- model = PeftModel.from_pretrained(
- model,
- finetuned,
- torch_dtype=torch.float16,
- device_map={"": "mps"}
- # force_download=force_download_ckpt,
- )
- else:
- model = BetterTransformer.transform(model)
-
- else:
- print("gpu mode")
- print(f"8bit = {mode_8bit}, 4bit = {mode_4bit}")
- model = LlamaForCausalLM.from_pretrained(
- base,
- load_in_8bit=mode_8bit,
- load_in_4bit=mode_4bit,
- torch_dtype=torch.float16,
- device_map="auto",
- use_safetensors=False
- )
-
- if not mode_8bit and not mode_4bit:
- model.half()
-
- if finetuned is not None and \
- finetuned != "" and \
- finetuned != "N/A":
-
- model = PeftModel.from_pretrained(
- model,
- finetuned,
- # force_download=force_download_ckpt,
- )
- else:
- model = BetterTransformer.transform(model)
-
- return model, tokenizer
-
diff --git a/spaces/chansung/zero2story/constants/desc.py b/spaces/chansung/zero2story/constants/desc.py
deleted file mode 100644
index 56b3ce77730fc36582b71127bce4ca0e2b4b01e9..0000000000000000000000000000000000000000
--- a/spaces/chansung/zero2story/constants/desc.py
+++ /dev/null
@@ -1,22 +0,0 @@
-pre_phase_description = """
-
-
-Zero2Story is a framework built on top of [PaLM API](https://developers.generativeai.google), [Stable Diffusion](https://en.wikipedia.org/wiki/Stable_Diffusion), [MusicGen](https://audiocraft.metademolab.com/musicgen.html) for ordinary people to create their own stories. This framework consists of the **background setup**, **character setup**, and **interative story generation** phases. Here is the short description of the above figure; Once setting the basic information of ① and ②, Zero2Story continuously suggests ③ stories , ④ actions, and ⑤ media in each turn while giving ⑥ regeneration control to refine the works interactively.
-"""
-
-background_setup_phase_description = """
-In this phase, users can setup the genre, place, and mood of the story. Especially, genre is the key that others are depending on.
-"""
-character_setup_phase_description = """
-In this phase, users can setup characters up to four. For each character, users can decide their characteristics and basic information such as name, age and personality. Also, the image of each character could be generated based on the information using Stable Diffusion.
-
-PaLM API translates the given character information into a list of keywords that Stable Diffusion could effectively understands. Then, Stable Diffusion generates images using the keywords as a prompt.
-"""
-story_generation_phase_description = """
-In this phase, the first few paragraphs are generated solely based on the information from the background and character setup phases. Afterwards, users could choose a direction from the given three options that PaLM API generated. Then, further stories are generated based on users' choice. This cycle of choosing an option and generating further stories are interatively continued until users decides to stop.
-
-In each story generation, users also could generate background images and music that describe each scene using Stable Diffusion and MusicGen. If the generated story, options, image, and music in each turn, users could ask to re-generate them.
-"""
-export_phase_description = """
-In this phase, you can export the generated whole stuffs including text, image, audio, and video in the form of a static HTML page.
-"""
\ No newline at end of file
diff --git a/spaces/chasetank/Visual-GPT-3.5-Turbo/app.py b/spaces/chasetank/Visual-GPT-3.5-Turbo/app.py
deleted file mode 100644
index 0a581bbf4fc963793e03760ea47ad565d7821d85..0000000000000000000000000000000000000000
--- a/spaces/chasetank/Visual-GPT-3.5-Turbo/app.py
+++ /dev/null
@@ -1,187 +0,0 @@
-VISUAL_CHATGPT_PREFIX = """Visual ChatGPT is designed to be able to assist with a wide range of text and visual related tasks, from answering simple questions to providing in-depth explanations and discussions on a wide range of topics. Visual ChatGPT is able to generate human-like text based on the input it receives, allowing it to engage in natural-sounding conversations and provide responses that are coherent and relevant to the topic at hand.
-Visual ChatGPT is able to process and understand large amounts of text and image. As a language model, Visual ChatGPT can not directly read images, but it has a list of tools to finish different visual tasks. Each image will have a file name formed as "image/xxx.png", and Visual ChatGPT can invoke different tools to indirectly understand pictures. When talking about images, Visual ChatGPT is very strict to the file name and will never fabricate nonexistent files. When using tools to generate new image files, Visual ChatGPT is also known that the image may not be the same as user's demand, and will use other visual question answering tools or description tools to observe the real image. Visual ChatGPT is able to use tools in a sequence, and is loyal to the tool observation outputs rather than faking the image content and image file name. It will remember to provide the file name from the last tool observation, if a new image is generated.
-Human may provide new figures to Visual ChatGPT with a description. The description helps Visual ChatGPT to understand this image, but Visual ChatGPT should use tools to finish following tasks, rather than directly imagine from the description.
-Overall, Visual ChatGPT is a powerful visual dialogue assistant tool that can help with a wide range of tasks and provide valuable insights and information on a wide range of topics.
-TOOLS:
-------
-Visual ChatGPT has access to the following tools:"""
-
-VISUAL_CHATGPT_FORMAT_INSTRUCTIONS = """To use a tool, please use the following format:
-```
-Thought: Do I need to use a tool? Yes
-Action: the action to take, should be one of [{tool_names}]
-Action Input: the input to the action
-Observation: the result of the action
-```
-When you have a response to say to the Human, or if you do not need to use a tool, you MUST use the format:
-```
-Thought: Do I need to use a tool? No
-{ai_prefix}: [your response here]
-```
-"""
-
-VISUAL_CHATGPT_SUFFIX = """You are very strict to the filename correctness and will never fake a file name if not exists.
-You will remember to provide the image file name loyally if it's provided in the last tool observation.
-Begin!
-Previous conversation history:
-{chat_history}
-New input: {input}
-Since Visual ChatGPT is a text language model, Visual ChatGPT must use tools to observe images rather than imagination.
-The thoughts and observations are only visible for Visual ChatGPT, Visual ChatGPT should remember to repeat important information in the final response for Human.
-Thought: Do I need to use a tool? {agent_scratchpad}"""
-
-from visual_foundation_models import *
-from langchain.agents.initialize import initialize_agent
-from langchain.agents.tools import Tool
-from langchain.chains.conversation.memory import ConversationBufferMemory
-from langchain.llms.openai import OpenAI
-import re
-import gradio as gr
-
-
-def cut_dialogue_history(history_memory, keep_last_n_words=400):
- if history_memory is None or len(history_memory) == 0:
- return history_memory
- tokens = history_memory.split()
- n_tokens = len(tokens)
- print(f"history_memory:{history_memory}, n_tokens: {n_tokens}")
- if n_tokens < keep_last_n_words:
- return history_memory
- paragraphs = history_memory.split('\n')
- last_n_tokens = n_tokens
- while last_n_tokens >= keep_last_n_words:
- last_n_tokens -= len(paragraphs[0].split(' '))
- paragraphs = paragraphs[1:]
- return '\n' + '\n'.join(paragraphs)
-
-
-class ConversationBot:
- def __init__(self, load_dict):
- # load_dict = {'VisualQuestionAnswering':'cuda:0', 'ImageCaptioning':'cuda:1',...}
- print(f"Initializing VisualChatGPT, load_dict={load_dict}")
- if 'ImageCaptioning' not in load_dict:
- raise ValueError("You have to load ImageCaptioning as a basic function for VisualChatGPT")
-
- self.memory = ConversationBufferMemory(memory_key="chat_history", output_key='output')
- self.models = dict()
- for class_name, device in load_dict.items():
- self.models[class_name] = globals()[class_name](device=device)
-
- self.tools = []
- for class_name, instance in self.models.items():
- for e in dir(instance):
- if e.startswith('inference'):
- func = getattr(instance, e)
- self.tools.append(Tool(name=func.name, description=func.description, func=func))
-
- def run_text(self, text, state):
- self.agent.memory.buffer = cut_dialogue_history(self.agent.memory.buffer, keep_last_n_words=500)
- res = self.agent({"input": text})
- res['output'] = res['output'].replace("\\", "/")
- response = re.sub('(image/\S*png)', lambda m: f'})*{m.group(0)}*', res['output'])
- state = state + [(text, response)]
- print(f"\nProcessed run_text, Input text: {text}\nCurrent state: {state}\n"
- f"Current Memory: {self.agent.memory.buffer}")
- return state, state
-
- def run_image(self, image, state, txt):
- image_filename = os.path.join('image', f"{str(uuid.uuid4())[:8]}.png")
- print("======>Auto Resize Image...")
- img = Image.open(image.name)
- width, height = img.size
- ratio = min(512 / width, 512 / height)
- width_new, height_new = (round(width * ratio), round(height * ratio))
- width_new = int(np.round(width_new / 64.0)) * 64
- height_new = int(np.round(height_new / 64.0)) * 64
- img = img.resize((width_new, height_new))
- img = img.convert('RGB')
- img.save(image_filename, "PNG")
- print(f"Resize image form {width}x{height} to {width_new}x{height_new}")
- description = self.models['ImageCaptioning'].inference(image_filename)
- Human_prompt = f'\nHuman: provide a figure named {image_filename}. The description is: {description}. This information helps you to understand this image, but you should use tools to finish following tasks, rather than directly imagine from my description. If you understand, say \"Received\". \n'
- AI_prompt = "Received. "
- self.agent.memory.buffer = self.agent.memory.buffer + Human_prompt + 'AI: ' + AI_prompt
- state = state + [(f"*{image_filename}*", AI_prompt)]
- print(f"\nProcessed run_image, Input image: {image_filename}\nCurrent state: {state}\n"
- f"Current Memory: {self.agent.memory.buffer}")
- return state, state, f'{txt} {image_filename} '
-
- def init_agent(self, openai_api_key=os.environ['OPENAI_API_KEY']):
- self.llm = OpenAI(temperature=0, openai_api_key=openai_api_key)
- self.agent = initialize_agent(
- self.tools,
- self.llm,
- agent="conversational-react-description",
- verbose=True,
- memory=self.memory,
- return_intermediate_steps=True,
- agent_kwargs={'prefix': VISUAL_CHATGPT_PREFIX, 'format_instructions': VISUAL_CHATGPT_FORMAT_INSTRUCTIONS, 'suffix': VISUAL_CHATGPT_SUFFIX}, )
-
- return gr.update(visible = True)
-
-bot = ConversationBot({'Text2Image': 'cuda:0',
- 'ImageCaptioning': 'cuda:0',
- 'ImageEditing': 'cuda:0',
- 'VisualQuestionAnswering': 'cuda:0',
- 'Image2Canny': 'cpu',
- 'CannyText2Image': 'cuda:0',
- 'InstructPix2Pix': 'cuda:0',
- 'Image2Depth': 'cpu',
- 'DepthText2Image': 'cuda:0',
- })
-
-with gr.Blocks(css="#chatbot {overflow:auto; height:500px;}") as demo:
- gr.Markdown("Visual ChatGPT You can duplicate this Space to skip the queue:
- ''')
-
- openai_api_key_textbox.submit(bot.init_agent, [openai_api_key_textbox], [input_raws])
- txt.submit(bot.run_text, [txt, state], [chatbot, state])
- txt.submit(lambda: "", None, txt)
- run.click(bot.run_text, [txt, state], [chatbot, state])
- run.click(lambda: "", None, txt)
- btn.upload(bot.run_image, [btn, state, txt], [chatbot, state, txt])
- clear.click(bot.memory.clear)
- clear.click(lambda: [], None, chatbot)
- clear.click(lambda: [], None, state)
-
- demo.queue(concurrency_count=10).launch(server_name="0.0.0.0", server_port=7860)
-
diff --git a/spaces/chendl/compositional_test/transformers/examples/pytorch/contrastive-image-text/README.md b/spaces/chendl/compositional_test/transformers/examples/pytorch/contrastive-image-text/README.md
deleted file mode 100644
index f22f2c82dce2dd576a62e89eee702fbe31601370..0000000000000000000000000000000000000000
--- a/spaces/chendl/compositional_test/transformers/examples/pytorch/contrastive-image-text/README.md
+++ /dev/null
@@ -1,102 +0,0 @@
-
-
-# VisionTextDualEncoder and CLIP model training examples
-
-The following example showcases how to train a CLIP-like vision-text dual encoder model
-using a pre-trained vision and text encoder.
-
-Such a model can be used for natural language image search and potentially zero-shot image classification.
-The model is inspired by [CLIP](https://openai.com/blog/clip/), introduced by Alec Radford et al.
-The idea is to train a vision encoder and a text encoder jointly to project the representation of images and their
-captions into the same embedding space, such that the caption embeddings are located near the embeddings
-of the images they describe.
-
-### Download COCO dataset (2017)
-This example uses COCO dataset (2017) through a custom dataset script, which requires users to manually download the
-COCO dataset before training.
-
-```bash
-mkdir data
-cd data
-wget http://images.cocodataset.org/zips/train2017.zip
-wget http://images.cocodataset.org/zips/val2017.zip
-wget http://images.cocodataset.org/zips/test2017.zip
-wget http://images.cocodataset.org/annotations/annotations_trainval2017.zip
-wget http://images.cocodataset.org/annotations/image_info_test2017.zip
-cd ..
-```
-
-Having downloaded COCO dataset manually you should be able to load with the `ydshieh/coc_dataset_script` dataset loading script:
-
-```py
-import os
-import datasets
-
-COCO_DIR = os.path.join(os.getcwd(), "data")
-ds = datasets.load_dataset("ydshieh/coco_dataset_script", "2017", data_dir=COCO_DIR)
-```
-
-### Create a model from a vision encoder model and a text encoder model
-Next, we create a [VisionTextDualEncoderModel](https://huggingface.co/docs/transformers/model_doc/vision-text-dual-encoder#visiontextdualencoder).
-The `VisionTextDualEncoderModel` class lets you load any vision and text encoder model to create a dual encoder.
-Here is an example of how to load the model using pre-trained vision and text models.
-
-```python3
-from transformers import (
- VisionTextDualEncoderModel,
- VisionTextDualEncoderProcessor,
- AutoTokenizer,
- AutoImageProcessor
-)
-
-model = VisionTextDualEncoderModel.from_vision_text_pretrained(
- "openai/clip-vit-base-patch32", "roberta-base"
-)
-
-tokenizer = AutoTokenizer.from_pretrained("roberta-base")
-image_processor = AutoImageProcessor.from_pretrained("openai/clip-vit-base-patch32")
-processor = VisionTextDualEncoderProcessor(image_processor, tokenizer)
-
-# save the model and processor
-model.save_pretrained("clip-roberta")
-processor.save_pretrained("clip-roberta")
-```
-
-This loads both the text and vision encoders using pre-trained weights, the projection layers are randomly
-initialized except for CLIP's vision model. If you use CLIP to initialize the vision model then the vision projection weights are also
-loaded using the pre-trained weights.
-
-### Train the model
-Finally, we can run the example script to train the model:
-
-```bash
-python examples/pytorch/contrastive-image-text/run_clip.py \
- --output_dir ./clip-roberta-finetuned \
- --model_name_or_path ./clip-roberta \
- --data_dir $PWD/data \
- --dataset_name ydshieh/coco_dataset_script \
- --dataset_config_name=2017 \
- --image_column image_path \
- --caption_column caption \
- --remove_unused_columns=False \
- --do_train --do_eval \
- --per_device_train_batch_size="64" \
- --per_device_eval_batch_size="64" \
- --learning_rate="5e-5" --warmup_steps="0" --weight_decay 0.1 \
- --overwrite_output_dir \
- --push_to_hub
-```
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/async_timeout/__init__.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/async_timeout/__init__.py
deleted file mode 100644
index 179d1b0a01bd896e9d1cb752a07be0f4422e0146..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/async_timeout/__init__.py
+++ /dev/null
@@ -1,247 +0,0 @@
-import asyncio
-import enum
-import sys
-import warnings
-from types import TracebackType
-from typing import Any, Optional, Type
-
-
-if sys.version_info >= (3, 8):
- from typing import final
-else:
- from typing_extensions import final
-
-
-__version__ = "4.0.2"
-
-
-__all__ = ("timeout", "timeout_at", "Timeout")
-
-
-def timeout(delay: Optional[float]) -> "Timeout":
- """timeout context manager.
-
- Useful in cases when you want to apply timeout logic around block
- of code or in cases when asyncio.wait_for is not suitable. For example:
-
- >>> async with timeout(0.001):
- ... async with aiohttp.get('https://github.com') as r:
- ... await r.text()
-
-
- delay - value in seconds or None to disable timeout logic
- """
- loop = _get_running_loop()
- if delay is not None:
- deadline = loop.time() + delay # type: Optional[float]
- else:
- deadline = None
- return Timeout(deadline, loop)
-
-
-def timeout_at(deadline: Optional[float]) -> "Timeout":
- """Schedule the timeout at absolute time.
-
- deadline argument points on the time in the same clock system
- as loop.time().
-
- Please note: it is not POSIX time but a time with
- undefined starting base, e.g. the time of the system power on.
-
- >>> async with timeout_at(loop.time() + 10):
- ... async with aiohttp.get('https://github.com') as r:
- ... await r.text()
-
-
- """
- loop = _get_running_loop()
- return Timeout(deadline, loop)
-
-
-class _State(enum.Enum):
- INIT = "INIT"
- ENTER = "ENTER"
- TIMEOUT = "TIMEOUT"
- EXIT = "EXIT"
-
-
-@final
-class Timeout:
- # Internal class, please don't instantiate it directly
- # Use timeout() and timeout_at() public factories instead.
- #
- # Implementation note: `async with timeout()` is preferred
- # over `with timeout()`.
- # While technically the Timeout class implementation
- # doesn't need to be async at all,
- # the `async with` statement explicitly points that
- # the context manager should be used from async function context.
- #
- # This design allows to avoid many silly misusages.
- #
- # TimeoutError is raised immadiatelly when scheduled
- # if the deadline is passed.
- # The purpose is to time out as sson as possible
- # without waiting for the next await expression.
-
- __slots__ = ("_deadline", "_loop", "_state", "_timeout_handler")
-
- def __init__(
- self, deadline: Optional[float], loop: asyncio.AbstractEventLoop
- ) -> None:
- self._loop = loop
- self._state = _State.INIT
-
- self._timeout_handler = None # type: Optional[asyncio.Handle]
- if deadline is None:
- self._deadline = None # type: Optional[float]
- else:
- self.update(deadline)
-
- def __enter__(self) -> "Timeout":
- warnings.warn(
- "with timeout() is deprecated, use async with timeout() instead",
- DeprecationWarning,
- stacklevel=2,
- )
- self._do_enter()
- return self
-
- def __exit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> Optional[bool]:
- self._do_exit(exc_type)
- return None
-
- async def __aenter__(self) -> "Timeout":
- self._do_enter()
- return self
-
- async def __aexit__(
- self,
- exc_type: Optional[Type[BaseException]],
- exc_val: Optional[BaseException],
- exc_tb: Optional[TracebackType],
- ) -> Optional[bool]:
- self._do_exit(exc_type)
- return None
-
- @property
- def expired(self) -> bool:
- """Is timeout expired during execution?"""
- return self._state == _State.TIMEOUT
-
- @property
- def deadline(self) -> Optional[float]:
- return self._deadline
-
- def reject(self) -> None:
- """Reject scheduled timeout if any."""
- # cancel is maybe better name but
- # task.cancel() raises CancelledError in asyncio world.
- if self._state not in (_State.INIT, _State.ENTER):
- raise RuntimeError(f"invalid state {self._state.value}")
- self._reject()
-
- def _reject(self) -> None:
- if self._timeout_handler is not None:
- self._timeout_handler.cancel()
- self._timeout_handler = None
-
- def shift(self, delay: float) -> None:
- """Advance timeout on delay seconds.
-
- The delay can be negative.
-
- Raise RuntimeError if shift is called when deadline is not scheduled
- """
- deadline = self._deadline
- if deadline is None:
- raise RuntimeError("cannot shift timeout if deadline is not scheduled")
- self.update(deadline + delay)
-
- def update(self, deadline: float) -> None:
- """Set deadline to absolute value.
-
- deadline argument points on the time in the same clock system
- as loop.time().
-
- If new deadline is in the past the timeout is raised immediatelly.
-
- Please note: it is not POSIX time but a time with
- undefined starting base, e.g. the time of the system power on.
- """
- if self._state == _State.EXIT:
- raise RuntimeError("cannot reschedule after exit from context manager")
- if self._state == _State.TIMEOUT:
- raise RuntimeError("cannot reschedule expired timeout")
- if self._timeout_handler is not None:
- self._timeout_handler.cancel()
- self._deadline = deadline
- if self._state != _State.INIT:
- self._reschedule()
-
- def _reschedule(self) -> None:
- assert self._state == _State.ENTER
- deadline = self._deadline
- if deadline is None:
- return
-
- now = self._loop.time()
- if self._timeout_handler is not None:
- self._timeout_handler.cancel()
-
- task = _current_task(self._loop)
- if deadline <= now:
- self._timeout_handler = self._loop.call_soon(self._on_timeout, task)
- else:
- self._timeout_handler = self._loop.call_at(deadline, self._on_timeout, task)
-
- def _do_enter(self) -> None:
- if self._state != _State.INIT:
- raise RuntimeError(f"invalid state {self._state.value}")
- self._state = _State.ENTER
- self._reschedule()
-
- def _do_exit(self, exc_type: Optional[Type[BaseException]]) -> None:
- if exc_type is asyncio.CancelledError and self._state == _State.TIMEOUT:
- self._timeout_handler = None
- raise asyncio.TimeoutError
- # timeout has not expired
- self._state = _State.EXIT
- self._reject()
- return None
-
- def _on_timeout(self, task: "asyncio.Task[None]") -> None:
- task.cancel()
- self._state = _State.TIMEOUT
- # drop the reference early
- self._timeout_handler = None
-
-
-if sys.version_info >= (3, 7):
-
- def _current_task(loop: asyncio.AbstractEventLoop) -> "Optional[asyncio.Task[Any]]":
- return asyncio.current_task(loop=loop)
-
-else:
-
- def _current_task(loop: asyncio.AbstractEventLoop) -> "Optional[asyncio.Task[Any]]":
- return asyncio.Task.current_task(loop=loop)
-
-
-if sys.version_info >= (3, 7):
-
- def _get_running_loop() -> asyncio.AbstractEventLoop:
- return asyncio.get_running_loop()
-
-else:
-
- def _get_running_loop() -> asyncio.AbstractEventLoop:
- loop = asyncio.get_event_loop()
- if not loop.is_running():
- raise RuntimeError("no running event loop")
- return loop
diff --git a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ufoLib/plistlib.py b/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ufoLib/plistlib.py
deleted file mode 100644
index 1f52f20a2b4836e39d3e292496928185dfe08534..0000000000000000000000000000000000000000
--- a/spaces/chuan-hd/law-assistant-chatbot/.venv/lib/python3.11/site-packages/fontTools/ufoLib/plistlib.py
+++ /dev/null
@@ -1,46 +0,0 @@
-"""DEPRECATED - This module is kept here only as a backward compatibility shim
-for the old ufoLib.plistlib module, which was moved to fontTools.misc.plistlib.
-Please use the latter instead.
-"""
-from fontTools.misc.plistlib import dump, dumps, load, loads
-from fontTools.misc.textTools import tobytes
-
-# The following functions were part of the old py2-like ufoLib.plistlib API.
-# They are kept only for backward compatiblity.
-from fontTools.ufoLib.utils import deprecated
-
-
-@deprecated("Use 'fontTools.misc.plistlib.load' instead")
-def readPlist(path_or_file):
- did_open = False
- if isinstance(path_or_file, str):
- path_or_file = open(path_or_file, "rb")
- did_open = True
- try:
- return load(path_or_file, use_builtin_types=False)
- finally:
- if did_open:
- path_or_file.close()
-
-
-@deprecated("Use 'fontTools.misc.plistlib.dump' instead")
-def writePlist(value, path_or_file):
- did_open = False
- if isinstance(path_or_file, str):
- path_or_file = open(path_or_file, "wb")
- did_open = True
- try:
- dump(value, path_or_file, use_builtin_types=False)
- finally:
- if did_open:
- path_or_file.close()
-
-
-@deprecated("Use 'fontTools.misc.plistlib.loads' instead")
-def readPlistFromString(data):
- return loads(tobytes(data, encoding="utf-8"), use_builtin_types=False)
-
-
-@deprecated("Use 'fontTools.misc.plistlib.dumps' instead")
-def writePlistToString(value):
- return dumps(value, use_builtin_types=False)
diff --git a/spaces/cihyFjudo/fairness-paper-search/Download Uyire Unakkaga Tamil Movie Songs in 1080p and 720p Quality.md b/spaces/cihyFjudo/fairness-paper-search/Download Uyire Unakkaga Tamil Movie Songs in 1080p and 720p Quality.md
deleted file mode 100644
index d9072a0ea996bf985e7cc9a278433f9005c9947a..0000000000000000000000000000000000000000
--- a/spaces/cihyFjudo/fairness-paper-search/Download Uyire Unakkaga Tamil Movie Songs in 1080p and 720p Quality.md
+++ /dev/null
@@ -1,7 +0,0 @@
-Pallavi Illamal Search Terms:
-Ododi Vilaiyadu Search Terms:
-Uyire Unakkaga Tamil Movie Songs Free Download Download ✺ https://tinurli.com/2uwjFg
Attention please : BollyGane never tends to provide any type of copyright contents or any copyright mp3 songs to download for free. We also need to say here that this website only store the songs information and not their physical files on its server also, We never hosted or store such copyright contents on our servers. Also this websites only store and includes such songs informations that are easily available in various search engines. In case of any type of copyright issue those websites are only responsible who stored such songs physical files on their own servers. If then also anyone feels that we and our website is indulging any of such copyright issue then just send an email to the suitable person and those hsting providers which are really providing users the physical files of such songs.If you want that any copyright content should be removed from our website then please do contact on given email id. DMCA POLICY
aaccfb2cb3OmniFocus Pro 3.1.4 Crack Mac Osx Download Zip 🔗 https://tinurli.com/2uwkNW
diff --git a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/_a_v_a_r.py b/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/_a_v_a_r.py
deleted file mode 100644
index 39039cf73a5346db144f39bd8c046a76bd52af31..0000000000000000000000000000000000000000
--- a/spaces/cloudtheboi/Lofi4All/.pythonlibs/lib/python3.10/site-packages/fontTools/ttLib/tables/_a_v_a_r.py
+++ /dev/null
@@ -1,138 +0,0 @@
-from fontTools.misc import sstruct
-from fontTools.misc.fixedTools import (
- fixedToFloat as fi2fl,
- floatToFixed as fl2fi,
- floatToFixedToStr as fl2str,
- strToFixedToFloat as str2fl,
-)
-from fontTools.misc.textTools import bytesjoin, safeEval
-from fontTools.ttLib import TTLibError
-from . import DefaultTable
-from . import otTables
-import struct
-import logging
-
-
-log = logging.getLogger(__name__)
-
-from .otBase import BaseTTXConverter
-
-
-class table__a_v_a_r(BaseTTXConverter):
- """Axis Variations Table
-
- This class represents the ``avar`` table of a variable font. The object has one
- substantive attribute, ``segments``, which maps axis tags to a segments dictionary::
-
- >>> font["avar"].segments # doctest: +SKIP
- {'wght': {-1.0: -1.0,
- 0.0: 0.0,
- 0.125: 0.11444091796875,
- 0.25: 0.23492431640625,
- 0.5: 0.35540771484375,
- 0.625: 0.5,
- 0.75: 0.6566162109375,
- 0.875: 0.81927490234375,
- 1.0: 1.0},
- 'ital': {-1.0: -1.0, 0.0: 0.0, 1.0: 1.0}}
-
- Notice that the segments dictionary is made up of normalized values. A valid
- ``avar`` segment mapping must contain the entries ``-1.0: -1.0, 0.0: 0.0, 1.0: 1.0``.
- fontTools does not enforce this, so it is your responsibility to ensure that
- mappings are valid.
- """
-
- dependencies = ["fvar"]
-
- def __init__(self, tag=None):
- super().__init__(tag)
- self.segments = {}
-
- def compile(self, ttFont):
- axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
- if not hasattr(self, "table"):
- self.table = otTables.avar()
- if not hasattr(self.table, "Reserved"):
- self.table.Reserved = 0
- self.table.Version = (getattr(self, "majorVersion", 1) << 16) | getattr(
- self, "minorVersion", 0
- )
- self.table.AxisCount = len(axisTags)
- self.table.AxisSegmentMap = []
- for axis in axisTags:
- mappings = self.segments[axis]
- segmentMap = otTables.AxisSegmentMap()
- segmentMap.PositionMapCount = len(mappings)
- segmentMap.AxisValueMap = []
- for key, value in sorted(mappings.items()):
- valueMap = otTables.AxisValueMap()
- valueMap.FromCoordinate = key
- valueMap.ToCoordinate = value
- segmentMap.AxisValueMap.append(valueMap)
- self.table.AxisSegmentMap.append(segmentMap)
- return super().compile(ttFont)
-
- def decompile(self, data, ttFont):
- super().decompile(data, ttFont)
- assert self.table.Version >= 0x00010000
- self.majorVersion = self.table.Version >> 16
- self.minorVersion = self.table.Version & 0xFFFF
- axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
- for axis in axisTags:
- self.segments[axis] = {}
- for axis, segmentMap in zip(axisTags, self.table.AxisSegmentMap):
- segments = self.segments[axis] = {}
- for segment in segmentMap.AxisValueMap:
- segments[segment.FromCoordinate] = segment.ToCoordinate
-
- def toXML(self, writer, ttFont):
- writer.simpletag(
- "version",
- major=getattr(self, "majorVersion", 1),
- minor=getattr(self, "minorVersion", 0),
- )
- writer.newline()
- axisTags = [axis.axisTag for axis in ttFont["fvar"].axes]
- for axis in axisTags:
- writer.begintag("segment", axis=axis)
- writer.newline()
- for key, value in sorted(self.segments[axis].items()):
- key = fl2str(key, 14)
- value = fl2str(value, 14)
- writer.simpletag("mapping", **{"from": key, "to": value})
- writer.newline()
- writer.endtag("segment")
- writer.newline()
- if getattr(self, "majorVersion", 1) >= 2:
- if self.table.VarIdxMap:
- self.table.VarIdxMap.toXML(writer, ttFont, name="VarIdxMap")
- if self.table.VarStore:
- self.table.VarStore.toXML(writer, ttFont)
-
- def fromXML(self, name, attrs, content, ttFont):
- if not hasattr(self, "table"):
- self.table = otTables.avar()
- if not hasattr(self.table, "Reserved"):
- self.table.Reserved = 0
- if name == "version":
- self.majorVersion = safeEval(attrs["major"])
- self.minorVersion = safeEval(attrs["minor"])
- self.table.Version = (getattr(self, "majorVersion", 1) << 16) | getattr(
- self, "minorVersion", 0
- )
- elif name == "segment":
- axis = attrs["axis"]
- segment = self.segments[axis] = {}
- for element in content:
- if isinstance(element, tuple):
- elementName, elementAttrs, _ = element
- if elementName == "mapping":
- fromValue = str2fl(elementAttrs["from"], 14)
- toValue = str2fl(elementAttrs["to"], 14)
- if fromValue in segment:
- log.warning(
- "duplicate entry for %s in axis '%s'", fromValue, axis
- )
- segment[fromValue] = toValue
- else:
- super().fromXML(name, attrs, content, ttFont)
diff --git a/spaces/cncn102/bingo1/README.md b/spaces/cncn102/bingo1/README.md
deleted file mode 100644
index d65eafbc8431818f738e8e086455fa6159f101bb..0000000000000000000000000000000000000000
--- a/spaces/cncn102/bingo1/README.md
+++ /dev/null
@@ -1,196 +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://bing.github1s.tk
-
-
-
-[](https://bing.github1s.tk)
-
-## 功能和特点
-
-- 完全基于 Next.js 重写，高度还原 New Bing Web 版 UI，使用体验和 Bing AI 基本一致。
-- 支持 Docker 构建，方便快捷地部署和访问。
-- Cookie 可全局配置，全局共享。
-- 支持持续语音对话
-
-## RoadMap
-
- - [x] 支持 wss 转发
- - [x] 支持一键部署
- - [x] 优化移动端展示
- - [x] 支持画图
- - [x] 支持语音输入(支持语音指令，目前仅支持 PC 版 Edge 及 Chrome 浏览器)
- - [x] 支持语音输出(需要手动开启)
- - [x] 支持图片输入
- - [x] 支持自定义域名
- - [ ] 支持历史记录
- - [ ] 适配深色模式
- - [ ] 支持内置提示词
- - [ ] 支持离线访问
- - [ ] 国际化翻译
-
-## 一键部署
-你也可以一键部署自己的 New Bing AI 到 🤗 HuggingFace 。
-
-### 部署到 Huggingface
-1. 点击此图标
-[](https://huggingface.co/login?next=%2Fspaces%2Fhf4all%2Fbingo%3Fduplicate%3Dtrue%26visibility%3Dpublic)，配置可以不改。
-
-2. 部署署完成后，点击“设置” 》“站点域名”，点一下，复制一下 HF 域名信息，然后分享给别人即可。
-
-> Huggingface 不支持绑定自己的域名，不过我们可以使用曲线救国的方式来达到这个目的
-> 1. 方式二，借助 Cloudflare Workers [部署Cloudflare Workers](#使用Cloudflare-Workers自定义域名)
-> 2. 方式一，借助 Github Pages 及 iframe [如何绑定域名](https://github.com/weaigc/bingo/issues/4)
-
-### 使用Cloudflare Workers自定义域名
-
-> 核心代码 [worker.js](./cloudflare/worker.js)
-
-- [注册 Cloudflare 账号](https://dash.cloudflare.com/sign-up)
-
-- 添加一个新的网站，需要你有自己的域名并且将域名`Name Server`托管给 Cloudflare 才行（更多信息可自行 Google)
-
-- 通过左侧菜单进入「Workers」，并点击「Create a Worker」。
-
-- 创建 Worker 服务，复制 [worker.js](./cloudflare/worker.js) 全部代码，粘贴至创建的服务中，根据注释进行改动，保存并部署。
-
-- 触发器 中自定义访问域名。
-
-### 部署其它平台
-
-
-由于其他平台目前遭到 New Bing 封杀，会遇到很多问题，不再做推荐，有需要的可以自行查看
-
-
-#### 部署到 Netlify
-[](https://app.netlify.com/start/deploy?repository=https://github.com/weaigc/bingo)
-
-#### 部署到 Vercel
-如果你是 Vercel 付费用户，可以点以下链接一键部署到 Vercel。免费版本有[接口超时限制](https://vercel.com/docs/concepts/limits/overview)，不推荐使用
-
-[](https://vercel.com/new/clone?demo-title=bingo&demo-description=bingo&demo-url=https%3A%2F%2Fbing.github1s.tk%2F&project-name=bingo&repository-name=bingo&repository-url=https%3A%2F%2Fgithub.com%2Fweaigc%2Fbingo&from=templates&skippable-integrations=1&env=BING_HEADER&envDescription=%E5%A6%82%E6%9E%9C%E4%B8%8D%E7%9F%A5%E9%81%93%E6%80%8E%E4%B9%88%E9%85%8D%E7%BD%AE%E8%AF%B7%E7%82%B9%E5%8F%B3%E4%BE%A7Learn+More&envLink=https%3A%2F%2Fgithub.com%2Fweaigc%2Fbingo%2Fblob%2Fmain%2F.env.example)
-
-#### 部署到 Render
-
-[](https://render.com/deploy?repo=https://github.com/weaigc/bingo)
-
-
-## 环境和依赖
-
-- Node.js >= 18
-- Bing AI 的[身份信息](#如何获取-BING_HEADER))
-
-## 安装和使用
-
-> 由于目前微软封杀比较严重，推荐优先使用 [部署 Huggingface](#部署到-huggingface) 。
-
-* 使用 Node 启动
-
-```bash
-git clone https://github.com/weaigc/bingo.git
-npm i # 推荐使用 pnpm i
-npm run build
-npm run start
-```
-
-* 使用 Docker 启动
-```bash
-docker pull weaigc/bingo
-docker run --rm -it -p 7860:7860 weaigc/bingo
-# 或者
-docker run --rm -it -e BING_HEADER=xxxx -p 7860:7860 weaigc/bingo
-```
-
-## 如何获取 BING_HEADER
-> 配置了 BING_HEADER 意味着你将自己的账号共享给所有使用此服务的人，如果不需要免登录画图的功能，不建议设置此变量
-
-打开 https://www.bing.com 并登录，然后访问 https://www.bing.com/turing/captcha/challenge ，通过人机校验，然后
-
-
-
-> 复制出来的内容应该如下所示。确认格式无误后，打开 https://effulgent-bubblegum-e2f5df.netlify.app/#dialog=%22settings%22 ，粘贴进去，点击“转成 BING_HEADER 并复制”，然后从剪切板粘贴即可得到。（你也可以先在网页上进行验证）
-
-以下是格式参考，需要注意的是，网页端保存的格式是以`curl`开头, 而服务端配置的 `BING_HEADER` 是 `base64` 格式，两者不能互通。
-
-正常格式/网页端保存的格式(格式仅供参考)
-
-```
-curl 'https://www.bing.com/turing/captcha/challenge' \
- -H 'authority: www.bing.com' \
- -H 'accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7' \
- -H 'accept-language: zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6' \
- -H 'cache-control: max-age=0' \
- -H 'cookie: MicrosoftApplicationsTelemetryDeviceId=3399c004-fd0e-48ec-bb92-d82a27b2bbd4; _EDGE_V=1; SRCHD=AF=NOFORM; SRCHUID=V=2&GUID=29EBDDA4E6674329ACCF1A0A423C3E98&dmnchg=1; _UR=QS=0&TQS=0; _HPVN=CS=eyJQbiI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiUCJ9LCJTYyI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiSCJ9LCJReiI6eyJDbiI6MSwiU3QiOjAsIlFzIjowLCJQcm9kIjoiVCJ9LCJBcCI6dHJ1ZSwiTXV0ZSI6dHJ1ZSwiTGFkIjoiMjAyMy0wNy0yNVQwMDowMDowMFoiLCJJb3RkIjowLCJHd2IiOjAsIkRmdCI6bnVsbCwiTXZzIjowLCJGbHQiOjAsIkltcCI6Mn0=; _RwBf=ilt=1&ihpd=1&ispd=0&rc=0&rb=0&gb=0&rg=200&pc=0&mtu=0&rbb=0&g=0&cid=&clo=0&v=1&l=2023-07-25T07:00:00.0000000Z&lft=0001-01-01T00:00:00.0000000&aof=0&o=2&p=&c=&t=0&s=0001-01-01T00:00:00.0000000+00:00&ts=2023-07-25T11:00:31.7111548+00:00&rwred=0&wls=&lka=0&lkt=0&TH=&dci=0; ANON=A=0043C6590EA808ED6E395059FFFFFFFF&E=1c8b&W=1; NAP=V=1.9&E=1c31&C=DnaMSbDN_4efZ_xXqBF3Daorjr53kYqYoaP8YHsupjmiXnysX7a37A&W=1; PPLState=1; KievRPSSecAuth=FABSBBRaTOJILtFsMkpLVWSG6AN6C/svRwNmAAAEgAAACMGUA7EGVSjGEAQBGHtNsc5sNL7unmJsfPJ2t6imfo4BeUJlAia3IpMTtMUy4PU/C5QAzRI5pODtsIee0+blgllXt/5IiWwGjwmdhivsFM597pRPkjARPfwsPhNLPNbJrCPNPHdje4Is78MnCADXw6/NBq2FL8V2/byw2fH6IuAMD2MvN/VvqpEa9ZxiDjZtENj4HEj0mO2SgzjfyEhVAkjvznJqU2rw/Q2tHmX94NAM2kzlzKF/hWPhCCUmu8IHLvCnHDS6mSptvJDDP/sp3ovtzOXkP1mlM/Xju5ftesUvccVEQGffXORa1dE5hEMbKIiKXz1tDdduSXE19g9/+mRMAjaQhpwhI8XmilCTx1adb1Ll5qK+VjC9GNfEZzcbsGBPVaOl+anG8rEMq+Xnhjo7J+NqTNolavHgcuV8kJsCeJZIged33UA8eOZeFo+wAECMguxMoSqgpGH+sthqynvD/FJD6r/tiU2N3uqVq8NE8V37asrN6T14Z0FGBJOe6ET1+PGApm3s11OY9/xhFEB9T5BEPUGEbvRcLcW2ncFQX0EU+xweiPqo1Q1hNUg/dCtSI+lZ7c2H8XheePZavZ0TJQ8oNCSAuKiTqJmI0fVGpwbXwfaADkEipuawz3fIuMJBNgMU0OtA7Hm59v2fGLIBuvi6YeKS6GgVk3BIPf+P/eKahwozrxQZaFnoHTSqMkvct7xCP4atBROfXKf5Ww0CcFKp+2WX9BIskTOo2jjk6bAyyYJ+ElUB1fgLKNk5m/YSMc9iYCLIBMIGN8F0Yvy3tZ7cvh7Ue5Klo98US/I+nW1G7ZJMHRgUO8h8lpneHqEMegKd8gynO4VF7RpCjJkunDmW0Ta+RkXAP619pg0dqHMFkoOgknN78oBbGTV6fJUKotv+vi61kLhAeXZGWoHGCRXh2wUC6YgfPgKA6ESRNHtFn7E5B3HHpLc5rVMDSNhKZYfdhupV4Ezf6+5DhMcZLZhi0kk+ivDiN1gdHlVtSN55xpvf+c+XZDzR0uhgcvgy0LAbmzgk6y4WbYH+LQsMpzNNj+aC72vMiWovWrKh9jY4MYCmdgxsS/skPtLdp18muiEIRXTbZQGUmhxFpJAIbBIsCscMpzL0BgeujxUwM5wr79Sd9r4xwbgSMwmBlBfUHRVBdNyg8feepeJbCS63nD6eHOuLqMRsPIio3w/ki/EAa92UUEiZeavLsMUD/y/qAvWUdzdP5Y+C/TM+CMGS/kGL4LEdY/28MQeTvU1qv1X21kQt2aiaj3pPVL36hAzxbcLgqcMo9oymDRy87kdCXW/+g4oKLtMh6fm/G6W6Y/B01JlxohyyvueHQIG557uzkEkTJ3FnOVODSKBKpb3WZ65rExfV71zSZa25F3GmpaIG6HiYrX2YYhQAkIE9pKEQBHbnwHuwNDGottZTXZw=; WLS=C=9df3f9d8518fae19&N=wen; WLID=pGY8HgWCu4p5XYCOk2oa0+DBdftkMUfmNIn8XtSjSTKsgv/Il7GUlYs0Jpjf/E12jZMgV7x44Dy3fXOgjjUoJx7Y/ClLrLhsk20THksJJoI=; _EDGE_S=F=1&SID=17CF6EE006426448213C7DB907436588&mkt=zh-CN; MUID=225621093D8A6C27301632413C0E6D08; MUIDB=225621093D8A6C27301632413C0E6D08; SUID=A; SNRHOP=I=&TS=; _U=nGyzKQruEsDwLiu65fZFIG6e12hf2lwTJmroW__k8joUJIKmG3OIjayXKGW9dCVR3sNhF76mEVxyW6yjUGPodOfjtSa3s3J_DxMOrEK1BqXCOBI9bC66spAIASV7prsYFlVAJz73jVNENp_tBubLHJy6EbT0BKRe4AjrYkH-9uMnmCKB8Zmyg; _SS=SID=17CF6EE006426448213C7DB907436588&R=0&RB=0&GB=0&RG=200&RP=0&PC=U531; SRCHS=PC=U531; USRLOC=HS=1&ELOC=LAT=22.501529693603516|LON=113.9263687133789|N=%E5%8D%97%E5%B1%B1%E5%8C%BA%EF%BC%8C%E5%B9%BF%E4%B8%9C%E7%9C%81|ELT=2|&CLOC=LAT=22.50153029046461|LON=113.92637070632928|A=733.4464586120832|TS=230726151034|SRC=W; SRCHUSR=DOB=20230725&T=1690384908000&POEX=W; ipv6=hit=1690388509974&t=6; SRCHHPGUSR=HV=1690384945&SRCHLANG=zh-Hans&PV=15.0.0&BRW=MW&BRH=MT&CW=410&CH=794&SCW=410&SCH=794&DPR=1.5&UTC=480&DM=0&WTS=63825879627&PRVCW=410&PRVCH=794&PR=1.5; cct=AjWIBYOoVP-Afq6gWwtx80If6yHn6iBuEVHA1XHdAKpny6Y_CVyi_MSyM94VyMWnjdYkkccVtm3czoIAtXUGQA; GC=AjWIBYOoVP-Afq6gWwtx80If6yHn6iBuEVHA1XHdAKpR3Y_D9Ytcks4Ht6XhadXk75dvhzP4YOUS0UmoEyqyxw' \
- -H 'dnt: 1' \
- -H 'sec-ch-ua: "Chromium";v="116", "Not)A;Brand";v="24", "Microsoft Edge";v="116"' \
- -H 'sec-ch-ua-arch: "x86"' \
- -H 'sec-ch-ua-bitness: "64"' \
- -H 'sec-ch-ua-full-version: "116.0.1938.29"' \
- -H 'sec-ch-ua-full-version-list: "Chromium";v="116.0.5845.42", "Not)A;Brand";v="24.0.0.0", "Microsoft Edge";v="116.0.1938.29"' \
- -H 'sec-ch-ua-mobile: ?0' \
- -H 'sec-ch-ua-model: ""' \
- -H 'sec-ch-ua-platform: "Windows"' \
- -H 'sec-ch-ua-platform-version: "15.0.0"' \
- -H 'sec-fetch-dest: document' \
- -H 'sec-fetch-mode: navigate' \
- -H 'sec-fetch-site: none' \
- -H 'sec-fetch-user: ?1' \
- -H 'sec-ms-gec: B3F47AD4A283CAB374C0451C46AAFD147C6A4DACAFF6A1C13F34B2C72B024494' \
- -H 'sec-ms-gec-version: 1-116.0.1938.29' \
- -H 'upgrade-insecure-requests: 1' \
- -H 'user-agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/116.0.0.0 Safari/537.36 Edg/116.0.0.0' \
- -H 'x-client-data: eyIxIjoiMiIsIjEwIjoiXCJTMGg3R05HOTF2aDQ1TUZSUnZ5NHN2akRmMWdlaVJKenNxNlA3aU1WbnF3PVwiIiwiMiI6IjEiLCIzIjoiMSIsIjQiOiIyMTU4ODQ5NTM4MjY4OTM5NTA3IiwiNSI6IlwiSm9GUWpPTDk3OS9MbkRRZnlCd2N1M2FsOUN3eTZTQmdaMGNYMXBtOWVMZz1cIiIsIjYiOiJiZXRhIiwiNyI6IjE4MDM4ODYyNjQzNSIsIjkiOiJkZXNrdG9wIn0=' \
- -H 'x-edge-shopping-flag: 1' \
- --compressed
-```
-
-
-
-转成base64之后的格式(BING_HEADER只能使用 base64 之后的格式)
-
-```
-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
-```
-
-
-
-## 鸣谢
- - 感谢 [EdgeGPT](https://github.com/acheong08/EdgeGPT) 提供的代理 API 的方法。
- - 感谢 [Vercel AI](https://github.com/vercel-labs/ai-chatbot) 提供的基础脚手架和 [ChatHub](https://github.com/chathub-dev/chathub) [go-proxy-bingai](https://github.com/adams549659584/go-proxy-bingai) 提供的部分代码。
-
-
-## 答疑及交流
-
-How to Play Nintendo Games on Your PC or Mobile Device with Dolphin Emulator Apkmody
-Do you miss playing your favorite Nintendo games from the GameCube and Wii era? Do you want to experience them in high definition, with improved graphics and performance? Do you want to use different controllers, play online with friends, or mod your games with apkmody? If you answered yes to any of these questions, then you might want to try dolphin emulator apkmody.
-Dolphin emulator is a free and open-source program that lets you play Nintendo GameCube and Wii games on your computer or mobile device. Apkmody is a website that offers modded APK files for Android games and apps, which can enhance your gaming experience with features like unlimited money, unlocked items, or cheats. In this article, we will give you an overview of dolphin emulator, its features, pros and cons, and some alternatives. We will also create some graphic art for you based on your topic.
-dolphin emulator apkmody Download Zip ☆☆☆ https://urlca.com/2uO8xM
Features of Dolphin Emulator
-Dolphin emulator has many features that make it one of the best emulators for Nintendo games. Here are some of them:
-
-High compatibility and performance: Dolphin emulator can run most GameCube and Wii games at full speed, with minimal glitches or errors. You can also adjust the settings to optimize the performance for your device.Graphical enhancements and customization: Dolphin emulator allows you to play games in full HD (1080p) or higher resolutions, with anti-aliasing, anisotropic filtering, shaders, and other effects. You can also customize the aspect ratio, window size, frame rate, and more.Controller support and netplay: Dolphin emulator supports various input devices, including keyboard, mouse, gamepad, Wiimote, GameCube controller, and more. You can also play online with other players using the netplay feature.Wii motion controls and online services: Dolphin emulator can emulate the Wii's motion controls using your mouse, keyboard, gamepad, or actual Wiimote with a Bluetooth adapter. You can also access the Wii's online services, such as the Wii Shop Channel or Nintendo Wi-Fi Connection.
- Pros and Cons of Dolphin Emulator
-Dolphin emulator has many advantages, but it also has some drawbacks. Here are some of them:
-
-Pros:
-
-You can play classic Nintendo games in HD, with improved graphics and performance.
-You can use various controllers, including the original ones for each console.
-You can enjoy multiplayer modes, either locally or online.
-You can mod your games with apkmody or other sources.
-You can save your progress anytime with save states.
-
-Cons:
-
-You need a powerful device to run dolphin emulator smoothly.
-Some games may have glitches or compatibility issues.
-You may You may face some legal issues with ROMs, depending on where you live and how you obtain them. ROMs are copyrighted material, and downloading or sharing them without permission is illegal. However, some people argue that downloading ROMs of games that you own physically is fair use, but this is not a clear-cut case. You should be aware of the risks and consequences of using ROMs before you decide to do so . How to Mod Games with Apkmody
-If you want to mod your games with apkmody, you will need to download the modded APK files from their website. APK files are the installation files for Android apps, and modded APK files are modified versions of the original apps that have extra features or cheats. Apkmody offers a variety of modded APK files for different games and genres, such as action, adventure, arcade, puzzle, racing, role-playing, simulation, sports, strategy, and more. You can browse their categories or use the search function to find the game you want to mod.
-To install the modded APK files, you will need to enable the option to install apps from unknown sources on your device. This option is usually found in the security settings of your device. Once you enable it, you can download the modded APK file from apkmody and tap on it to install it. You may also need to uninstall the original app if you have it installed already. After installing the modded app, you can launch it and enjoy the game with the modded features.
-Some of the benefits of using apkmody are:
-
-You can access premium features or items for free.
-You can get unlimited money, coins, gems, or other resources.
-You can unlock all levels, characters, skins, weapons, or other content.
-You can activate cheats or hacks, such as god mode, one-hit kill, speed hack, etc.
-You can customize the game settings or graphics to your preference.
-
-However, there are also some drawbacks of using apkmody, such as:
-dolphin emulator apk mod download
-
-You may encounter compatibility issues or bugs with some games or devices.
-You may get banned from online services or multiplayer modes if detected by the game developers.
-You may lose your progress or data if you uninstall the original app or update the modded app.
-You may expose your device to malware or viruses if you download from untrusted sources.
-You may violate the terms of service or intellectual property rights of the game developers.
- Alternatives to Dolphin Emulator
-If you are looking for other ways to play Nintendo games on your PC or mobile device, you may want to check out some of these alternatives to dolphin emulator:
-
-Cemu: This is a Wii U emulator for Windows that can run many games at 4K resolution and 60 FPS. It also supports online multiplayer, motion controls, and game mods. However, it requires a powerful PC and a Wii U console to dump the games and keys .OpenEmu: This is a multi-system emulator for macOS that can run games from various consoles, including the GameCube and Wii. It has a user-friendly interface, controller support, save states, and filters. However, it does not support online multiplayer, motion controls, or game mods .PrimeHack: This is a modified version of dolphin emulator that is optimized for the Metroid Prime Trilogy. It allows you to play the games with mouse and keyboard controls, as well as improved graphics and performance. However, it only works with the Metroid Prime Trilogy and requires a specific version of dolphin emulator .WhineCube: This is a GameCube emulator for Windows that can run some games at full speed and with sound. It also supports controller input and save states. However, it does not support Wii games, online multiplayer, motion controls, or game mods .Touchmote: This is a program that lets you use your Wiimote as a mouse or gamepad on Windows. It can work with dolphin emulator or any other program that supports mouse or gamepad input. However, it does not support motion controls or online services .
- Conclusion
-In this article, we have given you an overview of dolphin emulator apkmody, its features, pros and cons, and some alternatives. Dolphin emulator is a great way to play Nintendo GameCube and Wii games on your PC or mobile device, with enhanced graphics and performance, controller support, online multiplayer, motion controls, and game mods. Apkmody is a website that offers modded APK files for Android games and apps, which can give you access to premium features, unlimited resources, cheats, and more.
-However, dolphin emulator also has some drawbacks, such as requiring a powerful device, having some compatibility issues, and facing legal risks with ROMs. Apkmody also has some disadvantages, such as causing bugs or bans, losing data or progress, and violating intellectual property rights. You should be aware of these factors before you decide to use them.
-If you want to try dolphin emulator apkmody, here are some tips and tricks for you:
-
-Download the latest version of dolphin emulator from their official website or their Google Play Store page.
-Download the modded APK files from apkmody's website or their app. Make sure to enable the option to install apps from unknown sources on your device.
-Download the ROMs of the games you want to play from reputable sources. Make sure they are in ISO or WBFS format and compatible with dolphin emulator.
-Launch dolphin emulator and add the ROMs to your library. You can also configure the settings to optimize the performance and graphics for your device.
-Launch the modded app and enjoy the game with the modded features.
-
-We hope you found this article helpful and informative. If you have any questions or feedback about dolphin emulator apkmody, feel free to leave a comment below or contact us through our website. We would love to hear from you!
- Frequently Asked Questions
-
-Q: Is dolphin emulator safe? A: Dolphin emulator is safe to use as long as you download it from their official website or their Google Play Store page. However, you should be careful about downloading ROMs or modded APK files from untrusted sources, as they may contain malware or viruses.
-Q: Is dolphin emulator legal? A: Dolphin emulator is legal to use as long as you own the original games that you are emulating. However, downloading or sharing ROMs without permission is illegal in most countries. You should check the laws in your region before you use ROMs.
-Q: How do I update dolphin emulator? A: You can update dolphin emulator by You can update dolphin emulator by downloading the latest version from their official website or their Google Play Store page. You can also enable the auto-update option in the settings to get the latest updates automatically. Q: How do I use apkmody? A: You can use apkmody by downloading the modded APK files from their website or their app. You will need to enable the option to install apps from unknown sources on your device. You may also need to uninstall the original app if you have it installed already. Then, you can install the modded app and enjoy the game with the modded features.
-Q: What are some of the best games to play with dolphin emulator apkmody? A: Some of the best games to play with dolphin emulator apkmody are:
-
-Super Mario Galaxy 1 and 2: These are platform games that feature gravity-defying levels, colorful graphics, and fun gameplay. You can play them in HD, with improved performance, and with various controllers.
-The Legend of Zelda: Twilight Princess and Skyward Sword: These are action-adventure games that feature epic stories, puzzles, and combat. You can play them in HD, with enhanced graphics, and with motion controls.
-Mario Kart Wii: This is a racing game that features various characters, tracks, and items. You can play it in HD, with improved performance, and with online multiplayer.
-Resident Evil 4: This is a survival horror game that features a thrilling story, intense action, and scary enemies. You can play it in HD, with enhanced graphics, and with various controllers.
-New Super Mario Bros. Wii: This is a platform game that features classic gameplay, colorful graphics, and multiplayer modes. You can play it in HD, with improved performance, and with various controllers.
-
-
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Download Chess Royale The Ultimate Mobile Chess Experience.md b/spaces/congsaPfin/Manga-OCR/logs/Download Chess Royale The Ultimate Mobile Chess Experience.md
deleted file mode 100644
index c8f18e32ab0d0b1ecdb458efb33d46f7c359e367..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Download Chess Royale The Ultimate Mobile Chess Experience.md
+++ /dev/null
@@ -1,127 +0,0 @@
-
-
Download Chess Royale: A Game of Strategy and Magic
-
If you love chess, but you are looking for something more exciting and challenging, then you should try Chess Royale. Chess Royale is not your standard chess game, it's a game of magical powers, where the kings are the key to winning. You need to defeat the enemy king by combining moves and utilizing magical abilities to come up with a winning strategy. Use your logic, set up your strategy, and win the match!
-
download chess royale Download ✦✦✦ https://urlca.com/2uOd6O
-
What is Chess Royale?
-
Chess Royale is a chess game with a twist. It was developed by Mewton Games and released in 2021 for Android devices, in 2022 for Steam, and in 2023 for web browsers and iOS devices . It has over 50 million players across all platforms and has received positive reviews from critics and users alike.
-
A chess game with a twist
-
Chess Royale is based on the classic rules of chess, but it adds some new elements to make it more fun and dynamic. The most important difference is that each king has a health bar and can move around the board like any other piece. The goal of the game is not to checkmate the enemy king, but to reduce his health to zero by attacking him with your pieces or using magical abilities. The game ends when one of the kings dies or when the time runs out.
-
How to play Chess Royale
-
To play Chess Royale, you need to select a game mode, a board, and a set of pieces. Then, you can either play against the AI, against a friend, or against a random online opponent. You can also enter or create tournaments of various formats for more multiplayer fun.
-
download chess royale app
-
The game starts with each player having 16 pieces: one king, one queen, two rooks, two bishops, two knights, and eight pawns. The pieces move according to the standard chess rules, except for the king, which can move one square in any direction. Each piece has an attack value and a defense value, which determine how much damage they deal or receive when they capture or are captured by another piece.
-
Each player also has a deck of cards that represent magical abilities. These cards can be used to cast spells on the board, such as healing your king, damaging the enemy king, moving pieces around, changing the board layout, and more. Each card has a cost in mana points, which are replenished every turn. You can drag and drop the cards on the board to activate them.
-
Why play Chess Royale
-
Chess Royale is a game that will appeal to both chess enthusiasts and casual gamers. It offers a unique and exciting way to enjoy one of the world's oldest and most popular board games. It also provides many benefits for your brain, such as improving your strategic skills, developing logical and lateral thinking, enhancing your memory, and learning psychology.
-
Chess Royale is also fun and entertaining. It has colorful graphics, smooth animations, realistic sound effects, and catchy music. It also has dozens of unique boards, pieces, and avatars that you can customize to create your own playing environment. And it has a friendly and active community of players that you can chat with, challenge, or join in tournaments.
-
Features of Chess Royale
-
Chess Royale has many features that make it stand out from other chess games. Here are some of them:
-
Multiple game modes
-
You can choose from eight different game modes to suit your preferences and skills. You can play blitzes with varying time limitations, from 1 minute to 10 minutes per player. You can use the notifications system to play with friends when they are online. You can test yourself in private against the game's AI, which has three difficulty levels: easy, medium, and hard. You can play classic chess with no magic cards or special rules. You can play random chess, where the pieces are shuffled at the start of the game. You can play chess 960, where the pieces are randomly placed on the back rank. You can play king of the hill, where you need to move your king to the center of the board to win. And you can play chess royale, where you use magic cards and try to kill the enemy king.
-
Customizable boards and pieces
-
You can personalize your chess experience by choosing from over 50 different boards and pieces. You can select from various themes, such as medieval, fantasy, sci-fi, oriental, and more. You can also unlock new boards and pieces by completing achievements, winning tournaments, or buying them with in-game currency. You can mix and match different boards and pieces to create your own style.
-
Magical abilities and cards
-
You can spice up your chess game by using magic cards that give you special powers. You can collect over 100 different cards that have various effects on the board, such as healing, damaging, moving, swapping, transforming, freezing, burning, and more. You can also upgrade your cards to make them more powerful and effective. You can build your own deck of cards that suits your strategy and play style.
-
Online multiplayer and tournaments
-
You can challenge other players from around the world in online matches and tournaments. You can play with anyone who is online or invite your friends to join you. You can also create or join tournaments of different formats, such as round-robin, knockout, swiss, or ladder. You can compete for prizes, rankings, and glory in the global leaderboards.
-
How to download Chess Royale
-
If you want to play Chess Royale, you need to download it on your device. Here are the steps for downloading Chess Royale on different platforms:
-
For Android devices
-
If you have an Android device, you can download Chess Royale from the Google Play Store. Here is how:
-
-Open the Google Play Store app on your device.
-Search for Chess Royale in the search bar.
-Tap on the Chess Royale icon that appears in the results.
-Tap on the Install button to download and install the game.
-Once the installation is complete, tap on the Open button to launch the game.
-
-
For iOS devices
-
If you have an iOS device, you can download Chess Royale from the App Store. Here is how:
-
-Open the App Store app on your device.
-Search for Chess Royale in the search bar.
-Tap on the Chess Royale icon that appears in the results.
-Tap on the Get button to download and install the game.
-Once the installation is complete, tap on the Open button to launch the game.
-
-
For web browsers and Steam
-
If you want to play Chess Royale on your web browser or Steam, you need to visit the official website of Chess Royale. Here is how:
-
-Open your web browser and go to https://www.chessroyale.com/
-On the homepage, you will see two options: Play Now and Download on Steam.
-If you want to play on your web browser, click on Play Now. This will open a new tab where you can play Chess Royale without downloading anything.
-If you want to play on Steam, click on Download on Steam. This will redirect you to the Steam page of Chess Royale, where you can download and install the game.
-Once you have downloaded and installed Chess Royale on Steam, you can launch it from your Steam library.
-
-
Conclusion
-
Chess Royale is a game that combines chess with magic and strategy. It is a game that will challenge your mind and entertain you at the same time. It is a game that has many features and modes that will keep you hooked for hours. It is a game that you can play with anyone, anywhere, anytime. It is a game that you should definitely try if you love chess or if you are looking for something new and exciting.
-
FAQs
-
Here are some frequently asked questions about Chess Royale:
-
- Is Chess Royale free to play? Yes, Chess Royale is free to play on all platforms. However, it does have some optional in-game purchases that can enhance your gameplay experience such as buying more cards, coins, gems, or premium membership. These purchases are not required to play or enjoy the game, but they can give you some advantages or perks.
- Can I play Chess Royale offline? No, Chess Royale requires an internet connection to play. This is because the game is constantly updated with new content and features, and it also relies on online servers to match you with other players or store your progress. You need to have a stable and fast internet connection to play Chess Royale smoothly and without interruptions.
- How can I improve my skills in Chess Royale? There are many ways to improve your skills in Chess Royale. Here are some tips:
-
-Practice regularly. The more you play, the more you will learn and improve. You can practice against the AI, against your friends, or against random online opponents. You can also watch replays of your matches or other players' matches to analyze your mistakes and learn from them.
-Learn the basics of chess. Even though Chess Royale has some differences from standard chess, it still follows the same rules and principles. You need to know how the pieces move, how to capture, how to check and checkmate, how to avoid stalemate, and how to use basic tactics and strategies. You can find many online resources, books, videos, or courses that can teach you the basics of chess.
-Use your magic cards wisely. Magic cards are a powerful tool that can change the course of the game. However, they also have a cost and a cooldown. You need to use them at the right time and place, and not waste them on unnecessary or ineffective moves. You also need to balance your mana points and not run out of them when you need them most. You can experiment with different cards and combinations to find out what works best for you.
-Be flexible and adaptable. Chess Royale is a game that requires you to think on your feet and adjust your strategy according to the situation. You need to be aware of what is happening on the board, what your opponent is doing, what cards he has, what cards you have, and what moves are possible. You need to be ready to change your plan if something unexpected happens or if you see an opportunity to exploit. You also need to be creative and innovative in finding solutions and creating problems for your opponent.
-
- Is Chess Royale safe for kids? Yes, Chess Royale is safe for kids. It does not contain any violence, gore, nudity, profanity, or inappropriate content. It is rated E for Everyone by the ESRB and 3+ by PEGI. It is also moderated by a team of staff members who monitor the game for any abusive or offensive behavior or language. Players who violate the game's rules or terms of service can be reported, muted, banned, or suspended.
- How can I contact the developers of Chess Royale? If you have any questions, feedback, suggestions, or issues regarding Chess Royale, you can contact the developers through various channels. You can send them an email at support@chessroyale.com, visit their website at https://www.chessroyale.com/, follow them on social media platforms such as Facebook, Twitter, Instagram, or YouTube, or join their Discord server at https://discord.gg/chessroyale.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Enjoy the Ultimate Battle Experience in Stickman Hero Fight All Star MOD APK with Unlimited Money and Gems.md b/spaces/congsaPfin/Manga-OCR/logs/Enjoy the Ultimate Battle Experience in Stickman Hero Fight All Star MOD APK with Unlimited Money and Gems.md
deleted file mode 100644
index ff6a10fe46042cd80be8b84a91fe34eb18f76b6f..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Enjoy the Ultimate Battle Experience in Stickman Hero Fight All Star MOD APK with Unlimited Money and Gems.md
+++ /dev/null
@@ -1,102 +0,0 @@
-
-
Stickman Hero Fight All Star Mod APK: Unlimited Money and Gems
-
Do you love stickman games? Do you enjoy fighting with different weapons and skills? Do you want to have unlimited resources and access to all the features of the game? If you answered yes to any of these questions, then you should try Stickman Hero Fight All Star Mod APK .
-
Introduction
-
Stickman Hero Fight All Star is an action-packed game where you can control a stickman hero and fight against various enemies in different modes and levels. You can choose from a variety of characters, each with their own unique skills and abilities. You can also customize your hero with different outfits, weapons, and accessories. The game has simple controls, smooth animations, and realistic physics. You can unleash your creativity and imagination as you create your own stickman hero and fight your way to glory.
-
stickman hero fight all star mod apk unlimited money and gems Download File ———>>> https://urlca.com/2uO7dL
-
However, if you want to enjoy the game to the fullest, you might need a lot of money and gems. These are the in-game currencies that you can use to buy new items, upgrade your skills, unlock new characters, and more. But earning money and gems can be time-consuming and tedious. That's why we have a solution for you: Stickman Hero Fight All Star Mod APK .
-
This is a modified version of the original game that gives you unlimited money and gems. You can use these resources to get anything you want in the game without spending real money. You can also enjoy other features of the mod apk, such as:
-
-No ads
-No root required
-Easy installation
-Compatible with most devices
-Regular updates
-
-
To download and install Stickman Hero Fight All Star Mod APK, you just need to follow these simple steps:
-
stickman hero fight all star mod apk download free unlimited coins
-
-Click on this link to download the mod apk file.
-Allow unknown sources in your device settings.
-Locate the downloaded file in your file manager and tap on it.
-Follow the instructions on the screen to install the mod apk.
-Launch the game and enjoy unlimited money and gems.
-
-
Gameplay and Graphics
-
The gameplay of Stickman Hero Fight All Star is simple but fun. You just need to tap on the screen to move your hero, swipe to attack, and hold to charge your skill. You can also switch between different weapons and skills by tapping on their icons. You can play in different modes, such as:
-
-Campaign mode: This is where you can follow the story of your hero and fight against various enemies and bosses. You can also earn rewards and unlock new levels as you progress.
-Arena mode: This is where you can compete with other players online and show off your skills. You can also earn rankings and prizes based on your performance.
-Tournament mode: This is where you can join a tournament and fight against other players in a bracket system - You can win trophies and medals by defeating your opponents.
-Survival mode: This is where you can test your endurance and skills by fighting against endless waves of enemies. You can also earn coins and gems by surviving as long as possible.
-
-
The graphics of Stickman Hero Fight All Star are colorful and cartoonish. The game has a lot of details and effects that make it look lively and dynamic. The characters and backgrounds are well-designed and varied. The sound effects and music are also fitting and catchy. The game has a smooth performance and does not lag or crash.
-
Tips and Tricks
-
If you want to become the best stickman fighter in the game, you might need some tips and tricks to help you out. Here are some of them:
-
-Use the unlimited money and gems wisely. You can use them to buy new items, upgrade your skills, unlock new characters, and more. But don't spend them all at once. Save some for later when you need them more.
-Unlock all the characters and skills. Each character has their own strengths and weaknesses, as well as their own unique skills. You can switch between different characters and skills depending on the situation and your preference. Try to unlock all of them to have more options and strategies.
-Win every battle and become the best stickman fighter. To win every battle, you need to be fast, agile, and smart. You need to dodge, block, and counterattack your enemies. You need to use your skills at the right time and place. You need to exploit your enemies' weaknesses and avoid their strengths. You need to practice and improve your skills and tactics.
-
-
Conclusion
-
Stickman Hero Fight All Star Mod APK is a great game for anyone who loves stickman games, fighting games, or action games. It has a lot of features, modes, levels, characters, skills, items, and more that will keep you entertained for hours. It also has unlimited money and gems that will let you enjoy the game without any limitations or restrictions. It is easy to download and install, safe to use, compatible with most devices, and regularly updated.
-
However, like any other mod apk, it also has some drawbacks. It might not work on some devices or versions of the game. It might cause some glitches or errors in the game. It might not be compatible with some features or functions of the original game. It might also violate the terms and conditions of the game developers or publishers.
-
Therefore, you should download and use Stickman Hero Fight All Star Mod APK at your own risk and discretion. You should also respect the rights and efforts of the game developers or publishers by supporting them if you like their game.
-
If you want to find more information and updates about Stickman Hero Fight All Star Mod APK, you can visit this website or this blog . You can also follow the game's official Facebook page or Twitter account .
-
FAQs
-
Here are some frequently asked questions about Stickman Hero Fight All Star Mod APK:
-
-Is Stickman Hero Fight All Star Mod APK safe to use? Do I need to root my device to use the mod apk? Can I play Stickman Hero Fight All Star online with other players? What are the minimum requirements to run the game on my device?
-Android 4.4 or higher
-1 GB of RAM
-100 MB of free storage space
-A stable internet connection
-
-How can I contact the developers of the game if I have any issues or suggestions?
-
I hope you enjoyed this article and found it helpful. If you did, please share it with your friends and family who might also be interested in Stickman Hero Fight All Star Mod APK. And don't forget to download the game and have fun!
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Get Metamorphosis Ringtones Now - The Ultimate Collection of Phonk Slowed and Dark Tones.md b/spaces/congsaPfin/Manga-OCR/logs/Get Metamorphosis Ringtones Now - The Ultimate Collection of Phonk Slowed and Dark Tones.md
deleted file mode 100644
index 56a51cfd6dbc24b04473c4b30725d506cbe08bf4..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Get Metamorphosis Ringtones Now - The Ultimate Collection of Phonk Slowed and Dark Tones.md
+++ /dev/null
@@ -1,165 +0,0 @@
-
-
How to Download Metamorphosis Ringtones for Your Phone
-
Are you bored with the same old ringtones on your phone? Do you want to spice up your phone with some new and exciting sounds? If so, you might want to try out metamorphosis ringtones. These are ringtones that change their form, structure, or substance, just like the biological process of metamorphosis. In this article, we will show you what metamorphosis is, why you should choose metamorphosis ringtones, how to find and download them, and how to customize and create your own. Read on and discover how to transform your phone with metamorphosis ringtones.
-
What is Metamorphosis?
-
Before we dive into the world of metamorphosis ringtones, let's first understand what metamorphosis means. According to the Cambridge Dictionary, metamorphosis is "a complete change" or "the process by which the young form of insects and some animals, such as frogs, develops into the adult form". In other words, metamorphosis is a transformation from one state to another.
-
metamorphosis ringtone download DOWNLOAD ► https://urlca.com/2uOaDk
-
The meaning of metamorphosis
-
Metamorphosis can have different meanings depending on the context. In biology, metamorphosis is a physical change that occurs in some animals during their life cycle. For example, a caterpillar undergoes metamorphosis to become a butterfly, or a tadpole undergoes metamorphosis to become a frog. This change usually involves a change in appearance, behavior, and function.
-
In literature, art, and culture, metamorphosis can also refer to a symbolic or metaphorical change that affects a character, a story, or a theme. For example, in Greek mythology, many gods and humans were transformed into animals or plants by magic or curses. In modern fiction, such as Franz Kafka's The Metamorphosis, a character can experience a sudden and inexplicable change that alters his or her identity and relationship with others.
-
The examples of metamorphosis in nature and culture
-
Metamorphosis is a fascinating phenomenon that can be found in many aspects of nature and culture. Here are some examples of metamorphosis that you might be familiar with:
-
-The life cycle of insects : Many insects go through four stages of development: egg, larva, pupa, and adult. During the pupal stage, the insect undergoes a dramatic change in its body structure and emerges as a completely different creature. For example, a caterpillar becomes a butterfly, a maggot becomes a fly, or a bee becomes a wasp.The life cycle of amphibians : Some amphibians, such as frogs and salamanders, also undergo metamorphosis during their development. They start as aquatic larvae with gills and tails, then gradually grow legs and lungs and become terrestrial adults. For example, a tadpole becomes a frog, or an axolotl becomes a salamander.The seasons : The changing of the seasons can also be seen as a form of metamorphosis. As the earth orbits around the sun, the angle and intensity of sunlight changes throughout the year. This causes different weather patterns and affects the growth and appearance of plants and animals. For example, a tree changes its color and sheds its leaves in autumn, or a bear hibernates and grows a thicker fur in winter.The metamorphosis of art : Many artists have used the concept of metamorphosis to express their creativity and vision. For example, Pablo Picasso's cubist paintings show multiple perspectives of the same object or person, creating a distorted and abstract image. Salvador Dali's surrealist paintings depict objects and scenes that are transformed by dreams and imagination, creating a bizarre and illogical reality.
-
Why Choose Metamorphosis Ringtones?
-
Now that you have learned more about metamorphosis, you might be wondering why you should choose metamorphosis ringtones for your phone. Here are some reasons why metamorphosis ringtones are awesome and fun:
-
The benefits of metamorphosis ringtones
-
Metamorphosis ringtones have many benefits that can make your phone more enjoyable and personalized. Here are some of them:
-
-They are unique and original : Metamorphosis ringtones are not like the ordinary ringtones that you hear everywhere. They are different and distinctive, which can make your phone stand out from the crowd. You can impress your friends and family with your cool and creative ringtones.They are dynamic and adaptable : Metamorphosis ringtones can change according to your mood, preference, or situation. You can choose ringtones that match your personality, style, or theme. You can also switch ringtones depending on the time of day, the season, or the occasion. For example, you can have a cheerful and upbeat ringtone in the morning, a calm and relaxing ringtone in the evening, or a festive and cheerful ringtone during the holidays.They are fun and entertaining : Metamorphosis ringtones can add some fun and entertainment to your phone. You can enjoy listening to the different sounds and melodies that your phone makes. You can also play games or puzzles with your ringtones, such as guessing what they are or how they will change.
-
The types of metamorphosis ringtones
-
Metamorphosis ringtones come in various types and categories that can suit your taste and interest. Here are some examples of metamorphosis ringtones that you can choose from:
-
metamorphosis phonk ringtone download
-
-Nature sounds : These are ringtones that mimic the sounds of nature, such as animals, plants, or weather. For example, you can have a ringtone that starts as a bird chirping, then changes into a frog croaking, then into a thunderstorm rumbling.Musical sounds : These are ringtones that use musical instruments, genres, or songs. For example, you can have a ringtone that starts as a classical piano piece, then changes into a rock guitar solo, then into a rap song.Voice sounds : These are ringtones that use human voices, such as speech, laughter, or singing. For example, you can have a ringtone that starts as a hello greeting, then changes into a joke telling, then into a singing performance.Mixed sounds : These are ringtones that combine different types of sounds together. For example, you can have a ringtone that starts as a car engine revving, then changes into a dog barking, then into a baby crying.
-
How to Find and Download Metamorphosis Ringtones?
-
Now that you know why you should choose metamorphosis ringtones and what types of metamorphosis ringtones are available, you might be wondering how to find and download them for your phone. Here are some ways to do so:
-
The best websites for metamorphosis ringtones
-
One way to find and download metamorphosis ringtones is to visit some websites that offer them for free or for a fee. Here are some of the best websites for metamorphosis ringtones:
-
-Website Description [Zedge] This is one of the most popular websites for downloading free ringtones, wallpapers, and other phone content. You can browse through thousands of metamorphosis ringtones in different categories and genres. You can also upload your own metamorphosis ringtones or request custom ones from other users. [ToneTweet](^ ^)^ This is a website that allows you to create and download your own metamorphosis ringtones for free. You can choose from various sound effects, music tracks, and voice clips to mix and match. You can also adjust the volume, speed, and pitch of each sound. You can preview your ringtone before downloading it as an MP3 file. [Audiko] This is a website that lets you download free ringtones from a large collection of songs and artists. You can also upload your own music files and edit them to create your own metamorphosis ringtones. You can cut, crop, fade, and loop any part of the song. You can download your ringtone as an MP3 or M4R file. [Ringtone Maker] This is a website that enables you to make and download custom ringtones for free. You can upload your own audio files or record your own voice to create your own metamorphosis ringtones. You can also add effects, filters, and transitions to enhance your ringtone. You can download your ringtone as an MP3, WAV, or OGG file.
-
The best apps for metamorphosis ringtones
-
Another way to find and download metamorphosis ringtones is to use some apps that are designed for this purpose. Here are some of the best apps for metamorphosis ringtones:
-
-App Description [Metamorphosis Ringtones] This is an app that offers a variety of metamorphosis ringtones for free. You can browse through different categories and genres of metamorphosis ringtones, such as animals, nature, music, voice, and more. You can also set your favorite metamorphosis ringtone as your default ringtone, notification sound, or alarm sound. [Ringdroid] This is an app that allows you to create and edit your own metamorphosis ringtones for free. You can import any audio file from your device or record your own sound to make your own metamorphosis ringtone. You can also crop, trim, fade, and adjust the volume of your ringtone. You can save your ringtone as an MP3, WAV, AAC, or AMR file. [MP3 Cutter and Ringtone Maker] This is an app that enables you to cut and make your own metamorphosis ringtones for free. You can select any audio file from your device or record your own sound to make your own metamorphosis ringtone. You can also cut, merge, mix, and edit your ringtone. You can save your ringtone as an MP3, WAV, AAC, or AMR file.
-
How to transfer metamorphosis ringtones to your phone
-
Once you have found and downloaded your desired metamorphosis ringtones, you need to transfer them to your phone so that you can use them. Here are some steps to do so:
-
-Connect your phone to your computer using a USB cable or Bluetooth.
-Open the folder where you saved your metamorphosis ringtones on your computer.
-Copy or drag the metamorphosis ringtones files to the folder where you store your ringtones on your phone. This folder may vary depending on the model and brand of your phone, but it is usually called "Ringtones" or "Sounds".
-Disconnect your phone from your computer.
-Go to the settings menu on your phone and select the option for sound and notification.
-Select the option for ringtone and browse through the list of available ringtones on your phone.
-Select the metamorphosis ringtone that you want to use and confirm.
-Enjoy your new metamorphosis ringtone!
-
-
How to Customize and Create Your Own Metamorphosis Ringtones?
-
If you want to have more control and creativity over your metamorphosis ringtones, you can also customize and create your own. Here are some ways to do so:
-
The tools and steps for creating metamorphosis ringtones
-
To create your own metamorphosis ringtones, you will need some tools and steps that will help you achieve the best results. Here are some of them:
-
-A sound source : This is the first thing you need to create your own metamorphosis ringtone. You can use any sound that you like, such as music, voice, noise, or anything else. You can either record your own sound using a microphone or a voice recorder app, or you can use an existing sound file from your device or the internet.A sound editor : This is the tool that you need to edit and manipulate your sound source. You can use any sound editor software or app that you prefer, such as Audacity, GarageBand, WavePad, or any of the apps mentioned above. You can use the sound editor to cut, crop, fade, loop, mix, merge, and add effects to your sound source. You can also change the pitch, speed, volume, and tone of your sound source.A sound converter : This is the tool that you need to convert your sound source into a ringtone format. You can use any sound converter software or app that you like, such as Online Audio Converter, Zamzar, Convertio, or any of the apps mentioned above. You can use the sound converter to change the file type, size, quality, and bitrate of your sound source. You can also choose the output format that is compatible with your phone, such as MP3, WAV, AAC, or M4R.A sound transfer : This is the tool that you need to transfer your sound source to your phone. You can use any of the methods described above to transfer your metamorphosis ringtone to your phone. You can either use a USB cable or Bluetooth to connect your phone and your computer, or you can use an email or a cloud service to send your ringtone to your phone.
-
Once you have these tools ready, you can follow these steps to create your own metamorphosis ringtone:
-
-Select or record your sound source and save it on your computer or device.
-Open your sound editor and import your sound source.
-Edit and manipulate your sound source according to your preference and creativity. You can make it change its form, structure, or substance in any way you like.
-Save your edited sound source as a new file on your computer or device.
-Open your sound converter and import your edited sound source.
-Convert your edited sound source into a ringtone format that is compatible with your phone.
-Save your converted sound source as a new file on your computer or device.
-Transfer your converted sound source to your phone using any of the methods described above.
-Set your converted sound source as your metamorphosis ringtone on your phone.
-Enjoy your new metamorphosis ringtone!
-
-
The tips and tricks for making unique and catchy metamorphosis ringtones
-
To make your own metamorphosis ringtones more unique and catchy, you can also use some tips and tricks that will help you improve your skills and results. Here are some of them:
-
-Use a variety of sounds : To make your metamorphosis ringtone more interesting and diverse, you can use a variety of sounds from different sources and categories. You can mix and match sounds from nature, music, voice, and more. You can also use sounds that are related to the theme or meaning of metamorphosis, such as animals, plants, seasons, art, and more.Use a clear and smooth transition : To make your metamorphosis ringtone more coherent and seamless, you can use a clear and smooth transition between the different sounds. You can use effects such as fade in, fade out, crossfade, overlap, or blend to create a smooth change from one sound to another. You can also use sounds that have a similar pitch, speed, volume, or tone to create a clear connection between them.Use a suitable length and frequency : To make your metamorphosis ringtone more suitable and effective for your phone, you can use a suitable length and frequency for your metamorphosis ringtone. You can make your ringtone as long or as short as you want, but you should keep in mind that the average ringtone duration is about 30 seconds. You can also make your ringtone change its sound as often or as rarely as you want, but you should keep in mind that the average ringtone frequency is about 5 seconds. You can adjust these parameters according to your preference and purpose.Use a catchy and memorable sound : To make your metamorphosis ringtone more catchy and memorable, you can use a sound that is easy to recognize and remember. You can use a sound that has a distinctive melody, rhythm, or pattern. You can also use a sound that has a personal or emotional meaning for you or your contacts. You can choose a sound that represents your name, your hobby, your favorite song, or anything else that you like.
-
Conclusion
-
In conclusion, metamorphosis ringtones are ringtones that change their form, structure, or substance, just like the biological process of metamorphosis. They are unique, dynamic, fun, and entertaining ringtones that can spice up your phone and impress your friends and family. You can find and download metamorphosis ringtones from various websites and apps, or you can customize and create your own metamorphosis ringtones using some tools and steps. You can also use some tips and tricks to make your metamorphosis ringtones more unique and catchy. We hope that this article has helped you learn more about metamorphosis ringtones and how to download them for your phone. Why not try them out today and see how they transform your phone?
-
A call to action for the readers to try out metamorphosis ringtones
-
If you are interested in trying out metamorphosis ringtones for your phone, here are some things you can do:
-
-Visit the websites or download the apps mentioned in this article : You can browse through thousands of metamorphosis ringtones in different categories and genres. You can also create and edit your own metamorphosis ringtones using various sound effects, music tracks, and voice clips.Share your metamorphosis ringtones with others : You can share your metamorphosis ringtones with your friends and family via email, social media, or messaging apps. You can also upload your metamorphosis ringtones to the websites or apps mentioned in this article and let other users enjoy them.Give us your feedback : We would love to hear from you about your experience with metamorphosis ringtones. You can leave us a comment below or contact us via our website or social media accounts. You can also rate and review our article and our website or app.
-
Thank you for reading our article on how to download metamorphosis ringtones for your phone. We hope you have fun with your new metamorphosis ringtones!
-
5 unique FAQs after the conclusion
-
Here are some frequently asked questions (FAQs) about metamorphosis ringtones:
-
-What are metamorphosis ringtones? : Metamorphosis ringtones are ringtones that change their form, structure, or substance, just like the biological process of metamorphosis.Why should I choose metamorphosis ringtones? : Metamorphosis ringtones are unique, dynamic, fun, and entertaining ringtones that can spice up your phone and impress your friends and family.How can I find and download metamorphosis ringtones? : You can find and download metamorphosis ringtones from various websites and apps that offer them for free or for a fee. You can also customize and create your own metamorphosis ringtones using some tools and steps.How can I transfer metamorphosis ringtones to my phone? : You can transfer metamorphosis ringtones to your phone using a USB cable or Bluetooth to connect your phone and your computer, or using an email or a cloud service to send your ringtone to your phone.How can I make my own metamorphosis ringtones more unique and catchy? : You can make your own metamorphosis ringtones more unique and catchy by using a variety of sounds from different sources and categories, using a clear and smooth transition between the different sounds, using a suitable length and frequency for your ringtone, and using a catchy and memorable sound.
-
197e85843d
Color Book PDF: A Fun and Educational Way to Relax and Learn
-
Do you enjoy coloring as a hobby or as a way to keep your mind active? Do you want to help your children learn new words and improve their skills while having fun? If you answered yes to any of these questions, then you might be interested in color book PDFs. These are digital files that contain coloring pages that you can print or download on your device. In this article, we will explain what color book PDFs are, why they are beneficial for children and adults, how to find and use them, and what are some of the best color book PDFs for different topics and themes.
-
What is a color book PDF?
-
A color book PDF is a digital file that contains coloring pages that you can print or download
-
A color book PDF is a type of document that you can open with a PDF reader or a web browser. It contains one or more coloring pages that have black-and-white outlines of images that you can fill with colors. A coloring page is a single sheet or picture with a specific theme or subject. A coloring book is a collection of coloring pages that are related by a common theme or category.
-
color book pdf Download ->>->>->> https://urlca.com/2uOeux
-
Why are color book PDFs beneficial for children and adults?
-
They help children learn new words, improve their motor skills, and express their creativity
-
Coloring is not only a fun activity for children, but also an educational one. Coloring helps children learn new words by exposing them to different objects, animals, characters, and concepts. For example, a color book PDF about animals can teach children the names of different species, their habitats, their sounds, and their characteristics. Coloring also helps children improve their motor skills by developing their hand-eye coordination, fine motor control, and grip strength. Coloring also helps children express their creativity by allowing them to choose their own colors, patterns, and styles.
-
They help adults reduce stress, enhance their focus, and stimulate their brain
-
Coloring is not only for kids. Adults can also benefit from coloring as a way to relax and unwind. Coloring helps adults reduce stress by lowering their blood pressure, heart rate, and cortisol levels. Coloring also helps adults enhance their focus by blocking out distractions and concentrating on the task at hand. Coloring also helps adults stimulate their brain by activating both hemispheres and improving their memory, problem-solving, and cognitive abilities.
-
How to find and use color book PDFs?
-
There are many websites that offer free coloring pages and books in PDF format
-
Some examples are VerbNow, Cambridge English, and InfoBooks
-
If you are looking for color book PDFs online, you have plenty of options to choose from. There are many websites that offer free coloring pages and books in PDF format for different topics and themes. Some examples are: - VerbNow: This website offers free coloring pages and books for learning English verbs. You can find coloring pages for regular and irregular verbs, as well as verb tenses and moods. You can also download a PDF file with all the verbs and their definitions. - Cambridge English: This website offers free coloring pages and books for learning English vocabulary. You can find coloring pages for various topics, such as animals, food, clothes, and sports. You can also download a PDF file with all the words and their meanings. - InfoBooks: This website offers free coloring pages and books for learning about different subjects, such as science, history, art, and culture. You can find coloring pages for various topics, such as planets, dinosaurs, famous people, and landmarks. You can also download a PDF file with all the information and facts.
You can print the coloring pages or use a digital device to color them
-
You can use different tools and apps to color online or offline
-
If you want to use color book PDFs, you have two options: you can print them or use a digital device to color them. If you want to print them, you will need a printer, paper, and coloring materials, such as crayons, markers, or pencils. You can print the whole book or just the pages that you like. If you want to use a digital device to color them, you will need a computer, tablet, or smartphone, and an internet connection or an app. You can use different tools and apps to color online or offline. Some examples are: - Adobe Acrobat Reader: This is a free software that allows you to open and view PDF files on your computer or mobile device. You can also use it to fill and sign forms, add comments, and highlight text. You can use it to color the coloring pages by using the comment tool and choosing the drawing option. You can also change the color, size, and opacity of the drawing tool. - Colorfy: This is a free app that allows you to color online or offline on your tablet or smartphone. You can choose from hundreds of coloring pages and books for different topics and themes. You can also create your own drawings and share them with others. You can use different tools and effects to color the coloring pages, such as brushes, gradients, filters, and stickers. - Happy Color: This is a free app that allows you to color by numbers on your tablet or smartphone. You can choose from thousands of coloring pages and books for different topics and themes. You can also view the works of other users and rate them. You can use different tools and features to color the coloring pages, such as hints, zoom, undo, and save.
What are some of the best color book PDFs for different topics and themes?
-
If you are looking for some inspiration or suggestions for color book PDFs, you can check out some of the best ones for different topics and themes. Here are some examples:
-
Animals
-
You can find coloring pages for various animals, such as insects, reptiles, mammals, and birds
-
If you love animals, you can find color book PDFs that feature different kinds of animals, from cute and cuddly to wild and exotic. You can learn about their names, characteristics, habitats, and behaviors while coloring them. Some examples of animal color book PDFs are: - Insect Coloring Book: This color book PDF contains 20 coloring pages of different insects, such as butterflies, bees, ants, and spiders. You can also learn some fun facts about each insect on the page. - Reptile Coloring Book: This color book PDF contains 24 coloring pages of different reptiles, such as snakes, lizards, turtles, and crocodiles. You can also learn some interesting facts about each reptile on the page. - Mammal Coloring Book: This color book PDF contains 30 coloring pages of different mammals, such as cats, dogs, horses, and elephants. You can also learn some amazing facts about each mammal on the page. - Bird Coloring Book: This color book PDF contains 25 coloring pages of different birds, such as parrots, owls, penguins, and flamingos. You can also learn some cool facts about each bird on the page.
-
color book pdf free download
-
Cartoons
-
You can find coloring pages for popular cartoon characters, such as Peppa Pig, SpongeBob, and Mickey Mouse
-
If you love cartoons, you can find color book PDFs that feature your favorite cartoon characters, from classic to modern. You can have fun coloring them and reliving their adventures and personalities. Some examples of cartoon color book PDFs are: - Peppa Pig Coloring Book: This color book PDF contains 15 coloring pages of Peppa Pig and her family and friends. You can also find some activities and games on the pages. - SpongeBob Coloring Book: This color book PDF contains 20 coloring pages of SpongeBob SquarePants and his underwater pals. You can also find some jokes and riddles on the pages. - Mickey Mouse Coloring Book: This color book PDF contains 25 coloring pages of Mickey Mouse and his friends from the Disney universe. You can also find some trivia and puzzles on the pages.
Nature
-
You can find coloring pages for beautiful landscapes, plants, flowers, and seasons
-
If you love nature, you can find color book PDFs that feature stunning scenery, flora, and fauna. You can admire the beauty and diversity of nature while coloring it. Some examples of nature color book PDFs are: - Landscape Coloring Book: This color book PDF contains 20 coloring pages of different landscapes, such as mountains, forests, deserts, and oceans. You can also learn some facts about each landscape on the page. - Plant Coloring Book: This color book PDF contains 25 coloring pages of different plants, such as trees, grasses, herbs, and fruits. You can also learn some information about each plant on the page. - Flower Coloring Book: This color book PDF contains 30 coloring pages of different flowers, such as roses, tulips, sunflowers, and orchids. You can also learn some details about each flower on the page. - Season Coloring Book: This color book PDF contains 16 coloring pages of different seasons, such as spring, summer, autumn, and winter. You can also learn some characteristics of each season on the page.
-
Conclusion
-
Color book PDFs are a great way to have fun and learn at the same time
-
Coloring is a simple and enjoyable activity that can benefit both children and adults. It can help them learn new words, improve their skills, reduce their stress, enhance their focus, and stimulate their brain. It can also help them express their creativity and personality.
-
You can easily find and use them online or offline
-
Color book PDFs are easy to find and use. You can access them online or offline on your computer or mobile device. You can print them or use different tools and apps to color them. You can choose from a wide range of topics and themes to suit your preferences.
-
You can choose from a wide range of topics and themes to suit your preferences
-
Color book PDFs offer a variety of options for different topics and themes. You can find coloring pages and books for animals, cartoons, nature, and more. You can also create your own drawings and share them with others. You can have fun coloring alone or with your friends and family.
-
FAQs
-
Here are some frequently asked questions about color book PDFs:
-
Q: How do I download a color book PDF?
-
A: To download a color book PDF, you need to find a website that offers free coloring pages and books in PDF format. Then, you need to click on the download button or link and save the file on your device.
-
Q: How do I print a color book PDF?
-
A: To print a color book PDF, you need to open the file with a PDF reader or a web browser. Then, you need to select the print option and choose the settings that you want. You can print the whole book or just the pages that you like.
-
Q: How do I color online?
-
A: To color online, you need to find a website or an app that allows you to color online. Then, you need to choose a coloring page or book that you like and start coloring with the tools and features that are available.
-
Q: How do I color offline?
-
A: To color offline, you need to download an app that allows you to color offline. Then, you need to choose a coloring page or book that you like and start coloring with the tools and features that are available.
-
Q: How do I share my coloring work?
-
A: To share your coloring work, you need to save it as an image file on your device. Then, you need to upload it to a social media platform or an online gallery that allows you to share your work with others.
197e85843d
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Marvel Contest of Champions on PC How to Download and Install the Best Marvel Game Ever.md b/spaces/congsaPfin/Manga-OCR/logs/Marvel Contest of Champions on PC How to Download and Install the Best Marvel Game Ever.md
deleted file mode 100644
index 04e636ce7949e0e901c1c50ccee4325dc42fd28b..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Marvel Contest of Champions on PC How to Download and Install the Best Marvel Game Ever.md
+++ /dev/null
@@ -1,144 +0,0 @@
-
-
How to Download Marvel Contest of Champions for PC
-
If you are a fan of Marvel comics, movies, and games, you might have heard of Marvel Contest of Champions , a popular fighting game that features your favorite superheroes and villains in epic battles. The game is available for Android and iOS devices, but what if you want to play it on your PC?
-
Playing Marvel Contest of Champions on your PC has many advantages, such as a bigger screen, better graphics, faster performance, and more comfortable controls. You can also enjoy the game without worrying about battery life, storage space, or internet connection. Plus, you can access more features and options that are not available on mobile devices.
-
download marvel contest of champions for pc DOWNLOAD ->>> https://urlca.com/2uO99O
-
But how can you download Marvel Contest of Champions for PC? There are several methods that you can use, depending on your preferences and needs. In this article, we will show you three easy ways to play this awesome game on your computer. Let's get started!
-
Method 1: Use Windows 11 and native Android emulation
-
One of the easiest ways to play Android games on your PC is to use Windows 11 , the latest operating system from Microsoft. Windows 11 has a built-in feature that allows you to run Android apps natively on your PC, without needing to install a third-party emulator. This feature works by having the Windows Subsystem for Android , which is a virtualization instance of Android inside Windows.
-
By having Android running inside Windows, you can directly download and launch Android apps, including games, from the Amazon Appstore , which is embedded inside the Microsoft Store . You can also sync your progress and game library across devices with a single sign-in to your Google account. Plus, you can use your mouse and keyboard to gain agility and boost your performance.
-
Here are the steps to use Windows 11 and native Android emulation to play Marvel Contest of Champions on your PC:
-
-Check if your PC meets the minimum requirements for Windows 11 and Android emulationAccording to Microsoft, your PC needs to have at least a 1 GHz processor, 4 GB of RAM, 64 GB of storage, and a TPM 2.0 chip to run Windows 11. For Android emulation, you also need to have a compatible graphics card that supports DirectX 12 and WDDM 2.x. You can check your PC's compatibility by using the PC Health Check app or the WhyNotWin11 app . Update your PC to Windows 11 and enable the Windows Subsystem for Android
-If your PC meets the requirements, you can update your PC to Windows 11 by following the instructions on the Microsoft website . You can also join the Windows Insider Program to get early access to Windows 11 before its official release. Once you have Windows 11 installed, you need to enable the Windows Subsystem for Android by going to Settings > Apps > Apps & features > Optional features > Add a feature and selecting Windows Subsystem for Android. You may need to restart your PC after enabling this feature.
Install the Amazon Appstore from the Microsoft Store and search for Marvel Contest of Champions
-After enabling the Windows Subsystem for Android, you can install the Amazon Appstore from the Microsoft Store by searching for it or by clicking on this link . The Amazon Appstore is a digital distribution platform that offers thousands of Android apps and games, including Marvel Contest of Champions. You can sign in with your Amazon account or create one if you don't have one. Then, you can search for Marvel Contest of Champions in the Appstore and click on the Get button to download it.
Download and launch the game and enjoy playing it on your PC with improved controls and graphics
-Once you have downloaded Marvel Contest of Champions from the Amazon Appstore, you can launch it from the Start menu or the Taskbar. You will see a window that shows the game running on Android inside Windows. You can use your mouse and keyboard to control the game, or you can connect a gamepad or a joystick if you prefer. You can also adjust the window size, resolution, and orientation to suit your preferences. You will notice that the game runs smoothly and looks stunning on your PC, thanks to the native Android emulation.
-
Method 2: Use an Android emulator such as Bluestacks 5
-
If you don't have Windows 11 or you don't want to use native Android emulation, you can still play Marvel Contest of Champions on your PC by using an Android emulator. An Android emulator is a software that simulates an Android device on your PC, allowing you to run Android apps and games on your computer. There are many Android emulators available online, but one of the most popular and reliable ones is Bluestacks 5 .
-
Bluestacks 5 is an Android emulator that is designed specifically for gaming. It has many features that enhance your gaming experience, such as high performance, low CPU and memory usage, custom key mapping, multi-instance support, eco mode, smart controls, and more. It also supports over 2 million Android games, including Marvel Contest of Champions. You can download Bluestacks 5 for free from its official website .
-
Here are the steps to use Bluestacks 5 and play Marvel Contest of Champions on your PC:
-
-Download and install Bluestacks 5 from the official website
-Go to the Bluestacks website and click on the Download Bluestacks button. The website will automatically detect your operating system and download the appropriate installer for your PC. Once the download is complete, run the installer and follow the instructions to install Bluestacks 5 on your PC. The installation process may take some time depending on your internet speed and PC specifications.
Sign in with your Google account and access the Google Play Store
-After installing Bluestacks 5, launch it from your desktop or start menu. You will see a welcome screen that asks you to sign in with your Google account. This is necessary to access the Google Play Store and sync your game progress across devices. If you don't have a Google account, you can create one for free. Once you have signed in, you will see the Bluestacks home screen with various icons and options.
Search for Marvel Contest of Champions and install it on Bl uestacks 5
-On the Bluestacks home screen, you will see the Google Play Store icon. Click on it and search for Marvel Contest of Champions in the search bar. You will see the game's icon and name. Click on the Install button to download and install the game on Bluestacks 5. The installation process may take some time depending on your internet speed and PC specifications.
Customize your keyboard and mouse settings and start playing the game on your PC
-Once the game is installed, you can launch it from the Bluestacks home screen or the My Games tab. You will see a window that shows the game running on Bluestacks 5. You can use your keyboard and mouse to control the game, or you can connect a gamepad or a joystick if you prefer. You can also customize your keyboard and mouse settings by clicking on the Keyboard icon on the right side of the window. You can assign different keys to different actions, such as moving, attacking, blocking, and using special moves. You can also adjust the sensitivity, transparency, and size of the keys. You will notice that the game runs smoothly and looks amazing on your PC, thanks to the Bluestacks 5 features.
-
Method 3: Use other Android emulators or apps such as Nox Player, Gameloop, or Parsec
-
If you don't want to use Windows 11 or Bluestacks 5, you can still play Marvel Contest of Champions on your PC by using other Android emulators or apps. There are many alternatives that you can choose from, depending on your needs and preferences. Some of them are Nox Player , Gameloop , and Parsec .
-
How to download marvel contest of champions on pc with bluestacks
-
Nox Player is an Android emulator that is similar to Bluestacks 5, but with more customization options and features. It supports high performance, multi-instance support, macro recording, keyboard mapping, gamepad support, and more. It also supports over 1 million Android games, including Marvel Contest of Champions. You can download Nox Player for free from its official website .
-
Gameloop is an Android emulator that is designed specifically for Tencent games, such as PUBG Mobile, Call of Duty Mobile, and Arena of Valor. It has many features that optimize your gaming experience, such as turbo engine, anti-cheat system, network acceleration, smart controls, and more. It also supports other Android games, including Marvel Contest of Champions. You can download Gameloop for free from its official website .
-
Parsec is not an Android emulator, but an app that allows you to stream games from your PC to another device, such as a laptop, tablet, or phone. It works by having a host PC that runs the game and a client device that connects to it via the internet. You can use Parsec to play Marvel Contest of Champions on your PC by streaming it from another device that has the game installed. You can download Parsec for free from its official website .
-
Here are the steps to use other Android emulators or apps and play Marvel Contest of Champions on your PC:
-
-Choose an Android emulator or app that suits your needs and preferences
-Depending on what features and options you want to have when playing Marvel Contest of Champions on your PC, you can choose an Android emulator or app that meets your expectations. You can compare and contrast the pros and cons of each emulator or app by reading reviews, watching videos, or trying them out yourself.
Download and install the emulator or app on your PC and follow the instructions to set it up
-Once you have chosen an Android emulator or app that you like, you can download and install it on your PC by following the instructions on its website or store. The installation process may vary depending on the emulator or app you choose, but it usually involves running an installer file and agreeing to some terms and conditions.
Download and install Marvel Contest of Champions from the emulator's or app's store or website
-After installing the emulator or app on your PC, you need to download and install Marvel Contest of Champions from its store or website. The store or website may be different depending on the emulator or app you choose, but it usually involves searching for the game's name and clicking on the install button.
Launch the game and enjoy playing it on your PC with different features and options
-Once the game is installed, you can launch it from the emulator's or app's home screen or menu. You will see a window that shows the game running on the emulator or app . You can use your keyboard and mouse to control the game, or you can connect a gamepad or a joystick if you prefer. You can also adjust the window size, resolution, and orientation to suit your preferences. You will notice that the game runs differently depending on the emulator or app you choose, but it should still be enjoyable and playable on your PC.
-
Conclusion: Which method is the best for you?
-
As you can see, there are many ways to play Marvel Contest of Champions on your PC, each with its own advantages and disadvantages. The best method for you depends on your personal preference, needs, and situation. Here is a summary of the pros and cons of each method:
-
-
-Method
-Pros
-Cons
-
-
-Windows 11 and native Android emulation
-- Easy and convenient
-- Requires Windows 11 and compatible hardware
-
-
-Bluestacks 5
-- Popular and reliable
-- Requires downloading and installing Bluestacks 5
-
-
-Other Android emulators or apps
-- More choices and alternatives
-- Requires downloading and installing the emulator or app
-
-
-
In our opinion, the best method for playing Marvel Contest of Champions on your PC is to use Windows 11 and native Android emulation, if you have the necessary hardware and software. This method is the easiest, most convenient, and most efficient way to enjoy this game on your computer. However, if you don't have Windows 11 or you want to try other methods, you can also use Bluestacks 5 or other Android emulators or apps, as they are also good options that offer different features and options.
-
Ultimately, the choice is yours. You can experiment with different methods and see which one works best for you. The important thing is to have fun and enjoy playing Marvel Contest of Champions on your PC!
-
FAQs: Frequently asked questions about downloading Marvel Contest of Champions for PC
-
Here are some of the most common questions that people ask about downloading Marvel Contest of Champions for PC:
-
Q1: Is Marvel Contest of Champions free to play?
-
A1: Yes, Marvel Contest of Champions is free to play. You can download and install it on your PC without paying anything. However, the game has in-app purchases that allow you to buy items, currency, and upgrades with real money. You can also watch ads or complete offers to earn free rewards.
-
Q2: Can I play Marvel Contest of Champions with my friends on PC?
-
A2: Yes, you can play Marvel Contest of Champions with your friends on PC. The game has a multiplayer mode that allows you to join alliances, chat with other players, compete in events, and battle against other teams. You can also invite your friends to play with you by sending them a link or a code.
-
Q3: How can I update Marvel Contest of Champions on PC?
-
A3: To update Marvel Contest of Champions on PC, you need to follow the same steps as you would on your mobile device. Depending on the method you use to play the game on your PC, you need to either update it from the Amazon Appstore, the Google Play Store, or the emulator's or app's store or website. You can also enable automatic updates to get the latest version of the game without hassle.
-
Q4: What are the system requirements for Marvel Contest of Champions on PC?
-
A4: The system requirements for Marvel Contest of Champions on PC vary depending on the method you use to play the game on your computer. However, as a general guideline, you need to have at least a 1 GHz processor, 4 GB of RAM, 64 GB of storage, a compatible graphics card, and an internet connection. You also need to have either Windows 11 or an Android emulator or app installed on your PC.
-
Q5: How can I contact the support team for Marvel Contest of Champions on PC?
-
A5: If
If you have any issues, questions, or feedback about Marvel Contest of Champions on PC, you can contact the support team by following these steps:
-
-Go to the game's settings and tap on the Support button
-This will open a web page that shows the game's FAQ, troubleshooting tips, and contact options. You can browse through the topics and see if you can find an answer to your question or a solution to your problem.
If you can't find what you are looking for, tap on the Contact Us button
-This will open a form that asks you to provide some details about your issue, such as your game ID, device model, operating system, and description of the problem. You can also attach screenshots or videos to illustrate your issue. Fill in the form and tap on the Submit button.
Wait for a response from the support team
-After submitting your form, you will receive an email confirmation that your request has been received. The support team will review your issue and get back to you as soon as possible. You can also check the status of your request by tapping on the Check Status button on the web page.
-
The support team is available 24/7 and strives to provide the best service possible. However, please be patient and respectful when contacting them, as they may receive a high volume of requests.
-
I hope this article has helped you learn how to download Marvel Contest of Champions for PC and enjoy playing this amazing game on your computer. If you have any comments or suggestions, please feel free to share them below. Thank you for reading and have a great day!
401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Real Bike Racing Download the MOD APK and Race Like a Pro.md b/spaces/congsaPfin/Manga-OCR/logs/Real Bike Racing Download the MOD APK and Race Like a Pro.md
deleted file mode 100644
index fa61e0b5d18c4f438c724d2e7993c4e85a7ff09b..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Real Bike Racing Download the MOD APK and Race Like a Pro.md
+++ /dev/null
@@ -1,94 +0,0 @@
-
-
Real Bike Racing Game Mod APK: A Guide for Beginners
-
If you are a fan of motorcycle racing games, you might have heard of Real Bike Racing Game. This is a realistic and thrilling game that lets you experience the adrenaline rush of riding a super-fast bike on various tracks. But what if you want to enjoy the game without any limitations or interruptions? That's where Real Bike Racing Game Mod APK comes in. In this article, we will tell you everything you need to know about this modded version of the game, including its features, how to download and install it, why you should play it, and some tips and tricks to help you win every race.
-
real bike racing game mod apk DOWNLOAD –––––>>> https://urlca.com/2uO4LR
-
What is Real Bike Racing Game?
-
Real Bike Racing Game is a 3D motorcycle racing game developed by Italic Games. It has over 10 million downloads on Google Play Store and a 4.2-star rating from more than 300,000 users. The game features realistic graphics, sound effects, and physics that make you feel like you are riding a real bike. You can choose from over 20 different bikes, each with its own specifications and performance. You can also customize your bike with various colors and stickers. The game offers 10 different tracks, ranging from city streets to desert roads, where you can compete with other riders in various modes, such as Career, VR, and Championship. You can also challenge yourself in Time Trial mode, where you have to beat the clock and set new records.
-
How to Download and Install Real Bike Racing Game Mod APK
-
Real Bike Racing Game Mod APK is a modified version of the original game that gives you access to unlimited money, all bikes and tracks unlocked, and no ads. This means you can enjoy the game without any restrictions or annoyances. To download and install Real Bike Racing Game Mod APK, follow these simple steps:
-
-Click on this link to download the modded APK file.
-After the download is complete, go to your device's settings and enable installation from unknown sources.
-Locate the downloaded file in your file manager and tap on it to install it.
-Wait for the installation to finish and then launch the game.
-Enjoy playing Real Bike Racing Game Mod APK with unlimited money, all bikes and tracks unlocked, and no ads.
-
-
Why You Should Play Real Bike Racing Game Mod APK
-
Real Bike Racing Game Mod APK is not only a fun and exciting game, but also a great way to improve your skills and enjoy some benefits that the original game does not offer. Here are some reasons why you should play Real Bike Racing Game Mod APK:
-
real bike racing mod apk unlimited money
-
Unlimited Money
-
One of the best features of Real Bike Racing Game Mod APK is that it gives you unlimited money. This means you can buy any bike you want, upgrade it to the max level, and customize it as you like. You don't have to worry about saving up or earning money by completing races or watching ads. You can just enjoy the game and ride your dream bike.
-
Unlock All Bikes and Tracks
-
Another great feature of Real Bike Racing Game Mod APK is that it unlocks all bikes and tracks for you. This means you can choose from over 20 different bikes, each with its own unique design and performance. You can also race on 10 different tracks, each with its own challenges and scenery. You don't have to wait for levels or achievements to unlock them. You can just explore them all and find your favorite ones.
-
No Ads
-
The last but not least feature of Real Bike Racing Game Mod APK is that it removes all ads from the game. This means you can play the game without any interruptions or distractions. You don't have to watch any videos or banners to earn money or unlock features. You can just focus on the game and enjoy the racing experience.
-
Tips and Tricks for Playing Real Bike Racing Game Mod APK
-
Real Bike Racing Game Mod APK is a fun and easy game to play, but it can also be challenging and competitive. If you want to improve your skills and win every race, you need to follow some tips and tricks. Here are some of them:
-
Choose the Right Bike for Each Race
-
One of the most important things to consider when playing Real Bike Racing Game Mod APK is choosing the right bike for each race. Different bikes have different specifications, such as speed, acceleration, handling, and braking. You need to choose a bike that suits the track and the mode you are playing. For example, if you are playing on a city track with lots of turns and traffic, you might want to choose a bike with good handling and braking. If you are playing on a desert track with long straight roads, you might want to choose a bike with high speed and acceleration.
-
Master the Controls and Physics
-
Another important thing to consider when playing Real Bike Racing Game Mod APK is mastering the controls and physics of the game. The game has realistic graphics and sound effects, but it also has realistic physics that affect how your bike moves and reacts. You need to learn how to use the buttons and the tilt sensor to control your bike and balance it. You also need to learn how to use the nitro boost and the brake to speed up or slow down your bike. You need to practice a lot and get familiar with the controls and physics of the game.
-
Upgrade Your Bike Regularly
-
A third important thing to consider when playing Real Bike Racing Game Mod APK is upgrading your bike regularly. Since you have unlimited money, you can buy any bike you want and upgrade it to the max level. Upgrading your bike will improve its performance and make it faster, more agile, and more durable. You can upgrade your bike's engine, tires, suspension, brakes, nitro, and body. You can also customize your bike's color and stickers to make it look cool.
-
Challenge Yourself in Different Modes
-
A fourth important thing to consider when playing Real Bike Racing Game Mod APK is challenging yourself in different modes. The game offers various modes that test your skills and abilities in different ways. You can play in Career mode, where you have to complete various missions and objectives. You can play in VR mode, where you can experience the game in virtual reality using a VR headset. You can play in Championship mode, where you have to compete with other riders in a tournament. You can also play in Time Trial mode, where you have to beat the clock and set new records.
-
Conclusion
-
Real Bike Racing Game Mod APK is a great game for motorcycle racing fans who want to enjoy the game without any limitations or interruptions. It gives you unlimited money, all bikes and tracks unlocked, and no ads. It also lets you experience realistic graphics, sound effects, and physics that make you feel like you are riding a real bike. You can choose from over 20 different bikes, each with its own specifications and performance. You can also race on 10 different tracks, each with its own challenges and scenery. You can also challenge yourself in different modes, such as Career, VR, Championship, and Time Trial.
-
If you want to download and install Real Bike Racing Game Mod APK, just follow the simple steps we mentioned above. And if you want to improve your skills and win every race, just follow the tips and tricks we shared with you. We hope this article was helpful and informative for you. Now go ahead and enjoy playing Real Bike Racing Game Mod APK.
-
FAQs
-
Here are some frequently asked questions about Real Bike Racing Game Mod APK:
-
-Is Real Bike Racing Game Mod APK safe to download and install? Do I need to root my device to play Real Bike Racing Game Mod APK? Can I play Real Bike Racing Game Mod APK online with other players? What are the minimum requirements to play Real Bike Racing Game Mod APK?
-Android version: 4.1 or higher
-RAM: 1 GB or more
-Storage: 100 MB or more
-Internet connection: required for online mode
-
-How can I contact the developers of Real Bike Racing Game Mod APK? 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Word Search Express - Quick and Easy Puzzles Online.md b/spaces/congsaPfin/Manga-OCR/logs/Word Search Express - Quick and Easy Puzzles Online.md
deleted file mode 100644
index c7826c559e36dcfb2bba8c0cfa5750c5b11b0976..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Word Search Express - Quick and Easy Puzzles Online.md
+++ /dev/null
@@ -1,165 +0,0 @@
-
-
Word Search Puzzle: A Fun and Educational Brain Game
-
Do you enjoy finding hidden words in a grid of letters? Do you like challenging your brain and expanding your vocabulary? If you answered yes, then you might be a fan of word search puzzles. Word search puzzles are one of the most popular types of word games that millions of people play every day. They are not only fun and entertaining, but also educational and beneficial for your brain health. In this article, we will explore what word search puzzles are, what are their benefits, how to play them effectively, and where to find or create them.
-
What is a word search puzzle?
-
A word search puzzle is a game that consists of a grid of letters with hidden words that you have to find. The words can be arranged horizontally, vertically, diagonally, or backwards, and they can be related to a specific theme or topic. The goal is to find all the words in the grid as fast as possible.
-
word search puzzle Download Zip ★★★★★ https://urlca.com/2uO9gu
-
The basic rules of word search puzzles
-
The rules of word search puzzles are simple and easy to follow. Here are the main steps:
-
-Look at the list of words that you have to find in the grid.
-Scan the grid for any words that stand out or catch your eye.
-When you find a word, circle it or highlight it with a pen or a marker.
-Cross out the word from the list once you find it.
-Repeat until you find all the words in the list.
-
-
The different types of word search puzzles
-
There are many types of word search puzzles that vary in difficulty, size, and format. Some of the most common types are:
-
-Classic word search puzzles: These are the standard puzzles that have a square or rectangular grid with words hidden in different directions.
-Crossword-style word search puzzles: These are similar to classic puzzles, but instead of a list of words, you have clues or definitions that you have to match with the words in the grid.
-Wordle-style word search puzzles: These are a new type of puzzles that have become very popular recently. They consist of a five-letter word that you have to guess within six attempts. You get feedback on how many letters are correct and in the right position after each guess.
-Board game-style word search puzzles: These are puzzles that resemble board games like Scrabble or Words With Friends. You have to form words from letter tiles on a board and compete with other players or against the clock.
-
-
What are the benefits of playing word search puzzles?
-
Playing word search puzzles is not only enjoyable, but also good for your brain and overall well-being. Here are some of the benefits of playing word search puzzles:
-
word search puzzle maker
-
Supports language fluency and spelling
-
Word search puzzles expose you to new words and phrases that can enrich your vocabulary and improve your communication skills. They also help you practice your spelling and learn how to spell tricky or uncommon words correctly.
-
Improves concentration and focus
-
Word search puzzles require you to pay attention to details and scan the grid carefully for. hidden words. This helps you improve your concentration and focus, which are essential skills for learning and working efficiently.
-
Enhances memory and cognitive function
-
Word search puzzles stimulate your brain and activate different regions that are responsible for memory, language, and logic. They also challenge your brain to recall words and information that you have learned before. This enhances your memory and cognitive function, which can prevent or delay the onset of age-related cognitive decline and dementia.
-
Relieves stress and boredom
-
Word search puzzles are a great way to relax and unwind after a long day or a stressful situation. They can distract you from your worries and negative thoughts, and provide you with a sense of accomplishment and satisfaction. They can also keep you entertained and engaged when you are bored or have nothing else to do.
-
Boosts creativity and problem-solving skills
-
Word search puzzles encourage you to think outside the box and use your imagination to find words that are hidden or not obvious. They also require you to use your problem-solving skills to figure out the best strategies and techniques to solve the puzzles. This boosts your creativity and problem-solving skills, which can help you in various aspects of life and work.
-
How to play word search puzzles effectively?
-
Playing word search puzzles can be easy or hard, depending on the level of difficulty, the size of the grid, and the number of words. However, there are some tips and tricks that can help you play word search puzzles effectively and improve your performance. Here are some of them:
-
Ignore the word list at first
-
One of the best ways to play word search puzzles effectively is to ignore the word list at first and focus on the grid. This way, you can spot any words that are obvious or stand out, without being influenced by the list. You can also find words that are not in the list, which can give you extra points or hints.
-
Search for multiple words at a time
-
Another tip is to search for multiple words at a time, instead of looking for one word at a time. This can save you time and energy, as you can find more words in less time. You can do this by looking for common prefixes, suffixes, roots, or patterns that can form multiple words. For example, if you see the letters "ing", you can look for words that end with "ing", such as "running", "singing", or "ringing".
-
Look for unique letters and letter pairings
-
A third tip is to look for unique letters and letter pairings that can help you narrow down your search. For example, if you see a letter "q", you can look for words that have a "u" next to it, such as "queen", "quiz", or "quilt". Similarly, if you see a letter "x", you can look for words that have an "e" before it, such as "exit", "exile", or "excel".
-
Turn the puzzle upside-down or sideways
-
A fourth tip is to turn the puzzle upside-down or sideways, which can help you see the grid from a different perspective and find words that you might have missed before. This can also help you find words that are backwards or diagonal, which can be harder to spot otherwise.
-
Use online tools or apps for help
-
A fifth tip is to use online tools or apps for help, especially if you are stuck or want to check your answers. There are many websites and platforms that offer free word search puzzles that you can play online or print out. There are also word search maker tools and software that allow you to create your own word search puzzles with custom themes and topics. Some examples of these tools are:
-
-
-Name
-Description
-URL
-
-
-The Word Search
-A website that offers hundreds of free word search puzzles on various categories and levels of difficulty.
-[1](https://thewordsearch.com/)
-
-
-Puzzlemaker
-A website that allows you to create your own word search puzzles with custom words and clues.
-[2](https://www.puzzle-maker.com/WS/)
-
-
-Word Search Puzzle Maker
-A software that enables you to create professional-looking word search puzzles with custom fonts, colors, shapes, and sizes.
-[3](https://www.word-search-puzzle-maker.com/)
-
-
-Word Search Puzzle Game
-An app that lets you play unlimited word search puzzles on your phone or tablet with different themes and modes.
-[4](https://play.google.com/store/apps/details?id=com.wordsearch.puzzle.game&hl=en_US&gl=US)
-
-
-
Where to find or create word search puzzles?
-
If you are looking for more word search puzzles to play or create, you have plenty of options to choose from. Here are some of the places where you can find or create word search puzzles:
-
Online websites and platforms
-
One of the easiest and most convenient ways to find or create word search puzzles is to use online websites and platforms that offer free or paid services. You can access thousands of word search puzzles on various topics and levels of difficulty, or you can create your own word search puzzles with custom words and clues. Some of the online websites and platforms that you can use are:
-
-[The Word Search]: A website that offers hundreds of free word search puzzles on various categories and levels of difficulty.
-[Puzzlemaker]: A website that allows you to create your own word search puzzles with custom words and clues.
-[Word Search Puzzle Maker]: A software that enables you to create professional-looking word search puzzles with custom fonts, colors, shapes, and sizes.
-[Word Search Puzzle Game]: An app that lets you play unlimited word search puzzles on your phone or tablet with different themes and modes.
-
-
Printable books and magazines
-
Another way to find or create word search puzzles is to use printable books and magazines that contain word search puzzles on various topics and levels of difficulty. You can buy these books and magazines from bookstores, online stores, or libraries, or you can print them out from online sources. Some of the printable books and magazines that you can use are:
-
-[The Everything Large-Print Word Search Book](https://www.amazon.com/Everything-Large-Print-Word-Search-Book/dp/1440503190): A book that contains 150 easy-to-read word search puzzles on different themes.
-[The Big Book of Wordsearch: 500 Puzzles](https://www.amazon.com/Big-Book-Wordsearch-Puzzles/dp/1789503258): A book that contains 500 challenging word search puzzles on various topics.
-[Word Search Magazine](https://www.pennydellpuzzles.com/magazines/word-search/): A magazine that features 107 word search puzzles on different themes in each issue.
-[Word Search Puzzles Printable](https://www.freeprintable.com/free-printable-word-search): A website that offers free printable word search puzzles on various topics and levels of difficulty.
-
-
Word search maker tools and software
-
A third way to find or create word search puzzles is to use word search maker tools and software that allow you to create your own word search puzzles with custom words, clues, fonts, colors, shapes, and sizes. You can download these tools and software on your computer or use them online. Some of the word search maker tools and software that you can use are:
-
-[Word Search Puzzle Maker]: A software that enables you to create professional-looking word search puzzles with custom fonts, colors, shapes, and sizes.
-[Puzzlemaker]: A website that allows you to create your own word search puzzles with custom words and clues.
-[Discovery Education's Puzzlemaker](https://www.discoveryeducation.com/free-puzzlemaker/): A website that allows you to create your own word search puzzles with custom words, clues, fonts, colors, shapes, and sizes.
-[ABCya! Word Search Maker](https://www.abcya.com/games/make_a_word_search): A website that allows you to create your own word search puzzles with custom words, clues, fonts, colors, shapes, and sizes.
-
-
Conclusion
-
Word search puzzles are a fun and educational brain game that can provide you with many benefits. They can support your language fluency and spelling, improve your concentration and focus, enhance your memory and cognitive function, relieve your stress and boredom, and boost your creativity and problem-solving skills. They are also easy to play and accessible from various sources. You can find or create word search puzzles online, in printable books and magazines, or using word search maker tools and software. Whether you play them for fun or for learning, word search puzzles are a great way to exercise your brain and have fun at the same time.
-
FAQs Here are some of the frequently asked questions about word search puzzles:
-
-How do you make a word search puzzle more difficult?
-There are several ways to make a word search puzzle more difficult, such as increasing the size of the grid, adding more words, using longer or uncommon words, hiding words in multiple directions, overlapping words, using similar-looking letters, or omitting the word list.
-How do you solve a word search puzzle faster?
-There are several tips and tricks to solve a word search puzzle faster, such as ignoring the word list at first, searching for multiple words at a time, looking for unique letters and letter pairings, turning the puzzle upside-down or sideways, or using online tools or apps for help.
-What are some of the best word search puzzle themes or topics?
-There are many word search puzzle themes or topics that you can choose from, depending on your interests and preferences. Some of the most popular ones are animals, food, sports, holidays, movies, music, geography, history, science, and literature.
-How do you create your own word search puzzle?
-There are many ways to create your own word search puzzle, depending on the tools and resources that you have. You can use online websites and platforms that allow you to create your own word search puzzles with custom words and clues, such as Puzzlemaker or Word Search Puzzle Maker. You can also use printable books and magazines that contain blank grids and templates that you can fill in with your own words and clues. You can also use word search maker tools and software that enable you to create professional-looking word search puzzles with custom fonts, colors, shapes, and sizes.
-How do you play word search puzzles with others?
-There are many ways to play word search puzzles with others, depending on the type and format of the puzzles. You can play online word search puzzles with other players or against the clock on websites and platforms like The Word Search or Word Search Puzzle Game. You can also play printable word search puzzles with your friends or family by taking turns to find words or competing to see who can find more words in a given time. You can also create your own word search puzzles with custom words and clues that relate to your group or occasion.
- 401be4b1e0
-
-
\ No newline at end of file
diff --git a/spaces/congsaPfin/Manga-OCR/logs/Zombie Catchers APK Hunt Zombies with Harpoons Nets and Traps.md b/spaces/congsaPfin/Manga-OCR/logs/Zombie Catchers APK Hunt Zombies with Harpoons Nets and Traps.md
deleted file mode 100644
index 1305dd473e9655f076c508ed5fc814385a374f83..0000000000000000000000000000000000000000
--- a/spaces/congsaPfin/Manga-OCR/logs/Zombie Catchers APK Hunt Zombies with Harpoons Nets and Traps.md
+++ /dev/null
@@ -1,116 +0,0 @@
-
-
-
-
-
- Zombie Catchers APK: A Fun and Addictive Game for Android
-Introduction
-Do you love zombies? Do you love catching them? Do you love making money from them? If you answered yes to any of these questions, then you will love Zombie Catchers APK. Zombie Catchers APK is a casual action adventure game in a futuristic world riddled by a zombie invasion. You play as A.J. and Bud, two intergalactic businessmen who have decided to build a business empire by catching zombies and turning them into delicious products. Sounds fun, right?
-Zombie Catchers APK is one of the most popular games on Android, with over 50 million downloads and a 4.7-star rating on Google Play. It has been praised for its fun and engaging gameplay, colorful and cartoonish graphics, original and humorous story, and variety of features. It is also free to download and play, although it contains ads and in-app purchases that can enhance your experience.
-zombie catchers apk Download Zip 🔗 https://urlca.com/2uO8BL
If you are interested in trying out Zombie Catchers APK, you can easily download it from Uptodown or APKCombo. These are reliable sources that offer safe and updated versions of the game. All you need to do is click on the download button, install the APK file on your device, and start catching zombies!
-Features of Zombie Catchers APK
-Catch zombies with different gadgets
-One of the main features of Zombie Catchers APK is catching zombies with different gadgets. You can use a harpoon gun to shoot zombies from a distance, a net gun to trap them in a web, or a tranquilizer gun to put them to sleep. You can also use a jetpack to fly over obstacles, a drone to scout the area, or a sneaky suit to camouflage yourself. You can also upgrade your gadgets to make them more effective and efficient.
-Build your own zombie business empire
-Another feature of Zombie Catchers APK is building your own zombie business empire. You can use the zombies you catch to make various products, such as juices, candies, burgers, and more. You can sell these products at your juice stand, factory, or laboratory, and earn coins and plutonium. You can use these resources to expand your business, unlock new locations, and discover new zombies. You can also hire assistants to help you run your business and increase your profits.
-Explore different locations and discover new zombies
-Zombie Catchers APK also lets you explore different locations and discover new zombies. You can travel to the swamp, the beach, the city, and more, and find different types of zombies. Some zombies are easy to catch, while others are more challenging and require strategy and timing. Some zombies are also rare and unique, and can fetch a higher price in the market. You can also encounter boss zombies that are more powerful and dangerous, but also more rewarding.
-Upgrade your equipment and skills
-The last feature of Zombie Catchers APK is upgrading your equipment and skills. You can improve your harpoon gun, net gun, tranquilizer gun, jetpack, drone, sneaky suit, and other gadgets by spending coins and plutonium. You can also rank up by completing missions and achievements, and unlock new perks and bonuses. You can also collect trophies and badges to show off your progress and achievements.
-Pros and Cons of Zombie Catchers APK
-Pros
-Zombie Catchers APK has many pros that make it a fun and addictive game for Android. Some of the pros are:
-
-Fun and engaging gameplay: Zombie Catchers APK offers a unique and enjoyable gameplay that combines action, adventure, strategy, and management. You can catch zombies with different gadgets, make products from them, sell them at your business, explore new locations, discover new zombies, upgrade your equipment and skills, and more.
-Colorful and cartoonish graphics: Zombie Catchers APK has a colorful and cartoonish graphics style that suits the game's theme and tone. The game has a bright and vibrant palette that creates a contrast between the futuristic world and the zombie invasion. The game also has a smooth and fluid animation that enhances the gameplay experience.
-Original and humorous story: Zombie Catchers APK has an original and humorous story that adds to the game's charm and appeal. The game follows the adventures of A.J. and Bud, two intergalactic businessmen who have decided to save the world from zombies by turning them into profitable products. The game has a witty and humorous dialogue that makes the characters likable and relatable.
-
-Cons
-Zombie Catchers APK also has some cons that may affect some players' enjoyment of the game. Some of the cons are:
-
-Requires internet connection: Zombie Catchers APK requires an internet connection to play. This means that you cannot play the game offline or in areas with poor or no network coverage. This may limit your access to the game or cause interruptions or delays in your gameplay.
-Contains ads and in-app purchases: Zombie Catchers APK contains ads and in-app purchases that can enhance your gameplay experience. However, some players may find these features annoying or intrusive, as they may disrupt their gameplay or tempt them to spend real money on the game.
-May not be suitable for young children: Zombie Catchers APK may not be suitable for young children due to its theme and content. The game involves catching zombies with weapons, making products from them, selling them at your business, etc. Some parents may find these activities inappropriate or violent for their kids.
-
-Conclusion
-Zombie Catchers APK is a fun and addictive game for Android that offers a unique and enjoyable gameplay that combines action, adventure, strategy, and management. You can catch zombies with different gadgets, make products from them, sell them at your business, explore new locations, discover new zombies, upgrade your equipment and skills, and more. The game has a colorful and cartoonish graphics style, an original and humorous story, and a variety of features. The game is also free to download and play, although it requires an internet connection and contains ads and in-app purchases. The game may not be suitable for young children due to its theme and content.
-zombie catchers apk mod
-If you are looking for a fun and addictive game for Android that will keep you entertained for hours, you should definitely download Zombie Catchers APK. You will not regret it. You will have a blast catching zombies, making products, selling them at your business, exploring new locations, discovering new zombies, upgrading your equipment and skills, and more. You will also enjoy the game's colorful and cartoonish graphics, original and humorous story, and variety of features. You will also be able to play the game for free, although you may want to spend some money on the game to enhance your experience.
-So what are you waiting for? Download Zombie Catchers APK today and start catching zombies! You will love it!
-FAQs
-Q: What is Zombie Catchers APK?
-A: Zombie Catchers APK is a casual action adventure game in a futuristic world riddled by a zombie invasion. You play as A.J. and Bud, two intergalactic businessmen who have decided to build a business empire by catching zombies and turning them into delicious products.
-Q: How can I download Zombie Catchers APK?
-A: You can download Zombie Catchers APK from Uptodown or APKCombo. These are reliable sources that offer safe and updated versions of the game. All you need to do is click on the download button, install the APK file on your device, and start catching zombies!
-Q: What are the features of Zombie Catchers APK?
-A: Zombie Catchers APK has many features that make it a fun and addictive game for Android. Some of the features are:
-
-Catch zombies with different gadgets
-Build your own zombie business empire
-Explore different locations and discover new zombies
-Upgrade your equipment and skills
-
-Q: What are the pros and cons of Zombie Catchers APK?
-A: Zombie Catchers APK has many pros and cons that may affect your enjoyment of the game. Some of the pros are:
-
-Fun and engaging gameplay
-Colorful and cartoonish graphics
-Original and humorous story
-
-Some of the cons are:
-
-Requires internet connection
-Contains ads and in-app purchases
-May not be suitable for young children
-
-Q: Is Zombie Catchers APK safe to download?
-A: Yes, Zombie Catchers APK is safe to download from Uptodown or APKCombo. These are reputable sources that offer virus-free and malware-free versions of the game. However, you should always be careful when downloading any APK file from unknown sources, as they may contain harmful or malicious software.
197e85843dEntrepreneurial Finance 4th Leach Melicher Pdf Download File 🗹 https://ssurll.com/2uzylf
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/blocks.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/blocks.py
deleted file mode 100644
index 1995a4bf7339e8deb7eaaffda4f819dda55e7ac7..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/blocks.py
+++ /dev/null
@@ -1,111 +0,0 @@
-# -*- coding: utf-8 -*-
-# Copyright (c) Facebook, Inc. and its affiliates.
-
-import fvcore.nn.weight_init as weight_init
-from torch import nn
-
-from .batch_norm import FrozenBatchNorm2d, get_norm
-from .wrappers import Conv2d
-
-
-"""
-CNN building blocks.
-"""
-
-
-class CNNBlockBase(nn.Module):
- """
- A CNN block is assumed to have input channels, output channels and a stride.
- The input and output of `forward()` method must be NCHW tensors.
- The method can perform arbitrary computation but must match the given
- channels and stride specification.
-
- Attribute:
- in_channels (int):
- out_channels (int):
- stride (int):
- """
-
- def __init__(self, in_channels, out_channels, stride):
- """
- The `__init__` method of any subclass should also contain these arguments.
-
- Args:
- in_channels (int):
- out_channels (int):
- stride (int):
- """
- super().__init__()
- self.in_channels = in_channels
- self.out_channels = out_channels
- self.stride = stride
-
- def freeze(self):
- """
- Make this block not trainable.
- This method sets all parameters to `requires_grad=False`,
- and convert all BatchNorm layers to FrozenBatchNorm
-
- Returns:
- the block itself
- """
- for p in self.parameters():
- p.requires_grad = False
- FrozenBatchNorm2d.convert_frozen_batchnorm(self)
- return self
-
-
-class DepthwiseSeparableConv2d(nn.Module):
- """
- A kxk depthwise convolution + a 1x1 convolution.
-
- In :paper:`xception`, norm & activation are applied on the second conv.
- :paper:`mobilenet` uses norm & activation on both convs.
- """
-
- def __init__(
- self,
- in_channels,
- out_channels,
- kernel_size=3,
- padding=1,
- dilation=1,
- *,
- norm1=None,
- activation1=None,
- norm2=None,
- activation2=None,
- ):
- """
- Args:
- norm1, norm2 (str or callable): normalization for the two conv layers.
- activation1, activation2 (callable(Tensor) -> Tensor): activation
- function for the two conv layers.
- """
- super().__init__()
- self.depthwise = Conv2d(
- in_channels,
- in_channels,
- kernel_size=kernel_size,
- padding=padding,
- dilation=dilation,
- groups=in_channels,
- bias=not norm1,
- norm=get_norm(norm1, in_channels),
- activation=activation1,
- )
- self.pointwise = Conv2d(
- in_channels,
- out_channels,
- kernel_size=1,
- bias=not norm2,
- norm=get_norm(norm2, out_channels),
- activation=activation2,
- )
-
- # default initialization
- weight_init.c2_msra_fill(self.depthwise)
- weight_init.c2_msra_fill(self.pointwise)
-
- def forward(self, x):
- return self.pointwise(self.depthwise(x))
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/cocoeval/cocoeval.cpp b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/cocoeval/cocoeval.cpp
deleted file mode 100644
index 0a5b7b907c06720fefc77b0dfd921b8ec3ecf2be..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/oneformer/detectron2/layers/csrc/cocoeval/cocoeval.cpp
+++ /dev/null
@@ -1,507 +0,0 @@
-// Copyright (c) Facebook, Inc. and its affiliates.
-#include "cocoeval.h"
-#include
-#include
-#include
-#include
-
-using namespace pybind11::literals;
-
-namespace detectron2 {
-
-namespace COCOeval {
-
-// Sort detections from highest score to lowest, such that
-// detection_instances[detection_sorted_indices[t]] >=
-// detection_instances[detection_sorted_indices[t+1]]. Use stable_sort to match
-// original COCO API
-void SortInstancesByDetectionScore(
- const std::vector& detection_instances,
- std::vector* detection_sorted_indices) {
- detection_sorted_indices->resize(detection_instances.size());
- std::iota(
- detection_sorted_indices->begin(), detection_sorted_indices->end(), 0);
- std::stable_sort(
- detection_sorted_indices->begin(),
- detection_sorted_indices->end(),
- [&detection_instances](size_t j1, size_t j2) {
- return detection_instances[j1].score > detection_instances[j2].score;
- });
-}
-
-// Partition the ground truth objects based on whether or not to ignore them
-// based on area
-void SortInstancesByIgnore(
- const std::array& area_range,
- const std::vector& ground_truth_instances,
- std::vector* ground_truth_sorted_indices,
- std::vector* ignores) {
- ignores->clear();
- ignores->reserve(ground_truth_instances.size());
- for (auto o : ground_truth_instances) {
- ignores->push_back(
- o.ignore || o.area < area_range[0] || o.area > area_range[1]);
- }
-
- ground_truth_sorted_indices->resize(ground_truth_instances.size());
- std::iota(
- ground_truth_sorted_indices->begin(),
- ground_truth_sorted_indices->end(),
- 0);
- std::stable_sort(
- ground_truth_sorted_indices->begin(),
- ground_truth_sorted_indices->end(),
- [&ignores](size_t j1, size_t j2) {
- return (int)(*ignores)[j1] < (int)(*ignores)[j2];
- });
-}
-
-// For each IOU threshold, greedily match each detected instance to a ground
-// truth instance (if possible) and store the results
-void MatchDetectionsToGroundTruth(
- const std::vector& detection_instances,
- const std::vector& detection_sorted_indices,
- const std::vector& ground_truth_instances,
- const std::vector& ground_truth_sorted_indices,
- const std::vector& ignores,
- const std::vector>& ious,
- const std::vector& iou_thresholds,
- const std::array& area_range,
- ImageEvaluation* results) {
- // Initialize memory to store return data matches and ignore
- const int num_iou_thresholds = iou_thresholds.size();
- const int num_ground_truth = ground_truth_sorted_indices.size();
- const int num_detections = detection_sorted_indices.size();
- std::vector ground_truth_matches(
- num_iou_thresholds * num_ground_truth, 0);
- std::vector& detection_matches = results->detection_matches;
- std::vector& detection_ignores = results->detection_ignores;
- std::vector& ground_truth_ignores = results->ground_truth_ignores;
- detection_matches.resize(num_iou_thresholds * num_detections, 0);
- detection_ignores.resize(num_iou_thresholds * num_detections, false);
- ground_truth_ignores.resize(num_ground_truth);
- for (auto g = 0; g < num_ground_truth; ++g) {
- ground_truth_ignores[g] = ignores[ground_truth_sorted_indices[g]];
- }
-
- for (auto t = 0; t < num_iou_thresholds; ++t) {
- for (auto d = 0; d < num_detections; ++d) {
- // information about best match so far (match=-1 -> unmatched)
- double best_iou = std::min(iou_thresholds[t], 1 - 1e-10);
- int match = -1;
- for (auto g = 0; g < num_ground_truth; ++g) {
- // if this ground truth instance is already matched and not a
- // crowd, it cannot be matched to another detection
- if (ground_truth_matches[t * num_ground_truth + g] > 0 &&
- !ground_truth_instances[ground_truth_sorted_indices[g]].is_crowd) {
- continue;
- }
-
- // if detected instance matched to a regular ground truth
- // instance, we can break on the first ground truth instance
- // tagged as ignore (because they are sorted by the ignore tag)
- if (match >= 0 && !ground_truth_ignores[match] &&
- ground_truth_ignores[g]) {
- break;
- }
-
- // if IOU overlap is the best so far, store the match appropriately
- if (ious[d][ground_truth_sorted_indices[g]] >= best_iou) {
- best_iou = ious[d][ground_truth_sorted_indices[g]];
- match = g;
- }
- }
- // if match was made, store id of match for both detection and
- // ground truth
- if (match >= 0) {
- detection_ignores[t * num_detections + d] = ground_truth_ignores[match];
- detection_matches[t * num_detections + d] =
- ground_truth_instances[ground_truth_sorted_indices[match]].id;
- ground_truth_matches[t * num_ground_truth + match] =
- detection_instances[detection_sorted_indices[d]].id;
- }
-
- // set unmatched detections outside of area range to ignore
- const InstanceAnnotation& detection =
- detection_instances[detection_sorted_indices[d]];
- detection_ignores[t * num_detections + d] =
- detection_ignores[t * num_detections + d] ||
- (detection_matches[t * num_detections + d] == 0 &&
- (detection.area < area_range[0] || detection.area > area_range[1]));
- }
- }
-
- // store detection score results
- results->detection_scores.resize(detection_sorted_indices.size());
- for (size_t d = 0; d < detection_sorted_indices.size(); ++d) {
- results->detection_scores[d] =
- detection_instances[detection_sorted_indices[d]].score;
- }
-}
-
-std::vector EvaluateImages(
- const std::vector>& area_ranges,
- int max_detections,
- const std::vector& iou_thresholds,
- const ImageCategoryInstances>& image_category_ious,
- const ImageCategoryInstances&
- image_category_ground_truth_instances,
- const ImageCategoryInstances&
- image_category_detection_instances) {
- const int num_area_ranges = area_ranges.size();
- const int num_images = image_category_ground_truth_instances.size();
- const int num_categories =
- image_category_ious.size() > 0 ? image_category_ious[0].size() : 0;
- std::vector detection_sorted_indices;
- std::vector ground_truth_sorted_indices;
- std::vector ignores;
- std::vector results_all(
- num_images * num_area_ranges * num_categories);
-
- // Store results for each image, category, and area range combination. Results
- // for each IOU threshold are packed into the same ImageEvaluation object
- for (auto i = 0; i < num_images; ++i) {
- for (auto c = 0; c < num_categories; ++c) {
- const std::vector& ground_truth_instances =
- image_category_ground_truth_instances[i][c];
- const std::vector& detection_instances =
- image_category_detection_instances[i][c];
-
- SortInstancesByDetectionScore(
- detection_instances, &detection_sorted_indices);
- if ((int)detection_sorted_indices.size() > max_detections) {
- detection_sorted_indices.resize(max_detections);
- }
-
- for (size_t a = 0; a < area_ranges.size(); ++a) {
- SortInstancesByIgnore(
- area_ranges[a],
- ground_truth_instances,
- &ground_truth_sorted_indices,
- &ignores);
-
- MatchDetectionsToGroundTruth(
- detection_instances,
- detection_sorted_indices,
- ground_truth_instances,
- ground_truth_sorted_indices,
- ignores,
- image_category_ious[i][c],
- iou_thresholds,
- area_ranges[a],
- &results_all
- [c * num_area_ranges * num_images + a * num_images + i]);
- }
- }
- }
-
- return results_all;
-}
-
-// Convert a python list to a vector
-template
-std::vector list_to_vec(const py::list& l) {
- std::vector v(py::len(l));
- for (int i = 0; i < (int)py::len(l); ++i) {
- v[i] = l[i].cast();
- }
- return v;
-}
-
-// Helper function to Accumulate()
-// Considers the evaluation results applicable to a particular category, area
-// range, and max_detections parameter setting, which begin at
-// evaluations[evaluation_index]. Extracts a sorted list of length n of all
-// applicable detection instances concatenated across all images in the dataset,
-// which are represented by the outputs evaluation_indices, detection_scores,
-// image_detection_indices, and detection_sorted_indices--all of which are
-// length n. evaluation_indices[i] stores the applicable index into
-// evaluations[] for instance i, which has detection score detection_score[i],
-// and is the image_detection_indices[i]'th of the list of detections
-// for the image containing i. detection_sorted_indices[] defines a sorted
-// permutation of the 3 other outputs
-int BuildSortedDetectionList(
- const std::vector& evaluations,
- const int64_t evaluation_index,
- const int64_t num_images,
- const int max_detections,
- std::vector* evaluation_indices,
- std::vector* detection_scores,
- std::vector* detection_sorted_indices,
- std::vector* image_detection_indices) {
- assert(evaluations.size() >= evaluation_index + num_images);
-
- // Extract a list of object instances of the applicable category, area
- // range, and max detections requirements such that they can be sorted
- image_detection_indices->clear();
- evaluation_indices->clear();
- detection_scores->clear();
- image_detection_indices->reserve(num_images * max_detections);
- evaluation_indices->reserve(num_images * max_detections);
- detection_scores->reserve(num_images * max_detections);
- int num_valid_ground_truth = 0;
- for (auto i = 0; i < num_images; ++i) {
- const ImageEvaluation& evaluation = evaluations[evaluation_index + i];
-
- for (int d = 0;
- d < (int)evaluation.detection_scores.size() && d < max_detections;
- ++d) { // detected instances
- evaluation_indices->push_back(evaluation_index + i);
- image_detection_indices->push_back(d);
- detection_scores->push_back(evaluation.detection_scores[d]);
- }
- for (auto ground_truth_ignore : evaluation.ground_truth_ignores) {
- if (!ground_truth_ignore) {
- ++num_valid_ground_truth;
- }
- }
- }
-
- // Sort detections by decreasing score, using stable sort to match
- // python implementation
- detection_sorted_indices->resize(detection_scores->size());
- std::iota(
- detection_sorted_indices->begin(), detection_sorted_indices->end(), 0);
- std::stable_sort(
- detection_sorted_indices->begin(),
- detection_sorted_indices->end(),
- [&detection_scores](size_t j1, size_t j2) {
- return (*detection_scores)[j1] > (*detection_scores)[j2];
- });
-
- return num_valid_ground_truth;
-}
-
-// Helper function to Accumulate()
-// Compute a precision recall curve given a sorted list of detected instances
-// encoded in evaluations, evaluation_indices, detection_scores,
-// detection_sorted_indices, image_detection_indices (see
-// BuildSortedDetectionList()). Using vectors precisions and recalls
-// and temporary storage, output the results into precisions_out, recalls_out,
-// and scores_out, which are large buffers containing many precion/recall curves
-// for all possible parameter settings, with precisions_out_index and
-// recalls_out_index defining the applicable indices to store results.
-void ComputePrecisionRecallCurve(
- const int64_t precisions_out_index,
- const int64_t precisions_out_stride,
- const int64_t recalls_out_index,
- const std::vector& recall_thresholds,
- const int iou_threshold_index,
- const int num_iou_thresholds,
- const int num_valid_ground_truth,
- const std::vector& evaluations,
- const std::vector& evaluation_indices,
- const std::vector& detection_scores,
- const std::vector& detection_sorted_indices,
- const std::vector& image_detection_indices,
- std::vector* precisions,
- std::vector* recalls,
- std::vector* precisions_out,
- std::vector* scores_out,
- std::vector* recalls_out) {
- assert(recalls_out->size() > recalls_out_index);
-
- // Compute precision/recall for each instance in the sorted list of detections
- int64_t true_positives_sum = 0, false_positives_sum = 0;
- precisions->clear();
- recalls->clear();
- precisions->reserve(detection_sorted_indices.size());
- recalls->reserve(detection_sorted_indices.size());
- assert(!evaluations.empty() || detection_sorted_indices.empty());
- for (auto detection_sorted_index : detection_sorted_indices) {
- const ImageEvaluation& evaluation =
- evaluations[evaluation_indices[detection_sorted_index]];
- const auto num_detections =
- evaluation.detection_matches.size() / num_iou_thresholds;
- const auto detection_index = iou_threshold_index * num_detections +
- image_detection_indices[detection_sorted_index];
- assert(evaluation.detection_matches.size() > detection_index);
- assert(evaluation.detection_ignores.size() > detection_index);
- const int64_t detection_match =
- evaluation.detection_matches[detection_index];
- const bool detection_ignores =
- evaluation.detection_ignores[detection_index];
- const auto true_positive = detection_match > 0 && !detection_ignores;
- const auto false_positive = detection_match == 0 && !detection_ignores;
- if (true_positive) {
- ++true_positives_sum;
- }
- if (false_positive) {
- ++false_positives_sum;
- }
-
- const double recall =
- static_cast(true_positives_sum) / num_valid_ground_truth;
- recalls->push_back(recall);
- const int64_t num_valid_detections =
- true_positives_sum + false_positives_sum;
- const double precision = num_valid_detections > 0
- ? static_cast(true_positives_sum) / num_valid_detections
- : 0.0;
- precisions->push_back(precision);
- }
-
- (*recalls_out)[recalls_out_index] = !recalls->empty() ? recalls->back() : 0;
-
- for (int64_t i = static_cast(precisions->size()) - 1; i > 0; --i) {
- if ((*precisions)[i] > (*precisions)[i - 1]) {
- (*precisions)[i - 1] = (*precisions)[i];
- }
- }
-
- // Sample the per instance precision/recall list at each recall threshold
- for (size_t r = 0; r < recall_thresholds.size(); ++r) {
- // first index in recalls >= recall_thresholds[r]
- std::vector::iterator low = std::lower_bound(
- recalls->begin(), recalls->end(), recall_thresholds[r]);
- size_t precisions_index = low - recalls->begin();
-
- const auto results_ind = precisions_out_index + r * precisions_out_stride;
- assert(results_ind < precisions_out->size());
- assert(results_ind < scores_out->size());
- if (precisions_index < precisions->size()) {
- (*precisions_out)[results_ind] = (*precisions)[precisions_index];
- (*scores_out)[results_ind] =
- detection_scores[detection_sorted_indices[precisions_index]];
- } else {
- (*precisions_out)[results_ind] = 0;
- (*scores_out)[results_ind] = 0;
- }
- }
-}
-py::dict Accumulate(
- const py::object& params,
- const std::vector& evaluations) {
- const std::vector recall_thresholds =
- list_to_vec(params.attr("recThrs"));
- const std::vector max_detections =
- list_to_vec(params.attr("maxDets"));
- const int num_iou_thresholds = py::len(params.attr("iouThrs"));
- const int num_recall_thresholds = py::len(params.attr("recThrs"));
- const int num_categories = params.attr("useCats").cast() == 1
- ? py::len(params.attr("catIds"))
- : 1;
- const int num_area_ranges = py::len(params.attr("areaRng"));
- const int num_max_detections = py::len(params.attr("maxDets"));
- const int num_images = py::len(params.attr("imgIds"));
-
- std::vector precisions_out(
- num_iou_thresholds * num_recall_thresholds * num_categories *
- num_area_ranges * num_max_detections,
- -1);
- std::vector recalls_out(
- num_iou_thresholds * num_categories * num_area_ranges *
- num_max_detections,
- -1);
- std::vector scores_out(
- num_iou_thresholds * num_recall_thresholds * num_categories *
- num_area_ranges * num_max_detections,
- -1);
-
- // Consider the list of all detected instances in the entire dataset in one
- // large list. evaluation_indices, detection_scores,
- // image_detection_indices, and detection_sorted_indices all have the same
- // length as this list, such that each entry corresponds to one detected
- // instance
- std::vector evaluation_indices; // indices into evaluations[]
- std::vector detection_scores; // detection scores of each instance
- std::vector detection_sorted_indices; // sorted indices of all
- // instances in the dataset
- std::vector
- image_detection_indices; // indices into the list of detected instances in
- // the same image as each instance
- std::vector precisions, recalls;
-
- for (auto c = 0; c < num_categories; ++c) {
- for (auto a = 0; a < num_area_ranges; ++a) {
- for (auto m = 0; m < num_max_detections; ++m) {
- // The COCO PythonAPI assumes evaluations[] (the return value of
- // COCOeval::EvaluateImages() is one long list storing results for each
- // combination of category, area range, and image id, with categories in
- // the outermost loop and images in the innermost loop.
- const int64_t evaluations_index =
- c * num_area_ranges * num_images + a * num_images;
- int num_valid_ground_truth = BuildSortedDetectionList(
- evaluations,
- evaluations_index,
- num_images,
- max_detections[m],
- &evaluation_indices,
- &detection_scores,
- &detection_sorted_indices,
- &image_detection_indices);
-
- if (num_valid_ground_truth == 0) {
- continue;
- }
-
- for (auto t = 0; t < num_iou_thresholds; ++t) {
- // recalls_out is a flattened vectors representing a
- // num_iou_thresholds X num_categories X num_area_ranges X
- // num_max_detections matrix
- const int64_t recalls_out_index =
- t * num_categories * num_area_ranges * num_max_detections +
- c * num_area_ranges * num_max_detections +
- a * num_max_detections + m;
-
- // precisions_out and scores_out are flattened vectors
- // representing a num_iou_thresholds X num_recall_thresholds X
- // num_categories X num_area_ranges X num_max_detections matrix
- const int64_t precisions_out_stride =
- num_categories * num_area_ranges * num_max_detections;
- const int64_t precisions_out_index = t * num_recall_thresholds *
- num_categories * num_area_ranges * num_max_detections +
- c * num_area_ranges * num_max_detections +
- a * num_max_detections + m;
-
- ComputePrecisionRecallCurve(
- precisions_out_index,
- precisions_out_stride,
- recalls_out_index,
- recall_thresholds,
- t,
- num_iou_thresholds,
- num_valid_ground_truth,
- evaluations,
- evaluation_indices,
- detection_scores,
- detection_sorted_indices,
- image_detection_indices,
- &precisions,
- &recalls,
- &precisions_out,
- &scores_out,
- &recalls_out);
- }
- }
- }
- }
-
- time_t rawtime;
- struct tm local_time;
- std::array buffer;
- time(&rawtime);
-#ifdef _WIN32
- localtime_s(&local_time, &rawtime);
-#else
- localtime_r(&rawtime, &local_time);
-#endif
- strftime(
- buffer.data(), 200, "%Y-%m-%d %H:%num_max_detections:%S", &local_time);
- return py::dict(
- "params"_a = params,
- "counts"_a = std::vector(
- {num_iou_thresholds,
- num_recall_thresholds,
- num_categories,
- num_area_ranges,
- num_max_detections}),
- "date"_a = buffer,
- "precision"_a = precisions_out,
- "recall"_a = recalls_out,
- "scores"_a = scores_out);
-}
-
-} // namespace COCOeval
-
-} // namespace detectron2
diff --git a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/exp/upernet_global_small/test_config_g.py b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/exp/upernet_global_small/test_config_g.py
deleted file mode 100644
index e43737a98a3b174a9f2fe059c06d511144686459..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/uniformer/exp/upernet_global_small/test_config_g.py
+++ /dev/null
@@ -1,38 +0,0 @@
-_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=[3, 4, 8, 3],
- head_dim=64,
- drop_path_rate=0.25,
- 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/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/zoe/zoedepth/models/base_models/midas_repo/ros/additions/install_ros_melodic_ubuntu_17_18.sh b/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/zoe/zoedepth/models/base_models/midas_repo/ros/additions/install_ros_melodic_ubuntu_17_18.sh
deleted file mode 100644
index b868112631e9d9bc7bccb601407dfc857b8a99d5..0000000000000000000000000000000000000000
--- a/spaces/coreml-community/ControlNet-v1-1-Annotators-cpu/annotator/zoe/zoedepth/models/base_models/midas_repo/ros/additions/install_ros_melodic_ubuntu_17_18.sh
+++ /dev/null
@@ -1,34 +0,0 @@
-#@title { display-mode: "code" }
-
-#from http://wiki.ros.org/indigo/Installation/Ubuntu
-
-#1.2 Setup sources.list
-sudo sh -c 'echo "deb http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" > /etc/apt/sources.list.d/ros-latest.list'
-
-# 1.3 Setup keys
-sudo apt-key adv --keyserver 'hkp://keyserver.ubuntu.com:80' --recv-key C1CF6E31E6BADE8868B172B4F42ED6FBAB17C654
-sudo apt-key adv --keyserver 'hkp://ha.pool.sks-keyservers.net:80' --recv-key 421C365BD9FF1F717815A3895523BAEEB01FA116
-
-curl -sSL 'http://keyserver.ubuntu.com/pks/lookup?op=get&search=0xC1CF6E31E6BADE8868B172B4F42ED6FBAB17C654' | sudo apt-key add -
-
-# 1.4 Installation
-sudo apt-get update
-sudo apt-get upgrade
-
-# Desktop-Full Install:
-sudo apt-get install ros-melodic-desktop-full
-
-printf "\nsource /opt/ros/melodic/setup.bash\n" >> ~/.bashrc
-
-# 1.5 Initialize rosdep
-sudo rosdep init
-rosdep update
-
-
-# 1.7 Getting rosinstall (python)
-sudo apt-get install python-rosinstall
-sudo apt-get install python-catkin-tools
-sudo apt-get install python-rospy
-sudo apt-get install python-rosdep
-sudo apt-get install python-roscd
-sudo apt-get install python-pip
\ No newline at end of file
diff --git a/spaces/coyotte508/static-light-dark/index.html b/spaces/coyotte508/static-light-dark/index.html
deleted file mode 100644
index 58275de3b1c343a98420342baa076b9baaafa157..0000000000000000000000000000000000000000
--- a/spaces/coyotte508/static-light-dark/index.html
+++ /dev/null
@@ -1,19 +0,0 @@
-
-
-
- My static Space
-
-
Welcome to your static Space!
-
You can modify this app directly by editing index.html in the Files and versions tab.
-
- Also don't forget to check the
- Spaces documentation .
-
-
{escaped} ')
-
- def draw_rubberband(self, event, x0, y0, x1, y1):
- height = self.canvas.figure.bbox.height
- y1 = height - y1
- y0 = height - y0
- rect = [int(val) for val in (x0, y0, x1 - x0, y1 - y0)]
- self.canvas._draw_rubberband(rect)
-
- def remove_rubberband(self):
- self.canvas._draw_rubberband(None)
-
- def _update_buttons_checked(self):
- for name, active in [("Pan", "PAN"), ("Zoom", "ZOOM")]:
- button = self._gtk_ids.get(name)
- if button:
- with button.handler_block(button._signal_handler):
- button.set_active(self.mode.name == active)
-
- def pan(self, *args):
- super().pan(*args)
- self._update_buttons_checked()
-
- def zoom(self, *args):
- super().zoom(*args)
- self._update_buttons_checked()
-
- def set_history_buttons(self):
- can_backward = self._nav_stack._pos > 0
- can_forward = self._nav_stack._pos < len(self._nav_stack._elements) - 1
- if 'Back' in self._gtk_ids:
- self._gtk_ids['Back'].set_sensitive(can_backward)
- if 'Forward' in self._gtk_ids:
- self._gtk_ids['Forward'].set_sensitive(can_forward)
-
-
-class RubberbandGTK(backend_tools.RubberbandBase):
- def draw_rubberband(self, x0, y0, x1, y1):
- _NavigationToolbar2GTK.draw_rubberband(
- self._make_classic_style_pseudo_toolbar(), None, x0, y0, x1, y1)
-
- def remove_rubberband(self):
- _NavigationToolbar2GTK.remove_rubberband(
- self._make_classic_style_pseudo_toolbar())
-
-
-class ConfigureSubplotsGTK(backend_tools.ConfigureSubplotsBase):
- def trigger(self, *args):
- _NavigationToolbar2GTK.configure_subplots(self, None)
-
-
-class _BackendGTK(_Backend):
- backend_version = "%s.%s.%s" % (
- Gtk.get_major_version(),
- Gtk.get_minor_version(),
- Gtk.get_micro_version(),
- )
- mainloop = _FigureManagerGTK.start_main_loop
diff --git a/spaces/decodemai/market_sizing/app.py b/spaces/decodemai/market_sizing/app.py
deleted file mode 100644
index 00c63549ead77dd42e85f6cb4c62487fa96f1e13..0000000000000000000000000000000000000000
--- a/spaces/decodemai/market_sizing/app.py
+++ /dev/null
@@ -1,101 +0,0 @@
-import json
-import requests
-import gradio as gr
-import random
-import time
-import os
-import datetime
-from datetime import datetime
-
-#print('for update')
-
-API_TOKEN = os.getenv("API_TOKEN")
-DECODEM_TOKEN=os.getenv("DECODEM_TOKEN")
-
-
-from huggingface_hub import InferenceApi
-inference = InferenceApi("bigscience/bloom",token=API_TOKEN)
-
-headers = {'Content-type': 'application/json', 'Accept': 'text/plain'}
-url_decodemprompts='https://us-central1-createinsightsproject.cloudfunctions.net/getdecodemprompts'
-
-data={"prompt_type":'market_size',"decodem_token":DECODEM_TOKEN}
-try:
- r = requests.post(url_decodemprompts, data=json.dumps(data), headers=headers)
-except requests.exceptions.ReadTimeout as e:
- print(e)
-#print(r.content)
-
-prompt=str(r.content, 'UTF-8')
-print(prompt)
-
-def infer(prompt,
- max_length = 250,
- top_k = 0,
- num_beams = 0,
- no_repeat_ngram_size = 2,
- top_p = 0.9,
- seed=42,
- temperature=0.7,
- greedy_decoding = False,
- return_full_text = False):
-
- print(seed)
- top_k = None if top_k == 0 else top_k
- do_sample = False if num_beams > 0 else not greedy_decoding
- num_beams = None if (greedy_decoding or num_beams == 0) else num_beams
- no_repeat_ngram_size = None if num_beams is None else no_repeat_ngram_size
- top_p = None if num_beams else top_p
- early_stopping = None if num_beams is None else num_beams > 0
-
- params = {
- "max_new_tokens": max_length,
- "top_k": top_k,
- "top_p": top_p,
- "temperature": temperature,
- "do_sample": do_sample,
- "seed": seed,
- "early_stopping":early_stopping,
- "no_repeat_ngram_size":no_repeat_ngram_size,
- "num_beams":num_beams,
- "return_full_text":return_full_text
- }
-
- s = time.time()
- response = inference(prompt, params=params)
- #print(response)
- proc_time = time.time()-s
- #print(f"Processing time was {proc_time} seconds")
- return response
-
-def getideas(text_inp):
- print(text_inp)
- print(datetime.today().strftime("%d-%m-%Y"))
-
- text = prompt+"\nInput:"+text_inp + "\nOutput:"
- resp = infer(text,seed=random.randint(0,100))
-
- generated_text=resp[0]['generated_text']
- result = generated_text.replace(text,'').strip()
- result = result.replace("Output:","")
- parts = result.split("###")
- topic = parts[0].strip()
- topic="\n".join(topic.split('\n')[:3])
- print(topic)
- return(topic)
-
-with gr.Blocks() as demo:
- gr.Markdown("Market Sizing Framework for Your Business Decodem.ai for businesses.\nWhile ChatGPT has multiple use cases we have evolved specific use cases/ templates for businesses \n\n This template provides ideas on how a business can size a market they are entering. Enter a business area to size and get the results. Use examples as a guide. We use a equally powerful AI model bigscience/bloom."""
- )
- textbox = gr.Textbox(placeholder="Enter market size focus for business here...", lines=1,label='Your business area')
- btn = gr.Button("Generate")
- output1 = gr.Textbox(lines=2,label='Market Sizing Framework')
-
- btn.click(getideas,inputs=[textbox], outputs=[output1])
- examples = gr.Examples(examples=['ice cream parlor in London','HR saas for fintech','book shops in NYC','Starbucks cafe in Bangalore','organic vegetables via ecommerce','grocery delivery'],
- inputs=[textbox])
-
-
-demo.launch()
\ No newline at end of file
diff --git a/spaces/deepwisdom/MetaGPT/tests/metagpt/roles/test_qa_engineer.py b/spaces/deepwisdom/MetaGPT/tests/metagpt/roles/test_qa_engineer.py
deleted file mode 100644
index 8fd7c0373835d8793fb910ab3131f0da772c0d63..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/tests/metagpt/roles/test_qa_engineer.py
+++ /dev/null
@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Time : 2023/5/12 12:01
-@Author : alexanderwu
-@File : test_qa_engineer.py
-"""
diff --git a/spaces/deepwisdom/MetaGPT/tests/metagpt/tools/test_azure_tts.py b/spaces/deepwisdom/MetaGPT/tests/metagpt/tools/test_azure_tts.py
deleted file mode 100644
index b7f94a19c5f51c839c80e4121498d4b99720285b..0000000000000000000000000000000000000000
--- a/spaces/deepwisdom/MetaGPT/tests/metagpt/tools/test_azure_tts.py
+++ /dev/null
@@ -1,44 +0,0 @@
-#!/usr/bin/env python
-# -*- coding: utf-8 -*-
-"""
-@Time : 2023/7/1 22:50
-@Author : alexanderwu
-@File : test_azure_tts.py
-@Modified By: mashenquan, 2023-8-9, add more text formatting options
-@Modified By: mashenquan, 2023-8-17, move to `tools` folder.
-"""
-import asyncio
-
-from metagpt.config import CONFIG
-from metagpt.tools.azure_tts import AzureTTS
-
-
-def test_azure_tts():
- azure_tts = AzureTTS(subscription_key="", region="")
- text = """
- 女儿看见父亲走了进来，问道：
-
- “您来的挺快的，怎么过来的？”
-
- 父亲放下手提包，说：
-
- “Writing a binary file in Python is similar to writing a regular text file, but you'll work with bytes instead of strings.”
-
- """
- path = CONFIG.workspace / "tts"
- path.mkdir(exist_ok=True, parents=True)
- filename = path / "girl.wav"
- loop = asyncio.new_event_loop()
- v = loop.create_task(
- azure_tts.synthesize_speech(lang="zh-CN", voice="zh-CN-XiaomoNeural", text=text, output_file=str(filename))
- )
- result = loop.run_until_complete(v)
-
- print(result)
-
- # 运行需要先配置 SUBSCRIPTION_KEY
- # TODO: 这里如果要检验，还要额外加上对应的asr，才能确保前后生成是接近一致的，但现在还没有
-
-
-if __name__ == "__main__":
- test_azure_tts()
diff --git a/spaces/devthedeveloper/Bark-with-Voice-Cloning/bark/hubert/__init__.py b/spaces/devthedeveloper/Bark-with-Voice-Cloning/bark/hubert/__init__.py
deleted file mode 100644
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/spaces/dhansmair/flamingo-tiny-cap/app.py b/spaces/dhansmair/flamingo-tiny-cap/app.py
deleted file mode 100644
index bd56ce5150e2d0e7bf6b4a0c3b957b1454e8d76d..0000000000000000000000000000000000000000
--- a/spaces/dhansmair/flamingo-tiny-cap/app.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import os
-import gradio as gr
-import torch
-import PIL
-
-from flamingo_mini import FlamingoConfig, FlamingoModel, FlamingoProcessor
-
-
-
-EXAMPLES_DIR = 'examples'
-DEFAULT_PROMPT = ""
-
-device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-
-model = FlamingoModel.from_pretrained('dhansmair/flamingo-tiny')
-model.to(device)
-model.eval()
-
-processor = FlamingoProcessor(model.config)
-
-# setup some example images
-examples = []
-if os.path.isdir(EXAMPLES_DIR):
- for file in os.listdir(EXAMPLES_DIR):
- path = EXAMPLES_DIR + "/" + file
- examples.append([path, DEFAULT_PROMPT])
-
-
-def predict_caption(image, prompt):
- assert isinstance(prompt, str)
-
- caption = model.generate_captions(
- processor,
- images=[image],
- prompt=prompt
- )
-
- if isinstance(caption, list):
- caption = caption[0]
-
- return caption
-
-
-iface = gr.Interface(fn=predict_caption,
- inputs=[gr.Image(type="pil"), gr.Textbox(value=DEFAULT_PROMPT, label="Prompt")],
- examples=examples,
- outputs="text")
-
-iface.launch()
-
diff --git a/spaces/diacanFperku/AutoGPT/Garmin Topo Adriatopo Xl Downloadl.md b/spaces/diacanFperku/AutoGPT/Garmin Topo Adriatopo Xl Downloadl.md
deleted file mode 100644
index cec6c4cc8a597c2e11e9fb7d3b37a9539e5d1025..0000000000000000000000000000000000000000
--- a/spaces/diacanFperku/AutoGPT/Garmin Topo Adriatopo Xl Downloadl.md
+++ /dev/null
@@ -1,45 +0,0 @@
-
-How to Download and Install Garmin Topo Adriatopo Xl Maps
-If you are looking for detailed topographic maps of the Adriatic region, you might be interested in Garmin Topo Adriatopo Xl maps. These maps cover Croatia, Slovenia, Bosnia and Herzegovina, Serbia, Montenegro, Kosovo, Macedonia, Albania and parts of Italy and Greece. They are compatible with most Garmin devices that support mapping.
-Garmin Topo Adriatopo Xl Downloadl Download File ✪ https://gohhs.com/2uFUi5
Garmin Topo Adriatopo Xl maps provide digital topographic maps showing hiking trails, roads, mountains, woodlands and include a digital elevation model with mountain shading and more than 300,000 searchable points of interest (POIs), such as campsites, restaurants, hotels, museums, monuments and more. They also include the complete road network with street names and addressing.
-To download and install Garmin Topo Adriatopo Xl maps, you will need the following:
-
-A Garmin device that supports mapping
-A microSD card or a USB cable to transfer the maps to your device
-A computer with internet connection and Garmin Express software installed
-A valid credit card or PayPal account to purchase the maps from Garmin website
-
-Here are the steps to follow:
-
-Go to Garmin website and select your country and language.
-Find the product page for Garmin Topo Adriatopo Xl maps and click on "Add to Cart".
-Review your order and click on "Checkout".
-Enter your billing and payment information and click on "Place Order".
-You will receive an email confirmation with a download link and a product key.
-Open Garmin Express software on your computer and connect your device with a microSD card or a USB cable.
-Click on "Add a Device" and follow the instructions to register your device.
-Click on "Map Options" and then on "Redeem a Product Key".
-Enter the product key from the email confirmation and click on "Continue".
-Select your device or microSD card as the destination and click on "Install".
-Wait for the download and installation process to complete.
-Eject your device or microSD card from your computer and insert it into your device.
-Turn on your device and go to "Settings" > "Map & Vehicle" > "myMaps" and select Garmin Topo Adriatopo Xl maps.
-You are ready to explore the Adriatic region with detailed topographic maps.
-
-
-Garmin Topo Adriatopo Xl maps have many benefits for outdoor enthusiasts who want to explore the Adriatic region. Here are some of the advantages of using these maps:
-
-
-Elevation data: Topo maps include contour lines that indicate the elevation of the terrain, allowing users to visualize the steepness of the terrain and plan their route accordingly. This can be especially helpful for hikers and mountain bikers who need to know the difficulty of the terrain they will be traversing. Contour lines on topo maps can also give an indication of the slope of the terrain and help users to identify potential hazards such as cliffs, steep inclines, or rocky areas.Trail information: Topo maps often include information about trails, including their location, difficulty level, and distance. This can be helpful for planning a hike or bike ride, and for navigating during the activity. Some topo maps also show the direction of the trail and can help users to navigate through challenging areas such as switchbacks or rocky terrain.Water features: Topo maps also typically include information about water features such as rivers, streams, and lakes, which can be helpful for planning a fishing trip or a paddling excursion. The location of these water features on the map can help users to plan a route that takes advantage of the water sources in an area, or to avoid areas that are prone to flooding or have treacherous currents.Natural features: Topo maps show the natural features of an area, such as vegetation, rock formations, and wildlife habitats. This can be useful for outdoor enthusiasts who are interested in the natural history of an area. By studying topo maps, users can learn about the different types of vegetation and wildlife that are found in an area, and plan routes that take advantage of the natural features of an area.Orientation: Topo maps provide a detailed representation of the terrain, which can be helpful for orienting oneself in the wilderness. This is especially important if you are in an area with few landmarks or in low visibility conditions. Topo maps can also help users to identify important landmarks such as peaks, ridges, or valleys that can be used as reference points while navigating.Offline navigation: Topo maps can be loaded onto a Garmin device, allowing users to navigate without an internet connection. This is useful in remote areas where cellular service is limited or non-existent. With topo maps loaded on a Garmin device, users can navigate even in areas where there is no cellular coverage, and can rely on the GPS to provide accurate location information.Customized routes: Topo maps can be used to create customized routes on a Garmin device, allowing users to plan a route that is tailored to their specific needs and preferences. Users can plan routes that take advantage of the natural features of an area, such as scenic vistas or waterfalls, or that avoid areas that are too difficult or dangerous to navigate.Safety feature: Topo maps can be used to plan a safe route and avoid areas that are dangerous or inaccessible. For example, users can avoid areas that have landmines, unexploded ordnance, or other hazards that are common in some parts of the Adriatic region. Users can also use topo maps to find emergency services such as hospitals, police stations, or fire stations in case of an accident or injury.
-Garmin Topo Adriatopo Xl maps are a great way to enhance your outdoor experience in the Adriatic region. They provide detailed and accurate information about the terrain and features of an area, and allow you to plan and navigate your route with ease and confidence. Whether you are hiking, biking, fishing, paddling, or just sightseeing, Garmin Topo Adriatopo Xl maps will help you make the most of your adventure.
d5da3c52bf
-#include
-
-typedef struct decompress_args {
- int tid;
- int nthreads;
-
- int npids;
- int dim;
- int packed_dim;
- int npacked_vals_per_byte;
-
- int* pids;
- int64_t* lengths;
- int64_t* offsets;
- float* bucket_weights;
- uint8_t* reversed_bit_map;
- uint8_t* bucket_weight_combinations;
- uint8_t* binary_residuals;
- int* codes;
- float* centroids;
- int64_t* cumulative_lengths;
-
- float* output;
-} decompress_args_t;
-
-void* decompress(void* args) {
- decompress_args_t* decompress_args = (decompress_args_t*)args;
-
- int npids_per_thread = (int)std::ceil(((float)decompress_args->npids) /
- decompress_args->nthreads);
- int start = decompress_args->tid * npids_per_thread;
- int end = std::min((decompress_args->tid + 1) * npids_per_thread,
- decompress_args->npids);
-
- // Iterate over all documents
- for (int i = start; i < end; i++) {
- int pid = decompress_args->pids[i];
-
- // Offset into packed list of token vectors for the given document
- int64_t offset = decompress_args->offsets[pid];
-
- // For each document, iterate over all token vectors
- for (int j = 0; j < decompress_args->lengths[pid]; j++) {
- const int code = decompress_args->codes[offset + j];
-
- // For each token vector, iterate over the packed (8-bit) residual
- // values
- for (int k = 0; k < decompress_args->packed_dim; k++) {
- uint8_t x =
- decompress_args->binary_residuals
- [(offset + j) * decompress_args->packed_dim + k];
- x = decompress_args->reversed_bit_map[x];
-
- // For each packed residual value, iterate over the bucket
- // weight indices. If we use n-bit compression, that means there
- // will be (8 / n) indices per packed value.
- for (int l = 0; l < decompress_args->npacked_vals_per_byte;
- l++) {
- const int output_dim_idx =
- k * decompress_args->npacked_vals_per_byte + l;
- const int bucket_weight_idx =
- decompress_args->bucket_weight_combinations
- [x * decompress_args->npacked_vals_per_byte + l];
- decompress_args
- ->output[(decompress_args->cumulative_lengths[i] + j) *
- decompress_args->dim +
- output_dim_idx] =
- decompress_args->bucket_weights[bucket_weight_idx] +
- decompress_args->centroids[code * decompress_args->dim +
- output_dim_idx];
- }
- }
- }
- }
-
- return NULL;
-}
-
-torch::Tensor decompress_residuals(
- const torch::Tensor pids, const torch::Tensor lengths,
- const torch::Tensor offsets, const torch::Tensor bucket_weights,
- const torch::Tensor reversed_bit_map,
- const torch::Tensor bucket_weight_combinations,
- const torch::Tensor binary_residuals, const torch::Tensor codes,
- const torch::Tensor centroids, const int dim, const int nbits) {
- const int npacked_vals_per_byte = (8 / nbits);
- const int packed_dim = (int)(dim / npacked_vals_per_byte);
-
- int npids = pids.size(0);
- int* pids_a = pids.data_ptr();
- int64_t* lengths_a = lengths.data_ptr();
- int64_t* offsets_a = offsets.data_ptr();
- float* bucket_weights_a = bucket_weights.data_ptr();
- uint8_t* reversed_bit_map_a = reversed_bit_map.data_ptr();
- uint8_t* bucket_weight_combinations_a =
- bucket_weight_combinations.data_ptr
- # 
""")
-
- with gr.Row():
- gr.HTML("""